@lingjingai/scriptctl 0.63.14 → 0.63.15

package/dist/llm/registry.js

@@ -1,69 +0,0 @@
-function spec(id, mode, maxOutputTokens) {
-    return { id, mode, version: "1", maxOutputTokens, defaultProfile: "default" };
-}
-export const LLM_TASK_REGISTRY = {
-    "direct.episode-titles": spec("direct.episode-titles", "tool", 4096),
-    "direct.batch-extract": spec("direct.batch-extract", "text", 16000),
-    "direct.episode-synopsis": spec("direct.episode-synopsis", "tool", 2048),
-    "direct.synopsis-reduction": spec("direct.synopsis-reduction", "tool", 4096),
-    "direct.script-synopsis": spec("direct.script-synopsis", "tool", 2048),
-    "direct.asset-grouping": spec("direct.asset-grouping", "text", 8000),
-    "direct.asset-curation": spec("direct.asset-curation", "text", 20000),
-    "direct.asset-curation-audit": spec("direct.asset-curation-audit", "text", 20000),
-    "direct.location-canonicalization": spec("direct.location-canonicalization", "text", 20000),
-    "direct.state-curation": spec("direct.state-curation", "text", 20000),
-    "direct.state-binding": spec("direct.state-binding", "tool", 16000),
-    "metadata.global": spec("metadata.global", "text", 16000),
-    "metadata.descriptions": spec("metadata.descriptions", "text", 16000),
-    "synopsis.chunk": spec("synopsis.chunk", "text", 4096),
-    "synopsis.episode": spec("synopsis.episode", "text", 4096),
-    // Aggregation output is short, but reasoning models can consume several
-    // thousand hidden tokens before emitting it. Use the long-text budget so
-    // valid arc and whole-script summaries are not cut off mid-response.
-    "synopsis.arc": spec("synopsis.arc", "text", 16000),
-    "synopsis.script-overview": spec("synopsis.script-overview", "text", 16000),
-    // Locate where the actual screenplay body begins: a cheap text classifier
-    // scanned over 50-line windows, emitting just `起点: <行号>` / `起点: 无`. Text
-    // (not tool) mode so it runs on the cheap deepseek-flash profile, which does
-    // not support function calling. The reply is tiny, but reasoning models spend
-    // hidden tokens first — too small a budget truncates (finish_reason=length) and
-    // the whole call throws. A big cap costs nothing extra (the call stops when the
-    // model is done); it only prevents truncation, so match normalize's headroom.
-    "ingest.body-start": spec("ingest.body-start", "text", 16000),
-    // Compress a folded run of ~10 episodes' aged synopses into one arc paragraph.
-    // Fires rarely (only when the synopsis exceeds budget); output is a short
-    // paragraph, so a modest budget suffices (headroom for a reasoning model).
-    "ingest.arc-summary": spec("ingest.arc-summary", "text", 4096),
-    "ingest.text-normalize": spec("ingest.text-normalize", "text", 32000),
-    // Serial per-WINDOW asset/state annotation: model reads the running context + a
-    // token-bounded window of 1+ episodes (~10k body tokens), returns a structured
-    // Delta (SERIAL_DELTA_SCHEMA) covering all their scenes via native tool-calling —
-    // canonical names + aliases as separate fields, so no markdown delimiter can
-    // mangle a name. Output scales with the window's scene count → large cap so a
-    // dense window never truncates (a big cap costs nothing when small). Tool mode:
-    // the serial profile (ingest-normalize) must be a function-calling model.
-    "ingest.episode-assets": spec("ingest.episode-assets", "tool", 32000),
-    // Repair pass: names that appear in the body but resolved to nothing in the
-    // final registry (a missed merge). The model says merge-into-existing or new.
-    "ingest.name-fix": spec("ingest.name-fix", "tool", 16000),
-    "ingest.mention-resolve": spec("ingest.mention-resolve", "text", 8000),
-    "ingest.asset-extract": spec("ingest.asset-extract", "text", 8000),
-    "ingest.asset-curate": spec("ingest.asset-curate", "text", 32000),
-    "ingest.asset-recall": spec("ingest.asset-recall", "text", 65536),
-    "ingest.asset-refine": spec("ingest.asset-refine", "text", 32000),
-    "ingest.state-reconcile": spec("ingest.state-reconcile", "text", 32000),
-    // Final whole-script asset consistency audit. It reads a compact global
-    // roster and returns structured findings; no automatic merge is applied.
-    "ingest.asset-audit": spec("ingest.asset-audit", "tool", 32000),
-    "ingest.speaker-audit": spec("ingest.speaker-audit", "tool", 16000),
-    // Video understanding (Gemini, §10.2). One serial pass per episode: watches the
-    // video with the running cross-episode context and emits the episode content +
-    // a registry delta in one structured JSON response. Large output budget (§10.5
-    // verified 65536 for a full episode's scenes).
-    "ingest.video-serial": spec("ingest.video-serial", "video", 65536),
-};
-export const LLM_TASK_IDS = Object.keys(LLM_TASK_REGISTRY).filter(isLlmTaskId);
-export function isLlmTaskId(value) {
-    return Object.hasOwn(LLM_TASK_REGISTRY, value);
-}
-//# sourceMappingURL=registry.js.map

