@lingjingai/scriptctl 0.63.2 → 0.63.4

package/README.md

@@ -136,7 +136,7 @@ MIT
 
 ### 指定视频理解服务
 
-默认视频 ingest 沿用 Gemini 主流程，失败后由豆包兜底。显式选择服务时只调用所选服务和模型：
+Gemini 文本、结构化工具和视频请求先使用配置的主模型，再按 `gemini-3.8-flash → gemini-3.7-flash → gemini-3.6-flash` 尝试尚未调用的模型，全部失败后使用豆包。每个 Gemini 模型按 provider 的 `maxAttempts` 重试暂时性错误，豆包最多尝试 3 次；审核拒绝等不可重试错误直接进入下一模型，用户取消立即停止。切换 Gemini 模型保留服务地址、凭据和同一份视频；公共 Files API 上传重试耗尽时，由豆包读取本地视频。豆包使用 `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/changes/0.63.4.md

@@ -0,0 +1,5 @@
+# 0.63.4
+
+- Gemini 文本、结构化工具和视频请求先使用所选模型，再按 3.8 Flash → 3.7 Flash → 3.6 Flash 补齐尚未尝试的模型，最后由豆包兜底。
+- 每个 Gemini 模型独立执行配置的暂时性错误重试，豆包保留最多 3 次尝试；完整模型链耗尽后汇总报错，取消立即停止。
+- 复用 Gemini 视频媒体与已有分集检查点，保留各模型的实际用量、重试次数和失败原因。

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}` : "";
@@ -7785,6 +7802,7 @@ var DOUBAO_FALLBACK = {
   timeoutMs: 6e5,
   maxAttempts: 3
 };
+var GEMINI_FLASH_MODELS = ["gemini-3.8-flash", "gemini-3.7-flash", "gemini-3.6-flash"];
 function normalizeBaseUrl(value) {
   return value?.trim().replace(/\/+$/, "") ?? "anthropic-sdk-default";
 }
@@ -7816,6 +7834,45 @@ 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 exhaustedFailure(error, failures) {
+  if (failures.length === 1) return error;
+  const aggregate = aggregateFailures(failures, "All configured model routes failed.");
+  return new LlmTransportError(error.code, aggregate.message, {
+    retryable: aggregate.retryable,
+    classification: classificationOf(aggregate),
+    context: contextOf(aggregate),
+    modelFailures: failures,
+    details: failures.map(formatFailure)
+  });
+}
+function isGeminiRoute(route) {
+  return route.protocol === "google-gemini" || /(^|\/)gemini-/i.test(route.model);
+}
+function geminiRoutes(primary) {
+  const prefix = primary.info.model.slice(0, primary.info.model.lastIndexOf("/") + 1);
+  const models = /* @__PURE__ */ new Set([primary.info.model, ...GEMINI_FLASH_MODELS.map((model) => prefix + model)]);
+  return [...models].map((model) => {
+    if (model === primary.info.model) return primary;
+    const modelConfig = { ...primary.modelConfig, model };
+    return {
+      ...primary,
+      modelConfig,
+      info: { ...primary.info, model, fingerprint: routeFingerprint(primary.info.task, primary.providerConfig, modelConfig) }
+    };
+  });
+}
+function canFallback(error, signal) {
+  return !signal?.aborted && error instanceof LlmTransportError && error.code !== "cancelled";
+}
 var ModelRouter = class {
   constructor(config, options = {}) {
     this.config = config;
@@ -8096,15 +8153,84 @@ 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]);
+        }
+        const routes = geminiRoutes(route);
+        const failures = [];
+        for (const [index, candidate] of routes.entries()) {
+          request2.signal?.throwIfAborted();
+          try {
+            return await this.tracked(candidate.info, () => this.videoAdapter(candidate).generate({
+              ...request2,
+              maxOutputTokens: spec2.maxOutputTokens
+            }));
+          } catch (error) {
+            if (!canFallback(error, request2.signal)) throw error;
+            const failure = routedFailure(error, candidate.info);
+            failures.push(failure);
+            const next = routes[index + 1];
+            if (next) {
+              process.stderr.write(`\u21AA\uFE0F  ${candidate.info.model} \u8BF7\u6C42\u5931\u8D25\uFF0C\u5207\u6362\u5230 ${next.info.model} (${formatFailure(failure)})
+`);
+              continue;
+            }
+            if (!this.doubaoAdapter() || !request2.localPath) throw exhaustedFailure(error, failures);
+            return this.generateDoubaoVideo(task, request2, failures);
+          }
+        }
+        throw new Error("Gemini model routes cannot be empty.");
+      }
     };
   }
-  // Resolve explicitly selected Doubao video.
+  async generateDoubaoVideo(task, request2, failures) {
+    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  Gemini \u8DEF\u7531\u5DF2\u8017\u5C3D\uFF0C\u56DE\u9000\u5230\u8C46\u5305 ${route.model}
+`);
+    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 exhaustedFailure(error, [...failures, routedFailure(error, route)]);
+    }
+  }
+  // Resolve the default fallback or explicitly selected Doubao video.
   // Overridable in tests to inject a fake Ark client.
   doubaoAdapter(route) {
     return this.arkAdapter(route);
@@ -8128,29 +8254,50 @@ 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;
-      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 gemini = isGeminiRoute(route.info);
+    const routes = gemini ? geminiRoutes(route) : [route];
+    const failures = [];
+    for (const [index, candidate] of routes.entries()) {
+      signal?.throwIfAborted();
+      const adapter = this.adapter(candidate);
+      try {
+        return await this.tracked(candidate.info, () => generate(adapter));
+      } catch (error) {
+        if (!canFallback(error, signal) || !gemini && error.code !== "content_filtered") throw error;
+        const failure = routedFailure(error, candidate.info);
+        failures.push(failure);
+        const next = routes[index + 1];
+        if (next) {
+          process.stderr.write(`\u21AA\uFE0F  ${candidate.info.model} \u8BF7\u6C42\u5931\u8D25\uFF0C\u5207\u6362\u5230 ${next.info.model} (${formatFailure(failure)})
 `);
-      return this.tracked(this.doubaoRoute(task), () => generate(doubao));
+          continue;
+        }
+        const doubao = this.doubaoTextAdapter();
+        if (!doubao) throw exhaustedFailure(error, failures);
+        const fallback = this.doubaoRoute(task);
+        process.stderr.write(`\u21AA\uFE0F  \u4E3B\u6A21\u578B\u8DEF\u7531\u5DF2\u8017\u5C3D\uFF0C\u56DE\u9000\u5230\u8C46\u5305 ${fallback.model}
+`);
+        try {
+          return await this.tracked(fallback, () => generate(doubao));
+        } catch (fallbackError) {
+          if (!canFallback(fallbackError, signal)) throw fallbackError;
+          throw exhaustedFailure(fallbackError, [...failures, routedFailure(fallbackError, fallback)]);
+        }
+      }
     }
+    throw new Error("Text model routes cannot be empty.");
   }
   async generateText(task, 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) {