@lingjingai/scriptctl 0.8.2 → 0.9.0

package/dist/infra/providers.js

@@ -1,8 +1,7 @@
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { APICallError, NoObjectGeneratedError, RetryError, extractJsonMiddleware, generateObject, generateText, wrapLanguageModel, } from "ai";
-import { z } from "zod";
-import { CliError, DEFAULT_BATCH_MAX_TOKENS, DEFAULT_MAX_TOKENS, EXIT_RUNTIME, EXIT_USAGE, MARKDOWN_BATCH_PROMPT_SPEC, ROLE_TYPE_VALUES, WORLDVIEW_VALUES, } from "../common.js";
+import Anthropic from "@anthropic-ai/sdk";
+import { createDeepSeek } from "@ai-sdk/deepseek";
+import { APICallError, NoObjectGeneratedError, generateObject, generateText, jsonSchema, } from "ai";
+import { ASSET_CURATION_SCHEMA, CliError, DEFAULT_BATCH_MAX_TOKENS, DEFAULT_MAX_TOKENS, DEFAULT_THINKING_BUDGET_TOKENS, EPISODE_TITLE_EXTRACTION_SCHEMA, EXIT_RUNTIME, EXIT_USAGE, MARKDOWN_BATCH_PROMPT_SPEC, METADATA_EXTRACTION_SCHEMA, NONSTREAMING_MAX_TOKENS, WORLDVIEW_VALUES, } from "../common.js";
 import { _md_push_asset, _normalize_speaker_list, buildAssetCurationContext, buildEpisodeTitleContext, buildMetadataContext, deterministicEpisodeShortTitle, deterministicExtractEpisode, deterministicExtractMetadata, episodesNeedingGeneratedTitles, formatBatchSource, parseMarkdownBatch, } from "../domain/direct-core.js";
 function strOf(v) {
     if (v === null || v === undefined)
@@ -16,43 +15,6 @@ function asList(v) {
     return Array.isArray(v) ? v : [];
 }
 // ---------------------------------------------------------------------------
-// Zod schemas for structured extraction (LLM JSON-mode output)
-// ---------------------------------------------------------------------------
-const ROLE_TYPE_TUPLE = ROLE_TYPE_VALUES;
-const WORLDVIEW_TUPLE = WORLDVIEW_VALUES;
-const METADATA_SCHEMA = z.object({
-    confidence: z.enum(["high", "medium", "low"]),
-    worldview: z.enum(WORLDVIEW_TUPLE),
-    worldview_raw: z.string(),
-    actors: z.array(z.object({
-        actor_id: z.string(),
-        role_type: z.enum(ROLE_TYPE_TUPLE),
-        description: z.string(),
-    })),
-    locations: z.array(z.object({
-        location_id: z.string(),
-        description: z.string(),
-    })),
-    props: z.array(z.object({
-        prop_id: z.string(),
-        description: z.string(),
-    })),
-});
-const ASSET_CURATION_SCHEMA = z.object({
-    locations: z.array(z.object({
-        location_id: z.string(),
-        decision: z.enum(["keep", "merge"]),
-        target_location_id: z.string().nullable(),
-        reason: z.string(),
-    })),
-});
-const EPISODE_TITLE_SCHEMA = z.object({
-    episode_titles: z.array(z.object({
-        episode: z.number().int(),
-        title: z.string(),
-    })),
-});
-// ---------------------------------------------------------------------------
 // Mock provider
 // ---------------------------------------------------------------------------
 export class MockProvider {
@@ -138,23 +100,84 @@ export class MockProvider {
     }
 }
 // ---------------------------------------------------------------------------
-// LiteLLM provider — talks to PROJECT_LITELLM_GATEWAY via OpenAI-compatible
-// /v1/chat/completions. Backs every Claude / DeepSeek / etc. model fronted by
-// the gateway. The protocol switch from /v1/messages (Anthropic) to
-// /v1/chat/completions is intentional: it lets gateway-routed models that lack
-// Anthropic tool_use support (e.g. deepseek-v4-pro-packy) reuse the same
-// structured-output path via JSON-mode schemas.
+// Shared prompt builders
+// ---------------------------------------------------------------------------
 //
-// `name = "anthropic"` is preserved (not renamed to "litellm") so previously
-// written checkpoint metadata (`{"provider": "anthropic"}`) keeps validating
-// after upgrade — no forced re-extraction.
+// Same prompt text is used by every real provider (Anthropic, DeepSeek). Keep
+// these as the single source of truth; if a provider needs a tweak, fork the
+// helper rather than inlining a copy that will drift.
+export function buildBatchExtractPrompt(sourceText, batchPlan) {
+    const context = isList(batchPlan["context"]) || (typeof batchPlan["context"] === "object" && batchPlan["context"] !== null)
+        ? batchPlan["context"]
+        : {};
+    const numberedSource = formatBatchSource(sourceText, batchPlan);
+    return ("You convert one batch from an existing script into the documented markdown template.\n" +
+        "\n" +
+        `${MARKDOWN_BATCH_PROMPT_SPEC}\n` +
+        "\n" +
+        "Batch plan:\n" +
+        `${JSON.stringify(batchPlan)}\n` +
+        "\n" +
+        "Read-only context:\n" +
+        `${JSON.stringify(context)}\n` +
+        "\n" +
+        "Batch Source:\n" +
+        `${numberedSource}\n`);
+}
+export function buildEpisodeTitlesPrompt(context) {
+    return ("You generate missing episode titles for a direct script conversion.\n" +
+        "Use only each episode excerpt below. Do not invent plot events outside it.\n" +
+        "Return JSON matching the configured schema.\n" +
+        "\n" +
+        "Requirements:\n" +
+        "- Return one item for every input episode.\n" +
+        "- The title field must be a short Chinese episode title, 2-8 Chinese characters when possible.\n" +
+        "- Do not include episode numbers, `ep_###`, `Episode ###`, punctuation wrappers, or quotes.\n" +
+        "- Prefer concrete plot hooks, conflicts, reversals, or memorable images from the episode.\n" +
+        "\n" +
+        "Episodes needing titles:\n" +
+        `${JSON.stringify(context)}\n`);
+}
+export function buildAssetCurationPrompt(context) {
+    return ("You decide which extracted locations should be merged into stable parent locations.\n" +
+        "Use only the structured script context below. Do not decide from names alone.\n" +
+        "Return JSON matching the configured schema.\n" +
+        "\n" +
+        "Requirements:\n" +
+        "- This task only handles location merge decisions. Actors and props are pruned by deterministic scene-count rules outside this provider step.\n" +
+        "- For locations, choose merge only when the location is clearly the same stable space as another existing location_id.\n" +
+        "- Keep a location whenever its parent location is uncertain, it may need distinct visual continuity, or no stable parent exists.\n" +
+        "- target_location_id must be an existing location_id when decision is merge; use null for keep.\n" +
+        "- Reasons must cite evidence from the provided examples/usage, not a keyword rule.\n" +
+        "- Do not rewrite actions or metadata; this task only decides asset curation.\n" +
+        "\n" +
+        "Script asset curation context:\n" +
+        `${JSON.stringify(context)}\n`);
+}
+export function buildMetadataPrompt(context) {
+    return ("You produce global metadata for a direct script conversion.\n" +
+        "Use only the structured script context below. Do not invent plot events outside it.\n" +
+        "Return JSON matching the configured schema.\n" +
+        "\n" +
+        "Requirements:\n" +
+        `- worldview must be exactly one of: ${WORLDVIEW_VALUES.join(", ")}\n` +
+        "- confidence is high/medium/low; use low only when the script context is insufficient.\n" +
+        "- Every actor_id listed in the input must appear once with role_type 主角 or 配角 and a non-empty description.\n" +
+        "- Every location_id and prop_id listed in the input must appear once with a non-empty description.\n" +
+        "- Descriptions should be concise, useful for downstream asset generation, and grounded in names/states/examples.\n" +
+        "- Do not rewrite action/dialogue source content; this task only writes metadata fields.\n" +
+        "\n" +
+        "Script metadata context:\n" +
+        `${JSON.stringify(context)}\n`);
+}
+// ---------------------------------------------------------------------------
+// Anthropic provider
 // ---------------------------------------------------------------------------
-export class LiteLLMProvider {
+export class AnthropicProvider {
     name = "anthropic";
+    client;
     model;
-    modelId;
-    configuredMaxTokens;
-    constructor(modelId) {
+    constructor(model) {
         const apiKey = (process.env.PROJECT_LITELLM_GATEWAY_API_KEY ?? "").trim();
         if (!apiKey) {
             throw new CliError("INIT FAILED: provider not configured", "Provider credentials are not configured for this environment.", {
@@ -165,78 +188,83 @@ export class LiteLLMProvider {
                 errorCode: "PROVIDER_AUTH_MISSING",
             });
         }
-        const baseURL = (process.env.PROJECT_LITELLM_GATEWAY_BASE_URL ?? "").trim();
-        if (!baseURL) {
-            throw new CliError("INIT FAILED: provider not configured", "Provider gateway URL is not configured for this environment.", {
-                exitCode: EXIT_RUNTIME,
-                required: ["PROJECT_LITELLM_GATEWAY_BASE_URL"],
-                received: ["no gateway base URL environment variable"],
-                nextSteps: ["Run `scriptctl doctor` to identify missing configuration."],
-                errorCode: "PROVIDER_AUTH_MISSING",
-            });
-        }
-        // supportsStructuredOutputs: true makes ai-sdk send the full JSON schema
-        // through `response_format: { type: "json_schema", json_schema: {...} }`
-        // instead of dropping the schema and downgrading to `{type:"json_object"}`.
-        // Without this flag, LiteLLM downstream has no schema to forward to Claude
-        // and the model has to guess the top-level shape from the prompt — that's
-        // why it returned a bare array instead of { episode_titles: [...] }.
-        //
-        // LiteLLM must accept OpenAI-style json_schema response_format and
-        // translate it for the underlying provider. If a particular gateway model
-        // can't translate (e.g. some packy models), requests will 400; in that
-        // case fall back to overriding model id rather than disabling this flag.
-        const provider = createOpenAICompatible({
-            name: "litellm",
-            apiKey,
-            baseURL,
-            supportsStructuredOutputs: true,
-        });
-        this.modelId = modelId;
-        // Even with structured outputs forwarded, some Claude-family models
-        // continue to wrap output in ```json ... ``` fences. extractJsonMiddleware
-        // strips the fence before ai-sdk's JSON.parse runs.
-        this.model = wrapLanguageModel({
-            model: provider(modelId),
-            middleware: extractJsonMiddleware(),
-        });
-        const raw = (process.env.SCRIPTCTL_MAX_TOKENS ?? "").trim();
-        let mt = DEFAULT_MAX_TOKENS;
-        if (raw) {
-            const parsed = parseInt(raw, 10);
+        const baseUrl = (process.env.PROJECT_LITELLM_GATEWAY_BASE_URL ?? "").trim();
+        const opts = { apiKey };
+        if (baseUrl)
+            opts.baseURL = baseUrl;
+        this.client = new Anthropic(opts);
+        this.model = model;
+    }
+    messageRequest(prompt, maxTokens) {
+        const rawMaxTokens = (process.env.SCRIPTCTL_MAX_TOKENS ?? "").trim();
+        let configuredMaxTokens = DEFAULT_MAX_TOKENS;
+        if (rawMaxTokens) {
+            const parsed = parseInt(rawMaxTokens, 10);
             if (!Number.isNaN(parsed))
-                mt = parsed;
+                configuredMaxTokens = parsed;
         }
-        this.configuredMaxTokens = Math.max(1024, Math.min(mt, DEFAULT_MAX_TOKENS));
-    }
-    capTokens(maxTokens, fallback) {
-        const requested = maxTokens !== undefined ? maxTokens : fallback;
-        return Math.max(1024, Math.min(requested, this.configuredMaxTokens, DEFAULT_MAX_TOKENS));
+        let tokenBudget = maxTokens !== undefined ? maxTokens : configuredMaxTokens;
+        tokenBudget = Math.max(1024, Math.min(tokenBudget, configuredMaxTokens, DEFAULT_MAX_TOKENS));
+        const request = {
+            model: this.model,
+            max_tokens: tokenBudget,
+            messages: [{ role: "user", content: prompt }],
+        };
+        if (this.model.endsWith("-think")) {
+            const rawBudget = (process.env.SCRIPTCTL_THINKING_BUDGET_TOKENS ?? "").trim();
+            let budget = DEFAULT_THINKING_BUDGET_TOKENS;
+            if (rawBudget) {
+                const parsed = parseInt(rawBudget, 10);
+                if (!Number.isNaN(parsed))
+                    budget = parsed;
+            }
+            request.thinking = { type: "enabled", budget_tokens: Math.max(1024, Math.min(budget, tokenBudget - 1000)) };
+        }
+        return request;
     }
-    async complete(prompt, maxTokens) {
-        const max = this.capTokens(maxTokens, DEFAULT_BATCH_MAX_TOKENS);
-        let raw;
-        let finishReason;
-        try {
-            const result = await generateText({
-                model: this.model,
-                prompt,
-                maxOutputTokens: max,
-                maxRetries: 0,
-            });
-            raw = result.text.trim();
-            finishReason = strOf(result.finishReason);
+    async collectResponseText(request) {
+        if (request.max_tokens > NONSTREAMING_MAX_TOKENS) {
+            const stream = await this.client.messages.stream(request);
+            const text = await stream.finalText();
+            const message = await stream.finalMessage();
+            return [text.trim(), strOf(message.stop_reason)];
         }
-        catch (exc) {
-            throw translateLiteLLMError(exc, "DRAFT FAILED");
+        const response = await this.client.messages.create(request);
+        return [textFromResponse(response), strOf(response.stop_reason)];
+    }
+    /**
+     * Run a request that forces a specific tool call via `tool_choice`, then return that
+     * tool's `input` dict (already parsed by the SDK — no JSON.parse needed). Returns
+     * `null` when the provider didn't emit the expected tool_use block (e.g. refusal,
+     * truncated before tool call, gateway dropped tools field), letting the caller
+     * raise a method-specific CliError.
+     */
+    async collectToolUseInput(request, toolName) {
+        const maxTokens = Number(request["max_tokens"] ?? 0);
+        if (maxTokens > NONSTREAMING_MAX_TOKENS) {
+            const stream = await this.client.messages.stream(request);
+            const message = (await stream.finalMessage());
+            return [findToolUseInput(message.content ?? [], toolName), strOf(message.stop_reason)];
         }
-        if (finishReason === "length") {
+        const response = (await this.client.messages.create(request));
+        return [findToolUseInput(response.content ?? [], toolName), strOf(response.stop_reason)];
+    }
+    /**
+     * Generic completion entry point. Used by episode subcommand's gemini-writer to draft
+     * one episode's spec markdown from the assembled prompt. Throws CliError when the
+     * provider truncates output (so the caller can surface a deterministic error rather
+     * than committing a half-baked episode).
+     */
+    async complete(prompt, maxTokens) {
+        const request = this.messageRequest(prompt, maxTokens ?? DEFAULT_BATCH_MAX_TOKENS);
+        const [raw, stopReason] = await this.collectResponseText(request);
+        if (stopReason === "max_tokens") {
             throw new CliError("DRAFT FAILED: Provider output truncated", "Provider output truncated.", {
                 exitCode: EXIT_RUNTIME,
                 required: ["complete markdown within provider max_tokens"],
                 received: [
-                    `finishReason: ${finishReason}`,
-                    `max_tokens: ${max}`,
+                    `stop_reason: ${stopReason}`,
+                    `max_tokens: ${request.max_tokens}`,
                     `raw chars: ${raw.length}`,
                     `tail: ${raw.slice(-160) || "<empty response>"}`,
                 ],
@@ -252,45 +280,16 @@ export class LiteLLMProvider {
         return this.extractBatch(sourceText, episodePlan);
     }
     async extractBatch(sourceText, batchPlan) {
-        const context = isList(batchPlan["context"]) || (typeof batchPlan["context"] === "object" && batchPlan["context"] !== null)
-            ? batchPlan["context"]
-            : {};
-        const numberedSource = formatBatchSource(sourceText, batchPlan);
-        const prompt = "You convert one batch from an existing script into the documented markdown template.\n" +
-            "\n" +
-            `${MARKDOWN_BATCH_PROMPT_SPEC}\n` +
-            "\n" +
-            "Batch plan:\n" +
-            `${JSON.stringify(batchPlan)}\n` +
-            "\n" +
-            "Read-only context:\n" +
-            `${JSON.stringify(context)}\n` +
-            "\n" +
-            "Batch Source:\n" +
-            `${numberedSource}\n`;
-        const max = this.capTokens(DEFAULT_BATCH_MAX_TOKENS, DEFAULT_BATCH_MAX_TOKENS);
-        let raw;
-        let finishReason;
-        try {
-            const result = await generateText({
-                model: this.model,
-                prompt,
-                maxOutputTokens: max,
-                maxRetries: 0,
-            });
-            raw = result.text.trim();
-            finishReason = strOf(result.finishReason);
-        }
-        catch (exc) {
-            throw translateLiteLLMError(exc, "INIT FAILED");
-        }
-        if (finishReason === "length") {
+        const prompt = buildBatchExtractPrompt(sourceText, batchPlan);
+        const request = this.messageRequest(prompt, DEFAULT_BATCH_MAX_TOKENS);
+        const [raw, stopReason] = await this.collectResponseText(request);
+        if (stopReason === "max_tokens") {
             throw new CliError("INIT FAILED: Provider output truncated", "Provider output truncated.", {
                 exitCode: EXIT_RUNTIME,
                 required: ["complete markdown within provider max_tokens"],
                 received: [
-                    `finishReason: ${finishReason}`,
-                    `max_tokens: ${max}`,
+                    `stop_reason: ${stopReason}`,
+                    `max_tokens: ${request.max_tokens}`,
                     `raw chars: ${raw.length}`,
                     `tail: ${raw.slice(-160) || "<empty response>"}`,
                 ],
@@ -306,140 +305,117 @@ export class LiteLLMProvider {
         const context = buildEpisodeTitleContext(sourceText, episodePlan);
         if (context.length === 0)
             return { episode_titles: [] };
-        const prompt = "You generate missing episode titles for a direct script conversion.\n" +
-            "Use only each episode excerpt below. Do not invent plot events outside it.\n" +
-            "Return JSON matching the configured schema.\n" +
-            "\n" +
-            "Requirements:\n" +
-            "- Return one item for every input episode.\n" +
-            "- The title field must be a short Chinese episode title, 2-8 Chinese characters when possible.\n" +
-            "- Do not include episode numbers, `ep_###`, `Episode ###`, punctuation wrappers, or quotes.\n" +
-            "- Prefer concrete plot hooks, conflicts, reversals, or memorable images from the episode.\n" +
-            "\n" +
-            "Episodes needing titles:\n" +
-            `${JSON.stringify(context)}\n`;
-        return this.extractStructured({
-            prompt,
-            maxTokens: 4096,
-            schema: EPISODE_TITLE_SCHEMA,
-            title: "INIT FAILED: Episode title output truncated",
-            truncationMessage: "Episode title output truncated.",
-            required: ["complete episode title JSON within provider max_tokens"],
-            invalidTitle: "INIT FAILED: Provider returned invalid episode title JSON",
-            invalidMessage: "Provider returned invalid episode title JSON.",
-            invalidRequired: ["valid JSON matching the configured schema"],
-            truncationNext: ["Rerun init; if this repeats, split the source or provide explicit episode titles."],
-            invalidNext: ["Rerun init; title generation will retry before batch extraction."],
-        });
+        const prompt = buildEpisodeTitlesPrompt(context);
+        const toolName = "submit_episode_titles";
+        const request = { ...this.messageRequest(prompt, 4096) };
+        request["tools"] = [{
+                name: toolName,
+                description: "Return generated short Chinese titles for every input episode.",
+                input_schema: EPISODE_TITLE_EXTRACTION_SCHEMA,
+            }];
+        request["tool_choice"] = { type: "tool", name: toolName };
+        const [input, stopReason] = await this.collectToolUseInput(request, toolName);
+        if (stopReason === "max_tokens") {
+            throw new CliError("INIT FAILED: Episode title output truncated", "Episode title output truncated.", {
+                exitCode: EXIT_RUNTIME,
+                required: ["complete episode title JSON within provider max_tokens"],
+                received: [`stop_reason: ${stopReason}`, `max_tokens: ${request["max_tokens"]}`],
+                nextSteps: ["Rerun init; if this repeats, split the source or provide explicit episode titles."],
+            });
+        }
+        if (!input) {
+            throw new CliError("INIT FAILED: Provider returned invalid episode title JSON", "Provider returned invalid episode title JSON.", {
+                exitCode: EXIT_RUNTIME,
+                required: [`tool_use block with name "${toolName}"`],
+                received: [`stop_reason: ${stopReason || "unknown"}`, `missing tool_use block: ${toolName}`],
+                nextSteps: ["Rerun init; title generation will retry before batch extraction."],
+            });
+        }
+        return input;
     }
     async extractAssetCuration(_sourceText, script) {
         const context = buildAssetCurationContext(script);
-        const prompt = "You decide which extracted locations should be merged into stable parent locations.\n" +
-            "Use only the structured script context below. Do not decide from names alone.\n" +
-            "Return JSON matching the configured schema.\n" +
-            "\n" +
-            "Requirements:\n" +
-            "- This task only handles location merge decisions. Actors and props are pruned by deterministic scene-count rules outside this provider step.\n" +
-            "- For locations, choose merge only when the location is clearly the same stable space as another existing location_id.\n" +
-            "- Keep a location whenever its parent location is uncertain, it may need distinct visual continuity, or no stable parent exists.\n" +
-            "- target_location_id must be an existing location_id when decision is merge; use null for keep.\n" +
-            "- Reasons must cite evidence from the provided examples/usage, not a keyword rule.\n" +
-            "- Do not rewrite actions or metadata; this task only decides asset curation.\n" +
-            "\n" +
-            "Script asset curation context:\n" +
-            `${JSON.stringify(context)}\n`;
-        return this.extractStructured({
-            prompt,
-            maxTokens: DEFAULT_MAX_TOKENS,
-            schema: ASSET_CURATION_SCHEMA,
-            title: "INIT FAILED: Asset curation output truncated",
-            truncationMessage: "Asset curation output truncated.",
-            required: ["complete asset curation JSON within provider max_tokens"],
-            invalidTitle: "INIT FAILED: Provider returned invalid asset curation JSON",
-            invalidMessage: "Provider returned invalid asset curation JSON.",
-            invalidRequired: ["valid JSON matching the configured schema"],
-            truncationNext: ["Rerun init; extraction checkpoints will be reused and asset curation will retry."],
-            invalidNext: ["Rerun init; extraction checkpoints will be reused and asset curation will retry."],
-        });
+        const prompt = buildAssetCurationPrompt(context);
+        const toolName = "submit_asset_curation";
+        const request = { ...this.messageRequest(prompt, DEFAULT_MAX_TOKENS) };
+        request["tools"] = [{
+                name: toolName,
+                description: "Return location merge decisions for the provided script.",
+                input_schema: ASSET_CURATION_SCHEMA,
+            }];
+        request["tool_choice"] = { type: "tool", name: toolName };
+        const [input, stopReason] = await this.collectToolUseInput(request, toolName);
+        if (stopReason === "max_tokens") {
+            throw new CliError("INIT FAILED: Asset curation output truncated", "Asset curation output truncated.", {
+                exitCode: EXIT_RUNTIME,
+                required: ["complete asset curation JSON within provider max_tokens"],
+                received: [`stop_reason: ${stopReason}`, `max_tokens: ${request["max_tokens"]}`],
+                nextSteps: ["Rerun init; extraction checkpoints will be reused and asset curation will retry."],
+            });
+        }
+        if (!input) {
+            throw new CliError("INIT FAILED: Provider returned invalid asset curation JSON", "Provider returned invalid asset curation JSON.", {
+                exitCode: EXIT_RUNTIME,
+                required: [`tool_use block with name "${toolName}"`],
+                received: [`stop_reason: ${stopReason || "unknown"}`, `missing tool_use block: ${toolName}`],
+                nextSteps: ["Rerun init; extraction checkpoints will be reused and asset curation will retry."],
+            });
+        }
+        return input;
     }
     async extractMetadata(_sourceText, script) {
         const context = buildMetadataContext(script);
-        const prompt = "You produce global metadata for a direct script conversion.\n" +
-            "Use only the structured script context below. Do not invent plot events outside it.\n" +
-            "Return JSON matching the configured schema.\n" +
-            "\n" +
-            "Requirements:\n" +
-            `- worldview must be exactly one of: ${WORLDVIEW_VALUES.join(", ")}\n` +
-            "- confidence is high/medium/low; use low only when the script context is insufficient.\n" +
-            "- Every actor_id listed in the input must appear once with role_type 主角 or 配角 and a non-empty description.\n" +
-            "- Every location_id and prop_id listed in the input must appear once with a non-empty description.\n" +
-            "- Descriptions should be concise, useful for downstream asset generation, and grounded in names/states/examples.\n" +
-            "- Do not rewrite action/dialogue source content; this task only writes metadata fields.\n" +
-            "\n" +
-            "Script metadata context:\n" +
-            `${JSON.stringify(context)}\n`;
-        return this.extractStructured({
-            prompt,
-            maxTokens: DEFAULT_MAX_TOKENS,
-            schema: METADATA_SCHEMA,
-            title: "INIT FAILED: Metadata output truncated",
-            truncationMessage: "Metadata output truncated.",
-            required: ["complete metadata JSON within provider max_tokens"],
-            invalidTitle: "INIT FAILED: Provider returned invalid metadata JSON",
-            invalidMessage: "Provider returned invalid metadata JSON.",
-            invalidRequired: ["valid JSON matching the configured schema"],
-            truncationNext: ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
-            invalidNext: ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
-        });
-    }
-    async extractStructured(args) {
-        const max = this.capTokens(args.maxTokens, args.maxTokens);
-        try {
-            const result = await generateObject({
-                model: this.model,
-                prompt: args.prompt,
-                schema: args.schema,
-                maxOutputTokens: max,
-                maxRetries: 0,
+        const prompt = buildMetadataPrompt(context);
+        const toolName = "submit_script_metadata";
+        const request = { ...this.messageRequest(prompt, DEFAULT_MAX_TOKENS) };
+        request["tools"] = [{
+                name: toolName,
+                description: "Return global script metadata (worldview, actors, locations, props).",
+                input_schema: METADATA_EXTRACTION_SCHEMA,
+            }];
+        request["tool_choice"] = { type: "tool", name: toolName };
+        const [input, stopReason] = await this.collectToolUseInput(request, toolName);
+        if (stopReason === "max_tokens") {
+            throw new CliError("INIT FAILED: Metadata output truncated", "Metadata output truncated.", {
+                exitCode: EXIT_RUNTIME,
+                required: ["complete metadata JSON within provider max_tokens"],
+                received: [`stop_reason: ${stopReason}`, `max_tokens: ${request["max_tokens"]}`],
+                nextSteps: ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
             });
-            const finishReason = strOf(result.finishReason);
-            if (finishReason === "length") {
-                throw new CliError(args.title, args.truncationMessage, {
-                    exitCode: EXIT_RUNTIME,
-                    required: args.required,
-                    received: [`finishReason: ${finishReason}`, `max_tokens: ${max}`],
-                    nextSteps: args.truncationNext,
-                });
-            }
-            return result.object;
         }
-        catch (exc) {
-            if (exc instanceof CliError)
-                throw exc;
-            if (NoObjectGeneratedError.isInstance(exc)) {
-                const cause = exc.cause;
-                throw new CliError(args.invalidTitle, args.invalidMessage, {
-                    exitCode: EXIT_RUNTIME,
-                    required: args.invalidRequired,
-                    received: [
-                        `error: ${exc.message?.slice(0, 160) || "no object generated"}`,
-                        ...(cause?.message ? [`cause: ${cause.message.slice(0, 160)}`] : []),
-                    ],
-                    nextSteps: args.invalidNext,
-                });
-            }
-            throw translateLiteLLMError(exc, "INIT FAILED");
+        if (!input) {
+            throw new CliError("INIT FAILED: Provider returned invalid metadata JSON", "Provider returned invalid metadata JSON.", {
+                exitCode: EXIT_RUNTIME,
+                required: [`tool_use block with name "${toolName}"`],
+                received: [`stop_reason: ${stopReason || "unknown"}`, `missing tool_use block: ${toolName}`],
+                nextSteps: ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
+            });
         }
+        return input;
     }
 }
 // ---------------------------------------------------------------------------
-// Gemini provider — @ai-sdk/google direct to Google AI Studio.
-// Used by `scriptctl episode draft` when --provider gemini.
+// Gemini provider (used by `scriptctl episode draft` by default)
 // ---------------------------------------------------------------------------
+/**
+ * Google Gemini provider via REST API. No SDK dependency (uses fetch).
+ *
+ * Used as the default writer for `scriptctl episode draft`. The Anthropic provider
+ * stays available for other internal extraction tasks (metadata / title generation /
+ * direct-init batch extraction) where Claude tends to outperform Gemini on JSON
+ * schema adherence.
+ *
+ * Env:
+ *   - `SCRIPTCTL_GEMINI_API_KEY` (or fallback `GEMINI_API_KEY`)  required
+ *   - `SCRIPTCTL_GEMINI_BASE_URL`                                optional override
+ *   - `SCRIPTCTL_GEMINI_MODEL`                                   optional default-model override
+ */
 export class GeminiProvider {
     name = "gemini";
+    apiKey;
+    baseUrl;
     model;
-    constructor(modelId) {
+    constructor(model) {
         const apiKey = (process.env.SCRIPTCTL_GEMINI_API_KEY ?? process.env.GEMINI_API_KEY ?? "").trim();
         if (!apiKey) {
             throw new CliError("DRAFT FAILED: provider not configured", "Provider credentials are not configured for this environment.", {
@@ -450,128 +426,315 @@ export class GeminiProvider {
                 errorCode: "PROVIDER_AUTH_MISSING",
             });
         }
-        const baseURL = (process.env.SCRIPTCTL_GEMINI_BASE_URL ?? "").trim();
-        const opts = { apiKey };
-        if (baseURL)
-            opts.baseURL = baseURL.replace(/\/+$/, "");
-        const provider = createGoogleGenerativeAI(opts);
-        const id = (modelId || process.env.SCRIPTCTL_GEMINI_MODEL || "gemini-2.5-pro").trim();
-        this.model = provider(id);
+        this.apiKey = apiKey;
+        const baseUrl = (process.env.SCRIPTCTL_GEMINI_BASE_URL ?? "https://generativelanguage.googleapis.com").trim();
+        this.baseUrl = baseUrl.replace(/\/+$/, "");
+        this.model = (model || process.env.SCRIPTCTL_GEMINI_MODEL || "gemini-2.5-pro").trim();
     }
     /**
      * Plain-text completion. Used by `episode draft` to write a spec-md episode body.
      */
     async complete(prompt, maxTokens) {
         const tokens = Math.max(1024, Math.min(maxTokens ?? DEFAULT_BATCH_MAX_TOKENS, DEFAULT_MAX_TOKENS));
-        let raw;
-        let finishReason;
-        try {
-            const result = await generateText({
-                model: this.model,
-                prompt,
+        const url = `${this.baseUrl}/v1beta/models/${encodeURIComponent(this.model)}:generateContent?key=${encodeURIComponent(this.apiKey)}`;
+        const body = {
+            contents: [{ role: "user", parts: [{ text: prompt }] }],
+            generationConfig: {
                 maxOutputTokens: tokens,
                 temperature: 0,
-                maxRetries: 0,
+            },
+        };
+        let response;
+        try {
+            response = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
             });
-            raw = result.text.trim();
-            finishReason = strOf(result.finishReason);
         }
         catch (exc) {
-            throw translateGeminiError(exc, tokens);
+            throw new CliError("DRAFT FAILED: provider unreachable", "Provider endpoint is unreachable.", {
+                exitCode: EXIT_RUNTIME,
+                required: ["reachable Gemini endpoint"],
+                received: [String(exc.message ?? exc)],
+                nextSteps: ["Check network connectivity and retry. Run `scriptctl doctor` if the issue persists."],
+                errorCode: "PROVIDER_NETWORK",
+            });
         }
-        if (finishReason === "length") {
+        const text = await response.text();
+        if (!response.ok) {
+            const isAuth = response.status === 401 || response.status === 403;
+            const isRateLimit = response.status === 429;
+            const publicMessage = isAuth
+                ? "Provider rejected the request: authentication failed."
+                : isRateLimit
+                    ? "Provider is rate-limited."
+                    : "Provider returned an HTTP error.";
+            throw new CliError("DRAFT FAILED: provider returned error", publicMessage, {
+                exitCode: EXIT_RUNTIME,
+                required: ["HTTP 2xx from Gemini"],
+                received: [`status: ${response.status}`, `body: ${text.slice(0, 320) || "<empty>"}`],
+                nextSteps: isRateLimit
+                    ? ["Back off and retry after a short wait."]
+                    : isAuth
+                        ? ["Run `scriptctl doctor` to verify provider configuration."]
+                        : ["Retry once; if the issue persists, run `scriptctl doctor`."],
+                errorCode: isAuth
+                    ? "PROVIDER_AUTH_REJECTED"
+                    : isRateLimit
+                        ? "PROVIDER_RATE_LIMITED"
+                        : "PROVIDER_HTTP_ERROR",
+            });
+        }
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch (exc) {
+            throw new CliError("DRAFT FAILED: provider returned invalid response", "Provider returned a response that could not be parsed.", {
+                exitCode: EXIT_RUNTIME,
+                required: ["valid JSON response"],
+                received: [`body head: ${text.slice(0, 160)}`, `parse error: ${exc.message}`],
+                nextSteps: ["Retry once; if the issue persists, run `scriptctl doctor`."],
+                errorCode: "PROVIDER_INVALID_RESPONSE",
+            });
+        }
+        const candidate = payload.candidates?.[0];
+        const finishReason = strOf(candidate?.finishReason ?? "");
+        if (finishReason === "MAX_TOKENS") {
             throw new CliError("DRAFT FAILED: Provider output truncated", "Provider output truncated.", {
                 exitCode: EXIT_RUNTIME,
                 required: ["complete markdown within provider max_tokens"],
-                received: [`finishReason: ${finishReason}`, `maxOutputTokens: ${tokens}`],
+                received: [`finishReason: MAX_TOKENS`, `maxOutputTokens: ${tokens}`],
                 nextSteps: [
                     "Re-run with --regen, or split the episode outline into smaller scopes.",
                 ],
                 errorCode: "PROVIDER_OUTPUT_TRUNCATED",
             });
         }
-        if (finishReason && finishReason !== "stop" && finishReason !== "length") {
-            // content-filter / error / other — surface to agent rather than silently treat as success.
+        if (finishReason && finishReason !== "STOP" && finishReason !== "MAX_TOKENS") {
+            // SAFETY / RECITATION / OTHER — surface to agent rather than silently treat as success.
             throw new CliError("DRAFT FAILED: provider stopped abnormally", "Provider stopped before completing the response.", {
                 exitCode: EXIT_RUNTIME,
-                required: ["finishReason: stop"],
+                required: ["finishReason: STOP"],
                 received: [`finishReason: ${finishReason}`],
                 nextSteps: ["Inspect prompt / outline for triggering content; retry with --regen if it looks transient."],
                 errorCode: "PROVIDER_ABNORMAL_STOP",
             });
         }
-        if (!raw) {
+        const parts = candidate?.content?.parts ?? [];
+        const out = parts.map((p) => (typeof p.text === "string" ? p.text : "")).join("").trim();
+        if (!out) {
             throw new CliError("DRAFT FAILED: provider returned empty content", "Provider returned an empty response.", {
                 exitCode: EXIT_RUNTIME,
-                required: ["non-empty model output"],
-                received: [`finishReason: ${finishReason || "<unset>"}`, "text: <empty>"],
+                required: ["non-empty candidate content"],
+                received: [`finishReason: ${finishReason || "<unset>"}`, `parts: ${parts.length}`],
                 nextSteps: ["Retry once; if it persists, run `scriptctl doctor`."],
                 errorCode: "PROVIDER_EMPTY_RESPONSE",
             });
         }
-        return raw;
+        return out;
     }
 }
 // ---------------------------------------------------------------------------
-// Error translation
+// DeepSeek provider (Vercel AI SDK, routed via LiteLLM gateway)
 // ---------------------------------------------------------------------------
-function translateLiteLLMError(exc, titlePrefix) {
-    // ai-sdk wraps transient errors in RetryError after retries exhaust.
-    // Unwrap so 401/403/429 still resolve to their precise CliError variant
-    // instead of falling through to generic PROVIDER_NETWORK.
-    if (RetryError.isInstance(exc) && APICallError.isInstance(exc.lastError)) {
-        exc = exc.lastError;
+//
+// Selected by makeProvider() when model name starts with "deepseek-". Reuses
+// the same PROJECT_LITELLM_GATEWAY_{API_KEY,BASE_URL} env pair as
+// AnthropicProvider — the gateway exposes both /v1/messages (Anthropic-style)
+// and /chat/completions (OpenAI-style) endpoints, and createDeepSeek hits the
+// OpenAI-style one. Non-streaming on purpose: streaming is what gives the
+// gateway "Premature close" failures on long single-call requests.
+export class DeepSeekProvider {
+    name = "deepseek";
+    client;
+    model;
+    constructor(model) {
+        const apiKey = (process.env.PROJECT_LITELLM_GATEWAY_API_KEY ?? "").trim();
+        if (!apiKey) {
+            throw new CliError("INIT FAILED: provider not configured", "Provider credentials are not configured for this environment.", {
+                exitCode: EXIT_RUNTIME,
+                required: ["PROJECT_LITELLM_GATEWAY_API_KEY"],
+                received: ["no API key environment variable"],
+                nextSteps: ["Run `scriptctl doctor` to identify missing configuration."],
+                errorCode: "PROVIDER_AUTH_MISSING",
+            });
+        }
+        const baseURL = (process.env.PROJECT_LITELLM_GATEWAY_BASE_URL ?? "").trim();
+        this.client = createDeepSeek(baseURL ? { apiKey, baseURL } : { apiKey });
+        this.model = model;
     }
-    if (APICallError.isInstance(exc)) {
-        const status = exc.statusCode ?? 0;
-        const isAuth = status === 401 || status === 403;
-        const isRateLimit = status === 429;
-        const publicMessage = isAuth
-            ? "Provider rejected the request: authentication failed."
-            : isRateLimit
-                ? "Provider is rate-limited."
-                : "Provider returned an HTTP error.";
-        const body = strOf(exc.responseBody).slice(0, 320) || "<empty>";
-        return new CliError(`${titlePrefix}: provider returned error`, publicMessage, {
-            exitCode: EXIT_RUNTIME,
-            required: ["HTTP 2xx from provider"],
-            received: [`status: ${status || "unknown"}`, `body: ${body}`],
-            nextSteps: isRateLimit
-                ? ["Back off and retry after a short wait."]
-                : isAuth
-                    ? ["Run `scriptctl doctor` to verify provider configuration."]
-                    : ["Retry once; if the issue persists, run `scriptctl doctor`."],
-            errorCode: isAuth
-                ? "PROVIDER_AUTH_REJECTED"
-                : isRateLimit
-                    ? "PROVIDER_RATE_LIMITED"
-                    : "PROVIDER_HTTP_ERROR",
+    modelHandle() {
+        return this.client(this.model);
+    }
+    async complete(prompt, maxTokens) {
+        const tokens = clampDeepSeekTokens(maxTokens ?? DEFAULT_BATCH_MAX_TOKENS);
+        let text = "";
+        let finishReason = "";
+        try {
+            const result = await generateText({
+                model: this.modelHandle(),
+                prompt,
+                maxOutputTokens: tokens,
+            });
+            text = result.text;
+            finishReason = String(result.finishReason ?? "");
+        }
+        catch (exc) {
+            throw mapDeepSeekError(exc, "complete", "DRAFT FAILED");
+        }
+        if (finishReason === "length") {
+            throw new CliError("DRAFT FAILED: Provider output truncated", "Provider output truncated.", {
+                exitCode: EXIT_RUNTIME,
+                required: ["complete markdown within provider max_tokens"],
+                received: [
+                    `finishReason: length`,
+                    `maxOutputTokens: ${tokens}`,
+                    `raw chars: ${text.length}`,
+                    `tail: ${text.slice(-160) || "<empty response>"}`,
+                ],
+                nextSteps: ["Re-run with --regen, or split the episode outline into smaller scopes."],
+                errorCode: "PROVIDER_OUTPUT_TRUNCATED",
+            });
+        }
+        return text;
+    }
+    extractEpisode(sourceText, episodePlan) {
+        return this.extractBatch(sourceText, episodePlan);
+    }
+    async extractBatch(sourceText, batchPlan) {
+        const prompt = buildBatchExtractPrompt(sourceText, batchPlan);
+        const tokens = clampDeepSeekTokens(DEFAULT_BATCH_MAX_TOKENS);
+        let text = "";
+        let finishReason = "";
+        try {
+            const result = await generateText({
+                model: this.modelHandle(),
+                prompt,
+                maxOutputTokens: tokens,
+            });
+            text = result.text;
+            finishReason = String(result.finishReason ?? "");
+        }
+        catch (exc) {
+            throw mapDeepSeekError(exc, "batch", "INIT FAILED");
+        }
+        if (finishReason === "length") {
+            throw new CliError("INIT FAILED: Provider output truncated", "Provider output truncated.", {
+                exitCode: EXIT_RUNTIME,
+                required: ["complete markdown within provider max_tokens"],
+                received: [
+                    `finishReason: length`,
+                    `maxOutputTokens: ${tokens}`,
+                    `raw chars: ${text.length}`,
+                    `tail: ${text.slice(-160) || "<empty response>"}`,
+                ],
+                nextSteps: ["Rerun init; completed batch checkpoints will be reused. If this repeats, split the source episode."],
+                errorCode: "PROVIDER_OUTPUT_TRUNCATED",
+            });
+        }
+        const parsed = parseMarkdownBatch(text, batchPlan);
+        parsed["_raw_markdown"] = text;
+        return parsed;
+    }
+    async extractEpisodeTitles(sourceText, episodePlan) {
+        const context = buildEpisodeTitleContext(sourceText, episodePlan);
+        if (context.length === 0)
+            return { episode_titles: [] };
+        return this.runJsonExtract({
+            prompt: buildEpisodeTitlesPrompt(context),
+            schema: EPISODE_TITLE_EXTRACTION_SCHEMA,
+            maxOutputTokens: 4096,
+            truncatedTitle: "INIT FAILED: Episode title output truncated",
+            truncatedMessage: "Episode title output truncated.",
+            truncatedNextSteps: ["Rerun init; if this repeats, split the source or provide explicit episode titles."],
+            invalidTitle: "INIT FAILED: Provider returned invalid episode title JSON",
+            invalidMessage: "Provider returned invalid episode title JSON.",
+            invalidNextSteps: ["Rerun init; title generation will retry before batch extraction."],
         });
     }
-    if (RetryError.isInstance(exc)) {
-        return new CliError(`${titlePrefix}: provider unreachable`, "Provider endpoint is unreachable.", {
-            exitCode: EXIT_RUNTIME,
-            required: ["reachable provider endpoint"],
-            received: [strOf(exc.message).slice(0, 320) || "retries exhausted"],
-            nextSteps: ["Check network connectivity and retry. Run `scriptctl doctor` if the issue persists."],
-            errorCode: "PROVIDER_NETWORK",
+    async extractAssetCuration(_sourceText, script) {
+        const context = buildAssetCurationContext(script);
+        return this.runJsonExtract({
+            prompt: buildAssetCurationPrompt(context),
+            schema: ASSET_CURATION_SCHEMA,
+            maxOutputTokens: DEFAULT_MAX_TOKENS,
+            truncatedTitle: "INIT FAILED: Asset curation output truncated",
+            truncatedMessage: "Asset curation output truncated.",
+            truncatedNextSteps: ["Rerun init; extraction checkpoints will be reused and asset curation will retry."],
+            invalidTitle: "INIT FAILED: Provider returned invalid asset curation JSON",
+            invalidMessage: "Provider returned invalid asset curation JSON.",
+            invalidNextSteps: ["Rerun init; extraction checkpoints will be reused and asset curation will retry."],
         });
     }
-    const msg = strOf(exc?.message).slice(0, 320);
-    return new CliError(`${titlePrefix}: provider returned error`, "Provider returned an unexpected error.", {
-        exitCode: EXIT_RUNTIME,
-        required: ["successful provider response"],
-        received: [msg || String(exc)],
-        nextSteps: ["Retry once; if the issue persists, run `scriptctl doctor`."],
-        errorCode: "PROVIDER_HTTP_ERROR",
-    });
-}
-function translateGeminiError(exc, tokens) {
-    if (RetryError.isInstance(exc) && APICallError.isInstance(exc.lastError)) {
-        exc = exc.lastError;
+    async extractMetadata(_sourceText, script) {
+        const context = buildMetadataContext(script);
+        return this.runJsonExtract({
+            prompt: buildMetadataPrompt(context),
+            schema: METADATA_EXTRACTION_SCHEMA,
+            maxOutputTokens: DEFAULT_MAX_TOKENS,
+            truncatedTitle: "INIT FAILED: Metadata output truncated",
+            truncatedMessage: "Metadata output truncated.",
+            truncatedNextSteps: ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
+            invalidTitle: "INIT FAILED: Provider returned invalid metadata JSON",
+            invalidMessage: "Provider returned invalid metadata JSON.",
+            invalidNextSteps: ["Rerun init; extraction checkpoints will be reused and metadata will retry."],
+        });
     }
-    if (APICallError.isInstance(exc)) {
-        const status = exc.statusCode ?? 0;
+    async runJsonExtract(opts) {
+        const tokens = clampDeepSeekTokens(opts.maxOutputTokens);
+        let object;
+        let finishReason = "";
+        try {
+            const result = await generateObject({
+                model: this.modelHandle(),
+                schema: jsonSchema(opts.schema),
+                prompt: opts.prompt,
+                maxOutputTokens: tokens,
+            });
+            object = result.object;
+            finishReason = String(result.finishReason ?? "");
+        }
+        catch (exc) {
+            if (NoObjectGeneratedError.isInstance(exc)) {
+                throw new CliError(opts.invalidTitle, opts.invalidMessage, {
+                    exitCode: EXIT_RUNTIME,
+                    required: ["JSON object matching configured schema"],
+                    received: [`no object generated`, `error: ${exc.message?.slice(0, 200) ?? ""}`],
+                    nextSteps: opts.invalidNextSteps,
+                });
+            }
+            throw mapDeepSeekError(exc, "json_extract", "INIT FAILED");
+        }
+        if (finishReason === "length") {
+            throw new CliError(opts.truncatedTitle, opts.truncatedMessage, {
+                exitCode: EXIT_RUNTIME,
+                required: ["complete JSON within provider max_tokens"],
+                received: [`finishReason: length`, `maxOutputTokens: ${tokens}`],
+                nextSteps: opts.truncatedNextSteps,
+            });
+        }
+        if (!object || typeof object !== "object" || Array.isArray(object)) {
+            throw new CliError(opts.invalidTitle, opts.invalidMessage, {
+                exitCode: EXIT_RUNTIME,
+                required: ["JSON object matching configured schema"],
+                received: [`type: ${Array.isArray(object) ? "array" : typeof object}`],
+                nextSteps: opts.invalidNextSteps,
+            });
+        }
+        return object;
+    }
+}
+function clampDeepSeekTokens(tokens) {
+    return Math.max(1024, Math.min(tokens, DEFAULT_MAX_TOKENS));
+}
+function mapDeepSeekError(exc, stage, titlePrefix) {
+    // ai sdk retries 429/5xx 3 times then wraps the last failure in RetryError.lastError;
+    // peel one layer so HTTP status mapping (429 / 401 / 5xx) still works.
+    const peeled = (exc?.lastError ?? exc);
+    if (APICallError.isInstance(peeled)) {
+        const status = peeled.statusCode ?? 0;
         const isAuth = status === 401 || status === 403;
         const isRateLimit = status === 429;
         const publicMessage = isAuth
@@ -579,11 +742,10 @@ function translateGeminiError(exc, tokens) {
             : isRateLimit
                 ? "Provider is rate-limited."
                 : "Provider returned an HTTP error.";
-        const body = strOf(exc.responseBody).slice(0, 320) || "<empty>";
-        return new CliError("DRAFT FAILED: provider returned error", publicMessage, {
+        return new CliError(`${titlePrefix}: provider returned error`, publicMessage, {
             exitCode: EXIT_RUNTIME,
-            required: ["HTTP 2xx from Gemini"],
-            received: [`status: ${status || "unknown"}`, `body: ${body}`],
+            required: ["HTTP 2xx from provider"],
+            received: [`status: ${status || "unknown"}`, `stage: ${stage}`, `message: ${peeled.message?.slice(0, 200) ?? ""}`],
             nextSteps: isRateLimit
                 ? ["Back off and retry after a short wait."]
                 : isAuth
@@ -596,32 +758,51 @@ function translateGeminiError(exc, tokens) {
                     : "PROVIDER_HTTP_ERROR",
         });
     }
-    if (RetryError.isInstance(exc)) {
-        return new CliError("DRAFT FAILED: provider unreachable", "Provider endpoint is unreachable.", {
-            exitCode: EXIT_RUNTIME,
-            required: ["reachable Gemini endpoint"],
-            received: [strOf(exc.message).slice(0, 320) || "retries exhausted"],
-            nextSteps: ["Check network connectivity and retry. Run `scriptctl doctor` if the issue persists."],
-            errorCode: "PROVIDER_NETWORK",
-        });
-    }
-    const msg = strOf(exc?.message).slice(0, 320);
-    return new CliError("DRAFT FAILED: provider returned invalid response", "Provider returned a response that could not be parsed.", {
+    const message = exc?.message ?? String(exc);
+    return new CliError(`${titlePrefix}: provider unreachable`, "Provider endpoint is unreachable.", {
         exitCode: EXIT_RUNTIME,
-        required: ["valid response from Gemini"],
-        received: [msg || String(exc), `maxOutputTokens: ${tokens}`],
-        nextSteps: ["Retry once; if the issue persists, run `scriptctl doctor`."],
-        errorCode: "PROVIDER_INVALID_RESPONSE",
+        required: ["reachable provider endpoint"],
+        received: [`stage: ${stage}`, message.slice(0, 200)],
+        nextSteps: ["Check network connectivity and retry. Run `scriptctl doctor` if the issue persists."],
+        errorCode: "PROVIDER_NETWORK",
     });
 }
+function textFromResponse(response) {
+    const parts = [];
+    for (const block of response.content ?? []) {
+        if (block.text)
+            parts.push(block.text);
+    }
+    return parts.join("\n").trim();
+}
+/**
+ * Find a forced tool_use block by name in a Message's content array.
+ * Returns its `input` (already parsed by the SDK) or `null` when missing/non-object.
+ */
+function findToolUseInput(content, toolName) {
+    for (const block of content) {
+        if (block?.type === "tool_use" && block.name === toolName) {
+            const inp = block.input;
+            if (inp && typeof inp === "object" && !Array.isArray(inp))
+                return inp;
+            return null;
+        }
+    }
+    return null;
+}
 // ---------------------------------------------------------------------------
 // Factory
 // ---------------------------------------------------------------------------
 export function makeProvider(name, model) {
     if (name === "mock")
         return new MockProvider();
+    // Model-name prefix overrides provider name: deepseek-* models route to
+    // DeepSeekProvider regardless of --provider value. Lets the same litellm
+    // gateway expose Anthropic and DeepSeek models behind one --provider flag.
+    if (model.startsWith("deepseek-"))
+        return new DeepSeekProvider(model);
     if (name === "anthropic")
-        return new LiteLLMProvider(model);
+        return new AnthropicProvider(model);
     if (name === "gemini")
         return new GeminiProvider(model);
     throw new CliError("INIT FAILED: Unsupported provider", "Unsupported provider.", {