vidspotai-shared 1.0.82 → 1.0.83

package/lib/services/agent/tools/index.d.ts

@@ -5,12 +5,16 @@
 export * from "./searchStock.tool";
 export * from "./generateImage.tool";
 export * from "./generateVideo.tool";
+export * from "./extendVideo.tool";
 export * from "./generateVoiceover.tool";
 export * from "./generateCaptions.tool";
 export * from "./animateImage.tool";
 export * from "./animateImageWithMotionBrush.tool";
 export * from "./generateAvatarVideo.tool";
 export * from "./planVideo.tool";
+export * from "./generateScript.tool";
+export * from "./chapterOutline.tool";
+export * from "./matchBrollToScript.tool";
 export * from "./composeScene.tool";
 export * from "./render.tool";
 export * from "./analyzeReference.tool";

package/lib/services/agent/tools/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/lib/services/agent/tools/index.js

@@ -21,12 +21,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./searchStock.tool"), exports);
 __exportStar(require("./generateImage.tool"), exports);
 __exportStar(require("./generateVideo.tool"), exports);
+__exportStar(require("./extendVideo.tool"), exports);
 __exportStar(require("./generateVoiceover.tool"), exports);
 __exportStar(require("./generateCaptions.tool"), exports);
 __exportStar(require("./animateImage.tool"), exports);
 __exportStar(require("./animateImageWithMotionBrush.tool"), exports);
 __exportStar(require("./generateAvatarVideo.tool"), exports);
 __exportStar(require("./planVideo.tool"), exports);
+__exportStar(require("./generateScript.tool"), exports);
+__exportStar(require("./chapterOutline.tool"), exports);
+__exportStar(require("./matchBrollToScript.tool"), exports);
 __exportStar(require("./composeScene.tool"), exports);
 __exportStar(require("./render.tool"), exports);
 __exportStar(require("./analyzeReference.tool"), exports);

