@lingjingai/scriptctl 0.63.1 → 0.63.3

package/README.md

@@ -136,7 +136,7 @@ MIT
 
 ### 指定视频理解服务
 
-默认视频 ingest 沿用 Gemini 主流程，失败后由豆包兜底。显式选择服务时只调用所选服务和模型：
+Gemini 文本、结构化工具和视频请求在当前路由重试耗尽或被审核拦截后，由已配置的豆包兜底。视频的默认路由与显式指定的 Gemini 均保留所选主模型；视频上传失败时豆包读取同一份本地文件。用户取消不触发兜底。豆包使用 `ARK_API_KEY`，`ARK_MODEL` 可指定已开通的视频理解端点，默认 `ep-20260721150136-98dj9`。直接选择豆包时只调用豆包：
 
 ```bash
 # 豆包：默认读取 ARK_API_KEY；模型也可通过 ARK_MODEL 设置

package/changes/0.63.2.md

@@ -0,0 +1,4 @@
+# 0.63.2
+
+- Gemini 视频请求固定使用配置的模型与服务，在当前路由内有限重试，失败时直接返回原因。
+- 修复内置 Mastra 审核的 Google API 地址拼接，服务根地址和 /v1beta 地址均可正确请求。

package/changes/0.63.3.md

@@ -0,0 +1,5 @@
+# 0.63.3
+
+- Gemini 文本、结构化工具和视频请求在当前路由重试耗尽或被审核拦截后，使用已配置的豆包 Ark 端点兜底；默认与显式指定的 Gemini 均适用。
+- 视频上传失败时由豆包读取同一份本地视频，保留 Prompt、Schema、采样率和上下文；用户取消不触发兜底。
+- 分别记录主路由与豆包的实际用量；两边都失败时保留完整路由原因，已有分集检查点继续复用。

package/dist/bin.js

@@ -7794,10 +7794,6 @@ var OpenAiCompatibleModel = class {
 };
 
 // src/llm/router.ts
-var VIDEO_FALLBACK_MODELS = ["gemini-3.7-flash"];
-var PROXY_GEMINI_MODELS = [];
-var PROXY_GEMINI_API_KEY_ENVS = ["GEMINI_PROXY_API_KEY", "REDRAW_GEMINI_PROXY_API_KEY"];
-var PROXY_GEMINI_BASE_URL_ENVS = ["GEMINI_PROXY_BASE_URL", "REDRAW_GEMINI_PROXY_BASE_URL"];
 var DOUBAO_FALLBACK = {
   model: "ep-20260721150136-98dj9",
   modelEnv: "ARK_MODEL",
@@ -7838,24 +7834,30 @@ function credentialError(provider) {
   });
 }
 function routedFailure(error, route) {
-  if (error instanceof LlmTransportError) {
-    return createOperationalFailure(classificationOf(error.failure), {
-      ...contextOf(error.failure),
-      provider: route.provider,
-      model: route.model,
-      retryable: error.failure.retryable,
-      message: error.failure.message
-    });
-  }
-  return createOperationalFailure(
-    { failure_type: "unknown", failure_code: "unknown" },
-    {
-      provider: route.provider,
-      model: route.model,
-      retryable: false,
-      message: error instanceof Error ? error.message : String(error)
-    }
-  );
+  return createOperationalFailure(classificationOf(error.failure), {
+    ...contextOf(error.failure),
+    provider: route.provider,
+    model: route.model,
+    retryable: error.failure.retryable,
+    message: error.message
+  });
+}
+function fallbackFailure(primary, error, route) {
+  const failures = [primary, routedFailure(error, route)];
+  const aggregate = aggregateFailures(failures, "Primary model and Doubao fallback both failed.");
+  return new LlmTransportError(error.code, aggregate.message, {
+    retryable: aggregate.retryable,
+    classification: classificationOf(aggregate),
+    context: contextOf(aggregate),
+    modelFailures: failures,
+    details: failures.map(formatFailure)
+  });
+}
+function isGeminiRoute(route) {
+  return route.protocol === "google-gemini" || /(^|\/)gemini-/i.test(route.model);
+}
+function canFallback(error, signal) {
+  return !signal?.aborted && error instanceof LlmTransportError && error.code !== "cancelled";
 }
 var ModelRouter = class {
   constructor(config, options = {}) {
@@ -8027,52 +8029,6 @@ var ModelRouter = class {
       throw error;
     }
   }
-  videoRoute(route, model) {
-    const modelConfig = model === route.info.model ? route.modelConfig : { ...route.modelConfig, model };
-    return {
-      ...route.info,
-      model,
-      fingerprint: routeFingerprint(route.info.task, route.providerConfig, modelConfig)
-    };
-  }
-  resolvedVideoRoute(route, model) {
-    const modelConfig = model === route.info.model ? route.modelConfig : { ...route.modelConfig, model };
-    return {
-      info: this.videoRoute(route, model),
-      providerConfig: route.providerConfig,
-      modelConfig
-    };
-  }
-  proxyVideoRoutes(task) {
-    if (this.options.videoProvider) return [];
-    const apiKeyEnv = PROXY_GEMINI_API_KEY_ENVS.find((name) => (process.env[name] ?? "").trim());
-    const baseUrlEnv = PROXY_GEMINI_BASE_URL_ENVS.find((name) => (process.env[name] ?? "").trim());
-    if (!apiKeyEnv || !baseUrlEnv) return [];
-    const baseUrl = normalizeProviderBaseUrl(process.env[baseUrlEnv], baseUrlEnv);
-    return PROXY_GEMINI_MODELS.map((model, index) => {
-      const providerConfig = {
-        protocol: "google-gemini",
-        baseUrl,
-        apiKeyEnv,
-        timeoutMs: 9e4,
-        maxAttempts: index < 2 ? 2 : 1
-      };
-      const modelConfig = { provider: "gemini-proxy", model };
-      return {
-        info: {
-          task,
-          profile: "gemini-proxy",
-          provider: "gemini-proxy",
-          protocol: "google-gemini",
-          baseUrl,
-          model,
-          fingerprint: routeFingerprint(task, providerConfig, modelConfig)
-        },
-        providerConfig,
-        modelConfig
-      };
-    });
-  }
   resolveDoubao(task, explicit) {
     const overrides = explicit ? this.options.videoProvider : void 0;
     const modelName = explicit ? (overrides?.model ?? process.env["ARK_MODEL"] ?? "").trim() : this.doubaoModel();
@@ -8114,9 +8070,7 @@ var ModelRouter = class {
     this.adapters.set(key, adapter);
     return adapter;
   }
-  // model defaults to the route's model; pass an override to build a peer adapter
-  // that shares the provider/credential but targets a fallback model.
-  videoAdapter(route, model) {
+  videoAdapter(route) {
     if (route.providerConfig.protocol !== "google-gemini") {
       throw configRuntimeError(
         "Video tasks require a google-gemini provider.",
@@ -8124,14 +8078,13 @@ var ModelRouter = class {
         [`provider: ${route.info.provider}`, `protocol: ${route.providerConfig.protocol}`]
       );
     }
-    const modelName = model ?? route.info.model;
+    const modelName = route.info.model;
     const key = `${route.info.provider} ${route.providerConfig.baseUrl ?? "official"} ${modelName}`;
     const cached2 = this.videoAdapters.get(key);
     if (cached2) return cached2;
     const apiKey = this.videoCredential(route);
     if (!apiKey) throw credentialError(route.info.provider);
-    const modelConfig = model ? { ...route.modelConfig, model } : route.modelConfig;
-    const adapter = new GeminiVideoModel(route.providerConfig, modelConfig, apiKey);
+    const adapter = new GeminiVideoModel(route.providerConfig, route.modelConfig, apiKey);
     this.videoAdapters.set(key, adapter);
     return adapter;
   }
@@ -8146,8 +8099,8 @@ var ModelRouter = class {
     if (spec2.mode !== "video") throw configRuntimeError("The task does not support video generation.", ["video task"], [`task: ${task}`]);
     const route = this.resolve(task);
     if (this.options.videoProvider?.provider === "doubao") {
-      const adapter = this.doubaoAdapter(route);
-      if (!adapter) throw credentialError("doubao");
+      const adapter2 = this.doubaoAdapter(route);
+      if (!adapter2) throw credentialError("doubao");
       return {
         prepare: async (localPath, mimeType, mode, signal) => {
           if (mode !== "file-api") {
@@ -8162,7 +8115,7 @@ var ModelRouter = class {
           }
           request2.signal?.throwIfAborted();
           const { path: localPath, mimeType: localMime } = request2.media;
-          return this.tracked(route.info, () => adapter.run({
+          return this.tracked(route.info, () => adapter2.run({
             localPath,
             localMime,
             user: request2.user,
@@ -8184,88 +8137,68 @@ var ModelRouter = class {
         [`provider: ${route.info.provider}`, `protocol: ${route.providerConfig.protocol}`]
       );
     }
-    const officialRoutes = (this.options.videoProvider ? [route.info.model] : [route.info.model, ...VIDEO_FALLBACK_MODELS.filter((m) => m !== route.info.model)]).map((model) => this.resolvedVideoRoute(route, model));
-    const proxyRoutes = this.proxyVideoRoutes(task);
-    if (this.options.videoProvider || proxyRoutes.length === 0) void this.videoAdapter(route);
+    const adapter = this.videoAdapter(route);
     return {
       prepare: async (localPath, mimeType, mode, signal) => {
-        const prepareRoute = mode === "base64" && proxyRoutes.length > 0 ? proxyRoutes[0] : route;
+        const started = Date.now();
         try {
-          return await this.videoAdapter(prepareRoute).prepare(localPath, mimeType, mode, signal);
+          return await adapter.prepare(localPath, mimeType, mode, signal);
         } catch (error) {
-          if (signal?.aborted || mode !== "file-api" || this.options.videoProvider || !this.doubaoAdapter()) throw error;
-          const failure = routedFailure(error, route.info);
-          process.stderr.write(`\u21AA\uFE0F  Gemini \u6587\u4EF6\u4E0A\u4F20\u5931\u8D25,\u6539\u7531\u8C46\u5305\u8BFB\u53D6\u672C\u5730\u89C6\u9891 (${formatFailure(failure)})
-`);
-          return { kind: "local-fallback", path: localPath, mimeType, primaryFailure: failure };
+          if (!canFallback(error, signal) || !this.doubaoAdapter()) throw error;
+          this.recordEvent(
+            route.info,
+            "failed",
+            new Date(started).toISOString(),
+            (/* @__PURE__ */ new Date()).toISOString(),
+            Date.now() - started,
+            error.usage,
+            error.attempts,
+            error.code
+          );
+          return { kind: "local-fallback", path: localPath, mimeType, primaryFailure: routedFailure(error, route.info) };
         }
       },
-      release: (media, signal) => media.kind === "base64" || media.kind === "local-fallback" ? Promise.resolve() : this.videoAdapter(route).release(media, signal),
+      release: (media, signal) => media.kind === "local-fallback" ? Promise.resolve() : adapter.release(media, signal),
       generate: async (request2) => {
-        const failures = request2.media.kind === "local-fallback" ? [request2.media.primaryFailure] : [];
-        const skipped = [];
-        const geminiChain = request2.media.kind === "local-fallback" ? [] : request2.media.kind === "base64" ? [...proxyRoutes, ...officialRoutes] : officialRoutes;
-        for (const [index, attemptRoute] of geminiChain.entries()) {
-          try {
-            const response = await this.tracked(
-              attemptRoute.info,
-              () => this.videoAdapter(attemptRoute).generate({ ...request2, maxOutputTokens: spec2.maxOutputTokens })
-            );
-            if (index > 0) process.stderr.write(`\u21AA\uFE0F  \u5DF2\u5207\u6362\u5230\u5907\u7528\u6A21\u578B ${attemptRoute.info.model}
-`);
-            return response;
-          } catch (error) {
-            if (request2.signal?.aborted) throw error;
-            const failure = routedFailure(error, attemptRoute.info);
-            failures.push(failure);
-            const detail = formatFailure(failure);
-            if (index < geminiChain.length - 1) {
-              process.stderr.write(`\u21AA\uFE0F  ${attemptRoute.info.model} \u5F53\u524D\u4E0D\u53EF\u7528\uFF0C\u5207\u6362\u4E0B\u4E00\u7EBF\u8DEF (${detail})
-`);
-            }
-          }
+        request2.signal?.throwIfAborted();
+        if (request2.media.kind === "local-fallback") {
+          return this.generateDoubaoVideo(task, request2, request2.media.primaryFailure);
         }
-        const doubao = this.options.videoProvider ? null : this.doubaoAdapter();
-        const localPath = request2.media.kind === "local-fallback" ? request2.media.path : request2.localPath;
-        if (doubao && localPath) {
-          const attemptRoute = this.doubaoRoute(task);
-          try {
-            process.stderr.write(`\u21AA\uFE0F  Gemini \u5168\u90E8\u5931\u8D25,\u56DE\u9000\u5230\u8C46\u5305 ${this.doubaoModel()}
-`);
-            const response = await this.tracked(attemptRoute, () => doubao.run({
-              localPath,
-              localMime: request2.media.kind === "local-fallback" ? request2.media.mimeType : request2.localMime ?? "video/mp4",
-              user: request2.user,
-              fps: request2.fps,
-              maxOutputTokens: spec2.maxOutputTokens,
-              ...request2.system ? { system: request2.system } : {},
-              ...request2.responseJsonSchema ? { responseJsonSchema: request2.responseJsonSchema } : {},
-              ...request2.signal ? { signal: request2.signal } : {}
-            }));
-            return response;
-          } catch (error) {
-            if (request2.signal?.aborted) throw error;
-            failures.push(routedFailure(error, attemptRoute));
-          }
-        } else if (!doubao) {
-          if (!this.options.videoProvider) {
-            skipped.push("doubao: skipped (ARK_API_KEY not set)");
-          }
-        } else {
-          skipped.push("doubao: skipped (no local file to re-upload)");
+        try {
+          return await this.tracked(route.info, () => adapter.generate({ ...request2, maxOutputTokens: spec2.maxOutputTokens }));
+        } catch (error) {
+          if (!canFallback(error, request2.signal) || !this.doubaoAdapter() || !request2.localPath) throw error;
+          return this.generateDoubaoVideo(task, request2, routedFailure(error, route.info));
         }
-        const aggregate = aggregateFailures(failures, "All configured video model attempts failed.");
-        throw new LlmTransportError("request_failed", aggregate.message, {
-          retryable: aggregate.retryable,
-          classification: classificationOf(aggregate),
-          context: contextOf(aggregate),
-          modelFailures: failures,
-          details: [...failures.map(formatFailure), ...skipped]
-        });
       }
     };
   }
-  // Resolve an explicit Doubao route or the default fallback; absent fallback credentials skip it.
+  async generateDoubaoVideo(task, request2, primary) {
+    const adapter = this.doubaoAdapter();
+    if (!adapter) throw credentialError("doubao");
+    const localPath = request2.media.kind === "local-fallback" ? request2.media.path : request2.localPath;
+    if (!localPath) throw configRuntimeError("Doubao video fallback requires the local video.", ["localPath"], ["localPath: missing"]);
+    const localMime = request2.localMime ?? (request2.media.kind === "file-api" ? request2.media.file.mimeType : request2.media.mimeType);
+    const route = this.doubaoRoute(task);
+    process.stderr.write(`\u21AA\uFE0F  ${primary.model} \u8BF7\u6C42\u5931\u8D25\uFF0C\u56DE\u9000\u5230\u8C46\u5305 ${route.model} (${formatFailure(primary)})
+`);
+    try {
+      return await this.tracked(route, () => adapter.run({
+        localPath,
+        localMime,
+        user: request2.user,
+        fps: request2.fps,
+        maxOutputTokens: LLM_TASK_REGISTRY[task].maxOutputTokens,
+        ...request2.system ? { system: request2.system } : {},
+        ...request2.responseJsonSchema ? { responseJsonSchema: request2.responseJsonSchema } : {},
+        ...request2.signal ? { signal: request2.signal } : {}
+      }));
+    } catch (error) {
+      if (!canFallback(error, request2.signal)) throw error;
+      throw fallbackFailure(primary, error, route);
+    }
+  }
+  // Resolve the default fallback or explicitly selected Doubao video.
   // Overridable in tests to inject a fake Ark client.
   doubaoAdapter(route) {
     return this.arkAdapter(route);
@@ -8289,29 +8222,36 @@ var ModelRouter = class {
   doubaoModel() {
     return (process.env[DOUBAO_FALLBACK.modelEnv] ?? "").trim() || DOUBAO_FALLBACK.model;
   }
-  async withModerationFallback(task, signal, generate) {
+  async withTextFallback(task, signal, generate) {
     const route = this.resolve(task);
     const adapter = this.adapter(route);
     try {
       return await this.tracked(route.info, () => generate(adapter));
     } catch (error) {
-      if (signal?.aborted || !(error instanceof LlmTransportError) || error.code !== "content_filtered") throw error;
+      if (!canFallback(error, signal) || !isGeminiRoute(route.info) && error.code !== "content_filtered") throw error;
       const doubao = this.doubaoTextAdapter();
       if (!doubao) throw error;
-      process.stderr.write(`\u21AA\uFE0F  \u6587\u672C\u5185\u5BB9\u5BA1\u6838\u62D2\u7EDD\uFF0C\u56DE\u9000\u5230\u8C46\u5305 ${this.doubaoModel()}
+      const primary = routedFailure(error, route.info);
+      const fallback = this.doubaoRoute(task);
+      process.stderr.write(`\u21AA\uFE0F  ${route.info.model} \u8BF7\u6C42\u5931\u8D25\uFF0C\u56DE\u9000\u5230\u8C46\u5305 ${fallback.model} (${formatFailure(primary)})
 `);
