vidspotai-shared 1.0.68 → 1.0.69-dev.0

package/lib/services/agent/executor.js

@@ -0,0 +1,561 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Executor = void 0;
+exports.classifySceneFailure = classifySceneFailure;
+const voices_1 = require("../../globals/ttsModels/voices");
+const logger_1 = require("../../utils/logger");
+const referenceImageRenderer_1 = require("./referenceImageRenderer");
+const toolRegistry_1 = require("./toolRegistry");
+const ttsDuration_1 = require("./ttsDuration");
+const chains_1 = require("./providerFallback/chains");
+const providerTaskCache_1 = require("./providerTaskCache");
+/**
+ * AG-37: planners (LLMs) keep inventing voice IDs like "female-young-adult-en"
+ * or "narrator-1" that look reasonable but don't exist in any catalog. When
+ * those flow into ElevenLabs the API returns a 400 and the silent-fail VO
+ * outcome path drops the VO entirely — final video ships muted. Strip
+ * unknown IDs here so the provider falls back to its default voice instead.
+ */
+const ELEVENLABS_VOICE_IDS = new Set(voices_1.ELEVENLABS_VOICES.map((v) => v.id));
+function sanitizeVoiceId(voiceId) {
+    if (!voiceId)
+        return undefined;
+    if (ELEVENLABS_VOICE_IDS.has(voiceId))
+        return voiceId;
+    // Heuristic for non-ElevenLabs providers (openai = "alloy"/"echo"/..., minimax = "male-qn-qingse").
+    // Only strip strings that look like LLM-invented descriptive labels (contain a hyphen + recognisable word).
+    if (/^(female|male|narrator|presenter|voice)[-_]/i.test(voiceId)) {
+        logger_1.logger.warn("executor: stripping invalid voiceId (LLM hallucination)", { voiceId });
+        return undefined;
+    }
+    return voiceId;
+}
+/**
+ * AG-31: map a brief-level voice style adjective to ElevenLabs voice_settings.
+ * `style` is the exaggeration param (use sparingly above 0.5 — artifacts);
+ * `stability` is the consistency knob (low = more emotive, high = monotone);
+ * `speed` is rate (0.7-1.2). Defaults match ElevenLabs' own (style=0,
+ * stability=0.5, speed=1.0). Tuning per persona is conservative — we'd rather
+ * be slightly flat than artifact-laden.
+ */
+function resolveVoiceSettings(style) {
+    switch (style) {
+        case "calm":
+            return { style: 0.15, stability: 0.7, speed: 0.95 };
+        case "warm":
+            return { style: 0.25, stability: 0.6, speed: 1.0 };
+        case "casual":
+            return { style: 0.3, stability: 0.5, speed: 1.0 };
+        case "excited":
+            return { style: 0.55, stability: 0.35, speed: 1.05 };
+        case "energetic":
+            return { style: 0.6, stability: 0.35, speed: 1.08 };
+        case "happy":
+            return { style: 0.5, stability: 0.4, speed: 1.05 };
+        case "serious":
+            return { style: 0.2, stability: 0.75, speed: 0.95 };
+        case "dramatic":
+            return { style: 0.65, stability: 0.4, speed: 0.95 };
+        case "whisper":
+            return { style: 0.2, stability: 0.85, speed: 0.9 };
+        case "neutral":
+        case undefined:
+        default:
+            return {};
+    }
+}
+/**
+ * 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
+ */
+function classifySceneFailure(outcome) {
+    if (outcome.ok)
+        return null;
+    const c = outcome.error?.classification;
+    if (!c)
+        return "fail";
+    if (outcome.error?.needsReplan)
+        return "replan"; // safety / input
+    if (c === "auth")
+        return "fail";
+    if (c === "quota")
+        return "degrade";
+    if (c === "rate_limit" || c === "transient")
+        return "retry";
+    if (c === "capability")
+        return "degrade";
+    return "fail";
+}
+/**
+ * OD-T7 / AG-42 — give the planner's `preferredModel` a chance to actually run
+ * when the scene duration is just slightly off from what the model accepts.
+ *
+ * Decision tree:
+ *   1. Model has no duration constraint            → use planned duration
+ *   2. Planned duration already legal              → use planned duration
+ *   3. Nearest legal is within snap tolerance      → snap, log info
+ *   4. Outside tolerance + explicit preferredModel → log warn ("dropping
+ *      planner pick — too far from any allowed value"); use planned duration
+ *      anyway so the capability filter drops it and the chain fallback runs
+ *      (the withFallback warn AG-42 also logs there now)
+ *
+ * We intentionally do NOT throw — throwing would crash a scene mid-run and
+ * lose all the other planner output. The graceful fallback chain already
+ * exists; this helper just keeps the planner's pick alive when the drift is
+ * small, and makes the drop visible when it isn't.
+ */
+function resolveDurationForPreferredModel(modelKey, plannedDurationSec, explicit, sceneIndex) {
+    const snap = (0, chains_1.snapDurationForModel)(modelKey, plannedDurationSec);
+    if (!snap) {
+        if (explicit) {
+            logger_1.logger.warn("executor: preferredModel duration outside snap tolerance — chain fallback will pick", {
+                sceneIndex,
+                modelKey,
+                plannedDurationSec,
+            });
+        }
+        return plannedDurationSec;
+    }
+    if (snap.driftSec > 0.01) {
+        logger_1.logger.info("executor: snapped duration to fit preferredModel", {
+            sceneIndex,
+            modelKey,
+            from: snap.requestedSec,
+            to: snap.snappedSec,
+            driftSec: Number(snap.driftSec.toFixed(2)),
+        });
+    }
+    return snap.snappedSec;
+}
+class Executor {
+    constructor(opts = {}) {
+        this.concurrency = opts.concurrency ?? 4;
+        this.runTool = opts.runTool ?? toolRegistry_1.runTool;
+        this.onSceneComplete = opts.onSceneComplete;
+        this.taskCache = opts.taskCache;
+        this.onTaskMint = opts.onTaskMint;
+    }
+    /**
+     * 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.
+     */
+    checkTaskCache(clipId, tool, input) {
+        const inputsHash = (0, providerTaskCache_1.hashTaskInputs)(input);
+        const hit = (0, providerTaskCache_1.getCachedTask)(this.taskCache, clipId, inputsHash);
+        if (hit) {
+            logger_1.logger.info("executor: task-cache hit", {
+                clipId,
+                tool,
+                modelKey: hit.modelKey,
+                taskId: hit.taskId,
+                ageMs: Date.now() - hit.createdAt,
+            });
+        }
+        return { hit, inputsHash };
+    }
+    /**
+     * Best-effort mint. Swallows callback errors — a Firestore blip must not
+     * fail the scene (the tool already succeeded and produced a real taskId).
+     */
+    async mintTaskCache(clipId, entry) {
+        if (!this.onTaskMint)
+            return;
+        try {
+            await this.onTaskMint(clipId, entry);
+        }
+        catch (err) {
+            logger_1.logger.warn("executor: onTaskMint callback threw — swallowed", {
+                clipId,
+                err: err.message,
+            });
+        }
+    }
+    async run(plan, ctx) {
+        const queue = [...plan.scenes];
+        const results = new Array(plan.scenes.length);
+        const workers = [];
+        let cursor = 0;
+        const worker = async () => {
+            while (true) {
+                const i = cursor++;
+                if (i >= queue.length)
+                    return;
+                const scene = queue[i];
+                const outcome = await this.runScene(scene, ctx, plan.aspect, plan);
+                results[i] = outcome;
+                if (this.onSceneComplete) {
+                    try {
+                        await this.onSceneComplete(scene.sceneIndex, outcome);
+                    }
+                    catch (err) {
+                        logger_1.logger.warn("executor: onSceneComplete callback threw — swallowed", {
+                            sceneIndex: scene.sceneIndex,
+                            err: err.message,
+                        });
+                    }
+                }
+            }
+        };
+        for (let i = 0; i < Math.min(this.concurrency, queue.length); i++) {
+            workers.push(worker());
+        }
+        await Promise.all(workers);
+        return results;
+    }
+    async runScene(scene, ctx, aspect, plan) {
+        const start = Date.now();
+        const idempotencyKey = `${ctx.agentRunId}:scene-${scene.sceneIndex}`;
+        const sceneCtx = { ...ctx, idempotencyKey };
+        const visualOutcome = await this.runVisual(scene, sceneCtx, aspect, plan);
+        if (!visualOutcome.ok) {
+            return {
+                scene,
+                ok: false,
+                error: visualOutcome.error,
+                durationMs: Date.now() - start,
+            };
+        }
+        let voiceoverAudioBase64;
+        let voiceoverEstimateMs;
+        let voiceoverOverBudget = false;
+        // talking-head-avatar bakes the VO into the rendered MP4; running TTS again
+        // here would just waste credits and create a duplicate audio track.
+        if (scene.voiceoverLine && scene.strategy !== "talking-head-avatar") {
+            // AG-31: brief.voice.style → ElevenLabs voice_settings.
+            // AG-28: if estimated VO > scene.durationMs, speed up TTS within natural
+            // limits (≤1.15× extra over style.speed) before falling back to a
+            // freeze-frame-pad signal for the stitcher.
+            // AG-44: per-scene voiceStyle wins over plan-level when present, so the
+            // emotional arc can shift across the timeline (frustrated → curious → excited).
+            const effectiveVoiceStyle = (scene.voiceStyle ?? plan.voiceStyle);
+            const baseSettings = resolveVoiceSettings(effectiveVoiceStyle);
+            const baseSpeed = baseSettings.speed ?? 1.0;
+            const rawEstMs = (0, ttsDuration_1.estimateTtsMs)(scene.voiceoverLine);
+            const budgetMs = scene.durationMs * 1.05;
+            // Adjusted speed: only kick in if natural speech would overrun. Cap the
+            // speedup multiplier at 1.15× style-base; faster than that sounds rushed.
+            let speed = baseSpeed;
+            if (rawEstMs > budgetMs) {
+                const needed = rawEstMs / budgetMs;
+                const cappedMultiplier = Math.min(1.15, needed);
+                speed = +(baseSpeed * cappedMultiplier).toFixed(2);
+            }
+            const adjustedEstMs = rawEstMs * (baseSpeed / speed);
+            voiceoverEstimateMs = Math.round(adjustedEstMs);
+            voiceoverOverBudget = adjustedEstMs > budgetMs;
+            const voInput = {
+                text: scene.voiceoverLine,
+                ...baseSettings,
+                // Override speed when AG-28 budget forced an adjustment.
+                speed: +Math.max(0.7, Math.min(1.2, speed)).toFixed(2),
+            };
+            const sanitized = sanitizeVoiceId(plan.voiceId);
+            if (sanitized)
+                voInput.voiceId = sanitized;
+            const voOutcome = await this.runTool("generate_voiceover", voInput, { ...sceneCtx, idempotencyKey: `${idempotencyKey}:vo` });
+            if (voOutcome.ok) {
+                voiceoverAudioBase64 = voOutcome.output.audioBase64;
+            }
+            else {
+                // AG-37: don't swallow silently — final video shipping muted with no
+                // log was the original bug. Surface the error in the result so the
+                // trace shows WHY VO is missing.
+                logger_1.logger.warn("executor: voiceover tool failed", {
+                    sceneIndex: scene.sceneIndex,
+                    error: voOutcome.error,
+                    voiceIdRequested: plan.voiceId,
+                    voiceIdSent: sanitized,
+                });
+            }
+            // Don't fail the whole scene on VO miss — host can re-run just the VO.
+        }
+        return {
+            scene,
+            ok: true,
+            result: {
+                ...visualOutcome.output,
+                voiceoverAudioBase64,
+                voiceoverEstimateMs,
+                voiceoverOverBudget,
+                idempotencyKey,
+            },
+            durationMs: Date.now() - start,
+        };
+    }
+    async runVisual(scene, ctx, aspect, plan) {
+        const durationSec = Math.max(2, Math.round(scene.durationMs / 1000));
+        // AG-13: collect reference images for this scene's bible entities. Empty
+        // array when bible is C0/C1 or no entities are tagged — image-gen falls
+        // back to pure text prompt.
+        const referenceImageUrls = (0, referenceImageRenderer_1.collectReferenceImageUrls)(plan.bible, scene.bibleEntityIds ?? []);
+        const wrap = (tool, outcome) => outcome.ok
+            ? { ok: true, output: { tool, ...outcome.output } }
+            : { ok: false, error: outcome.error };
+        switch (scene.strategy) {
+            case "stock-video":
+            case "stock-image-ken-burns": {
+                const out = await this.runTool("search_stock", {
+                    query: scene.prompt,
+                    kind: scene.strategy === "stock-video" ? "video" : "image",
+                    aspectRatio: aspect,
+                    minDurationSec: scene.strategy === "stock-video" ? durationSec : undefined,
+                }, ctx);
+                if (!out.ok)
+                    return wrap("search_stock", out);
+                const url = out.output.assets[0]?.url;
+                if (!url)
+                    return {
+                        ok: false,
+                        error: {
+                            code: "NO_STOCK_RESULTS",
+                            message: `No stock results for: ${scene.prompt}`,
+                            attemptedProviders: out.output.attemptedProviders,
+                        },
+                    };
+                return {
+                    ok: true,
+                    output: {
+                        tool: "search_stock",
+                        visualUrl: url,
+                        attemptedProviders: out.output.attemptedProviders,
+                    },
+                };
+            }
+            case "ai-image-static":
+            case "ai-image-motion": {
+                const out = await this.runTool("generate_image", {
+                    prompt: scene.prompt,
+                    modelKey: scene.preferredModel ?? "google-nano-banana",
+                    aspectRatio: aspect,
+                    ...(referenceImageUrls.length
+                        ? { inputImageUrls: referenceImageUrls }
+                        : {}),
+                }, ctx);
+                if (!out.ok)
+                    return wrap("generate_image", out);
+                return { ok: true, output: { tool: "generate_image", visualUrl: out.output.imageUrl } };
+            }
+            case "ai-image-to-video": {
+                const animateModelKey = scene.preferredModel ?? "kling-v2.6";
+                const animateDurationSec = resolveDurationForPreferredModel(animateModelKey, durationSec, !!scene.preferredModel, scene.sceneIndex);
+                // Stage 7 slice 1: cache key spans the WHOLE strategy (both image-gen
+                // + animate). Hashing only upstream-stable inputs — prompt, model,
+                // duration, aspect, reference images — lets a re-execute skip BOTH
+                // tool calls, replaying the cached animate taskId through the poller.
+                const clipId = `scene-${scene.sceneIndex}-visual`;
+                const cacheInput = {
+                    strategy: "ai-image-to-video",
+                    prompt: scene.prompt,
+                    modelKey: animateModelKey,
+                    durationSec: animateDurationSec,
+                    aspect,
+                    referenceImageUrls,
+                };
+                const { hit, inputsHash } = this.checkTaskCache(clipId, "animate_image", cacheInput);
+                if (hit) {
+                    return {
+                        ok: true,
+                        output: {
+                            tool: "animate_image",
+                            pendingTaskId: hit.taskId,
+                            pendingModelKey: hit.modelKey,
+                        },
+                    };
+                }
+                const img = await this.runTool("generate_image", {
+                    prompt: scene.prompt,
+                    modelKey: "google-nano-banana",
+                    aspectRatio: aspect,
+                    ...(referenceImageUrls.length
+                        ? { inputImageUrls: referenceImageUrls }
+                        : {}),
+                }, { ...ctx, idempotencyKey: `${ctx.idempotencyKey}:img` });
+                if (!img.ok)
+                    return wrap("generate_image", img);
+                const animate = await this.runTool("animate_image", {
+                    imageUrl: img.output.imageUrl,
+                    motionHint: scene.prompt,
+                    durationSec: animateDurationSec,
+                    modelKey: animateModelKey,
+                }, ctx);
+                if (!animate.ok)
+                    return wrap("animate_image", animate);
+                const mintedModelKey = animate.output.modelKeyUsed ?? animateModelKey;
+                await this.mintTaskCache(clipId, {
+                    tool: "animate_image",
+                    taskId: animate.output.taskId,
+                    modelKey: mintedModelKey,
+                    inputsHash,
+                    createdAt: Date.now(),
+                });
+                return {
+                    ok: true,
+                    output: {
+                        tool: "animate_image",
+                        pendingTaskId: animate.output.taskId,
+                        pendingModelKey: mintedModelKey,
+                        attemptedProviders: animate.output.attemptedProviders,
+                    },
+                };
+            }
+            case "ai-text-to-video": {
+                const t2vModelKey = scene.preferredModel ?? "kling-v2.6";
+                const t2vDurationSec = resolveDurationForPreferredModel(t2vModelKey, durationSec, !!scene.preferredModel, scene.sceneIndex);
+                const clipId = `scene-${scene.sceneIndex}-visual`;
+                const cacheInput = {
+                    strategy: "ai-text-to-video",
+                    prompt: scene.prompt,
+                    modelKey: t2vModelKey,
+                    durationSec: t2vDurationSec,
+                };
+                const { hit, inputsHash } = this.checkTaskCache(clipId, "generate_video", cacheInput);
+                if (hit) {
+                    return {
+                        ok: true,
+                        output: {
+                            tool: "generate_video",
+                            pendingTaskId: hit.taskId,
+                            pendingModelKey: hit.modelKey,
+                        },
+                    };
+                }
+                const out = await this.runTool("generate_video", {
+                    prompt: scene.prompt,
+                    modelKey: t2vModelKey,
+                    durationSec: t2vDurationSec,
+                }, ctx);
+                if (!out.ok)
+                    return wrap("generate_video", out);
+                const mintedModelKey = out.output.modelKeyUsed ?? t2vModelKey;
+                await this.mintTaskCache(clipId, {
+                    tool: "generate_video",
+                    taskId: out.output.taskId,
+                    modelKey: mintedModelKey,
+                    inputsHash,
+                    createdAt: Date.now(),
+                });
+                return {
+                    ok: true,
+                    output: {
+                        tool: "generate_video",
+                        pendingTaskId: out.output.taskId,
+                        pendingModelKey: mintedModelKey,
+                        attemptedProviders: out.output.attemptedProviders,
+                    },
+                };
+            }
+            case "user-asset": {
+                // Per-user library search. The host injects the searcher at boot
+                // (see userLibrarySearcher bootstrap); if no match, fall back to
+                // stock so the scene still renders rather than failing hard.
+                const out = await this.runTool("search_user_library", { query: scene.prompt, limit: 5 }, ctx);
+                if (out.ok) {
+                    const first = out.output.assets[0];
+                    if (first) {
+                        return { ok: true, output: { tool: "search_user_library", visualUrl: first.url } };
+                    }
+                }
+                // No hits or searcher missing — fall back to stock-video as the
+                // closest cheap substitute so the executor still produces an asset.
+                const stock = await this.runTool("search_stock", {
+                    query: scene.prompt,
+                    kind: "video",
+                    aspectRatio: aspect,
+                    minDurationSec: durationSec,
+                }, ctx);
+                if (!stock.ok)
+                    return wrap("search_stock", stock);
+                const fallbackUrl = stock.output.assets[0]?.url;
+                if (!fallbackUrl) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "USER_ASSET_NO_MATCH",
+                            message: `No user-library match for "${scene.prompt}" and no stock fallback.`,
+                            attemptedProviders: stock.output.attemptedProviders,
+                        },
+                    };
+                }
+                return {
+                    ok: true,
+                    output: {
+                        tool: "search_user_library",
+                        visualUrl: fallbackUrl,
+                        attemptedProviders: stock.output.attemptedProviders,
+                    },
+                };
+            }
+            case "talking-head-avatar": {
+                if (!scene.avatarFaceUrl) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "AVATAR_FACE_REQUIRED",
+                            message: "talking-head-avatar requires scene.avatarFaceUrl (set on the user's brand kit).",
+                        },
+                    };
+                }
+                if (!scene.voiceoverLine) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "AVATAR_VO_REQUIRED",
+                            message: "talking-head-avatar requires scene.voiceoverLine for the lipsync audio.",
+                        },
+                    };
+                }
+                const avatarMode = scene.tier === "T3" ? "pro" : "std";
+                const clipId = `scene-${scene.sceneIndex}-visual`;
+                const cacheInput = {
+                    strategy: "talking-head-avatar",
+                    inputImageUrl: scene.avatarFaceUrl,
+                    ttsText: scene.voiceoverLine,
+                    mode: avatarMode,
+                };
+                const { hit, inputsHash } = this.checkTaskCache(clipId, "generate_avatar_video", cacheInput);
+                if (hit) {
+                    return {
+                        ok: true,
+                        output: {
+                            tool: "generate_avatar_video",
+                            pendingTaskId: hit.taskId,
+                            pendingModelKey: hit.modelKey,
+                        },
+                    };
+                }
+                const out = await this.runTool("generate_avatar_video", {
+                    inputImageUrl: scene.avatarFaceUrl,
+                    ttsText: scene.voiceoverLine,
+                    mode: avatarMode,
+                }, ctx);
+                if (!out.ok)
+                    return wrap("generate_avatar_video", out);
+                await this.mintTaskCache(clipId, {
+                    tool: "generate_avatar_video",
+                    taskId: out.output.taskId,
+                    // Avatar tool hardcodes Kling Avatar internally; poller needs the
+                    // actual model key to route via getAiGenProviderService (no special
+                    // resolver exists). AG-20: was "generate_avatar_video" which would
+                    // throw at factory lookup the moment the avatar path was polled.
+                    modelKey: "kling-avatar",
+                    inputsHash,
+                    createdAt: Date.now(),
+                });
+                return {
+                    ok: true,
+                    output: {
+                        tool: "generate_avatar_video",
+                        pendingTaskId: out.output.taskId,
+                        pendingModelKey: "kling-avatar",
+                    },
+                };
+            }
+        }
+    }
+}
+exports.Executor = Executor;

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