package/lib/services/agent/tools/matchBrollToScript.tool.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { Aspect } from "../../../schemas/project.schema";
+import { LlmCaller } from "../llmCaller";
+import { ToolDefinition } from "../toolRegistry";
+declare const InputSchema: z.ZodObject<{
+    narration: z.ZodString;
+    aspect: z.ZodEnum<{
+        "9:16": "9:16";
+        "1:1": "1:1";
+        "4:5": "4:5";
+        "16:9": "16:9";
+    }>;
+    niche: z.ZodOptional<z.ZodString>;
+    startSceneIndex: z.ZodDefault<z.ZodNumber>;
+    wpm: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const BrollSceneSchema: z.ZodObject<{
+    sceneIndex: z.ZodNumber;
+    intent: z.ZodString;
+    prompt: z.ZodString;
+    voiceoverLine: z.ZodString;
+    strategy: z.ZodLiteral<"ai-image-to-video">;
+    durationMs: z.ZodNumber;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    scenes: z.ZodArray<z.ZodObject<{
+        sceneIndex: z.ZodNumber;
+        intent: z.ZodString;
+        prompt: z.ZodString;
+        voiceoverLine: z.ZodString;
+        strategy: z.ZodLiteral<"ai-image-to-video">;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BrollScene = z.infer<typeof BrollSceneSchema>;
+/**
+ * Pure core, shared by the tool handler and the script-first planner (L-3).
+ */
+export declare function matchBrollToScriptCore(llm: LlmCaller, args: {
+    narration: string;
+    aspect: Aspect;
+    niche?: string;
+    startSceneIndex: number;
+    wpm?: number;
+}): Promise<{
+    scenes: BrollScene[];
+}>;
+export declare const matchBrollToScriptTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=matchBrollToScript.tool.d.ts.map

package/lib/services/agent/tools/matchBrollToScript.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchBrollToScript.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/matchBrollToScript.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,MAAM,EAAgB,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAIzC,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAkB/D,QAAA,MAAM,WAAW;;;;;;;;;;;iBAef,CAAC;AAyBH,QAAA,MAAM,gBAAgB;;;;;;;iBASpB,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;iBAEhB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,SAAS,EACd,IAAI,EAAE;IACJ,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GACA,OAAO,CAAC;IAAE,MAAM,EAAE,UAAU,EAAE,CAAA;CAAE,CAAC,CAmDnC;AAED,eAAO,MAAM,sBAAsB,EAAE,cAAc,CACjD,OAAO,WAAW,EAClB,OAAO,YAAY,CAoBpB,CAAC"}

package/lib/services/agent/tools/matchBrollToScript.tool.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchBrollToScriptTool = void 0;
+exports.matchBrollToScriptCore = matchBrollToScriptCore;
+const zod_1 = require("zod");
+const project_schema_1 = require("../../../schemas/project.schema");
+const llmCallerRegistry_1 = require("../llmCallerRegistry");
+const modelRouter_1 = require("../modelRouter");
+const ttsDuration_1 = require("../ttsDuration");
+const toolRegistry_1 = require("../toolRegistry");
+/**
+ * Stream L (L-4) — match_broll_to_script. Third pass of script-first authoring:
+ * explodes ONE chapter's narration into a sequence of B-roll scenes. Each scene
+ * pairs a VERBATIM sentence-boundary slice of the narration (the voiceoverLine)
+ * with a concrete B-roll visual prompt that illustrates it. Run once per chapter
+ * (from chapter_outline); the orchestrator (L-3) concatenates the per-chapter
+ * scene lists into the plan and back-fills chapter.sceneIndices.
+ *
+ * Durations are computed deterministically from the voiceoverLine's TTS length
+ * (estimateTtsMs) clamped to the long-form 3-8s band — the model only writes
+ * the visual prompt + chooses the sentence grouping, it does NOT set durations.
+ */
+const LONGFORM_MIN_MS = 3000;
+const LONGFORM_MAX_MS = 8000;
+const InputSchema = zod_1.z.object({
+    narration: zod_1.z
+        .string()
+        .min(1)
+        .describe("A single chapter's narration text (verbatim slice of the script)."),
+    aspect: project_schema_1.AspectSchema.describe("Target aspect ratio — steers the visual prompts."),
+    niche: zod_1.z.string().optional().describe("Brief niche, for visual style steering."),
+    /**
+     * sceneIndex to assign to the FIRST scene of this chapter; subsequent scenes
+     * increment from here. Lets the orchestrator keep indices globally unique and
+     * contiguous across chapters.
+     */
+    startSceneIndex: zod_1.z.number().int().nonnegative().default(0),
+    /** wpm for duration estimates; defaults to TTS calibration. */
+    wpm: zod_1.z.number().int().positive().optional(),
+});
+/** The model groups sentences + writes visuals; we stamp index + duration. */
+const LlmBrollSchema = zod_1.z.object({
+    scenes: zod_1.z
+        .array(zod_1.z.object({
+        voiceoverLine: zod_1.z
+            .string()
+            .describe("One or a few consecutive sentences from the narration, VERBATIM. Concatenating all scenes' voiceoverLines in order must reproduce the chapter narration exactly."),
+        intent: zod_1.z
+            .string()
+            .describe("One-line plain-English description of what this scene shows."),
+        prompt: zod_1.z
+            .string()
+            .describe("A concrete B-roll visual prompt that illustrates the voiceoverLine — subject, setting, lighting, camera. Describe the VISUAL, not the words."),
+    }))
+        .min(1),
+});
+const BrollSceneSchema = zod_1.z.object({
+    sceneIndex: zod_1.z.number().int().nonnegative(),
+    intent: zod_1.z.string(),
+    prompt: zod_1.z.string(),
+    voiceoverLine: zod_1.z.string(),
+    /** Strategy hint — long-form B-roll defaults to ai-image-to-video. */
+    strategy: zod_1.z.literal("ai-image-to-video"),
+    /** TTS-derived duration, clamped to the long-form 3-8s band. */
+    durationMs: zod_1.z.number().int().positive(),
+});
+const OutputSchema = zod_1.z.object({
+    scenes: zod_1.z.array(BrollSceneSchema),
+});
+/**
+ * Pure core, shared by the tool handler and the script-first planner (L-3).
+ */
+async function matchBrollToScriptCore(llm, args) {
+    const router = new modelRouter_1.ModelRouter();
+    const wpm = args.wpm ?? ttsDuration_1.TTS_DEFAULT_WPM;
+    const system = [
+        "You are a video editor matching B-roll to narration. Split the chapter",
+        "narration into a sequence of short scenes. For each scene: (1) copy one or",
+        "a few CONSECUTIVE sentences VERBATIM as the voiceoverLine — together they",
+        "must reproduce the whole chapter narration with nothing added or dropped;",
+        "(2) write a concrete B-roll visual prompt illustrating that line. Prefer",
+        "one scene per sentence or two; aim for ~3-8s of speech per scene. Visuals",
+        "should vary shot-to-shot (don't repeat the same composition).",
+    ].join(" ");
+    const user = [
+        `Target aspect: ${args.aspect}.`,
+        args.niche ? `Niche: ${args.niche}.` : "",
+        "",
+        "CHAPTER NARRATION:",
+        args.narration,
+    ]
+        .filter(Boolean)
+        .join("\n");
+    const res = await llm.structured({
+        model: router.pickFor("planner"),
+        fallbackModel: router.fallbackFor("planner"),
+        schema: LlmBrollSchema,
+        schemaName: "BrollScenes",
+        messages: [
+            { role: "system", content: system },
+            { role: "user", content: user },
+        ],
+        temperature: 0.6,
+        maxTokens: 8000,
+    });
+    const scenes = res.data.scenes.map((s, i) => {
+        const raw = (0, ttsDuration_1.estimateTtsMs)(s.voiceoverLine, wpm);
+        const durationMs = Math.min(LONGFORM_MAX_MS, Math.max(LONGFORM_MIN_MS, raw));
+        return {
+            sceneIndex: args.startSceneIndex + i,
+            intent: s.intent,
+            prompt: s.prompt,
+            voiceoverLine: s.voiceoverLine.trim(),
+            strategy: "ai-image-to-video",
+            durationMs,
+        };
+    });
+    return { scenes };
+}
+exports.matchBrollToScriptTool = {
+    name: "match_broll_to_script",
+    description: [
+        "Explode one chapter's narration into B-roll scenes: each scene = a verbatim",
+        "sentence slice (voiceoverLine) + a visual prompt. Third pass of script-first",
+        "authoring, run once per chapter from chapter_outline. Durations are computed",
+        "from TTS length (3-8s band), not chosen by the model.",
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: false,
+    handler: async (input) => matchBrollToScriptCore((0, llmCallerRegistry_1.getLlmCaller)(), {
+        narration: input.narration,
+        aspect: input.aspect,
+        niche: input.niche,
+        startSceneIndex: input.startSceneIndex,
+        wpm: input.wpm,
+    }),
+};
+(0, toolRegistry_1.registerTool)(exports.matchBrollToScriptTool);

package/lib/services/agent/tools/planVideo.tool.d.ts

@@ -55,6 +55,14 @@ declare const InputSchema: z.ZodObject<{
             "4:5": "4:5";
             "16:9": "16:9";
         }>>;
+        lengthTier: z.ZodOptional<z.ZodEnum<{
+            S1: "S1";
+            S2: "S2";
+            M1: "M1";
+            L1: "L1";
+            L2: "L2";
+            L3: "L3";
+        }>>;
         voice: z.ZodOptional<z.ZodObject<{
             gender: z.ZodOptional<z.ZodEnum<{
                 male: "male";
@@ -114,12 +122,14 @@ declare const InputSchema: z.ZodObject<{
                 transcriptExcerpt: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>>>;
+        preferredModelKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
         tierBudget: z.ZodDefault<z.ZodEnum<{
             T0: "T0";
             T1: "T1";
             T2: "T2";
             T3: "T3";
         }>>;
+        maxSpendUSD: z.ZodOptional<z.ZodNumber>;
         videoStrategy: z.ZodOptional<z.ZodEnum<{
             auto: "auto";
             direct: "direct";
@@ -151,6 +161,14 @@ declare const OutputSchema: z.ZodObject<{
         }>;
         totalDurationMs: z.ZodNumber;
         totalEstimatedCredits: z.ZodNumber;
+        lengthTier: z.ZodOptional<z.ZodEnum<{
+            S1: "S1";
+            S2: "S2";
+            M1: "M1";
+            L1: "L1";
+            L2: "L2";
+            L3: "L3";
+        }>>;
         scenes: z.ZodArray<z.ZodObject<{
             sceneIndex: z.ZodNumber;
             intent: z.ZodString;
@@ -175,7 +193,15 @@ declare const OutputSchema: z.ZodObject<{
             prompt: z.ZodString;
             durationMs: z.ZodNumber;
             voiceoverLine: z.ZodOptional<z.ZodString>;
+            autoCaptions: z.ZodOptional<z.ZodBoolean>;
             voiceStyle: z.ZodOptional<z.ZodString>;
+            captionStyle: z.ZodOptional<z.ZodObject<{
+                fontFamily: z.ZodOptional<z.ZodString>;
+                fontSize: z.ZodOptional<z.ZodNumber>;
+                fontWeight: z.ZodOptional<z.ZodNumber>;
+                color: z.ZodOptional<z.ZodString>;
+                highlightColor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
             onScreenText: z.ZodOptional<z.ZodString>;
             overlays: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 text: z.ZodString;
@@ -250,6 +276,7 @@ declare const OutputSchema: z.ZodObject<{
             avatarFaceUrl: z.ZodOptional<z.ZodString>;
             characterAnchorSceneIndex: z.ZodOptional<z.ZodNumber>;
             bibleEntityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            lastFramePrompt: z.ZodOptional<z.ZodString>;
             allowTrailingSilence: z.ZodOptional<z.ZodBoolean>;
             layout: z.ZodOptional<z.ZodObject<{
                 composition: z.ZodEnum<{
@@ -273,6 +300,28 @@ declare const OutputSchema: z.ZodObject<{
                     gradient: "gradient";
                 }>>;
             }, z.core.$strip>>;
+            broll: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                assetUrl: z.ZodString;
+                kind: z.ZodDefault<z.ZodEnum<{
+                    image: "image";
+                    video: "video";
+                }>>;
+                startMs: z.ZodDefault<z.ZodNumber>;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        chapters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            narration: z.ZodOptional<z.ZodString>;
+            estimatedDurationMs: z.ZodOptional<z.ZodNumber>;
+            sceneIndices: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>>>;
+        script: z.ZodOptional<z.ZodObject<{
+            fullText: z.ZodString;
+            wordCount: z.ZodOptional<z.ZodNumber>;
+            estimatedDurationMs: z.ZodOptional<z.ZodNumber>;
+            wpm: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
         music: z.ZodOptional<z.ZodObject<{
             strategy: z.ZodEnum<{
@@ -292,6 +341,13 @@ declare const OutputSchema: z.ZodObject<{
         voiceId: z.ZodOptional<z.ZodString>;
         voiceStyle: z.ZodOptional<z.ZodString>;
         notes: z.ZodOptional<z.ZodString>;
+        captionStyle: z.ZodOptional<z.ZodObject<{
+            fontFamily: z.ZodOptional<z.ZodString>;
+            fontSize: z.ZodOptional<z.ZodNumber>;
+            fontWeight: z.ZodOptional<z.ZodNumber>;
+            color: z.ZodOptional<z.ZodString>;
+            highlightColor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
         bible: z.ZodOptional<z.ZodObject<{
             characters: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;

package/lib/services/agent/tools/planVideo.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"planVideo.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/planVideo.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAQ/D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAExD;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEhB,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,cAAc,CACxC,OAAO,WAAW,EAClB,OAAO,YAAY,CAuBpB,CAAC"}
+{"version":3,"file":"planVideo.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/planVideo.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAQ/D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAExD;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEhB,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,cAAc,CACxC,OAAO,WAAW,EAClB,OAAO,YAAY,CAuBpB,CAAC"}

package/lib/services/agent/tools/planVideo.tool.js

@@ -8,9 +8,9 @@ const videoPlan_schema_1 = require("../../../schemas/videoPlan.schema");
 const planner_1 = require("../planner");
 const toolRegistry_1 = require("../toolRegistry");
 /**
- * The Planner needs an LlmCaller, which is host-wired (Vercel AI Gateway /
- * OpenRouter). The tool layer is host-agnostic, so we expose a setter that
- * the host calls once at boot. Until set, the tool errors loudly.
+ * The Planner needs an LlmCaller, which is host-wired (the native
+ * ProviderRoutingLlmCaller). The tool layer is host-agnostic, so we expose a
+ * setter that the host calls once at boot. Until set, the tool errors loudly.
  */
 let injectedLlm = null;
 function setPlannerLlmCaller(llm) {

package/lib/services/agent/tools/render.tool.d.ts

@@ -98,6 +98,10 @@ declare const InputSchema: z.ZodObject<{
                 assetHash: z.ZodOptional<z.ZodString>;
                 creditsSpent: z.ZodOptional<z.ZodNumber>;
                 generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
             effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -154,6 +158,10 @@ declare const InputSchema: z.ZodObject<{
                 assetHash: z.ZodOptional<z.ZodString>;
                 creditsSpent: z.ZodOptional<z.ZodNumber>;
                 generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
             effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -202,6 +210,10 @@ declare const InputSchema: z.ZodObject<{
                 assetHash: z.ZodOptional<z.ZodString>;
                 creditsSpent: z.ZodOptional<z.ZodNumber>;
                 generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
             effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -253,6 +265,10 @@ declare const InputSchema: z.ZodObject<{
                 assetHash: z.ZodOptional<z.ZodString>;
                 creditsSpent: z.ZodOptional<z.ZodNumber>;
                 generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
             effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -280,6 +296,7 @@ declare const InputSchema: z.ZodObject<{
             }, z.core.$strip>>>;
             fontFamily: z.ZodDefault<z.ZodString>;
             fontSize: z.ZodDefault<z.ZodNumber>;
+            fontWeight: z.ZodOptional<z.ZodNumber>;
             color: z.ZodDefault<z.ZodString>;
             highlightColor: z.ZodOptional<z.ZodString>;
             language: z.ZodDefault<z.ZodString>;
@@ -303,6 +320,10 @@ declare const InputSchema: z.ZodObject<{
                 assetHash: z.ZodOptional<z.ZodString>;
                 creditsSpent: z.ZodOptional<z.ZodNumber>;
                 generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
             effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;

package/lib/services/agent/tools/render.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/render.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IACvC,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;CAC3C,KAAK,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAGvC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,CAE5D;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,QAAA,MAAM,YAAY;;;iBAGhB,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,cAAc,CACrC,OAAO,WAAW,EAClB,OAAO,YAAY,CA2BpB,CAAC"}
+{"version":3,"file":"render.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/render.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IACvC,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;CAC3C,KAAK,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAGvC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,CAE5D;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,QAAA,MAAM,YAAY;;;iBAGhB,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,cAAc,CACrC,OAAO,WAAW,EAClB,OAAO,YAAY,CA2BpB,CAAC"}

package/lib/services/aiGen/aiGenFactory.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aiGenFactory.service.d.ts","sourceRoot":"","sources":["../../../src/services/aiGen/aiGenFactory.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EACL,iBAAiB,EAEjB,eAAe,EACf,aAAa,EACb,cAAc,EACd,eAAe,EACf,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAahC,KAAK,uBAAuB,GAAG,UAAU,wBAAwB,CAAC;AAElE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CA+DxB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,iBAAiB,EACjB,uBAAuB,CA2CxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CAMxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,aAAa,EACb,uBAAuB,CAGxB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,uBAAuB,CAQzE,CAAC;AAEJ,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,WAAW,GACpB,wBAAwB,CAkB1B"}
+{"version":3,"file":"aiGenFactory.service.d.ts","sourceRoot":"","sources":["../../../src/services/aiGen/aiGenFactory.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EACL,iBAAiB,EAEjB,eAAe,EACf,aAAa,EACb,cAAc,EACd,eAAe,EACf,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAchC,KAAK,uBAAuB,GAAG,UAAU,wBAAwB,CAAC;AAElE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CA+DxB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,iBAAiB,EACjB,uBAAuB,CA2CxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CAMxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,aAAa,EACb,uBAAuB,CAGxB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,uBAAuB,CAsBzE,CAAC;AAEJ,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,WAAW,GACpB,wBAAwB,CAkB1B"}

package/lib/services/aiGen/aiGenFactory.service.js

@@ -13,6 +13,7 @@ const alibaba_1 = require("./providers/alibaba/alibaba");
 const pixverse_service_1 = require("./providers/pixverse/pixverse.service");
 const bytedance_service_1 = require("./providers/bytedance/bytedance.service");
 const elevenlabs_service_1 = require("./providers/elevenlabs/elevenlabs.service");
+const anthropic_service_1 = require("./providers/anthropic/anthropic.service");
 exports.videoServicesMap = {
     // --- Pixverse ---
     "pixverse-v6": pixverse_service_1.PixVerseService,
@@ -134,12 +135,26 @@ exports.sfxServicesMap = {
     [aiModels_1.ESfxGenModels.ELEVENLABS_SOUND_EFFECTS]: elevenlabs_service_1.ElevenLabsAiGenService,
 };
 exports.textServicesMap = {
-    "openai-gpt-4o-mini": openai_service_1.OpenaiService,
+    // --- OpenAI ---
+    "openai-gpt-5.5": openai_service_1.OpenaiService,
+    "openai-gpt-5.4-mini": openai_service_1.OpenaiService,
     "openai-gpt-5-mini": openai_service_1.OpenaiService,
+    "openai-gpt-4o-mini": openai_service_1.OpenaiService,
+    // Native Anthropic / Gemini text-gen (LLM_NATIVE_MIGRATION_PLAN Phase 6).
+    // GoogleService gained a generateText() alongside its video/image/music
+    // methods; AnthropicService is text-only.
+    // --- Anthropic ---
+    "anthropic-claude-fable-5": anthropic_service_1.AnthropicService,
+    "anthropic-claude-opus-4-8": anthropic_service_1.AnthropicService,
+    "anthropic-claude-sonnet-4-6": anthropic_service_1.AnthropicService,
+    "anthropic-claude-haiku-4-5": anthropic_service_1.AnthropicService,
+    // --- Google ---
+    "google-gemini-3.5-flash": google_service_1.GoogleService,
+    "google-gemini-3.1-pro": google_service_1.GoogleService,
+    "google-gemini-2.5-flash": google_service_1.GoogleService,
+    "google-gemini-2.5-pro": google_service_1.GoogleService,
     // "openai-gpt-4o": OpenaiService,
     // "openai-gpt-3.5-turbo": OpenaiService,
-    // "anthropic-claude-3": ClaudeService,
-    // "anthropic-claude-instant-100k": ClaudeService,
 };
 function getAiGenProviderService(modelKey) {
     if (modelKey in exports.videoServicesMap) {

package/lib/services/aiGen/providers/anthropic/anthropic.service.d.ts

@@ -0,0 +1,26 @@
+import { BaseAiGenProviderService } from "../baseAiGenProvider.service";
+import { TextGenerationParams, TextGenerationResult } from "../types";
+/**
+ * Native Anthropic text-gen service for the aiGen text factory
+ * (LLM_NATIVE_MIGRATION_PLAN Phase 6). Anthropic is text-only in our stack, so
+ * this service implements `generateText` only — every other capability falls
+ * through to BaseAiGenProviderService's throw.
+ *
+ * Mirrors OpenaiService.generateText's contract: accepts a bare prompt string
+ * or an OpenAI-style message array (role + string content). System messages
+ * fold into Anthropic's top-level `system`; the rest map to user/assistant
+ * turns. Reads ANTHROPIC_API_KEY (same key the agent AnthropicLlmCaller uses).
+ */
+export declare class AnthropicService extends BaseAiGenProviderService {
+    private client;
+    constructor();
+    generateText(params: TextGenerationParams): Promise<TextGenerationResult>;
+    /**
+     * Map an OpenAI-style `input` (string | {role, content}[]) onto Anthropic's
+     * shape: a top-level `system` string + user/assistant MessageParam[]. Array
+     * `content` (vision parts) is flattened to its text segments — the text
+     * factory is text-only; image inputs go through the agent AnthropicLlmCaller.
+     */
+    private encodeTextInput;
+}
+//# sourceMappingURL=anthropic.service.d.ts.map

package/lib/services/aiGen/providers/anthropic/anthropic.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/anthropic/anthropic.service.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,qBAAa,gBAAiB,SAAQ,wBAAwB;IAC5D,OAAO,CAAC,MAAM,CAAY;;IAOpB,YAAY,CAChB,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,oBAAoB,CAAC;IAuChC;;;;;OAKG;IACH,OAAO,CAAC,eAAe;CAuCxB"}

package/lib/services/aiGen/providers/anthropic/anthropic.service.js

@@ -0,0 +1,95 @@
+"use strict";
+// anthropic.service.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicService = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const aiModels_1 = require("../../../../globals/aiModels");
+const baseAiGenProvider_service_1 = require("../baseAiGenProvider.service");
+/**
+ * Native Anthropic text-gen service for the aiGen text factory
+ * (LLM_NATIVE_MIGRATION_PLAN Phase 6). Anthropic is text-only in our stack, so
+ * this service implements `generateText` only — every other capability falls
+ * through to BaseAiGenProviderService's throw.
+ *
+ * Mirrors OpenaiService.generateText's contract: accepts a bare prompt string
+ * or an OpenAI-style message array (role + string content). System messages
+ * fold into Anthropic's top-level `system`; the rest map to user/assistant
+ * turns. Reads ANTHROPIC_API_KEY (same key the agent AnthropicLlmCaller uses).
+ */
+class AnthropicService extends baseAiGenProvider_service_1.BaseAiGenProviderService {
+    constructor() {
+        super();
+        this.client = new sdk_1.default({ apiKey: process.env.ANTHROPIC_API_KEY });
+    }
+    async generateText(params) {
+        const { input, modelKey, options } = params;
+        const model = aiModels_1.aiModelConfigs[modelKey];
+        const modelId = model?.modelId || "claude-haiku-4-5";
+        const { system, messages } = this.encodeTextInput(input);
+        // Anthropic requires max_tokens; fall back to the config default.
+        const maxTokens = (typeof options?.maxOutputTokens === "number"
+            ? options.maxOutputTokens
+            : undefined) ??
+            (typeof model?.fields?.maxOutputTokens?.default === "number"
+                ? model.fields.maxOutputTokens.default
+                : 4096);
+        const temperature = model?.fields?.temperature?.default
+            ? options?.temperature ?? model.fields.temperature.default
+            : undefined;
+        const msg = await this.client.messages.create({
+            model: modelId,
+            max_tokens: maxTokens,
+            messages,
+            ...(system ? { system } : {}),
+            ...(typeof temperature === "number" ? { temperature } : {}),
+        });
+        const text = msg.content
+            .filter((b) => b.type === "text")
+            .map((b) => b.text)
+            .join("")
+            .trim() || "No response";
+        return { text };
+    }
+    /**
+     * Map an OpenAI-style `input` (string | {role, content}[]) onto Anthropic's
+     * shape: a top-level `system` string + user/assistant MessageParam[]. Array
+     * `content` (vision parts) is flattened to its text segments — the text
+     * factory is text-only; image inputs go through the agent AnthropicLlmCaller.
+     */
+    encodeTextInput(input) {
+        if (typeof input === "string") {
+            return { messages: [{ role: "user", content: input }] };
+        }
+        const raw = Array.isArray(input)
+            ? input
+            : [];
+        let system;
+        const messages = [];
+        for (const m of raw) {
+            const text = typeof m.content === "string"
+                ? m.content
+                : Array.isArray(m.content)
+                    ? m.content
+                        .map((p) => p?.text ?? "")
+                        .join("")
+                    : String(m.content ?? "");
+            if (m.role === "system") {
+                system = system ? `${system}\n\n${text}` : text;
+                continue;
+            }
+            const role = m.role === "assistant" ? "assistant" : "user";
+            messages.push({ role, content: text });
+        }
+        // Anthropic rejects an empty messages array — guarantee at least one turn.
+        if (messages.length === 0) {
+            messages.push({ role: "user", content: system ?? "" });
+            if (system)
+                system = undefined;
+        }
+        return { system, messages };
+    }
+}
+exports.AnthropicService = AnthropicService;

package/lib/services/aiGen/providers/google/google.service.d.ts

@@ -1,10 +1,28 @@
 import { BaseAiGenProviderService } from "../baseAiGenProvider.service";
-import { CreditUsageParams, ImageGenerationParams, ImageGenerationResult, MusicGenerationParams, MusicGenerationResult, VideoGenerationParams, VideoGenerationResult, VideoStatusParams, VideoStatusResult } from "../types";
+import { CreditUsageParams, ImageGenerationParams, ImageGenerationResult, MusicGenerationParams, MusicGenerationResult, TextGenerationParams, TextGenerationResult, VideoGenerationParams, VideoGenerationResult, VideoStatusParams, VideoStatusResult } from "../types";
 export declare class GoogleService extends BaseAiGenProviderService {
     private ai;
     private keyPool;
     private static readonly MAX_RETRY_ATTEMPTS;
     constructor();
+    /**
+     * Plain text generation via Gemini (`@google/genai` generateContent) for the
+     * aiGen text factory (LLM_NATIVE_MIGRATION_PLAN Phase 6). Accepts the same
+     * `input` shape as OpenaiService.generateText — a bare prompt string or an
+     * OpenAI-style message array (role + string content). System messages fold
+     * into Gemini's `systemInstruction`; assistant turns map to the "model" role.
+     * `options.responseFormat` of type json_object/json_schema flips on Gemini's
+     * native JSON mode (responseMimeType) so callers asking OpenAI for JSON get
+     * the same contract here.
+     */
+    generateText(params: TextGenerationParams): Promise<TextGenerationResult>;
+    /**
+     * Map an OpenAI-style `input` (string | {role, content}[]) onto Gemini's
+     * shape: merged systemInstruction + Content[] (assistant→"model"). Array
+     * `content` (vision parts) is flattened to its text segments — the text
+     * factory is text-only; image inputs go through the agent GeminiLlmCaller.
+     */
+    private encodeTextInput;
     /**
      * Retries `fn` on transient network errors (undici "fetch failed", ECONNRESET, ETIMEDOUT,
      * DNS hiccups, etc.) with exponential backoff: 1s → 2s → 4s. Non-network errors
@@ -22,6 +40,11 @@ export declare class GoogleService extends BaseAiGenProviderService {
      *
      * Required env: GCP_PROJECT_ID. Optional: GCP_LOCATION (default us-central1).
      */
+    /**
+     * Lyria 2 (Vertex AI) — delegates to the standalone generateGoogleMusic
+     * (Vertex predict endpoint via ADC, not the GoogleGenAI client). See
+     * ./googleMusic.
+     */
     generateMusic(params: MusicGenerationParams): Promise<MusicGenerationResult>;
     getCreditUsed({ modelKey, duration, resolution, multiClip, numImages, imageSize }: CreditUsageParams): number;
 }