-      return this.tracked(this.doubaoRoute(task), () => generate(doubao));
+      try {
+        return await this.tracked(fallback, () => generate(doubao));
+      } catch (fallbackError) {
+        if (!canFallback(fallbackError, signal)) throw fallbackError;
+        throw fallbackFailure(primary, fallbackError, fallback);
+      }
     }
   }
   async generateText(task, request2) {
     const spec2 = LLM_TASK_REGISTRY[task];
     if (spec2.mode !== "text") throw configRuntimeError("The task does not support text generation.", ["text task"], [`task: ${task}`]);
-    return this.withModerationFallback(task, request2.signal, (adapter) => adapter.generateText({ ...request2, maxOutputTokens: spec2.maxOutputTokens }));
+    return this.withTextFallback(task, request2.signal, (adapter) => adapter.generateText({ ...request2, maxOutputTokens: spec2.maxOutputTokens }));
   }
   async generateTool(task, request2) {
     const spec2 = LLM_TASK_REGISTRY[task];
     if (spec2.mode !== "tool") throw configRuntimeError("The task does not support tool generation.", ["tool task"], [`task: ${task}`]);
-    return this.withModerationFallback(task, request2.signal, (adapter) => adapter.generateTool({ ...request2, maxOutputTokens: spec2.maxOutputTokens }));
+    return this.withTextFallback(task, request2.signal, (adapter) => adapter.generateTool({ ...request2, maxOutputTokens: spec2.maxOutputTokens }));
   }
 };
 function createLlmExecutor(explicitConfigPath, options) {