package/dist/llm/registry.js.map

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

package/dist/llm/router.d.ts

@@ -1,46 +0,0 @@
-import { type DoubaoRunRequest } from "../infra/llm/doubao-model.js";
-import { type LlmModelConfig, type LlmProviderConfig, type ResolvedLlmConfig } from "./config.js";
-import type { LlmAdapter, LlmExecutorOptions, LlmRouteInfo, LlmRouteUsage, LlmTaskExecutor, LlmTaskId, LlmUsageEvent, TaskVideoPort, TextGenerationRequest, TextGenerationResponse, ToolGenerationRequest, ToolGenerationResponse, VideoUnderstandingPort, VideoGenerationResponse } from "./types.js";
-export interface ResolvedRoute {
-    info: LlmRouteInfo;
-    providerConfig: LlmProviderConfig;
-    modelConfig: LlmModelConfig;
-}
-export interface DoubaoVideoRunner {
-    run(request: DoubaoRunRequest): Promise<VideoGenerationResponse>;
-}
-export declare class ModelRouter implements LlmTaskExecutor {
-    private readonly config;
-    private readonly options;
-    private readonly adapters;
-    private readonly videoAdapters;
-    private readonly doubaoAdapters;
-    private readonly resolvedRoutes;
-    private readonly usageLog;
-    constructor(config: ResolvedLlmConfig, options?: LlmExecutorOptions);
-    get configSource(): "builtin" | "file";
-    private resolve;
-    route(task: LlmTaskId): LlmRouteInfo;
-    routes(): LlmRouteInfo[];
-    private emptyUsage;
-    recordReuse(task: LlmTaskId): void;
-    usage(): LlmRouteUsage[];
-    usageEvents(): LlmUsageEvent[];
-    private recordEvent;
-    private tracked;
-    private resolveDoubao;
-    private doubaoRoute;
-    private adapter;
-    protected videoAdapter(route: ResolvedRoute): VideoUnderstandingPort;
-    private videoCredential;
-    videoPort(task: LlmTaskId): TaskVideoPort;
-    private generateDoubaoVideo;
-    protected doubaoAdapter(route?: ResolvedRoute): DoubaoVideoRunner | null;
-    protected doubaoTextAdapter(): LlmAdapter | null;
-    private arkAdapter;
-    protected doubaoModel(): string;
-    private withTextFallback;
-    generateText(task: LlmTaskId, request: Omit<TextGenerationRequest, "maxOutputTokens">): Promise<TextGenerationResponse>;
-    generateTool(task: LlmTaskId, request: Omit<ToolGenerationRequest, "maxOutputTokens">): Promise<ToolGenerationResponse>;
-}
-export declare function createLlmExecutor(explicitConfigPath?: string, options?: LlmExecutorOptions): ModelRouter;

