@lingjingai/scriptctl 0.7.4 → 0.8.0

package/dist/infra/providers.js

@@ -1,5 +1,8 @@
-import Anthropic from "@anthropic-ai/sdk";
-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 { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { APICallError, NoObjectGeneratedError, RetryError, generateObject, generateText, } 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 { _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)
@@ -12,50 +15,43 @@ function isList(v) {
 function asList(v) {
     return Array.isArray(v) ? v : [];
 }
-// aihubmix / litellm gateways frequently drop long-running SSE connections with
-// "Premature close" or fetch failures. The Anthropic SDK's automatic retry does
-// not cover mid-stream failures, so we wrap each provider call in our own
-// bounded retry loop on transient transport errors only.
-function isTransientStreamError(err) {
-    if (!err || typeof err !== "object")
-        return false;
-    const e = err;
-    const name = strOf(e.name);
-    const msg = strOf(e.message);
-    const code = strOf(e.code);
-    if (name === "APIConnectionError" || name === "APIConnectionTimeoutError")
-        return true;
-    if (/Premature close/i.test(msg))
-        return true;
-    if (/fetch failed/i.test(msg))
-        return true;
-    if (/socket hang up/i.test(msg))
-        return true;
-    if (/ECONNRESET|ETIMEDOUT|EPIPE|UND_ERR_SOCKET|UND_ERR_CONNECT_TIMEOUT/i.test(`${msg} ${code}`))
-        return true;
-    if (e.cause && isTransientStreamError(e.cause))
-        return true;
-    return false;
-}
-const STREAM_RETRY_MAX_ATTEMPTS = 3;
-async function runWithStreamRetry(fn) {
-    let attempt = 0;
-    let lastErr;
-    while (attempt < STREAM_RETRY_MAX_ATTEMPTS) {
-        try {
-            return await fn();
-        }
-        catch (err) {
-            lastErr = err;
-            attempt += 1;
-            if (attempt >= STREAM_RETRY_MAX_ATTEMPTS || !isTransientStreamError(err))
-                throw err;
-            const delayMs = 1000 * Math.pow(2, attempt - 1); // 1s, 2s
-            await new Promise((resolve) => setTimeout(resolve, delayMs));
-        }
-    }
-    throw lastErr;
-}
+// ---------------------------------------------------------------------------
+// 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
 // ---------------------------------------------------------------------------
@@ -142,13 +138,23 @@ export class MockProvider {
     }
 }
 // ---------------------------------------------------------------------------
-// Anthropic provider
+// 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.
+//
+// `name = "anthropic"` is preserved (not renamed to "litellm") so previously
+// written checkpoint metadata (`{"provider": "anthropic"}`) keeps validating
+// after upgrade — no forced re-extraction.
 // ---------------------------------------------------------------------------
-export class AnthropicProvider {
+export class LiteLLMProvider {
     name = "anthropic";
-    client;
     model;
-    constructor(model) {
+    modelId;
+    configuredMaxTokens;
+    constructor(modelId) {
         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.", {
@@ -159,87 +165,60 @@ export class AnthropicProvider {
                 errorCode: "PROVIDER_AUTH_MISSING",
             });
         }
-        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))
-                configuredMaxTokens = parsed;
+        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",
+            });
         }
-        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)) };
+        const provider = createOpenAICompatible({
+            name: "litellm",
+            apiKey,
+            baseURL,
+        });
+        this.modelId = modelId;
+        this.model = provider(modelId);
+        const raw = (process.env.SCRIPTCTL_MAX_TOKENS ?? "").trim();
+        let mt = DEFAULT_MAX_TOKENS;
+        if (raw) {
+            const parsed = parseInt(raw, 10);
+            if (!Number.isNaN(parsed))
+                mt = parsed;
         }
-        return request;
+        this.configuredMaxTokens = Math.max(1024, Math.min(mt, DEFAULT_MAX_TOKENS));
     }
