vidspotai-shared 1.0.68 → 1.0.69-dev.0

package/lib/services/agent/eval/types.d.ts

@@ -0,0 +1,230 @@
+import { z } from "zod";
+/**
+ * Eval set + replay infrastructure.
+ *
+ * The eval harness exists so we can measure agent quality every time we change
+ * the planner prompt, the model routing, or a tool description — instead of
+ * shipping blind. Every interactive agent run is also recorded as a trace so it
+ * can be replayed offline against a candidate change.
+ *
+ * 50 hand-curated briefs target launch; a handful of seed briefs ship in code
+ * so the harness is runnable from day one.
+ */
+/** Rubric axes, scored 0-1 by the judge. */
+export declare const EvalRubricSchema: z.ZodObject<{
+    hookStrength: z.ZodNumber;
+    voVisualSync: z.ZodNumber;
+    pacingFit: z.ZodNumber;
+    brandSafety: z.ZodNumber;
+    costVsTier: z.ZodNumber;
+    intentMatch: z.ZodNumber;
+}, z.core.$strip>;
+export type EvalRubric = z.infer<typeof EvalRubricSchema>;
+export declare const EvalBriefSchema: z.ZodObject<{
+    id: z.ZodString;
+    niche: z.ZodString;
+    brief: z.ZodObject<{
+        rawPrompt: z.ZodString;
+        goal: z.ZodOptional<z.ZodString>;
+        niche: z.ZodOptional<z.ZodEnum<{
+            other: "other";
+            news: "news";
+            "ugc-ad": "ugc-ad";
+            "faceless-yt": "faceless-yt";
+            "product-demo": "product-demo";
+            "talking-head": "talking-head";
+            "social-recap": "social-recap";
+            "real-estate": "real-estate";
+            recipe: "recipe";
+            travel: "travel";
+            fitness: "fitness";
+            "podcast-clip": "podcast-clip";
+            education: "education";
+        }>>;
+        audience: z.ZodOptional<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            professional: "professional";
+            energetic: "energetic";
+            calm: "calm";
+            cinematic: "cinematic";
+            casual: "casual";
+            playful: "playful";
+            edgy: "edgy";
+            warm: "warm";
+            informational: "informational";
+        }>>;
+        hookStyle: z.ZodOptional<z.ZodEnum<{
+            question: "question";
+            "bold-claim": "bold-claim";
+            "pattern-interrupt": "pattern-interrupt";
+            story: "story";
+            stat: "stat";
+            demo: "demo";
+            "voiceover-only": "voiceover-only";
+        }>>;
+        pacing: z.ZodOptional<z.ZodEnum<{
+            medium: "medium";
+            fast: "fast";
+            slow: "slow";
+            "very-fast": "very-fast";
+        }>>;
+        durationSec: z.ZodOptional<z.ZodNumber>;
+        aspect: z.ZodOptional<z.ZodEnum<{
+            "9:16": "9:16";
+            "1:1": "1:1";
+            "4:5": "4:5";
+            "16:9": "16:9";
+        }>>;
+        voice: z.ZodOptional<z.ZodObject<{
+            gender: z.ZodOptional<z.ZodEnum<{
+                male: "male";
+                female: "female";
+                neutral: "neutral";
+            }>>;
+            ageRange: z.ZodOptional<z.ZodEnum<{
+                child: "child";
+                teen: "teen";
+                "young-adult": "young-adult";
+                adult: "adult";
+                senior: "senior";
+            }>>;
+            accent: z.ZodOptional<z.ZodString>;
+            language: z.ZodDefault<z.ZodString>;
+            voiceId: z.ZodOptional<z.ZodString>;
+            style: z.ZodOptional<z.ZodEnum<{
+                energetic: "energetic";
+                calm: "calm";
+                casual: "casual";
+                warm: "warm";
+                neutral: "neutral";
+                excited: "excited";
+                happy: "happy";
+                serious: "serious";
+                dramatic: "dramatic";
+                whisper: "whisper";
+            }>>;
+        }, z.core.$strip>>;
+        music: z.ZodOptional<z.ZodObject<{
+            moods: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                energetic: "energetic";
+                calm: "calm";
+                cinematic: "cinematic";
+                playful: "playful";
+                uplifting: "uplifting";
+                tense: "tense";
+                dreamy: "dreamy";
+                dark: "dark";
+            }>>>;
+            bpmMin: z.ZodOptional<z.ZodNumber>;
+            bpmMax: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        cta: z.ZodOptional<z.ZodString>;
+        claims: z.ZodDefault<z.ZodObject<{
+            allow: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            block: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        references: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            analyzed: z.ZodOptional<z.ZodObject<{
+                durationMs: z.ZodNumber;
+                sceneCount: z.ZodNumber;
+                hookMs: z.ZodNumber;
+                cutsPerSecond: z.ZodNumber;
+                bpm: z.ZodOptional<z.ZodNumber>;
+                transcriptExcerpt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        tierBudget: z.ZodDefault<z.ZodEnum<{
+            T0: "T0";
+            T1: "T1";
+            T2: "T2";
+            T3: "T3";
+        }>>;
+        videoStrategy: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            direct: "direct";
+            indirect: "indirect";
+        }>>;
+        consistencyTier: z.ZodOptional<z.ZodEnum<{
+            C0: "C0";
+            C1: "C1";
+            C2: "C2";
+        }>>;
+        confidence: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>;
+    goodOutputNotes: z.ZodString;
+}, z.core.$strip>;
+export type EvalBrief = z.infer<typeof EvalBriefSchema>;
+export declare const ToolCallTraceSchema: z.ZodObject<{
+    ts: z.ZodNumber;
+    tool: z.ZodString;
+    input: z.ZodUnknown;
+    outcome: z.ZodUnion<readonly [z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        output: z.ZodUnknown;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<false>;
+        error: z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export type ToolCallTrace = z.infer<typeof ToolCallTraceSchema>;
+/** C46 — wall-clock span for a single agent pipeline stage. */
+export declare const StageTimingSchema: z.ZodObject<{
+    stage: z.ZodString;
+    startedAt: z.ZodNumber;
+    durationMs: z.ZodNumber;
+}, z.core.$strip>;
+export type StageTiming = z.infer<typeof StageTimingSchema>;
+export declare const AgentRunTraceSchema: z.ZodObject<{
+    agentRunId: z.ZodString;
+    briefId: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodString;
+    endedAt: z.ZodOptional<z.ZodString>;
+    modelRouting: z.ZodRecord<z.ZodString, z.ZodString>;
+    rngSeed: z.ZodString;
+    toolCalls: z.ZodArray<z.ZodObject<{
+        ts: z.ZodNumber;
+        tool: z.ZodString;
+        input: z.ZodUnknown;
+        outcome: z.ZodUnion<readonly [z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            output: z.ZodUnknown;
+            durationMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            ok: z.ZodLiteral<false>;
+            error: z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strip>;
+            durationMs: z.ZodNumber;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>>;
+    stageTimings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        stage: z.ZodString;
+        startedAt: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type AgentRunTrace = z.infer<typeof AgentRunTraceSchema>;
+export declare const EvalScoreSchema: z.ZodObject<{
+    briefId: z.ZodString;
+    agentRunId: z.ZodString;
+    rubric: z.ZodObject<{
+        hookStrength: z.ZodNumber;
+        voVisualSync: z.ZodNumber;
+        pacingFit: z.ZodNumber;
+        brandSafety: z.ZodNumber;
+        costVsTier: z.ZodNumber;
+        intentMatch: z.ZodNumber;
+    }, z.core.$strip>;
+    score: z.ZodNumber;
+    judgeNotes: z.ZodString;
+    scoredAt: z.ZodString;
+}, z.core.$strip>;
+export type EvalScore = z.infer<typeof EvalScoreSchema>;
+//# sourceMappingURL=types.d.ts.map

package/lib/services/agent/eval/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/eval/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;GAUG;AAEH,4CAA4C;AAC5C,eAAO,MAAM,gBAAgB;;;;;;;iBAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAY9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;iBAQ1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/lib/services/agent/eval/types.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvalScoreSchema = exports.AgentRunTraceSchema = exports.StageTimingSchema = exports.ToolCallTraceSchema = exports.EvalBriefSchema = exports.EvalRubricSchema = void 0;
+const zod_1 = require("zod");
+const brief_schema_1 = require("../../../schemas/brief.schema");
+/**
+ * Eval set + replay infrastructure.
+ *
+ * The eval harness exists so we can measure agent quality every time we change
+ * the planner prompt, the model routing, or a tool description — instead of
+ * shipping blind. Every interactive agent run is also recorded as a trace so it
+ * can be replayed offline against a candidate change.
+ *
+ * 50 hand-curated briefs target launch; a handful of seed briefs ship in code
+ * so the harness is runnable from day one.
+ */
+/** Rubric axes, scored 0-1 by the judge. */
+exports.EvalRubricSchema = zod_1.z.object({
+    hookStrength: zod_1.z.number().min(0).max(1),
+    voVisualSync: zod_1.z.number().min(0).max(1),
+    pacingFit: zod_1.z.number().min(0).max(1),
+    brandSafety: zod_1.z.number().min(0).max(1),
+    costVsTier: zod_1.z.number().min(0).max(1),
+    /** Did the result actually look like the niche/persona? Catches off-brief drift. */
+    intentMatch: zod_1.z.number().min(0).max(1),
+});
+exports.EvalBriefSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    niche: zod_1.z.string(),
+    brief: brief_schema_1.VideoBriefSchema,
+    /** Free-form rubric notes the judge prompt prepends — what "good" looks like for THIS brief. */
+    goodOutputNotes: zod_1.z.string(),
+});
+exports.ToolCallTraceSchema = zod_1.z.object({
+    ts: zod_1.z.number(),
+    tool: zod_1.z.string(),
+    input: zod_1.z.unknown(),
+    outcome: zod_1.z.union([
+        zod_1.z.object({ ok: zod_1.z.literal(true), output: zod_1.z.unknown(), durationMs: zod_1.z.number() }),
+        zod_1.z.object({
+            ok: zod_1.z.literal(false),
+            error: zod_1.z.object({ code: zod_1.z.string(), message: zod_1.z.string() }),
+            durationMs: zod_1.z.number(),
+        }),
+    ]),
+});
+/** C46 — wall-clock span for a single agent pipeline stage. */
+exports.StageTimingSchema = zod_1.z.object({
+    stage: zod_1.z.string(),
+    startedAt: zod_1.z.number(),
+    durationMs: zod_1.z.number(),
+});
+exports.AgentRunTraceSchema = zod_1.z.object({
+    agentRunId: zod_1.z.string(),
+    briefId: zod_1.z.string().optional(),
+    startedAt: zod_1.z.string().datetime(),
+    endedAt: zod_1.z.string().datetime().optional(),
+    modelRouting: zod_1.z.record(zod_1.z.string(), zod_1.z.string()),
+    /** Deterministic RNG seed so re-runs (with the same models + tool stubs) are reproducible. */
+    rngSeed: zod_1.z.string(),
+    toolCalls: zod_1.z.array(exports.ToolCallTraceSchema),
+    /** C46 — wall-clock per-stage timings; lets us distinguish slow-but-progressing from stuck. */
+    stageTimings: zod_1.z.array(exports.StageTimingSchema).optional(),
+});
+exports.EvalScoreSchema = zod_1.z.object({
+    briefId: zod_1.z.string(),
+    agentRunId: zod_1.z.string(),
+    rubric: exports.EvalRubricSchema,
+    /** Weighted aggregate; weights live in the harness. */
+    score: zod_1.z.number().min(0).max(1),
+    judgeNotes: zod_1.z.string(),
+    scoredAt: zod_1.z.string().datetime(),
+});

package/lib/services/agent/executor.d.ts

@@ -0,0 +1,141 @@
+import { PlannedScene, VideoPlan } from "../../schemas/videoPlan.schema";
+import { ToolContext, ToolOutcome } from "./toolRegistry";
+import { ProviderTaskCache, ProviderTaskCacheEntry } from "./providerTaskCache";
+export type RunToolFn = <O = unknown>(name: string, input: unknown, ctx: ToolContext) => Promise<ToolOutcome<O>>;
+/**
+ * Executor — turns an approved VideoPlan into per-scene asset results.
+ *
+ * Plan-then-execute split (not free-form ReAct): the executor does NOT pick
+ * tools. The plan dictates which tool runs per scene; the executor only does
+ * the dispatch + per-scene parallelism + idempotency-key generation.
+ *
+ * Returns a SceneOutcome per scene, leaving composition (compose_scene),
+ * critique (Critic.review), and render to the orchestrator above.
+ */
+export interface SceneAssetResult {
+    /** Concrete asset URL for the visual track (image or video). */
+    visualUrl?: string;
+    /** Voiceover audio (base64 or url depending on host policy). */
+    voiceoverAudioBase64?: string;
+    /**
+     * Resolved voiceover URL once the host has uploaded the base64 buffer to
+     * its asset store (GCS / Firebase Storage). The agent.controller flow
+     * sets this in `onSceneComplete` so `planToProject` can render a real VO
+     * clip on `track-vo`. When unset, planToProject skips the VO clip.
+     */
+    voiceoverUrl?: string;
+    /** Provider task id for async generations the host still needs to poll. */
+    pendingTaskId?: string;
+    /** Model key the pending task was triggered on — the poller needs this to pick the provider. */
+    pendingModelKey?: string;
+    /** AG-22: provider chain the tool walked (in order, primary first). For trace + post-mortem. */
+    attemptedProviders?: string[];
+    /** Tool name used. */
+    tool: string;
+    /** Idempotency key the executor minted; useful for retries. */
+    idempotencyKey: string;
+    /**
+     * AG-28: estimated VO duration (ms) from the wpm heuristic. Set when
+     * voiceoverAudioBase64 is set. Used pre-upload for budget math; the
+     * editor-side display window prefers voiceoverActualMs when available.
+     */
+    voiceoverEstimateMs?: number;
+    /**
+     * Probed actual mp3 duration (ms). Stamped by `resolveVoiceoverUrl` after
+     * generation, before the buffer is discarded. Reflects real playback
+     * length — required to size the editor VO clip's display window so
+     * Remotion's `endAt` doesn't truncate emotive/punctuated deliveries that
+     * the wpm estimate undershoots. Falls back to `voiceoverEstimateMs` when
+     * ffprobe is unavailable.
+     */
+    voiceoverActualMs?: number;
+    /**
+     * AG-28: TTS over-budget signal. True when the line + style produces audio
+     * longer than scene.durationMs * 1.05 even after the executor's atempo
+     * adjustment. Stitcher should freeze-frame-pad rather than clip.
+     */
+    voiceoverOverBudget?: boolean;
+}
+export interface SceneOutcome {
+    scene: PlannedScene;
+    ok: boolean;
+    result?: SceneAssetResult;
+    error?: {
+        code: string;
+        message: string;
+        /**
+         * Set when the failure came from a provider-fallback-wrapped tool whose
+         * entire chain exhausted (or terminated on auth/safety/input). Used by
+         * the orchestrator to decide between agent re-plan / scene degrade /
+         * hard fail.
+         */
+        classification?: "transient" | "rate_limit" | "capability" | "safety" | "auth" | "quota" | "input" | "unknown";
+        needsReplan?: boolean;
+        attemptedProviders?: string[];
+    };
+    durationMs: number;
+}
+/**
+ * Inspect a failed scene to decide the next orchestration step.
+ *
+ *   - "replan"  : agent should re-plan the scene (safety / bad input)
+ *   - "degrade" : try a cheaper strategy (e.g. T2/T3 chain exhausted on quota)
+ *   - "fail"    : terminal — surface to user (auth / chain-exhausted-unknown)
+ *   - "retry"   : transient — caller may re-run the scene as-is later
+ */
+export declare function classifySceneFailure(outcome: SceneOutcome): "replan" | "degrade" | "fail" | "retry" | null;
+export interface ExecutorOptions {
+    /** Max scenes to run in parallel. Generation providers rate-limit themselves; this guards on top. */
+    concurrency?: number;
+    /** Inject a recording wrapper (e.g. runToolRecorded) for eval / replay. */
+    runTool?: RunToolFn;
+    /**
+     * Stage 3 hook: invoked after each scene finishes (success OR failure).
+     * Lets the orchestrator stream incremental Project updates into Firestore
+     * so the editor + agent drawer surfaces light up as scenes complete,
+     * rather than waiting for the whole executor to finish. Errors thrown
+     * from the callback are swallowed (logged) so a Firestore blip can't
+     * crash the executor.
+     */
+    onSceneComplete?: (sceneIndex: number, outcome: SceneOutcome) => Promise<void>;
+    /**
+     * Stage 7 slice 1: provider task-id cache (read side). When the upstream
+     * inputs for animate_image / generate_video / generate_avatar_video hash
+     * to the same value as a cached entry (and entry is within TTL), the
+     * executor returns the cached taskId + modelKey and skips the tool call.
+     * /execute passes the project's cache here so re-runs after downstream
+     * (poll/stitch/critic) bugs reuse the prior $$ gens. /regenerate-scene
+     * deliberately omits this (user wants a fresh gen) but still mints.
+     */
+    taskCache?: ProviderTaskCache;
+    /**
+     * Stage 7 slice 1: cache write side. Invoked after a successful tool call
+     * that produced a pendingTaskId. Orchestrator persists the entry on the
+     * AgentProject doc so the NEXT execute can replay. Errors swallowed —
+     * cache is best-effort optimisation, not correctness.
+     */
+    onTaskMint?: (clipId: string, entry: ProviderTaskCacheEntry) => Promise<void>;
+}
+export declare class Executor {
+    private readonly concurrency;
+    private readonly runTool;
+    private readonly onSceneComplete?;
+    private readonly taskCache?;
+    private readonly onTaskMint?;
+    constructor(opts?: ExecutorOptions);
+    /**
+     * Stage 7 slice 1 helper. Returns cached pending-task output if the
+     * upstream input hash matches and entry is within TTL; null otherwise.
+     * Logs the hit so trace shows where $$ was saved.
+     */
+    private checkTaskCache;
+    /**
+     * Best-effort mint. Swallows callback errors — a Firestore blip must not
+     * fail the scene (the tool already succeeded and produced a real taskId).
+     */
+    private mintTaskCache;
+    run(plan: VideoPlan, ctx: ToolContext): Promise<SceneOutcome[]>;
+    private runScene;
+    private runVisual;
+}
+//# sourceMappingURL=executor.d.ts.map

package/lib/services/agent/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/services/agent/executor.ts"],"names":[],"mappings":"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"}