package/dist/llm/router.js

@@ -1,512 +0,0 @@
-import * as crypto from "node:crypto";
-import { CliError, EXIT_INPUT, EXIT_RUNTIME } from "../common.js";
-import { aggregateFailures, classificationOf, contextOf, createOperationalFailure, formatFailure } from "../failures.js";
-import { AnthropicModel } from "../infra/llm/anthropic-model.js";
-import { DoubaoModel, } from "../infra/llm/doubao-model.js";
-import { GeminiVideoModel } from "../infra/llm/gemini-video-model.js";
-import { OpenAiCompatibleModel } from "../infra/llm/openai-compatible-model.js";
-import { loadLlmConfig, normalizeProviderBaseUrl, } from "./config.js";
-import { LLM_TASK_IDS, LLM_TASK_REGISTRY } from "./registry.js";
-import { LlmTransportError } from "./types.js";
-// Ark endpoint shared by Gemini recovery and explicitly selected Doubao video.
-const DOUBAO_FALLBACK = {
-    model: "ep-20260721150136-98dj9",
-    modelEnv: "ARK_MODEL",
-    baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
-    apiKeyEnv: "ARK_API_KEY",
-    timeoutMs: 600_000,
-    maxAttempts: 3,
-};
-const GEMINI_FLASH_MODELS = ["gemini-3.8-flash", "gemini-3.7-flash", "gemini-3.6-flash"];
-function normalizeBaseUrl(value) {
-    return value?.trim().replace(/\/+$/, "") ?? "anthropic-sdk-default";
-}
-function routeFingerprint(task, provider, model) {
-    const spec = LLM_TASK_REGISTRY[task];
-    const material = JSON.stringify({
-        task,
-        taskVersion: spec.version,
-        protocol: provider.protocol,
-        baseUrl: normalizeBaseUrl(provider.baseUrl),
-        model: model.model,
-        thinkingBudgetTokens: model.thinkingBudgetTokens ?? null,
-    });
-    return crypto.createHash("sha256").update(material).digest("hex");
-}
-function configRuntimeError(message, required, received) {
-    return new CliError(message, {
-        exitCode: EXIT_INPUT,
-        errorCode: "LLM_CONFIG_INVALID",
-        hint: "Fix the selected LLM configuration and run `scriptctl doctor`.",
-        data: { expected: required, actual: received },
-    });
-}
-function credentialError(provider) {
-    return new CliError("The selected LLM provider credential is not configured.", {
-        exitCode: EXIT_RUNTIME,
-        errorCode: "LLM_CREDENTIAL_MISSING",
-        hint: "Configure the credential and rerun `scriptctl doctor`.",
-        data: { expected: ["credential environment variable referenced by the selected provider"], actual: [`provider: ${provider}`, "credential: missing"] },
-    });
-}
-function routedFailure(error, route) {
-    return createOperationalFailure(classificationOf(error.failure), {
-        ...contextOf(error.failure), provider: route.provider, model: route.model,
-        retryable: error.failure.retryable, message: error.message,
-    });
-}
-function exhaustedFailure(error, failures) {
-    if (failures.length === 1)
-        return error;
-    const aggregate = aggregateFailures(failures, "All configured model routes failed.");
-    return new LlmTransportError(error.code, aggregate.message, {
-        retryable: aggregate.retryable, classification: classificationOf(aggregate),
-        context: contextOf(aggregate), modelFailures: failures, details: failures.map(formatFailure),
-    });
-}
-function isGeminiRoute(route) {
-    return route.protocol === "google-gemini" || /(^|\/)gemini-/i.test(route.model);
-}
-function geminiRoutes(primary) {
-    const prefix = primary.info.model.slice(0, primary.info.model.lastIndexOf("/") + 1);
-    const models = new Set([primary.info.model, ...GEMINI_FLASH_MODELS.map((model) => prefix + model)]);
-    return [...models].map((model) => {
-        if (model === primary.info.model)
-            return primary;
-        const modelConfig = { ...primary.modelConfig, model };
-        return {
-            ...primary, modelConfig,
-            info: { ...primary.info, model, fingerprint: routeFingerprint(primary.info.task, primary.providerConfig, modelConfig) },
-        };
-    });
-}
-function canFallback(error, signal) {
-    return !signal?.aborted && error instanceof LlmTransportError && error.code !== "cancelled";
-}
-export class ModelRouter {
-    config;
-    options;
-    adapters = new Map();
-    videoAdapters = new Map();
-    doubaoAdapters = new Map();
-    resolvedRoutes = new Map();
-    usageLog = [];
-    constructor(config, options = {}) {
-        this.config = config;
-        this.options = options;
-    }
-    get configSource() {
-        return this.config.source;
-    }
-    resolve(task) {
-        const cached = this.resolvedRoutes.get(task);
-        if (cached)
-            return cached;
-        const spec = LLM_TASK_REGISTRY[task];
-        if (spec.mode === "video" && this.options.videoProvider?.provider === "doubao") {
-            const resolved = this.resolveDoubao(task, true);
-            this.resolvedRoutes.set(task, resolved);
-            return resolved;
-        }
-        const profile = this.config.tasks[task] ?? spec.defaultProfile;
-        const modelConfig = this.config.models[profile];
-        if (!modelConfig)
-            throw configRuntimeError("The task route references a missing model profile.", [profile], [`task: ${task}`]);
-        const providerConfig = this.config.providers[modelConfig.provider];
-        if (!providerConfig) {
-            throw configRuntimeError("The model profile references a missing provider.", [modelConfig.provider], [`profile: ${profile}`]);
-        }
-        if (providerConfig.protocol === "openai-compatible" && !providerConfig.baseUrl) {
-            throw configRuntimeError("OpenAI-compatible providers require an explicit endpoint — set the provider's baseUrl, or PROJECT_LITELLM_GATEWAY_BASE_URL for the built-in gateway.", ["provider.baseUrl"], [`provider: ${modelConfig.provider}`]);
-        }
-        if (modelConfig.thinkingBudgetTokens !== undefined && spec.mode === "tool") {
-            throw configRuntimeError("Anthropic thinking cannot be combined with a forced tool call.", ["a text task or a profile without thinking"], [`task: ${task}`, `profile: ${profile}`]);
-        }
-        if (modelConfig.thinkingBudgetTokens !== undefined && modelConfig.thinkingBudgetTokens >= spec.maxOutputTokens) {
-            throw configRuntimeError("The thinking token budget must be smaller than the task output budget.", [`thinking budget < ${spec.maxOutputTokens}`], [`task: ${task}`, `thinking budget: ${modelConfig.thinkingBudgetTokens}`]);
-        }
-        const videoOverrides = spec.mode === "video" ? this.options.videoProvider : undefined;
-        const overriddenProvider = videoOverrides?.baseUrl
-            ? { ...providerConfig, baseUrl: normalizeProviderBaseUrl(videoOverrides.baseUrl, "--provider-base-url") }
-            : providerConfig;
-        const overriddenModel = videoOverrides?.model
-            ? { ...modelConfig, model: videoOverrides.model.trim() }
-            : modelConfig;
-        if (videoOverrides?.model !== undefined && !overriddenModel.model) {
-            throw configRuntimeError("The video provider model cannot be empty.", ["non-empty --provider-model"], ["model: empty"]);
-        }
-        const resolved = {
-            info: {
-                task,
-                profile,
-                provider: modelConfig.provider,
-                protocol: overriddenProvider.protocol,
-                baseUrl: overriddenProvider.baseUrl,
-                model: overriddenModel.model,
-                fingerprint: routeFingerprint(task, overriddenProvider, overriddenModel),
-            },
-            providerConfig: overriddenProvider,
-            modelConfig: overriddenModel,
-        };
-        this.resolvedRoutes.set(task, resolved);
-        return resolved;
-    }
-    route(task) {
-        return this.resolve(task).info;
-    }
-    routes() {
-        return LLM_TASK_IDS.map((task) => this.route(task));
-    }
-    emptyUsage() {
-        return {
-            calls: 0,
-            succeeded: 0,
-            failed: 0,
-            reused: 0,
-            attempts: 0,
-            durationMs: 0,
-            inputTokens: 0,
-            outputTokens: 0,
-            cachedInputTokens: 0,
-            cacheCreationTokens: 0,
-        };
-    }
-    recordReuse(task) {
-        const at = new Date().toISOString();
-        this.recordEvent(this.route(task), "reused", at, at, 0, {});
-    }
-    usage() {
-        const aggregate = new Map();
-        for (const event of this.usageLog) {
-            const key = `${event.task}\u0000${event.provider}\u0000${event.protocol}\u0000${event.model}\u0000${event.fingerprint}`;
-            const usage = aggregate.get(key) ?? {
-                task: event.task,
-                profile: event.profile,
-                provider: event.provider,
-                protocol: event.protocol,
-                baseUrl: event.baseUrl,
-                model: event.model,
-                fingerprint: event.fingerprint,
-                ...this.emptyUsage(),
-            };
-            if (event.status === "reused")
-                usage.reused += 1;
-            else {
-                usage.calls += 1;
-                usage[event.status] += 1;
-                usage.attempts += event.attempts;
-                usage.durationMs += event.durationMs;
-                usage.inputTokens += event.inputTokens;
-                usage.outputTokens += event.outputTokens;
-                usage.cachedInputTokens += event.cachedInputTokens;
-                usage.cacheCreationTokens += event.cacheCreationTokens;
-            }
-            aggregate.set(key, usage);
-        }
-        return [...aggregate.values()];
-    }
-    usageEvents() {
-        return this.usageLog.map((event) => ({ ...event }));
-    }
-    recordEvent(route, status, startedAt, endedAt, durationMs, usage, attempts = 0, errorCode) {
-        this.usageLog.push({
-            ...route,
-            sequence: this.usageLog.length + 1,
-            status,
-            attempts,
-            startedAt,
-            endedAt,
-            durationMs,
-            inputTokens: usage.inputTokens ?? 0,
-            outputTokens: usage.outputTokens ?? 0,
-            cachedInputTokens: usage.cachedInputTokens ?? 0,
-            cacheCreationTokens: usage.cacheCreationTokens ?? 0,
-            ...(errorCode ? { errorCode } : {}),
-        });
-    }
-    async tracked(route, operation) {
-        const startedMs = Date.now();
-        const startedAt = new Date(startedMs).toISOString();
-        try {
-            const response = await operation();
-            const endedMs = Date.now();
-            this.recordEvent(route, "succeeded", startedAt, new Date(endedMs).toISOString(), endedMs - startedMs, response.usage ?? {}, response.attempts);
-            return response;
-        }
-        catch (error) {
-            const endedMs = Date.now();
-            const transport = error instanceof LlmTransportError ? error : null;
-            this.recordEvent(route, "failed", startedAt, new Date(endedMs).toISOString(), endedMs - startedMs, transport?.usage ?? {}, transport?.attempts ?? 1, transport?.code);
-            throw error;
-        }
-    }
-    resolveDoubao(task, explicit) {
-        const overrides = explicit ? this.options.videoProvider : undefined;
-        const modelName = explicit
-            ? (overrides?.model ?? process.env["ARK_MODEL"] ?? "").trim()
-            : this.doubaoModel();
-        if (!modelName) {
-            throw configRuntimeError("Doubao requires --provider-model or ARK_MODEL.", ["--provider-model <id> or ARK_MODEL"], ["model: empty"]);
-        }
-        const providerConfig = {
-            protocol: "openai-compatible",
-            baseUrl: overrides?.baseUrl
-                ? normalizeProviderBaseUrl(overrides.baseUrl, "--provider-base-url")
-                : DOUBAO_FALLBACK.baseUrl,
-            apiKeyEnv: DOUBAO_FALLBACK.apiKeyEnv,
-            timeoutMs: DOUBAO_FALLBACK.timeoutMs,
-            maxAttempts: DOUBAO_FALLBACK.maxAttempts,
-        };
-        const modelConfig = { provider: "doubao", model: modelName };
-        return {
-            info: {
-                task,
-                profile: explicit ? "doubao" : "doubao-fallback",
-                provider: "doubao",
-                protocol: providerConfig.protocol,
-                baseUrl: providerConfig.baseUrl,
-                model: modelName,
-                fingerprint: routeFingerprint(task, providerConfig, modelConfig),
-            },
-            providerConfig,
-            modelConfig,
-        };
-    }
-    doubaoRoute(task) {
-        return this.resolveDoubao(task, false).info;
-    }
-    adapter(route) {
-        const key = `${route.info.provider}\u0000${route.info.model}\u0000${route.modelConfig.thinkingBudgetTokens ?? ""}`;
-        const cached = this.adapters.get(key);
-        if (cached)
-            return cached;
-        const apiKey = (process.env[route.providerConfig.apiKeyEnv] ?? "").trim();
-        if (!apiKey)
-            throw credentialError(route.info.provider);
-        const adapter = route.providerConfig.protocol === "anthropic"
-            ? new AnthropicModel(route.providerConfig, route.modelConfig, apiKey)
-            : new OpenAiCompatibleModel(route.providerConfig, route.modelConfig, apiKey);
-        this.adapters.set(key, adapter);
-        return adapter;
-    }
-    videoAdapter(route) {
-        if (route.providerConfig.protocol !== "google-gemini") {
-            throw configRuntimeError("Video tasks require a google-gemini provider.", ["provider.protocol: google-gemini"], [`provider: ${route.info.provider}`, `protocol: ${route.providerConfig.protocol}`]);
-        }
-        const modelName = route.info.model;
-        const key = `${route.info.provider} ${route.providerConfig.baseUrl ?? "official"} ${modelName}`;
-        const cached = this.videoAdapters.get(key);
-        if (cached)
-            return cached;
-        const apiKey = this.videoCredential(route);
-        if (!apiKey)
-            throw credentialError(route.info.provider);
-        const adapter = new GeminiVideoModel(route.providerConfig, route.modelConfig, apiKey);
-        this.videoAdapters.set(key, adapter);
-        return adapter;
-    }
-    videoCredential(route) {
-        const override = this.options.videoProvider?.apiKey;
-        const apiKey = override?.kind === "literal"
-            ? override.value.trim()
-            : override?.kind === "env"
-                ? (process.env[override.name] ?? "").trim()
-                : (process.env[route.providerConfig.apiKeyEnv] ?? "").trim();
-        if (!apiKey)
-            throw credentialError(route.info.provider);
-        return apiKey;
-    }
-    videoPort(task) {
-        const spec = LLM_TASK_REGISTRY[task];
-        if (spec.mode !== "video")
-            throw configRuntimeError("The task does not support video generation.", ["video task"], [`task: ${task}`]);
-        const route = this.resolve(task);
-        if (this.options.videoProvider?.provider === "doubao") {
-            const adapter = this.doubaoAdapter(route);
-            if (!adapter)
-                throw credentialError("doubao");
-            return {
-                prepare: async (localPath, mimeType, mode, signal) => {
-                    if (mode !== "file-api") {
-                        throw configRuntimeError("Doubao requires file-api upload mode.", ["file-api"], [mode]);
-                    }
-                    signal?.throwIfAborted();
-                    return { kind: "local", path: localPath, mimeType };
-                },
-                generate: (request) => {
-                    if (request.media.kind !== "local") {
-                        throw configRuntimeError("Doubao requires locally prepared video.", ["local media"], [request.media.kind]);
-                    }
-                    request.signal?.throwIfAborted();
-                    const { path: localPath, mimeType: localMime } = request.media;
-                    return this.tracked(route.info, () => adapter.run({
-                        localPath,
-                        localMime,
-                        user: request.user,
-                        fps: request.fps,
-                        maxOutputTokens: spec.maxOutputTokens,
-                        ...(request.system ? { system: request.system } : {}),
-                        ...(request.responseJsonSchema ? { responseJsonSchema: request.responseJsonSchema } : {}),
-                        ...(request.signal ? { signal: request.signal } : {}),
-                    }));
-                },
-                release: async () => { },
-            };
-        }
-        if (route.providerConfig.protocol !== "google-gemini") {
-            throw configRuntimeError("Video tasks require a google-gemini provider.", ["provider.protocol: google-gemini"], [`provider: ${route.info.provider}`, `protocol: ${route.providerConfig.protocol}`]);
-        }
-        const adapter = this.videoAdapter(route);
-        return {
-            prepare: async (localPath, mimeType, mode, signal) => {
-                const started = Date.now();
-                try {
-                    return await adapter.prepare(localPath, mimeType, mode, signal);
-                }
-                catch (error) {
-                    if (!canFallback(error, signal) || !this.doubaoAdapter())
-                        throw error;
-                    this.recordEvent(route.info, "failed", new Date(started).toISOString(), new Date().toISOString(), Date.now() - started, error.usage, error.attempts, error.code);
-                    return { kind: "local-fallback", path: localPath, mimeType, primaryFailure: routedFailure(error, route.info) };
-                }
-            },
-            release: (media, signal) => media.kind === "local-fallback" ? Promise.resolve() : adapter.release(media, signal),
-            generate: async (request) => {
-                request.signal?.throwIfAborted();
-                if (request.media.kind === "local-fallback") {
-                    return this.generateDoubaoVideo(task, request, [request.media.primaryFailure]);
-                }
-                const routes = geminiRoutes(route);
-                const failures = [];
-                for (const [index, candidate] of routes.entries()) {
-                    request.signal?.throwIfAborted();
-                    try {
-                        return await this.tracked(candidate.info, () => this.videoAdapter(candidate).generate({
-                            ...request, maxOutputTokens: spec.maxOutputTokens,
-                        }));
-                    }
-                    catch (error) {
-                        if (!canFallback(error, request.signal))
-                            throw error;
-                        const failure = routedFailure(error, candidate.info);
-                        failures.push(failure);
-                        const next = routes[index + 1];
-                        if (next) {
-                            process.stderr.write(`↪️  ${candidate.info.model} 请求失败，切换到 ${next.info.model} (${formatFailure(failure)})\n`);
-                            continue;
-                        }
-                        if (!this.doubaoAdapter() || !request.localPath)
-                            throw exhaustedFailure(error, failures);
-                        return this.generateDoubaoVideo(task, request, failures);
-                    }
-                }
-                throw new Error("Gemini model routes cannot be empty.");
-            },
-        };
-    }
-    async generateDoubaoVideo(task, request, failures) {
-        const adapter = this.doubaoAdapter();
-        if (!adapter)
-            throw credentialError("doubao");
-        const localPath = request.media.kind === "local-fallback" ? request.media.path : request.localPath;
-        if (!localPath)
-            throw configRuntimeError("Doubao video fallback requires the local video.", ["localPath"], ["localPath: missing"]);
-        const localMime = request.localMime ?? (request.media.kind === "file-api" ? request.media.file.mimeType : request.media.mimeType);
-        const route = this.doubaoRoute(task);
-        process.stderr.write(`↪️  Gemini 路由已耗尽，回退到豆包 ${route.model}\n`);
-        try {
-            return await this.tracked(route, () => adapter.run({
-                localPath, localMime, user: request.user, fps: request.fps,
-                maxOutputTokens: LLM_TASK_REGISTRY[task].maxOutputTokens,
-                ...(request.system ? { system: request.system } : {}),
-                ...(request.responseJsonSchema ? { responseJsonSchema: request.responseJsonSchema } : {}),
-                ...(request.signal ? { signal: request.signal } : {}),
-            }));
-        }
-        catch (error) {
-            if (!canFallback(error, request.signal))
-                throw error;
-            throw exhaustedFailure(error, [...failures, routedFailure(error, route)]);
-        }
-    }
-    // Resolve the default fallback or explicitly selected Doubao video.
-    // Overridable in tests to inject a fake Ark client.
-    doubaoAdapter(route) {
-        return this.arkAdapter(route);
-    }
-    doubaoTextAdapter() {
-        return this.arkAdapter();
-    }
-    arkAdapter(route) {
-        const apiKey = route ? this.videoCredential(route) : (process.env[DOUBAO_FALLBACK.apiKeyEnv] ?? "").trim();
-        if (!apiKey)
-            return null;
-        const model = route?.info.model ?? this.doubaoModel();
-        const baseUrl = route?.providerConfig.baseUrl ?? DOUBAO_FALLBACK.baseUrl;
-        const key = `doubao ${baseUrl} ${model}`;
-        const cached = this.doubaoAdapters.get(key);
-        if (cached)
-            return cached;
-        const adapter = new DoubaoModel(model, DOUBAO_FALLBACK.timeoutMs, DOUBAO_FALLBACK.maxAttempts, apiKey, baseUrl);
-        this.doubaoAdapters.set(key, adapter);
-        return adapter;
-    }
-    // Ark endpoint id / model name, ARK_MODEL overriding the account-specific default.
-    doubaoModel() {
-        return (process.env[DOUBAO_FALLBACK.modelEnv] ?? "").trim() || DOUBAO_FALLBACK.model;
-    }
-    async withTextFallback(task, signal, generate) {
-        const route = this.resolve(task);
-        const gemini = isGeminiRoute(route.info);
-        const routes = gemini ? geminiRoutes(route) : [route];
-        const failures = [];
-        for (const [index, candidate] of routes.entries()) {
-            signal?.throwIfAborted();
-            const adapter = this.adapter(candidate);
-            try {
-                return await this.tracked(candidate.info, () => generate(adapter));
-            }
-            catch (error) {
-                if (!canFallback(error, signal) || (!gemini && error.code !== "content_filtered"))
-                    throw error;
-                const failure = routedFailure(error, candidate.info);
-                failures.push(failure);
-                const next = routes[index + 1];
-                if (next) {
-                    process.stderr.write(`↪️  ${candidate.info.model} 请求失败，切换到 ${next.info.model} (${formatFailure(failure)})\n`);
-                    continue;
-                }
-                const doubao = this.doubaoTextAdapter();
-                if (!doubao)
-                    throw exhaustedFailure(error, failures);
-                const fallback = this.doubaoRoute(task);
-                process.stderr.write(`↪️  主模型路由已耗尽，回退到豆包 ${fallback.model}\n`);
-                try {
-                    return await this.tracked(fallback, () => generate(doubao));
-                }
-                catch (fallbackError) {
-                    if (!canFallback(fallbackError, signal))
-                        throw fallbackError;
-                    throw exhaustedFailure(fallbackError, [...failures, routedFailure(fallbackError, fallback)]);
-                }
-            }
-        }
-        throw new Error("Text model routes cannot be empty.");
-    }
-    async generateText(task, request) {
-        const spec = LLM_TASK_REGISTRY[task];
-        if (spec.mode !== "text")
-            throw configRuntimeError("The task does not support text generation.", ["text task"], [`task: ${task}`]);
-        return this.withTextFallback(task, request.signal, (adapter) => adapter.generateText({ ...request, maxOutputTokens: spec.maxOutputTokens }));
-    }
-    async generateTool(task, request) {
-        const spec = LLM_TASK_REGISTRY[task];
-        if (spec.mode !== "tool")
-            throw configRuntimeError("The task does not support tool generation.", ["tool task"], [`task: ${task}`]);
-        return this.withTextFallback(task, request.signal, (adapter) => adapter.generateTool({ ...request, maxOutputTokens: spec.maxOutputTokens }));
-    }
-}
-export function createLlmExecutor(explicitConfigPath, options) {
-    return new ModelRouter(loadLlmConfig(explicitConfigPath), options);
-}
-//# sourceMappingURL=router.js.map