@lingjingai/scriptctl 0.63.2 → 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.3.md

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

package/dist/bin.js

@@ -265,6 +265,23 @@ function contextOf(failure) {
     ...failure.details !== void 0 ? { details: failure.details } : {}
   };
 }
+function aggregateFailures(failures, message2) {
+  if (failures.length === 0) {
+    return createOperationalFailure(
+      { failure_type: "unknown", failure_code: "unknown" },
+      { retryable: false, message: message2 }
+    );
+  }
+  const first = failures[0];
+  const sameClassification = failures.every(
+    (failure) => failure.failure_type === first.failure_type && failure.failure_code === first.failure_code
+  );
+  const classification = sameClassification ? classificationOf(first) : { failure_type: "provider", failure_code: "attempts_exhausted" };
+  return createOperationalFailure(classification, {
+    retryable: failures.some((failure) => failure.retryable),
+    message: message2
+  });
+}
 function formatFailure(failure) {
   const route = failure.provider || failure.model ? `${failure.provider ?? "provider"}/${failure.model ?? "model"} ` : "";
   const reason = failure.provider_reason ? ` provider_reason=${failure.provider_reason}` : "";
@@ -7816,6 +7833,32 @@ function credentialError(provider) {
     data: { expected: ["credential environment variable referenced by the selected provider"], actual: [`provider: ${provider}`, "credential: missing"] }
   });
 }
+function routedFailure(error, route) {
+  return createOperationalFailure(classificationOf(error.failure), {
+    ...contextOf(error.failure),
+    provider: route.provider,
+    model: route.model,
+    retryable: error.failure.retryable,
+    message: error.message
+  });
+}
+function 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 = {}) {
     this.config = config;
@@ -8096,15 +8139,66 @@ var ModelRouter = class {
     }
     const adapter = this.videoAdapter(route);
     return {
-      prepare: (localPath, mimeType, mode, signal) => adapter.prepare(localPath, mimeType, mode, signal),
-      release: (media, signal) => adapter.release(media, signal),
-      generate: (request2) => this.tracked(route.info, () => adapter.generate({
-        ...request2,
-        maxOutputTokens: spec2.maxOutputTokens
-      }))
+      prepare: async (localPath, mimeType, mode, signal) => {
+        const started = Date.now();
+        try {
+          return await adapter.prepare(localPath, mimeType, mode, signal);
+        } catch (error) {
+          if (!canFallback(error, signal) || !this.doubaoAdapter()) throw error;
+          this.recordEvent(
+            route.info,
+            "failed",
+            new Date(started).toISOString(),
+            (/* @__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 === "local-fallback" ? Promise.resolve() : adapter.release(media, signal),
+      generate: async (request2) => {
+        request2.signal?.throwIfAborted();
+        if (request2.media.kind === "local-fallback") {
+          return this.generateDoubaoVideo(task, request2, request2.media.primaryFailure);
+        }
+        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));
+        }
+      }
     };
   }
-  // Resolve explicitly selected Doubao video.
+  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);
@@ -8128,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) {