968 lines
32 KiB
TypeScript
968 lines
32 KiB
TypeScript
import { ResearchProvider, ResearchConfig } from "./blogWriterApi";
|
||
import {
|
||
storyWriterApi,
|
||
StorySetupGenerationResponse,
|
||
} from "./storyWriterApi";
|
||
import { getResearchConfig, ResearchPersona } from "../api/researchConfig";
|
||
import { aiApiClient } from "../api/client";
|
||
import {
|
||
CreateProjectPayload,
|
||
CreateProjectResult,
|
||
Fact,
|
||
Knobs,
|
||
PodcastAnalysis,
|
||
PodcastEstimate,
|
||
Query,
|
||
RenderJobResult,
|
||
Research,
|
||
Scene,
|
||
Script,
|
||
} from "../components/PodcastMaker/types";
|
||
import { checkPreflight, PreflightOperation } from "./billingService";
|
||
import { TaskStatus } from "./storyWriterApi";
|
||
import { isPodcastOnlyDemoMode } from "../utils/demoMode";
|
||
|
||
const DEFAULT_KNOBS: Knobs = {
|
||
voice_emotion: "neutral",
|
||
voice_speed: 1,
|
||
voice_id: "Wise_Woman",
|
||
custom_voice_id: undefined,
|
||
resolution: "720p",
|
||
scene_length_target: 45,
|
||
sample_rate: 24000,
|
||
bitrate: "standard",
|
||
};
|
||
|
||
// const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
|
||
|
||
const createId = (prefix: string) => {
|
||
if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
|
||
return `${prefix}_${crypto.randomUUID()}`;
|
||
}
|
||
return `${prefix}_${Date.now()}_${Math.floor(Math.random() * 10000)}`;
|
||
};
|
||
|
||
type OptionLike = StorySetupGenerationResponse["options"][0] | { plot_elements?: string; premise?: string };
|
||
|
||
const deriveSegments = (option?: OptionLike): string[] => {
|
||
const segments: string[] = [];
|
||
if (option?.plot_elements) {
|
||
option.plot_elements
|
||
.split(/[,.;]+/)
|
||
.map((p) => p.trim())
|
||
.filter(Boolean)
|
||
.forEach((p) => segments.push(p));
|
||
}
|
||
if (!segments.length && "premise" in (option || {}) && (option as any)?.premise) {
|
||
segments.push("Intro", "Key Takeaways", "Examples", "CTA");
|
||
}
|
||
return segments.slice(0, 5);
|
||
};
|
||
|
||
const toPodcastEstimate = (raw: any, voiceId?: string): PodcastEstimate | null => {
|
||
if (!raw || typeof raw !== "object") return null;
|
||
const numeric = ["ttsCost", "avatarCost", "videoCost", "researchCost", "total"] as const;
|
||
if (numeric.some((key) => typeof raw[key] !== "number" || Number.isNaN(raw[key]))) {
|
||
return null;
|
||
}
|
||
const isCustomVoice = Boolean(
|
||
voiceId &&
|
||
![
|
||
"Wise_Woman",
|
||
"Friendly_Person",
|
||
"Inspirational_girl",
|
||
"Deep_Voice_Man",
|
||
"Calm_Woman",
|
||
"Casual_Guy",
|
||
"Lively_Girl",
|
||
"Patient_Man",
|
||
"Young_Knight",
|
||
"Determined_Man",
|
||
"Lovely_Girl",
|
||
"Decent_Boy",
|
||
"Imposing_Manner",
|
||
"Elegant_Man",
|
||
"Abbess",
|
||
"Sweet_Girl_2",
|
||
"Exuberant_Girl",
|
||
].includes(voiceId)
|
||
);
|
||
return {
|
||
ttsCost: raw.ttsCost,
|
||
avatarCost: raw.avatarCost,
|
||
videoCost: raw.videoCost,
|
||
researchCost: raw.researchCost,
|
||
total: raw.total,
|
||
voiceName: isCustomVoice ? "My Voice Clone" : (!voiceId ? "Wise Woman" : voiceId.replace(/_/g, " ")),
|
||
isCustomVoice,
|
||
};
|
||
};
|
||
|
||
const mapPersonaQueries = (persona: ResearchPersona | undefined, seed: string): Query[] => {
|
||
const baseIdea = seed || "AI marketing for small businesses";
|
||
const personaKeywords = persona?.suggested_keywords?.filter(Boolean) || [];
|
||
const angles = persona?.research_angles ?? [];
|
||
const generated: Query[] = [];
|
||
|
||
const addQuery = (q: string, why: string, needsRecent = false) => {
|
||
if (!q.trim()) return;
|
||
generated.push({
|
||
id: createId("q"),
|
||
query: q.trim(),
|
||
rationale: why,
|
||
needsRecentStats: needsRecent,
|
||
});
|
||
};
|
||
|
||
if (personaKeywords.length) {
|
||
personaKeywords.slice(0, 4).forEach((k, idx) =>
|
||
addQuery(k, angles[idx % Math.max(1, angles.length)] || "Persona-aligned query", /202[45]|latest|trend/i.test(k))
|
||
);
|
||
}
|
||
|
||
if (!generated.length) {
|
||
addQuery(`How is ${baseIdea} evolving in 2024?`, "Trend + outcome focus", true);
|
||
addQuery(`Best practices for ${baseIdea}`, "Actionable guidance", false);
|
||
addQuery(`${baseIdea} case studies with ROI`, "Proof and outcomes", true);
|
||
addQuery(`${baseIdea} risks and objections`, "Address listener concerns", false);
|
||
}
|
||
|
||
return generated.slice(0, 6);
|
||
};
|
||
|
||
type ExaSource = {
|
||
title?: string;
|
||
url?: string;
|
||
excerpt?: string;
|
||
published_at?: string;
|
||
publishedDate?: string; // Exa format
|
||
highlights?: string[];
|
||
summary?: string;
|
||
source_type?: string;
|
||
index?: number;
|
||
image?: string;
|
||
author?: string;
|
||
text?: string; // Exa full text content
|
||
credibility_score?: number;
|
||
};
|
||
|
||
const mapSourcesToFacts = (sources: ExaSource[]): Fact[] => {
|
||
if (!sources || !sources.length) return [];
|
||
|
||
// Deduplicate by URL
|
||
const seenUrls = new Set<string>();
|
||
const uniqueSources = sources.filter(s => {
|
||
if (!s.url || seenUrls.has(s.url)) return false;
|
||
seenUrls.add(s.url);
|
||
return true;
|
||
});
|
||
|
||
return uniqueSources.slice(0, 12).map((source: ExaSource, idx: number) => ({
|
||
id: source.url || `fact-${idx}`,
|
||
quote: source.excerpt || source.highlights?.[0] || source.summary || source.title || "Insight",
|
||
url: source.url || "",
|
||
// Use published_at (backend format) or publishedDate (Exa format)
|
||
date: source.published_at || source.publishedDate || "Unknown",
|
||
confidence: source.credibility_score || Math.max(0.5, 0.85 - idx * 0.02),
|
||
image: source.image,
|
||
author: source.author,
|
||
highlights: source.highlights,
|
||
// Include full text if available
|
||
fullText: source.text,
|
||
}));
|
||
};
|
||
|
||
type ExaResearchResult = {
|
||
sources: ExaSource[];
|
||
search_queries?: string[];
|
||
cost_est?: {
|
||
total?: number;
|
||
breakdown?: { phase: "Analyze" | "Gather" | "Write" | "Produce"; cost: number }[];
|
||
currency?: "USD";
|
||
last_updated?: string;
|
||
};
|
||
cost?: { total?: number };
|
||
estimate?: PodcastEstimate | null;
|
||
search_type?: string;
|
||
provider?: string;
|
||
content?: string;
|
||
};
|
||
|
||
const mapExaResearchResponse = (response: any): Research => {
|
||
const factCards = mapSourcesToFacts(response.sources);
|
||
const summary = response.summary || response.content || "Research completed.";
|
||
|
||
const keyInsights = (response.key_insights || []).map((insight: any) => ({
|
||
title: insight.title || "Insight",
|
||
content: insight.content || "",
|
||
source_indices: insight.source_indices || []
|
||
}));
|
||
|
||
const expertQuotes = (response.expert_quotes || []).map((eq: any) => ({
|
||
quote: eq.quote || eq.text || "",
|
||
source_index: eq.source_index ?? 0
|
||
}));
|
||
|
||
const listenerCta = response.listener_cta_suggestions || response.listener_cta || [];
|
||
|
||
const mappedAngles = (response.mapped_angles || []).map((angle: any) => ({
|
||
title: angle.title || "",
|
||
why: angle.why || angle.rationale || "",
|
||
mappedFactIds: angle.mapped_fact_ids || angle.mappedFactIds || []
|
||
}));
|
||
|
||
return {
|
||
summary,
|
||
keyInsights,
|
||
factCards,
|
||
mappedAngles,
|
||
expertQuotes,
|
||
listenerCta,
|
||
searchQueries: response.search_queries,
|
||
searchType: response.search_type,
|
||
provider: response.provider || "exa",
|
||
costEst: response.cost_est
|
||
? {
|
||
total: Number(response.cost_est.total || 0),
|
||
breakdown: Array.isArray(response.cost_est.breakdown) ? response.cost_est.breakdown : [],
|
||
currency: response.cost_est.currency || "USD",
|
||
last_updated: response.cost_est.last_updated || new Date().toISOString(),
|
||
}
|
||
: undefined,
|
||
sourceCount: response.sources?.length || 0,
|
||
};
|
||
};
|
||
|
||
const ensurePreflight = async (operation: PreflightOperation) => {
|
||
console.log('[podcastApi] Running preflight for:', operation);
|
||
const result = await checkPreflight(operation);
|
||
console.log('[podcastApi] Preflight result:', result);
|
||
if (!result.can_proceed) {
|
||
const message = result.operations[0]?.message || "Pre-flight validation failed";
|
||
throw new Error(message);
|
||
}
|
||
return result;
|
||
};
|
||
|
||
export const podcastApi = {
|
||
async createProject(payload: CreateProjectPayload, bible?: any, feedback?: string): Promise<CreateProjectResult> {
|
||
const storyIdea = payload.ideaOrUrl || "AI marketing for small businesses";
|
||
|
||
await ensurePreflight({
|
||
provider: "gemini",
|
||
operation_type: "podcast_analysis",
|
||
tokens_requested: 1500,
|
||
actual_provider_name: "gemini",
|
||
});
|
||
|
||
// Podcast-specific analysis (not story setup)
|
||
const analysisResp = await aiApiClient.post("/api/podcast/analyze", {
|
||
idea: storyIdea,
|
||
duration: payload.duration,
|
||
speakers: payload.speakers,
|
||
bible: bible,
|
||
avatar_url: payload.avatarUrl,
|
||
feedback: feedback,
|
||
podcast_mode: payload.podcastMode, // Pass mode to skip avatar for audio_only
|
||
});
|
||
|
||
const outlines = (analysisResp.data?.suggested_outlines || []).map((o: any, idx: number) => ({
|
||
id: o.id || `outline-${idx + 1}`,
|
||
title: o.title || `Outline ${idx + 1}`,
|
||
segments: Array.isArray(o.segments) ? o.segments : deriveSegments({ plot_elements: o.segments }),
|
||
}));
|
||
|
||
const analysis: PodcastAnalysis = {
|
||
audience: analysisResp.data?.audience || "Growth-minded pros",
|
||
contentType: analysisResp.data?.content_type || "Podcast interview",
|
||
topKeywords: analysisResp.data?.top_keywords || outlines[0]?.segments?.slice(0, 3) || [],
|
||
suggestedOutlines: outlines,
|
||
suggestedKnobs: { ...DEFAULT_KNOBS, ...payload.knobs },
|
||
titleSuggestions: (analysisResp.data?.title_suggestions || []).filter(Boolean),
|
||
episode_hook: analysisResp.data?.episode_hook || "",
|
||
key_takeaways: analysisResp.data?.key_takeaways || [],
|
||
guest_talking_points: analysisResp.data?.guest_talking_points || [],
|
||
listener_cta: analysisResp.data?.listener_cta || "",
|
||
research_queries: analysisResp.data?.research_queries || [],
|
||
exaSuggestedConfig: analysisResp.data?.exa_suggested_config || undefined,
|
||
};
|
||
|
||
const researchConfig = isPodcastOnlyDemoMode() ? null : await getResearchConfig();
|
||
|
||
// Use AI-generated queries if available, fallback to legacy mapping
|
||
let queries: Query[] = [];
|
||
if (analysis.research_queries && analysis.research_queries.length > 0) {
|
||
queries = analysis.research_queries.map(rq => ({
|
||
id: createId("q"),
|
||
query: rq.query,
|
||
rationale: rq.rationale,
|
||
needsRecentStats: /202[45]|latest|trend/i.test(rq.query)
|
||
}));
|
||
} else {
|
||
queries = mapPersonaQueries(researchConfig?.research_persona, storyIdea);
|
||
}
|
||
|
||
// Note: selectedQueries should be set to empty Set by the caller (workflow)
|
||
// so users can manually choose which queries to run
|
||
|
||
const projectId = createId("podcast");
|
||
const estimate = toPodcastEstimate(analysisResp.data?.estimate, payload.knobs.voice_id);
|
||
|
||
return {
|
||
projectId,
|
||
analysis,
|
||
estimate,
|
||
queries,
|
||
bible: analysisResp.data?.bible || undefined,
|
||
avatar_url: analysisResp.data?.avatar_url || null,
|
||
avatar_prompt: analysisResp.data?.avatar_prompt || null,
|
||
};
|
||
},
|
||
|
||
async enhanceIdea(params: { idea: string; bible?: any }): Promise<{ enhanced_ideas: string[]; rationales: string[] }> {
|
||
const response = await aiApiClient.post("/api/podcast/idea/enhance", params);
|
||
return response.data;
|
||
},
|
||
|
||
async runResearch(params: {
|
||
projectId: string;
|
||
topic: string;
|
||
approvedQueries: Query[];
|
||
provider?: ResearchProvider;
|
||
exaConfig?: ResearchConfig;
|
||
bible?: any;
|
||
analysis?: PodcastAnalysis | null;
|
||
onProgress?: (message: string) => void;
|
||
}): Promise<{ research: Research; raw: any; estimate?: PodcastEstimate | null }> {
|
||
const keywords = params.approvedQueries.map((q) => q.query).filter(Boolean);
|
||
if (!keywords.length) {
|
||
throw new Error("At least one query must be approved for research.");
|
||
}
|
||
|
||
// Ensure Exa payload respects API constraint: when requesting contents, only one of includeDomains or excludeDomains.
|
||
let sanitizedExaConfig: ResearchConfig | undefined = params.exaConfig;
|
||
if (sanitizedExaConfig && sanitizedExaConfig.exa_include_domains?.length) {
|
||
sanitizedExaConfig = {
|
||
...sanitizedExaConfig,
|
||
exa_exclude_domains: undefined,
|
||
};
|
||
} else if (sanitizedExaConfig && sanitizedExaConfig.exa_exclude_domains?.length) {
|
||
sanitizedExaConfig = {
|
||
...sanitizedExaConfig,
|
||
exa_include_domains: undefined,
|
||
};
|
||
}
|
||
|
||
await ensurePreflight({
|
||
provider: "exa",
|
||
operation_type: "exa_neural_search",
|
||
tokens_requested: 0,
|
||
actual_provider_name: "exa",
|
||
});
|
||
|
||
let response;
|
||
try {
|
||
response = await aiApiClient.post("/api/podcast/research/exa", {
|
||
topic: params.topic || keywords[0],
|
||
queries: keywords,
|
||
exa_config: sanitizedExaConfig,
|
||
bible: params.bible,
|
||
analysis: params.analysis,
|
||
}, { timeout: 300000 }); // 5 minute timeout for research
|
||
console.log('[podcastApi] Exa research response received:', response.status, response.data);
|
||
} catch (error: any) {
|
||
console.error('[podcastApi] Exa research error:', error?.response?.status, error?.response?.data, error?.message);
|
||
throw error;
|
||
}
|
||
|
||
const exaResult = response.data as ExaResearchResult;
|
||
if (params.onProgress) {
|
||
params.onProgress("Deep research completed with Exa.");
|
||
}
|
||
const mapped = mapExaResearchResponse(exaResult);
|
||
return {
|
||
research: mapped,
|
||
raw: exaResult,
|
||
estimate: toPodcastEstimate(exaResult.estimate, params.analysis?.suggestedKnobs?.voice_id),
|
||
};
|
||
},
|
||
|
||
async generateScript(params: {
|
||
projectId: string;
|
||
idea: string;
|
||
research?: ExaResearchResult | null;
|
||
knobs: Knobs;
|
||
speakers: number;
|
||
durationMinutes: number;
|
||
bible?: any;
|
||
outline?: any;
|
||
analysis?: PodcastAnalysis | null;
|
||
onProgress?: (message: string) => void;
|
||
}): Promise<Script> {
|
||
await ensurePreflight({
|
||
provider: "gemini",
|
||
operation_type: "script_generation",
|
||
tokens_requested: 2000,
|
||
actual_provider_name: "gemini",
|
||
});
|
||
|
||
if (params.onProgress) {
|
||
params.onProgress("Analyzing research data and extracting key insights...");
|
||
}
|
||
|
||
const response = await aiApiClient.post("/api/podcast/script", {
|
||
idea: params.idea,
|
||
duration_minutes: params.durationMinutes,
|
||
speakers: params.speakers,
|
||
research: params.research,
|
||
bible: params.bible,
|
||
outline: params.outline,
|
||
analysis: params.analysis,
|
||
});
|
||
|
||
if (params.onProgress) {
|
||
params.onProgress("Creating podcast structure with scenes and dialogue...");
|
||
}
|
||
|
||
const scenes = response.data?.scenes || [];
|
||
const scriptScenes: Scene[] = scenes.map((scene: any) => ({
|
||
id: scene.id || createId("scene"),
|
||
title: scene.title || "Scene",
|
||
duration: scene.duration || Math.max(20, params.knobs.scene_length_target || DEFAULT_KNOBS.scene_length_target),
|
||
lines:
|
||
Array.isArray(scene.lines) && scene.lines.length
|
||
? scene.lines.map((l: any) => ({
|
||
id: createId("line"),
|
||
speaker: l.speaker || "Host",
|
||
text: l.text || "",
|
||
}))
|
||
: [
|
||
{
|
||
id: createId("line"),
|
||
speaker: "Host",
|
||
text: "Let's dive into today's topic.",
|
||
},
|
||
],
|
||
approved: false,
|
||
}));
|
||
|
||
return { scenes: scriptScenes };
|
||
},
|
||
|
||
async previewLine(
|
||
text: string,
|
||
options: { voiceId?: string; speed?: number; emotion?: string } = {}
|
||
): Promise<{ ok: boolean; message: string; audioUrl?: string }> {
|
||
await ensurePreflight({
|
||
provider: "audio",
|
||
operation_type: "tts_preview",
|
||
tokens_requested: text.length,
|
||
actual_provider_name: "wavespeed",
|
||
});
|
||
|
||
const response = await storyWriterApi.generateAIAudio({
|
||
scene_number: 0,
|
||
scene_title: "Preview",
|
||
text,
|
||
voice_id: options.voiceId || "Wise_Woman",
|
||
speed: options.speed || 1.0,
|
||
emotion: options.emotion || "neutral",
|
||
});
|
||
|
||
if (!response.success) {
|
||
throw new Error(response.error || "Preview failed");
|
||
}
|
||
|
||
return {
|
||
ok: true,
|
||
message: "Preview ready – opening audio in new tab.",
|
||
audioUrl: response.audio_url,
|
||
};
|
||
},
|
||
|
||
async renderSceneAudio(params: {
|
||
scene: Scene;
|
||
voiceId?: string;
|
||
customVoiceId?: string;
|
||
emotion?: string; // Fallback if scene doesn't have emotion
|
||
speed?: number;
|
||
volume?: number;
|
||
pitch?: number;
|
||
englishNormalization?: boolean;
|
||
sampleRate?: number;
|
||
bitrate?: number;
|
||
channel?: "1" | "2";
|
||
format?: "mp3" | "wav" | "pcm" | "flac";
|
||
languageBoost?: string;
|
||
}): Promise<RenderJobResult> {
|
||
// Use scene-specific emotion if available, otherwise fallback to provided/default
|
||
const sceneEmotion = params.scene.emotion || params.emotion || "neutral";
|
||
|
||
// Optimize text for Minimax Speech-02-HD TTS
|
||
// - Strip markdown formatting (bold, italic, etc.) - TTS reads it literally
|
||
// - Use pause markers <#x#> for natural speech rhythm
|
||
// - Add longer pauses for speaker changes
|
||
// - Preserve punctuation for natural breathing
|
||
// - Add emphasis pauses for important points
|
||
const text = params.scene.lines
|
||
.map((line, idx) => {
|
||
let lineText = line.text.trim();
|
||
|
||
// Strip markdown formatting - TTS reads asterisks and other markdown literally
|
||
// Remove bold (**text** or __text__)
|
||
lineText = lineText.replace(/\*\*([^*]+)\*\*/g, '$1'); // **bold**
|
||
lineText = lineText.replace(/\*([^*]+)\*/g, '$1'); // *bold* (single asterisk)
|
||
lineText = lineText.replace(/__([^_]+)__/g, '$1'); // __bold__
|
||
lineText = lineText.replace(/_([^_]+)_/g, '$1'); // _italic_ (single underscore)
|
||
// Remove any remaining stray asterisks or underscores
|
||
lineText = lineText.replace(/\*+/g, ''); // Remove any remaining asterisks
|
||
lineText = lineText.replace(/_+/g, ''); // Remove any remaining underscores
|
||
// Clean up extra spaces
|
||
lineText = lineText.replace(/\s+/g, ' ').trim();
|
||
|
||
// Preserve punctuation (Minimax uses it for natural breathing)
|
||
// Don't strip punctuation - it helps TTS understand natural pauses
|
||
|
||
// Add emphasis pause after lines marked with emphasis
|
||
if (line.emphasis) {
|
||
// Minimal pause after emphasized content (0.15s for subtle emphasis)
|
||
lineText = `${lineText}<#0.15#>`;
|
||
}
|
||
|
||
// Check for speaker change (longer pause for natural conversation flow)
|
||
const prevLine = idx > 0 ? params.scene.lines[idx - 1] : null;
|
||
const isSpeakerChange = prevLine && prevLine.speaker !== line.speaker;
|
||
|
||
if (isSpeakerChange) {
|
||
// Short pause for speaker changes (0.2s - enough for natural transition)
|
||
lineText = `<#0.2#>${lineText}`;
|
||
}
|
||
|
||
// Add minimal pause between lines (only between regular lines, very short)
|
||
if (idx < params.scene.lines.length - 1) {
|
||
if (!line.emphasis && !isSpeakerChange) {
|
||
// Very short pause between lines (0.08s - barely noticeable but helps flow)
|
||
lineText = `${lineText}<#0.08#>`;
|
||
}
|
||
// If emphasis or speaker change, the pause is already added above
|
||
}
|
||
|
||
return lineText;
|
||
})
|
||
.join(" ");
|
||
|
||
// Validate character limit (Minimax max: 10,000 characters)
|
||
const MAX_CHARS = 10000;
|
||
let textToUse = text;
|
||
if (text.length > MAX_CHARS) {
|
||
console.warn(
|
||
`[Podcast] Scene "${params.scene.title}" exceeds ${MAX_CHARS} character limit (${text.length} chars). Truncating...`
|
||
);
|
||
// Truncate at word boundary to avoid cutting mid-word
|
||
const truncated = text.substring(0, MAX_CHARS);
|
||
const lastSpace = truncated.lastIndexOf(" ");
|
||
textToUse = lastSpace > 0 ? truncated.substring(0, lastSpace) : truncated;
|
||
}
|
||
|
||
await ensurePreflight({
|
||
provider: "audio",
|
||
operation_type: "tts_full_render",
|
||
tokens_requested: textToUse.length,
|
||
actual_provider_name: "wavespeed",
|
||
});
|
||
|
||
const response = await aiApiClient.post("/api/podcast/audio", {
|
||
scene_id: params.scene.id,
|
||
scene_title: params.scene.title,
|
||
text: textToUse,
|
||
voice_id: params.voiceId || "Wise_Woman",
|
||
custom_voice_id: params.customVoiceId || null,
|
||
speed: params.speed ?? 1.0, // Normal speed (was 0.9, but too slow - causing duration issues)
|
||
volume: params.volume ?? 1.0,
|
||
pitch: params.pitch ?? 0.0,
|
||
emotion: sceneEmotion,
|
||
english_normalization: params.englishNormalization ?? true, // Better number reading for statistics
|
||
sample_rate: params.sampleRate || null,
|
||
bitrate: params.bitrate || null,
|
||
channel: params.channel || null,
|
||
format: params.format || null,
|
||
language_boost: params.languageBoost || null,
|
||
});
|
||
|
||
return {
|
||
audioUrl: response.data.audio_url,
|
||
audioFilename: response.data.audio_filename,
|
||
provider: response.data.provider,
|
||
model: response.data.model,
|
||
cost: response.data.cost,
|
||
voiceId: response.data.voice_id,
|
||
fileSize: response.data.file_size,
|
||
};
|
||
},
|
||
|
||
async approveScene(params: { projectId: string; sceneId: string; notes?: string }) {
|
||
await aiApiClient.post("/api/podcast/script/approve", {
|
||
project_id: params.projectId,
|
||
scene_id: params.sceneId,
|
||
approved: true,
|
||
notes: params.notes,
|
||
});
|
||
},
|
||
|
||
// Project persistence endpoints
|
||
async saveProject(projectId: string, state: any): Promise<void> {
|
||
try {
|
||
await aiApiClient.put(`/api/podcast/projects/${projectId}`, state);
|
||
} catch (error) {
|
||
console.error("Failed to save project to database:", error);
|
||
// Don't throw - localStorage fallback is acceptable
|
||
}
|
||
},
|
||
|
||
async loadProject(projectId: string): Promise<any> {
|
||
const response = await aiApiClient.get(`/api/podcast/projects/${projectId}`);
|
||
return response.data;
|
||
},
|
||
|
||
async listProjects(params?: {
|
||
status?: string;
|
||
favorites_only?: boolean;
|
||
limit?: number;
|
||
offset?: number;
|
||
order_by?: "updated_at" | "created_at";
|
||
}): Promise<{ projects: any[]; total: number; limit: number; offset: number }> {
|
||
const response = await aiApiClient.get("/api/podcast/projects", { params });
|
||
return response.data;
|
||
},
|
||
|
||
async createProjectInDb(params: {
|
||
project_id: string;
|
||
idea: string;
|
||
duration: number;
|
||
speakers: number;
|
||
budget_cap: number;
|
||
avatar_url?: string | null;
|
||
}): Promise<any> {
|
||
try {
|
||
const response = await aiApiClient.post("/api/podcast/projects", params);
|
||
return response.data;
|
||
} catch (error: any) {
|
||
if (error?.response?.status === 409) {
|
||
// Duplicate idea detected - throw specific error for UI handling
|
||
const conflictData = error.response.data?.detail || {};
|
||
throw new Error(JSON.stringify({
|
||
type: "DUPLICATE_IDEA",
|
||
existing_project_id: conflictData.existing_project_id,
|
||
existing_idea: conflictData.existing_idea,
|
||
message: conflictData.message,
|
||
}));
|
||
}
|
||
throw error;
|
||
}
|
||
},
|
||
|
||
async updateProject(projectId: string, updates: any): Promise<any> {
|
||
const response = await aiApiClient.put(`/api/podcast/projects/${projectId}`, updates);
|
||
return response.data;
|
||
},
|
||
|
||
async deleteProject(projectId: string): Promise<void> {
|
||
await aiApiClient.delete(`/api/podcast/projects/${projectId}`);
|
||
},
|
||
|
||
async toggleFavorite(projectId: string): Promise<any> {
|
||
const response = await aiApiClient.post(`/api/podcast/projects/${projectId}/favorite`);
|
||
return response.data;
|
||
},
|
||
|
||
async regenerateResearchQueries(params: {
|
||
idea: string;
|
||
feedback: string;
|
||
existing_analysis?: any;
|
||
bible?: any;
|
||
}): Promise<{ research_queries: { query: string; rationale: string }[] }> {
|
||
const response = await aiApiClient.post("/api/podcast/regenerate-queries", params);
|
||
return response.data;
|
||
},
|
||
|
||
async saveAudioToAssetLibrary(params: {
|
||
audioUrl: string;
|
||
filename: string;
|
||
title: string;
|
||
description?: string;
|
||
projectId: string;
|
||
sceneId?: string;
|
||
cost?: number;
|
||
provider?: string;
|
||
model?: string;
|
||
fileSize?: number;
|
||
}): Promise<{ assetId: number }> {
|
||
const response = await aiApiClient.post("/api/content-assets/", {
|
||
asset_type: "audio",
|
||
source_module: "podcast_maker",
|
||
filename: params.filename,
|
||
file_url: params.audioUrl,
|
||
title: params.title,
|
||
description: params.description || `Podcast episode audio: ${params.title}`,
|
||
tags: ["podcast", "audio", params.projectId],
|
||
asset_metadata: {
|
||
project_id: params.projectId,
|
||
scene_id: params.sceneId,
|
||
provider: params.provider,
|
||
model: params.model,
|
||
},
|
||
provider: params.provider,
|
||
model: params.model,
|
||
cost: params.cost || 0,
|
||
file_size: params.fileSize,
|
||
mime_type: "audio/mpeg",
|
||
});
|
||
return { assetId: response.data.id };
|
||
},
|
||
|
||
async generateVideo(params: {
|
||
projectId: string;
|
||
sceneId: string;
|
||
sceneTitle: string;
|
||
audioUrl: string;
|
||
avatarImageUrl?: string;
|
||
bible?: any;
|
||
analysis?: any;
|
||
sceneImagePrompt?: string;
|
||
sceneNarration?: string;
|
||
resolution?: string;
|
||
prompt?: string;
|
||
seed?: number;
|
||
maskImageUrl?: string;
|
||
}): Promise<{ taskId: string; status: string; message: string }> {
|
||
const response = await aiApiClient.post("/api/podcast/render/video", {
|
||
project_id: params.projectId,
|
||
scene_id: params.sceneId,
|
||
scene_title: params.sceneTitle,
|
||
audio_url: params.audioUrl,
|
||
avatar_image_url: params.avatarImageUrl,
|
||
bible: params.bible,
|
||
analysis: params.analysis,
|
||
scene_image_prompt: params.sceneImagePrompt,
|
||
scene_narration: params.sceneNarration,
|
||
resolution: params.resolution || "720p",
|
||
prompt: params.prompt,
|
||
seed: params.seed ?? -1,
|
||
mask_image_url: params.maskImageUrl,
|
||
});
|
||
|
||
// Backend returns snake_case (task_id); normalize to camelCase for callers
|
||
const { task_id, status, message } = response.data || {};
|
||
return {
|
||
taskId: task_id,
|
||
status,
|
||
message,
|
||
};
|
||
},
|
||
|
||
async pollTaskStatus(taskId: string): Promise<TaskStatus | null> {
|
||
const response = await aiApiClient.get(`/api/podcast/task/${taskId}/status`);
|
||
// Backend returns null if task not found
|
||
return response.data || null;
|
||
},
|
||
|
||
async listVideos(projectId?: string): Promise<{
|
||
videos: Array<{
|
||
scene_number: number;
|
||
filename: string;
|
||
video_url: string;
|
||
file_size: number;
|
||
}>;
|
||
}> {
|
||
const params = projectId ? { project_id: projectId } : {};
|
||
const response = await aiApiClient.get("/api/podcast/videos", { params });
|
||
return response.data;
|
||
},
|
||
|
||
async combineVideos(params: {
|
||
projectId: string;
|
||
sceneVideoUrls: string[];
|
||
podcastTitle?: string;
|
||
}): Promise<{
|
||
taskId: string;
|
||
status: string;
|
||
message: string;
|
||
}> {
|
||
const response = await aiApiClient.post("/api/podcast/render/combine-videos", {
|
||
project_id: params.projectId,
|
||
scene_video_urls: params.sceneVideoUrls,
|
||
podcast_title: params.podcastTitle || "Podcast",
|
||
});
|
||
|
||
const { task_id, status, message } = response.data || {};
|
||
return {
|
||
taskId: task_id,
|
||
status,
|
||
message,
|
||
};
|
||
},
|
||
|
||
async generateSceneImage(params: {
|
||
sceneId: string;
|
||
sceneTitle: string;
|
||
sceneContent?: string;
|
||
sceneEmotion?: string;
|
||
baseAvatarUrl?: string;
|
||
bible?: any;
|
||
idea?: string;
|
||
analysis?: {
|
||
audience?: string;
|
||
contentType?: string;
|
||
topKeywords?: string[];
|
||
};
|
||
width?: number;
|
||
height?: number;
|
||
customPrompt?: string;
|
||
style?: "Auto" | "Fiction" | "Realistic";
|
||
renderingSpeed?: "Default" | "Turbo" | "Quality";
|
||
aspectRatio?: "1:1" | "16:9" | "9:16" | "4:3" | "3:4";
|
||
}): Promise<{
|
||
scene_id: string;
|
||
scene_title: string;
|
||
image_filename: string;
|
||
image_url: string;
|
||
width: number;
|
||
height: number;
|
||
provider: string;
|
||
model?: string;
|
||
cost: number;
|
||
image_prompt?: string;
|
||
}> {
|
||
const response = await aiApiClient.post("/api/podcast/image", {
|
||
scene_id: params.sceneId,
|
||
scene_title: params.sceneTitle,
|
||
scene_content: params.sceneContent,
|
||
scene_emotion: params.sceneEmotion || null,
|
||
base_avatar_url: params.baseAvatarUrl || null,
|
||
bible: params.bible,
|
||
idea: params.idea || null,
|
||
analysis: params.analysis || null,
|
||
width: params.width || 1024,
|
||
height: params.height || 1024,
|
||
custom_prompt: params.customPrompt || null,
|
||
style: params.style || null,
|
||
rendering_speed: params.renderingSpeed || null,
|
||
aspect_ratio: params.aspectRatio || null,
|
||
});
|
||
return response.data;
|
||
},
|
||
|
||
async cancelTask(taskId: string): Promise<void> {
|
||
// Note: Task cancellation may not be fully supported by backend yet
|
||
// This is a placeholder for future implementation
|
||
try {
|
||
await aiApiClient.post(`/api/story/task/${taskId}/cancel`);
|
||
} catch (error) {
|
||
console.warn("Task cancellation not supported:", error);
|
||
}
|
||
},
|
||
|
||
async combineAudio(params: {
|
||
projectId: string;
|
||
sceneIds: string[];
|
||
sceneAudioUrls: string[];
|
||
}): Promise<{
|
||
combined_audio_url: string;
|
||
combined_audio_filename: string;
|
||
total_duration: number;
|
||
file_size: number;
|
||
scene_count: number;
|
||
}> {
|
||
const response = await aiApiClient.post("/api/podcast/combine-audio", {
|
||
project_id: params.projectId,
|
||
scene_ids: params.sceneIds,
|
||
scene_audio_urls: params.sceneAudioUrls,
|
||
});
|
||
return response.data;
|
||
},
|
||
|
||
async uploadAvatar(file: File, projectId?: string): Promise<{ avatar_url: string; avatar_filename: string }> {
|
||
const formData = new FormData();
|
||
formData.append('file', file);
|
||
if (projectId) {
|
||
formData.append('project_id', projectId);
|
||
}
|
||
const response = await aiApiClient.post('/api/podcast/avatar/upload', formData, {
|
||
headers: { 'Content-Type': 'multipart/form-data' },
|
||
});
|
||
return response.data;
|
||
},
|
||
|
||
async generatePresenters(
|
||
speakers: number,
|
||
projectId?: string,
|
||
audience?: string,
|
||
contentType?: string,
|
||
topKeywords?: string[]
|
||
): Promise<{
|
||
avatars: Array<{ avatar_url: string; speaker_number: number; prompt?: string; persona_id?: string; seed?: number }>;
|
||
persona_id?: string;
|
||
}> {
|
||
const formData = new FormData();
|
||
formData.append('speakers', speakers.toString());
|
||
if (projectId) {
|
||
formData.append('project_id', projectId);
|
||
}
|
||
if (audience) {
|
||
formData.append('audience', audience);
|
||
}
|
||
if (contentType) {
|
||
formData.append('content_type', contentType);
|
||
}
|
||
if (topKeywords && Array.isArray(topKeywords) && topKeywords.length > 0) {
|
||
formData.append('top_keywords', JSON.stringify(topKeywords));
|
||
}
|
||
const response = await aiApiClient.post('/api/podcast/avatar/generate', formData, {
|
||
headers: { 'Content-Type': 'multipart/form-data' },
|
||
});
|
||
return response.data;
|
||
},
|
||
|
||
async makeAvatarPresentable(avatarUrl: string, projectId?: string): Promise<{ avatar_url: string; avatar_filename: string }> {
|
||
const formData = new FormData();
|
||
formData.append('avatar_url', avatarUrl);
|
||
if (projectId) {
|
||
formData.append('project_id', projectId);
|
||
}
|
||
const response = await aiApiClient.post('/api/podcast/avatar/make-presentable', formData, {
|
||
headers: { 'Content-Type': 'multipart/form-data' },
|
||
});
|
||
return response.data;
|
||
},
|
||
|
||
async generateBatchAudio(params: {
|
||
scenes: { id: string; title: string; lines: { text: string }[] }[];
|
||
voiceId: string;
|
||
customVoiceId?: string;
|
||
speed: number;
|
||
emotion: string;
|
||
englishNormalization?: boolean;
|
||
projectId?: string;
|
||
}): Promise<{ results: any[] }> {
|
||
await ensurePreflight({
|
||
provider: "wavespeed",
|
||
operation_type: "tts_generation",
|
||
tokens_requested: 1000,
|
||
actual_provider_name: "wavespeed",
|
||
});
|
||
const response = await aiApiClient.post('/api/podcast/audio/batch', params);
|
||
return response.data;
|
||
},
|
||
|
||
async generateChartPreview(params: {
|
||
chart_data: Record<string, any>;
|
||
chart_type: string;
|
||
title: string;
|
||
}): Promise<{ image_url: string; preview_url: string; chart_id: string }> {
|
||
const response = await aiApiClient.post('/api/podcast/chart/preview', params);
|
||
return response.data;
|
||
},
|
||
};
|
||
|
||
export type PodcastApi = typeof podcastApi;
|