@peterwangze/claude-trigger-router 1.11.0 → 1.13.0

package/dist/cli.js

@@ -4299,16 +4299,21 @@ var init_SSEParser_transform = __esm({
     SSEParserTransform = class {
       buffer = "";
       currentEvent = {};
+      decoder = new TextDecoder();
       constructor() {
         const transformStream = new TransformStream({
           start: (controller) => {
           },
           transform: (chunk, controller) => {
-            const text = new TextDecoder().decode(chunk);
+            const text = this.decoder.decode(chunk, { stream: true });
             this.buffer += text;
             this.parseBuffer(controller);
           },
           flush: (controller) => {
+            const remaining = this.decoder.decode();
+            if (remaining) {
+              this.buffer += remaining;
+            }
             if (this.buffer.trim()) {
               this.parseBuffer(controller, true);
             } else if (Object.keys(this.currentEvent).length > 0) {
@@ -4363,6 +4368,15 @@ function serializeEvent(event2) {
   output3 += "\n";
   return new TextEncoder().encode(output3);
 }
+function serializeStreamErrorEvent(message) {
+  return serializeEvent({
+    event: "error",
+    data: {
+      type: "upstream_stream_error",
+      message
+    }
+  });
+}
 function parseSSEBlock(block) {
   const event2 = {};
   const dataLines = [];
@@ -4422,6 +4436,9 @@ function finalizeStreamingTrace(req, observation) {
   for (const finding of outputGuardrail.findings) {
     appendTraceReason(req.governanceTrace, `output_guardrail:${finding.code}`);
   }
+  if (observation.streamError) {
+    appendTraceReason(req.governanceTrace, "upstream_stream_error");
+  }
   req.governanceTrace.handoffSummary = summarizeRouteHandoffTrace(
     req.governanceTrace,
     getRuntimePipeline(req)
@@ -4439,25 +4456,44 @@ function passThroughStreamingResponse(stream, req) {
   const decoder = new TextDecoder();
   const observation = { text: "", sawText: false };
   let buffer = "";
-  return stream.pipeThrough(new TransformStream({
-    transform(chunk, controller) {
-      controller.enqueue(chunk);
-      buffer = observeSSEChunk(buffer, decoder.decode(chunk, { stream: true }), observation);
-    },
-    flush() {
-      const remaining = decoder.decode();
-      if (remaining) {
-        buffer = observeSSEChunk(buffer, remaining, observation);
-      }
-      if (buffer.trim()) {
-        const event2 = parseSSEBlock(buffer);
-        if (event2) {
-          collectEventObservation(event2, observation);
+  let reader;
+  return new ReadableStream({
+    async start(controller) {
+      reader = stream.getReader();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          controller.enqueue(value);
+          buffer = observeSSEChunk(buffer, decoder.decode(value, { stream: true }), observation);
+        }
+      } catch (error) {
+        const message = error instanceof Error && error.message ? error.message : "The upstream stream closed before completion.";
+        observation.streamError = message;
+        controller.enqueue(serializeStreamErrorEvent("The upstream stream closed before completion."));
+      } finally {
+        const remaining = decoder.decode();
+        if (remaining) {
+          buffer = observeSSEChunk(buffer, remaining, observation);
+        }
+        if (buffer.trim()) {
+          const event2 = parseSSEBlock(buffer);
+          if (event2) {
+            collectEventObservation(event2, observation);
+          }
         }
+        finalizeStreamingTrace(req, observation);
+        reader.releaseLock();
+        reader = void 0;
+        controller.close();
       }
-      finalizeStreamingTrace(req, observation);
+    },
+    cancel(reason) {
+      return reader?.cancel(reason);
     }
-  }));
+  });
 }
 async function collectSSE(stream) {
   const parser = new SSEParserTransform();
@@ -11754,6 +11790,37 @@ function buildRemoteForwardHeaders(req, authToken) {
   headers["x-ctr-remote-forward"] = "1";
   return headers;
 }
+function isSSEContentType(contentType) {
+  return Boolean(contentType?.toLowerCase().includes("text/event-stream"));
+}
+function clearTimerOnStreamClose(stream, clear) {
+  let reader;
+  return new ReadableStream({
+    async start(controller) {
+      reader = stream.getReader();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          controller.enqueue(value);
+        }
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        clear();
+        reader?.releaseLock();
+        reader = void 0;
+      }
+    },
+    cancel(reason) {
+      clear();
+      return reader?.cancel(reason);
+    }
+  });
+}
 async function forwardModelCallToRemote(req, reply, config) {
   if (!isModelCallPath(req.url) || !isRemoteForwardEnabled(config) || req.headers?.["x-ctr-remote-forward"] === "1") {
     return false;
@@ -11763,12 +11830,28 @@ async function forwardModelCallToRemote(req, reply, config) {
   const forwardPath = getRemoteForwardPath(req.url);
   const path = forwardPath.split("?")[0];
   const targetUrl = `${remoteBaseUrl}${forwardPath}`;
+  const abortController = new AbortController();
+  let timeout;
+  const clearRemoteTimeout = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = void 0;
+    }
+  };
+  timeout = setTimeout(() => {
+    abortController.abort(new Error("remote_forward_timeout"));
+  }, config.API_TIMEOUT_MS ?? 6e5);
+  const abortOnClientClose = () => {
+    clearRemoteTimeout();
+    abortController.abort(new Error("client_connection_closed"));
+  };
+  reply.raw?.once?.("close", abortOnClientClose);
   try {
     const response = await fetch(targetUrl, {
       method: String(req.method ?? "POST").toUpperCase(),
       headers: buildRemoteForwardHeaders(req, remoteService.auth_token),
       body: req.body === void 0 ? void 0 : JSON.stringify(req.body),
-      signal: AbortSignal.timeout(config.API_TIMEOUT_MS ?? 6e5)
+      signal: abortController.signal
     });
     reply.code(response.status);
     const contentType = response.headers.get("content-type");
@@ -11782,9 +11865,11 @@ async function forwardModelCallToRemote(req, reply, config) {
     req.remoteForwarded = true;
     req.responseGovernanceApplied = true;
     if (response.body) {
-      reply.send(response.body);
+      const body = clearTimerOnStreamClose(response.body, clearRemoteTimeout);
+      reply.send(isSSEContentType(contentType) ? governStreamingResponse(body, req, config, config.PORT ?? 5678) : body);
       return true;
     }
+    clearRemoteTimeout();
     reply.send(response.ok ? {} : { error: `Remote service returned HTTP ${response.status}` });
     return true;
   } catch (error) {
@@ -11801,6 +11886,10 @@ async function forwardModelCallToRemote(req, reply, config) {
       }
     });
     return true;
+  } finally {
+    if (!req.remoteForwarded) {
+      clearRemoteTimeout();
+    }
   }
 }
 async function run(options = {}) {
@@ -13970,6 +14059,8 @@ function createDefaultDeps(io = createConsoleIO()) {
 }
 function printRoutingNextSteps(io) {
   io.info("\u4F60\u53EF\u4EE5\u6309\u9700\u7EE7\u7EED\u914D\u7F6E\u8DEF\u7531\u80FD\u529B\uFF1A");
+  io.info('  - \u5148\u8FD0\u884C ctr doctor --route-preview --route-text "\u4F60\u7684\u8BF7\u6C42"\uFF0C\u786E\u8BA4\u672C\u6B21\u4F1A\u547D\u4E2D\u54EA\u4E2A\u69FD\u4F4D\u6216 SmartRouter \u8DEF\u5F84');
+  io.info("  - \u57FA\u7840\u8DEF\u7531\u987A\u5E8F\uFF1A\u663E\u5F0F\u4E0A\u6E38\u6A21\u578B -> longContext -> background -> think -> webSearch -> default");
   io.info("  - SmartRouter.rules\uFF1A\u9002\u5408\u9AD8\u786E\u5B9A\u6027\u4EFB\u52A1\uFF0C\u628A\u67B6\u6784\u8BBE\u8BA1\u3001\u4EE3\u7801\u5BA1\u67E5\u7B49\u8BF7\u6C42\u56FA\u5B9A\u5207\u5230\u6307\u5B9A\u6A21\u578B");
   io.info("  - SmartRouter candidates\uFF1A\u9002\u5408\u6A21\u7CCA\u4EFB\u52A1\uFF0C\u5728\u5019\u9009\u6A21\u578B\u4E4B\u95F4\u81EA\u52A8\u9009\u62E9\u66F4\u5408\u9002\u7684\u6A21\u578B");
   io.info("  - \u914D\u7F6E\u6A21\u677F\u53C2\u8003\uFF1Aconfig/trigger.advanced.yaml");
@@ -14155,6 +14246,294 @@ var init_setup2 = __esm({
   }
 });
 
+// src/router/route-preview.ts
+function resolveDisplayModel(config, ref) {
+  if (!ref) {
+    return {};
+  }
+  const resolved = resolveModelReference(config, ref);
+  return {
+    model: ref,
+    resolved
+  };
+}
+function extractRuleMatch(text, rules) {
+  const sortedRules = rules.filter((rule) => rule.enabled !== false).sort((a, b) => (b.priority || 0) - (a.priority || 0));
+  for (const rule of sortedRules) {
+    for (const pattern of rule.patterns ?? []) {
+      const result = patternMatcher.match(text, pattern);
+      if (!result.matched) {
+        continue;
+      }
+      const detail = result.matchedKeyword ? `keyword "${result.matchedKeyword}"` : result.regexMatch ? `regex "${pattern.pattern}"` : pattern.type;
+      return { rule, detail };
+    }
+  }
+  return void 0;
+}
+function buildSemanticCandidates(rules, config) {
+  const defaultThreshold = config.semantic?.threshold;
+  const prototypes = config.semantic?.prototypes ?? {};
+  return rules.filter((rule) => rule.enabled !== false).map((rule) => {
+    const prototype = rule.semantic_profile?.prototype ?? prototypes[rule.name] ?? rule.description;
+    if (!prototype || rule.semantic_profile?.enabled === false) {
+      return void 0;
+    }
+    return {
+      intent: rule.name,
+      prototype,
+      threshold: rule.semantic_profile?.threshold ?? defaultThreshold,
+      rule
+    };
+  }).filter((item) => Boolean(item));
+}
+function previewBasicRouter(config, input3) {
+  const steps = [];
+  const warnings = [];
+  const registry = buildModelRegistry(config);
+  const tokenCount = input3.tokenCount ?? 0;
+  const longContextThreshold = config.Router.longContextThreshold || 6e4;
+  const explicit = resolveModelReference(config, input3.model);
+  if (explicit && explicit.includes(",")) {
+    steps.push({
+      label: "Explicit model",
+      status: "matched",
+      detail: `\u8BF7\u6C42\u6A21\u578B "${input3.model}" \u5DF2\u89E3\u6790\u4E3A\u4E0A\u6E38\u5F15\u7528\uFF0C\u57FA\u7840\u69FD\u4F4D\u4E0D\u4F1A\u518D\u8986\u76D6\u3002`
+    });
+    return {
+      input: input3,
+      finalModel: explicit,
+      finalModelRef: input3.model,
+      source: "explicit_model",
+      steps,
+      warnings
+    };
+  }
+  if (tokenCount > longContextThreshold && config.Router.longContext) {
+    const model = resolveDisplayModel(config, config.Router.longContext);
+    steps.push({
+      label: "Router.longContext",
+      status: "matched",
+      detail: `tokenCount ${tokenCount} > threshold ${longContextThreshold}\uFF0C\u4F18\u5148\u4F7F\u7528\u957F\u4E0A\u4E0B\u6587\u69FD\u4F4D\u3002`
+    });
+    return {
+      input: input3,
+      finalModel: model.resolved,
+      finalModelRef: model.model,
+      source: "basic_long_context",
+      steps,
+      warnings
+    };
+  }
+  steps.push({
+    label: "Router.longContext",
+    status: config.Router.longContext ? "info" : "skipped",
+    detail: config.Router.longContext ? `\u5F53\u524D tokenCount ${tokenCount} \u672A\u8D85\u8FC7 threshold ${longContextThreshold}\uFF1B\u771F\u5B9E\u8FD0\u884C\u8FD8\u4F1A\u5728\u6700\u7EC8\u5B9A\u6A21\u540E\u68C0\u67E5 safe_input/context_window\u3002` : "\u672A\u914D\u7F6E Router.longContext\uFF0C\u5927\u4E0A\u4E0B\u6587\u8BF7\u6C42\u4F1A\u56DE\u5230\u5F53\u524D\u9009\u4E2D\u6A21\u578B\u3002"
+  });
+  if (input3.model?.startsWith("claude-3-5-haiku") && config.Router.background) {
+    const model = resolveDisplayModel(config, config.Router.background);
+    steps.push({
+      label: "Router.background",
+      status: "matched",
+      detail: "\u8BF7\u6C42\u6A21\u578B\u4EE5 claude-3-5-haiku \u5F00\u5934\uFF0C\u6309\u5F53\u524D\u57FA\u7840\u8DEF\u7531\u5B9E\u73B0\u8BC6\u522B\u4E3A\u540E\u53F0\u8BF7\u6C42\u3002"
+    });
+    return {
+      input: input3,
+      finalModel: model.resolved,
+      finalModelRef: model.model,
+      source: "basic_background",
+      steps,
+      warnings
+    };
+  }
+  steps.push({
+    label: "Router.background",
+    status: config.Router.background ? "info" : "skipped",
+    detail: config.Router.background ? "\u4EC5\u5F53\u8BF7\u6C42\u6A21\u578B\u4EE5 claude-3-5-haiku \u5F00\u5934\u65F6\u547D\u4E2D\uFF1B\u5982\u679C Claude Code \u540E\u53F0\u6A21\u578B\u6807\u8BC6\u53D8\u5316\uFF0C\u9700\u8981\u91CD\u65B0\u6821\u51C6\u3002" : "\u672A\u914D\u7F6E Router.background\u3002"
+  });
+  if (input3.thinking && config.Router.think) {
+    const model = resolveDisplayModel(config, config.Router.think);
+    steps.push({
+      label: "Router.think",
+      status: "matched",
+      detail: "\u8BF7\u6C42\u5305\u542B thinking\uFF0C\u4F7F\u7528\u601D\u8003\u69FD\u4F4D\u3002"
+    });
+    return {
+      input: input3,
+      finalModel: model.resolved,
+      finalModelRef: model.model,
+      source: "basic_thinking",
+      steps,
+      warnings
+    };
+  }
+  steps.push({
+    label: "Router.think",
+    status: config.Router.think ? "info" : "skipped",
+    detail: config.Router.think ? "\u672C\u6B21\u672A\u58F0\u660E thinking\uFF1B\u5982\u679C\u540C\u65F6\u8D85\u8FC7 longContext threshold\uFF0C\u957F\u4E0A\u4E0B\u6587\u4F1A\u5148\u4E8E thinking \u547D\u4E2D\u3002" : "\u672A\u914D\u7F6E Router.think\u3002"
+  });
+  if (input3.webSearch && config.Router.webSearch) {
+    const model = resolveDisplayModel(config, config.Router.webSearch);
+    steps.push({
+      label: "Router.webSearch",
+      status: "matched",
+      detail: "\u8BF7\u6C42\u5305\u542B web_search \u5DE5\u5177\uFF0C\u4F7F\u7528\u8054\u7F51\u641C\u7D22\u69FD\u4F4D\u3002"
+    });
+    return {
+      input: input3,
+      finalModel: model.resolved,
+      finalModelRef: model.model,
+      source: "basic_web_search",
+      steps,
+      warnings
+    };
+  }
+  steps.push({
+    label: "Router.webSearch",
+    status: config.Router.webSearch ? "info" : "skipped",
+    detail: config.Router.webSearch ? "\u672C\u6B21\u672A\u58F0\u660E web_search\uFF1B\u5982\u679C\u540C\u65F6\u8D85\u8FC7 longContext threshold\uFF0C\u957F\u4E0A\u4E0B\u6587\u4F1A\u5148\u4E8E webSearch \u547D\u4E2D\u3002" : "\u672A\u914D\u7F6E Router.webSearch\u3002"
+  });
+  const defaultModel = resolveDisplayModel(config, config.Router.default);
+  if (!defaultModel.resolved || !getCompiledModelRef(config, defaultModel.resolved)) {
+    warnings.push(`Router.default "${config.Router.default}" \u672A\u89E3\u6790\u5230\u53EF\u7528\u6A21\u578B\u3002`);
+  }
+  steps.push({
+    label: "Router.default",
+    status: defaultModel.resolved ? "matched" : "warning",
+    detail: defaultModel.resolved ? "\u524D\u7F6E\u69FD\u4F4D\u5747\u672A\u547D\u4E2D\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u6A21\u578B\u3002" : "Router.default \u672A\u89E3\u6790\u5230\u53EF\u7528\u6A21\u578B\u3002"
+  });
+  if (defaultModel.model && !registry.modelMap[defaultModel.model] && !defaultModel.model.includes(",")) {
+    warnings.push(`Router.default "${defaultModel.model}" \u4E0D\u5728 Models/Providers/Registration \u4E2D\u3002`);
+  }
+  return {
+    input: input3,
+    finalModel: defaultModel.resolved,
+    finalModelRef: defaultModel.model,
+    source: defaultModel.resolved ? "basic_default" : "unresolved",
+    steps,
+    warnings
+  };
+}
+function previewRoute(config, input3) {
+  const smartRouterConfig = deriveRuntimeSmartRouterConfig(config, config);
+  const text = input3.text.trim();
+  const smartRouterEnabled = Boolean(smartRouterConfig?.enabled);
+  const rules = smartRouterConfig?.rules ?? [];
+  if (smartRouterEnabled && smartRouterConfig && text) {
+    const ruleMatch = extractRuleMatch(text, rules);
+    if (ruleMatch) {
+      const model = resolveDisplayModel(config, ruleMatch.rule.model);
+      return {
+        input: input3,
+        finalModel: model.resolved,
+        finalModelRef: model.model,
+        source: "smart_rule",
+        confidence: 1,
+        ruleName: ruleMatch.rule.name,
+        steps: [
+          {
+            label: "SmartRouter.rules",
+            status: "matched",
+            detail: `\u547D\u4E2D\u89C4\u5219 "${ruleMatch.rule.name}"\uFF08${ruleMatch.detail}\uFF09\uFF0C\u4F1A\u5728\u57FA\u7840 Router \u524D\u9009\u5B9A\u6A21\u578B\u3002`
+          }
+        ],
+        warnings: []
+      };
+    }
+    const semanticCandidates = buildSemanticCandidates(rules, smartRouterConfig);
+    if (smartRouterConfig.semantic?.enabled && smartRouterConfig.semantic.mode !== "classifier" && semanticCandidates.length) {
+      const result = semanticRouter.analyzeCandidates(
+        text,
+        semanticCandidates.map((candidate) => ({
+          intent: candidate.intent,
+          prototype: candidate.prototype,
+          threshold: candidate.threshold
+        })),
+        smartRouterConfig.semantic.threshold
+      );
+      if (result) {
+        const candidate = semanticCandidates.find((item) => item.intent === result.intent);
+        const model = resolveDisplayModel(config, candidate?.rule.model);
+        return {
+          input: input3,
+          finalModel: model.resolved,
+          finalModelRef: model.model,
+          source: "semantic_match",
+          confidence: result.confidence,
+          ruleName: result.intent,
+          steps: [
+            {
+              label: "SmartRouter.semantic",
+              status: "matched",
+              detail: `\u8BED\u4E49 prototype \u547D\u4E2D "${result.intent}"\uFF0Cconfidence=${result.confidence.toFixed(3)}\u3002`
+            }
+          ],
+          warnings: []
+        };
+      }
+    }
+    if (smartRouterConfig.router_model && (smartRouterConfig.candidates?.length ?? 0) >= 2) {
+      const model = resolveDisplayModel(config, smartRouterConfig.router_model);
+      return {
+        input: input3,
+        finalModel: void 0,
+        finalModelRef: void 0,
+        source: "smart_router_pending",
+        steps: [
+          {
+            label: "SmartRouter.router_model",
+            status: "info",
+            detail: `\u672A\u547D\u4E2D\u786E\u5B9A\u6027\u89C4\u5219\uFF1B\u771F\u5B9E\u8BF7\u6C42\u4F1A\u5148\u8C03\u7528 router_model "${smartRouterConfig.router_model}"\uFF08${model.resolved ?? "\u672A\u89E3\u6790"}\uFF09\u5728 ${smartRouterConfig.candidates?.length ?? 0} \u4E2A\u5019\u9009\u4E2D\u9009\u62E9\uFF0C\u4F1A\u589E\u52A0\u9996\u5305\u524D\u7B49\u5F85\u3002`
+          },
+          {
+            label: "Basic Router fallback",
+            status: "info",
+            detail: "\u5982\u679C SmartRouter \u8C03\u7528\u5931\u8D25\u6216\u8FD4\u56DE\u65E0\u6548\u6A21\u578B\uFF0C\u8BF7\u6C42\u4F1A\u7EE7\u7EED\u8FDB\u5165\u57FA\u7840 Router fallback\u3002"
+          }
+        ],
+        warnings: [
+          "doctor route preview \u4E0D\u4F1A\u8C03\u7528 SmartRouter LLM\uFF1B\u8FD9\u91CC\u5C55\u793A\u7684\u662F\u5F85\u51B3\u7B56\u8DEF\u5F84\uFF0C\u4E0D\u4EE3\u8868\u6700\u7EC8\u5019\u9009\u9009\u62E9\u3002"
+        ]
+      };
+    }
+  }
+  const basic = previewBasicRouter(config, input3);
+  if (smartRouterEnabled) {
+    basic.steps.unshift({
+      label: "SmartRouter",
+      status: "skipped",
+      detail: "SmartRouter \u5DF2\u542F\u7528\uFF0C\u4F46\u672C\u6B21\u672A\u547D\u4E2D\u89C4\u5219/\u8BED\u4E49\uFF0C\u4E14\u6CA1\u6709\u53EF\u7528 router_model+candidates \u515C\u5E95\u3002"
+    });
+  }
+  return basic;
+}
+function formatRoutePreview(result) {
+  const lines = [
+    `\u8DEF\u7531\u9884\u6F14\uFF1A${result.input.text || "<empty>"}`,
+    `\u9884\u8BA1\u6765\u6E90\uFF1A${result.source}${result.ruleName ? ` (${result.ruleName})` : ""}`,
+    `\u9884\u8BA1\u6A21\u578B\uFF1A${result.finalModelRef ?? "-"}${result.finalModel ? ` -> ${result.finalModel}` : ""}`
+  ];
+  if (result.confidence !== void 0) {
+    lines.push(`\u7F6E\u4FE1\u5EA6\uFF1A${result.confidence.toFixed(3)}`);
+  }
+  for (const step of result.steps) {
+    lines.push(`- [${step.status}] ${step.label}: ${step.detail}`);
+  }
+  for (const warning of result.warnings) {
+    lines.push(`! ${warning}`);
+  }
+  return lines;
+}
+var init_route_preview = __esm({
+  "src/router/route-preview.ts"() {
+    "use strict";
+    init_compile();
+    init_matcher();
+    init_config();
+    init_semantic_router();
+  }
+});
+
 // src/doctor/index.ts
 function collectCompatibilityPreviewDiagnostics(model) {
   const registry = buildModelRegistry({
@@ -14222,6 +14601,18 @@ function collectCompatibilityPreviewDiagnostics(model) {
 function hasArg(flag) {
   return process.argv.slice(2).includes(flag);
 }
+function readArgValue(flag) {
+  const args = process.argv.slice(2);
+  const index = args.indexOf(flag);
+  if (index < 0) {
+    return void 0;
+  }
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) {
+    return void 0;
+  }
+  return value;
+}
 function createConsoleIO2() {
   if (process.env.CTR_DOCTOR_FORCE_SCRIPTED_INPUT === "1") {
     const scriptedInput = (0, import_fs10.readFileSync)(0, "utf-8");
@@ -14807,6 +15198,57 @@ function reportRouterSlotSummary(config, registry, deps) {
     deps.io.info("\u957F\u4E0A\u4E0B\u6587\u63D0\u793A\uFF1ARouter.longContext \u7684 context_window_tokens \u4E0D\u9AD8\u4E8E Router.default\uFF1B\u8BF7\u786E\u8BA4\u5B83\u786E\u5B9E\u662F\u957F\u4E0A\u4E0B\u6587\u6A21\u578B\u3002");
   }
 }
+function buildDoctorRoutePreviewInputs() {
+  const customText = readArgValue("--route-text");
+  if (customText) {
+    return [{
+      text: customText,
+      model: readArgValue("--route-model") ?? "claude-3-5-sonnet",
+      thinking: hasArg("--route-thinking"),
+      webSearch: hasArg("--route-web-search"),
+      tokenCount: Number(readArgValue("--route-tokens")) || void 0
+    }];
+  }
+  return [
+    {
+      text: "\u65E5\u5E38\u4EE3\u7801\u4FEE\u6539\u548C\u89E3\u91CA",
+      model: "claude-3-5-sonnet",
+      tokenCount: 1e3
+    },
+    {
+      text: "\u8BF7\u6DF1\u5165\u5206\u6790\u8FD9\u4E2A\u590D\u6742\u8BBE\u8BA1\u95EE\u9898",
+      model: "claude-3-5-sonnet",
+      thinking: true,
+      tokenCount: 1e3
+    },
+    {
+      text: "\u957F\u6587\u6863\u5168\u6587\u603B\u7ED3",
+      model: "claude-3-5-sonnet",
+      tokenCount: 12e4
+    },
+    {
+      text: "\u9700\u8981\u8054\u7F51\u641C\u7D22\u8D44\u6599",
+      model: "claude-3-5-sonnet",
+      webSearch: true,
+      tokenCount: 1e3
+    },
+    {
+      text: "\u540E\u53F0\u8F7B\u91CF\u4EFB\u52A1",
+      model: "claude-3-5-haiku",
+      tokenCount: 1e3
+    }
+  ];
+}
+function reportRoutePreview(config, deps) {
+  deps.io.info("\u8DEF\u7531\u9884\u6F14\uFF1A\u6839\u636E\u5F53\u524D\u914D\u7F6E\u9884\u4F30\u8BF7\u6C42\u4F1A\u547D\u4E2D\u54EA\u4E2A\u6A21\u578B\uFF1B\u4E0D\u4F1A\u8C03\u7528\u4E0A\u6E38\u6A21\u578B\u6216 SmartRouter LLM\u3002");
+  for (const input3 of buildDoctorRoutePreviewInputs()) {
+    const result = previewRoute(config, input3);
+    for (const line of formatRoutePreview(result)) {
+      deps.io.info(line);
+    }
+  }
+  deps.io.info("\u8DEF\u7531\u9884\u6F14\u63D0\u793A\uFF1A\u771F\u5B9E\u8FD0\u884C\u4ECD\u4F1A\u5728\u6700\u7EC8\u5B9A\u6A21\u540E\u6267\u884C context window guard\u3001\u6A21\u578B\u6C60 fallback\u3001\u8FDC\u7A0B\u4E2D\u8F6C\u548C\u6D41\u5F0F\u6CBB\u7406\u3002");
+}
 function createDefaultDeps2(io = createConsoleIO2()) {
   return {
     readLegacyConfig,
@@ -14867,6 +15309,9 @@ async function runDoctorCli(customDeps) {
     await reportRuntimeServiceContext(normalized.config, deps);
     const registry = buildModelRegistry(normalized.config);
     reportRouterSlotSummary(normalized.config, registry, deps);
+    if (hasArg("--route-preview")) {
+      reportRoutePreview(normalized.config, deps);
+    }
     for (const model of normalized.config.Models ?? []) {
       const compiledModel = registry.modelMap[model.id];
       if (!compiledModel) {
@@ -14954,6 +15399,7 @@ var init_doctor = __esm({
     init_service_health();
     init_templates();
     init_api_keys();
+    init_route_preview();
     ROUTER_SLOT_DIAGNOSTICS = [
       {
         key: "default",
@@ -15104,6 +15550,7 @@ Claude Trigger Router - \u667A\u80FD\u89E6\u53D1\u8DEF\u7531\u5668
 \u4F7F\u7528\u793A\u4F8B\uFF1A
   ctr setup                # \u590D\u7528\u5F53\u524D\u914D\u7F6E / \u8FC1\u79FB\u65E7\u914D\u7F6E / \u65B0\u5EFA\u6700\u5C0F\u914D\u7F6E
   ctr doctor               # \u8BCA\u65AD\u914D\u7F6E / \u4FEE\u590D\u683C\u5F0F\u95EE\u9898 / \u6309\u9700\u63A2\u6D4B\u6A21\u578B\u53EF\u7528\u6027
+  ctr doctor --route-preview --route-text "\u8BF7\u505A\u67B6\u6784\u8BBE\u8BA1"  # \u9884\u6F14\u5F53\u524D\u8BF7\u6C42\u4F1A\u8D70\u54EA\u4E2A\u6A21\u578B
   ctr eval --tasks         # \u67E5\u770B\u56FA\u5B9A\u8BC4\u6D4B\u4EFB\u52A1\u3001prompt \u548C rubric
   ctr eval --input results.json  # \u7528\u56FA\u5B9A\u4EFB\u52A1\u96C6 rubric \u8BC4\u6D4B\u591A\u6A21\u578B\u8F93\u51FA\u7ED3\u679C
   ctr eval --run --models "sonnet;haiku"  # \u81EA\u52A8\u8C03\u7528 CTR /v1/messages \u540E\u8BC4\u6D4B