@@ -0,0 +1,49 @@
+/**
+ * Session K (Stage 7) — global project-level regen actions.
+ *
+ * Pairs with `AgentRegenTargetSchema.kind === "global"`. The worker dispatches
+ * here instead of through `executeRegenTarget` (which is per-scene / per-
+ * component) because these actions mutate project-wide state:
+ *
+ *   - "soften-music"    — drop volume + mood + bpm, refetch a mellower track
+ *                         via selectMusicForPlan, swap the "music" clip src.
+ *   - "add-cta"         — bias the closing scene's overlays toward a strong
+ *                         CTA via planner.regenerateOverlaysForScene; splice
+ *                         new overlay clips on top of the existing visual.
+ *   - "switch-persona"  — re-run Planner.plan() with the new persona. Project
+ *                         status reverts to "planned" — visuals are stale
+ *                         relative to the new plan, the user must /execute
+ *                         again. projectJson is left intact for inspection.
+ *
+ * Pure logic; never touches Firestore. Caller persists the returned
+ * `projectPatch` as one merge update.
+ */
+import { IAgentProjectModel } from "../../models/agent.model";
+import { RegenCostEstimate } from "../credits/pricing";
+export type GlobalAction = "soften-music" | "add-cta" | "switch-persona";
+export interface GlobalActionContext {
+    projectId: string;
+    userId: string;
+}
+export interface GlobalActionSuccess {
+    ok: true;
+    /** Patch applied directly to agentProjects/{id} doc; caller writes one merge update. */
+    projectPatch: Partial<IAgentProjectModel>;
+    cost: RegenCostEstimate;
+    details: Record<string, unknown>;
+}
+export interface GlobalActionError {
+    ok: false;
+    status?: number;
+    error: string;
+    code?: string;
+}
+export type GlobalActionResult = GlobalActionSuccess | GlobalActionError;
+/**
+ * Per-action cost estimate. Mirrors what `estimateRegenCost` does for the
+ * per-component path so the controller's pre-flight preview and the
+ * worker's refund-on-failure path agree on a number.
+ */
+export declare function estimateGlobalActionCost(action: GlobalAction, _params?: Record<string, unknown>): RegenCostEstimate;
+export declare function executeGlobalAction(action: GlobalAction, params: Record<string, unknown> | undefined, project: IAgentProjectModel, _ctx: GlobalActionContext): Promise<GlobalActionResult>;
+//# sourceMappingURL=globalActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"globalActions.d.ts","sourceRoot":"","sources":["../../../src/services/agent/globalActions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AASH,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAKL,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAQ5B,MAAM,MAAM,YAAY,GAAG,cAAc,GAAG,SAAS,GAAG,gBAAgB,CAAC;AAEzE,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,IAAI,CAAC;IACT,wFAAwF;IACxF,YAAY,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC1C,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,GAAG,iBAAiB,CAAC;AAWzE;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,iBAAiB,CA0BnB;AAED,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC3C,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,kBAAkB,CAAC,CA4Q7B"}