-    async collectResponseText(request) {
-        return runWithStreamRetry(async () => {
-            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)];
-            }
-            const response = await this.client.messages.create(request);
-            return [textFromResponse(response), strOf(response.stop_reason)];
-        });
+    capTokens(maxTokens, fallback) {
+        const requested = maxTokens !== undefined ? maxTokens : fallback;
+        return Math.max(1024, Math.min(requested, this.configuredMaxTokens, DEFAULT_MAX_TOKENS));
     }
-    /**
-     * 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);
-        return runWithStreamRetry(async () => {
-            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)];
-            }
-            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") {
+        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);
+        }
+        catch (exc) {
+            throw translateLiteLLMError(exc, "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: [
-                    `stop_reason: ${stopReason}`,
-                    `max_tokens: ${request.max_tokens}`,
+                    `finishReason: ${finishReason}`,
+                    `max_tokens: ${max}`,
                     `raw chars: ${raw.length}`,
                     `tail: ${raw.slice(-160) || "<empty response>"}`,
                 ],
@@ -255,7 +234,7 @@ export class AnthropicProvider {
         return this.extractBatch(sourceText, episodePlan);
     }
     async extractBatch(sourceText, batchPlan) {
-        const context = isList(batchPlan["context"]) || typeof batchPlan["context"] === "object" && batchPlan["context"] !== null
+        const context = isList(batchPlan["context"]) || (typeof batchPlan["context"] === "object" && batchPlan["context"] !== null)
             ? batchPlan["context"]
             : {};
         const numberedSource = formatBatchSource(sourceText, batchPlan);
@@ -271,15 +250,29 @@ export class AnthropicProvider {
             "\n" +
             "Batch Source:\n" +
             `${numberedSource}\n`;
-        const request = this.messageRequest(prompt, DEFAULT_BATCH_MAX_TOKENS);
-        const [raw, stopReason] = await this.collectResponseText(request);
-        if (stopReason === "max_tokens") {
+        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") {
             throw new CliError("INIT FAILED: Provider output truncated", "Provider output truncated.", {
                 exitCode: EXIT_RUNTIME,
                 required: ["complete markdown within provider max_tokens"],
                 received: [
-                    `stop_reason: ${stopReason}`,
-                    `max_tokens: ${request.max_tokens}`,
+                    `finishReason: ${finishReason}`,
+                    `max_tokens: ${max}`,
                     `raw chars: ${raw.length}`,
                     `tail: ${raw.slice(-160) || "<empty response>"}`,
                 ],
@@ -307,32 +300,19 @@ export class AnthropicProvider {
             "\n" +
             "Episodes needing titles:\n" +
             `${JSON.stringify(context)}\n`;
-        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;
+        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."],
+        });
     }
     async extractAssetCuration(_sourceText, script) {
         const context = buildAssetCurationContext(script);
@@ -350,32 +330,19 @@ export class AnthropicProvider {
             "\n" +
             "Script asset curation context:\n" +
             `${JSON.stringify(context)}\n`;
-        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;
+        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."],
+        });
     }
     async extractMetadata(_sourceText, script) {
         const context = buildMetadataContext(script);
@@ -393,56 +360,68 @@ export class AnthropicProvider {
             "\n" +
             "Script metadata context:\n" +
             `${JSON.stringify(context)}\n`;
-        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."],
+        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 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;
         }
-        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."],
-            });
+        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");
         }
-        return input;
     }
 }
 // ---------------------------------------------------------------------------
-// Gemini provider (used by `scriptctl episode draft` by default)
+// Gemini provider — @ai-sdk/google direct to Google AI Studio.
+// Used by `scriptctl episode draft` when --provider gemini.
 // ---------------------------------------------------------------------------
-/**
- * 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(model) {
+    constructor(modelId) {
         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.", {
@@ -453,138 +432,169 @@ export class GeminiProvider {
                 errorCode: "PROVIDER_AUTH_MISSING",
             });
         }
-        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();
+        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);
     }
     /**
      * 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));
-        const url = `${this.baseUrl}/v1beta/models/${encodeURIComponent(this.model)}:generateContent?key=${encodeURIComponent(this.apiKey)}`;
-        const body = {
-            contents: [{ role: "user", parts: [{ text: prompt }] }],
-            generationConfig: {
+        let raw;
+        let finishReason;
+        try {
+            const result = await generateText({
+                model: this.model,
+                prompt,
                 maxOutputTokens: tokens,
                 temperature: 0,
-            },
-        };
-        let response;
-        try {
-            response = await fetch(url, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(body),
-            });
-        }
-        catch (exc) {
-            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",
-            });
-        }
-        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",
+                maxRetries: 0,
             });
-        }
-        let payload;
-        try {
-            payload = JSON.parse(text);
+            raw = result.text.trim();
+            finishReason = strOf(result.finishReason);
         }
         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",
-            });
+            throw translateGeminiError(exc, tokens);
         }
-        const candidate = payload.candidates?.[0];
-        const finishReason = strOf(candidate?.finishReason ?? "");
-        if (finishReason === "MAX_TOKENS") {
+        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: MAX_TOKENS`, `maxOutputTokens: ${tokens}`],
+                received: [`finishReason: ${finishReason}`, `maxOutputTokens: ${tokens}`],
                 nextSteps: [
                     "Re-run with --regen, or split the episode outline into smaller scopes.",
                 ],
                 errorCode: "PROVIDER_OUTPUT_TRUNCATED",
             });
         }
-        if (finishReason && finishReason !== "STOP" && finishReason !== "MAX_TOKENS") {
-            // SAFETY / RECITATION / OTHER — surface to agent rather than silently treat as success.
+        if (finishReason && finishReason !== "stop" && finishReason !== "length") {
+            // content-filter / error / 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",
             });
         }
-        const parts = candidate?.content?.parts ?? [];
-        const out = parts.map((p) => (typeof p.text === "string" ? p.text : "")).join("").trim();
-        if (!out) {
+        if (!raw) {
             throw new CliError("DRAFT FAILED: provider returned empty content", "Provider returned an empty response.", {
                 exitCode: EXIT_RUNTIME,
-                required: ["non-empty candidate content"],
-                received: [`finishReason: ${finishReason || "<unset>"}`, `parts: ${parts.length}`],
+                required: ["non-empty model output"],
+                received: [`finishReason: ${finishReason || "<unset>"}`, "text: <empty>"],
                 nextSteps: ["Retry once; if it persists, run `scriptctl doctor`."],
                 errorCode: "PROVIDER_EMPTY_RESPONSE",
             });
         }
-        return out;
+        return raw;
     }
 }
-function textFromResponse(response) {
-    const parts = [];
-    for (const block of response.content ?? []) {
-        if (block.text)
-            parts.push(block.text);
+// ---------------------------------------------------------------------------
+// Error translation
+// ---------------------------------------------------------------------------
+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;
     }
-    return parts.join("\n").trim();
+    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",
+        });
+    }
+    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",
+        });
+    }
+    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",
+    });
 }
-/**
- * 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;
-        }
+function translateGeminiError(exc, tokens) {
+    if (RetryError.isInstance(exc) && APICallError.isInstance(exc.lastError)) {
+        exc = exc.lastError;
     }
-    return null;
+    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("DRAFT FAILED: provider returned error", publicMessage, {
+            exitCode: EXIT_RUNTIME,
+            required: ["HTTP 2xx from Gemini"],
+            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",
+        });
+    }
+    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.", {
+        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",
+    });
 }
 // ---------------------------------------------------------------------------
 // Factory
@@ -593,7 +603,7 @@ export function makeProvider(name, model) {
     if (name === "mock")
         return new MockProvider();
     if (name === "anthropic")
-        return new AnthropicProvider(model);
+        return new LiteLLMProvider(model);
     if (name === "gemini")
         return new GeminiProvider(model);
     throw new CliError("INIT FAILED: Unsupported provider", "Unsupported provider.", {