@@ -19,7 +19,6 @@ import {
   ExitCode,
   parseAigcToolResult,
   imageFileToDataUri,
-  audioFileToDataUri,
   isMcpTtsVoice,
   MCP_TTS_VOICES,
   MCP_CALL_SERVICE,
@@ -288,10 +287,25 @@ export function resolveAutoImageInput(source: string): string {
   return imageFileToDataUri(source);
 }
 
-/** Resolve an `auto`-mode audio input the same way (ASR `file_urls`). */
-export function resolveAutoAudioInput(source: string): string {
-  if (isUrlScheme(source)) return source;
-  return audioFileToDataUri(source);
+/**
+ * Resolve an `auto`-mode ASR input: the live `bailian_speech_to_text` server
+ * only transcribes public http(s) URLs — data-URI input (including inlined
+ * local files) comes back as an empty transcript with no error at all — so
+ * anything else is rejected up front with an actionable USAGE error instead of
+ * a silent empty result.
+ */
+export function resolveAutoAsrInput(source: string, localize: Localize): string {
+  if (/^https?:/i.test(source)) return source;
+  const message = localize({
+    "en-US": `The current model (auto) recognizes audio via Bailian MCP, which only transcribes public http(s) URLs; cannot use "${source}".`,
+    "zh-CN": `当前模型（auto）经百炼 MCP 识别音频，仅支持公网 http(s) URL，无法使用 "${source}"。`,
+  });
+  const hint = localize({
+    "en-US":
+      "Host the audio at a public http(s) URL, or pass --model <id> to recognize local files with a specific model.",
+    "zh-CN": "请将音频托管为公网 http(s) URL，或传入 --model <id> 使用指定模型识别本地文件。",
+  });
+  throw new BailianError(message, ExitCode.USAGE, hint);
 }
 
 // ---- Shared-session MCP call wrapper ----
 
@@ -39,7 +39,7 @@ import {
   assertAutoMcpAvailable,
   assertMcpCompatible,
   withAigcMcpSession,
-  resolveAutoAudioInput,
+  resolveAutoAsrInput,
   type Localize,
 } from "../shared/aigc-mcp.ts";
 
@@ -359,9 +359,9 @@ async function handleAutoMcpMode(
     throw new BailianError("Provide at least one --url to recognize.", ExitCode.USAGE);
   }
 
-  // Public http(s)/oss URLs pass through; local files become inline base64 data
-  // URIs (the MCP server rejects oss:// and cannot fetch private uploads).
-  const fileUrls = rawUrls.map((source) => resolveAutoAudioInput(source));
+  // The live MCP ASR server only transcribes public http(s) URLs; local files
+  // and data URIs are rejected up front instead of silently empty results.
+  const fileUrls = rawUrls.map((source) => resolveAutoAsrInput(source, localize));
   const args = buildSpeechToTextArgs(fileUrls);
 
   if (settings.dryRun) {
 
@@ -8,6 +8,7 @@ import {
   isAutoModel,
   mcpSingleImageOnlyError,
   mcpUnsupportedError,
+  resolveAutoAsrInput,
   resolveAutoImageSize,
   type AigcMcpOperation,
   type Localize,
@@ -201,3 +202,19 @@ describe("assertMcpTtsVoice rejects REST voice IDs", () => {
     expect(error.hint).toContain("--model");
   });
 });
+
+describe("resolveAutoAsrInput only accepts public http(s) URLs", () => {
+  test("http(s) URLs pass through verbatim", () => {
+    expect(resolveAutoAsrInput("https://x/a.wav", enUS)).toBe("https://x/a.wav");
+    expect(resolveAutoAsrInput("http://x/a.wav", zhCN)).toBe("http://x/a.wav");
+  });
+
+  test("local paths and data URIs throw USAGE with a switch-model hint", () => {
+    const local = captureUsage(() => resolveAutoAsrInput("./a.wav", enUS));
+    expect(local.message).toContain("./a.wav");
+    expect(local.hint).toContain("--model");
+    const dataUri = captureUsage(() => resolveAutoAsrInput("data:audio/wav;base64,AA==", zhCN));
+    expect(dataUri.message).toContain("data:audio/wav");
+    expect(dataUri.hint).toContain("--model");
+  });
+});
@@ -210,12 +210,14 @@ describe("e2e: aigc auto → mcp", () => {
     expect(data.arguments?.file_urls).toEqual(["https://example.com/a.mp3"]);
   });
 
-  test("speech recognize auto 本地音频内联为脱敏 data URI", async () => {
+  test("speech recognize auto 拒绝本地音频（服务端仅转写公网 URL）", async () => {
+    // The live MCP ASR server silently returns an empty transcript for data
+    // URIs, so local inputs must fail up front with a USAGE error.
     const configDir = makeE2eOutputDir("aigc-auto-speech-recognize-local");
     const audioPath = join(configDir, "input.wav");
     writeFileSync(audioPath, Buffer.from([1, 2, 3]));
 
-    const { stdout, stderr, exitCode } = await runCommandE2e(AUTO_ROUTES, [
+    const { stderr, exitCode } = await runCommandE2e(AUTO_ROUTES, [
       "speech",
       "recognize",
       "--model",
@@ -226,9 +228,25 @@ describe("e2e: aigc auto → mcp", () => {
       "--output",
       "json",
     ]);
+    expect(exitCode).toBe(2);
+    expect(stderr).toMatch(/--model/);
+  });
+
+  test("speech recognize auto dry-run 预览公网 URL 透传", async () => {
+    const { stdout, stderr, exitCode } = await runCommandE2e(AUTO_ROUTES, [
+      "speech",
+      "recognize",
+      "--model",
+      "auto",
+      "--url",
+      "https://example.com/audio.wav",
+      "--dry-run",
+      "--output",
+      "json",
+    ]);
     expect(exitCode, stderr).toBe(0);
     const data = parseStdoutJson<McpPreview>(stdout);
-    expect(data.arguments?.file_urls).toEqual(["data:audio/wav;base64,<omitted>"]);
+    expect(data.arguments?.file_urls).toEqual(["https://example.com/audio.wav"]);
   });
 
   test("image generate auto dry-run 预览把 --size 比例映射为 MCP 宽*高", async () => {
 
@@ -87,15 +87,14 @@ export interface SdkMcpAdapterOptions {
 /**
  * Translate an SDK/transport error into the CLI error contract.
  *
- * - `BailianError` (already ours, produced by the fetch interceptor) passes through.
- * - `McpError`: SDK-local failures only — the protocol timer (`Request timed
- *   out` / `Maximum total timeout exceeded`, carrying its payload in `data`) →
- *   TIMEOUT, and the transport-close rejection (`Connection closed`) → NETWORK.
- *   A server-side JSON-RPC error reusing those codes (-32000 / -32001) carries
- *   the server's own message, so it falls through to GENERAL with the
- *   `MCP error (code): message` shape (message passed through verbatim per
- *   AGENTS.md §3) — the exit code must not mislead callers into retrying a
- *   business error as a network/timeout failure.
+ * - `BailianError` (already ours, produced by local timeout or the fetch
+ *   interceptor) passes through.
+ * - `McpError`: treated as a server-side JSON-RPC error by default and mapped to
+ *   `GENERAL` with the `MCP error (<code>): <message>` shape (message passed
+ *   through verbatim per AGENTS.md §3). Callers that can distinguish local
+ *   transport-close events pass `localCloseFired: true` so that
+ *   `ConnectionClosed` errors arising after the transport has closed are mapped
+ *   to `NETWORK` instead.
  * - `StreamableHTTPError` (HTTP status in `.code`) → GENERAL with the
  *   `MCP request failed: <status>` shape so the fallback detectors still match.
  * - `SseError` (classic SSE): when the fetch interceptor captured the failing
@@ -107,15 +106,16 @@ export interface SdkMcpAdapterOptions {
  * - Anything else (e.g. a `TypeError` from `fetch`) is returned unchanged so the
  *   runtime keeps its errno-specific handling.
  */
-export function mapSdkError(error: unknown, sseGetFailure?: SseGetFailure): unknown {
+export function mapSdkError(
+  error: unknown,
+  sseGetFailure?: SseGetFailure,
+  options?: { localCloseFired?: boolean },
+): unknown {
   if (error instanceof BailianError) return error;
 
   if (error instanceof McpError) {
     const raw = rawMcpMessage(error);
-    if (error.code === ErrorCode.RequestTimeout && isLocalTimeoutSignature(error, raw)) {
-      return new BailianError(raw || "MCP request timed out.", ExitCode.TIMEOUT);
-    }
-    if (error.code === ErrorCode.ConnectionClosed && raw === LOCAL_CLOSE_MESSAGE) {
+    if (error.code === ErrorCode.ConnectionClosed && options?.localCloseFired) {
       return new BailianError(raw || "MCP connection closed.", ExitCode.NETWORK);
     }
     return new BailianError(`MCP error (${error.code}): ${raw}`, ExitCode.GENERAL);
@@ -154,24 +154,6 @@ function rawMcpMessage(error: McpError): string {
   return error.message.startsWith(prefix) ? error.message.slice(prefix.length) : error.message;
 }
 
-/** Fixed message of the SDK's transport-close rejection of pending requests. */
-const LOCAL_CLOSE_MESSAGE = "Connection closed";
-
-/**
- * True when a `RequestTimeout` McpError came from the SDK's own request timer,
- * not from a server JSON-RPC error response reusing code -32001. The protocol
- * timer attaches its payload as `data` (`{ timeout }` / `{ maxTotalTimeout, … }`);
- * the fixed timer messages are matched as a fallback so the contract survives
- * SDK builds that drop the payload.
- */
-function isLocalTimeoutSignature(error: McpError, raw: string): boolean {
-  const data = error.data as Record<string, unknown> | undefined;
-  if (data && (typeof data.timeout === "number" || typeof data.maxTotalTimeout === "number")) {
-    return true;
-  }
-  return raw === "Request timed out" || raw === "Maximum total timeout exceeded";
-}
-
 /**
  * Server-side failure of a classic SSE stream GET, captured by the fetch
  * interceptor before `eventsource` discards the body (it only reports
@@ -281,6 +263,12 @@ export class SdkMcpAdapter implements McpConnectedClient {
   private connecting: Promise<void> | undefined;
   /** Last failed classic SSE stream GET, for `SseError` contract reconstruction. */
   private sseGetFailure: SseGetFailure | undefined;
+  /**
+   * Set when the transport's `onclose` callback fires. Used to distinguish
+   * SDK-generated `ConnectionClosed` errors (local network events) from
+   * server-authored JSON-RPC errors that reuse code -32000.
+   */
+  private transportClosed = false;
 
   constructor(options: SdkMcpAdapterOptions) {
     this.deps = options.deps;
@@ -308,7 +296,9 @@ export class SdkMcpAdapter implements McpConnectedClient {
   async listTools(): Promise<McpTool[]> {
     const client = await this.requireClient();
     try {
-      const result = await client.listTools(undefined, this.requestOptions());
+      const result = await this.withLocalTimeout(
+        client.listTools(undefined, this.requestOptions()),
+      );
       // Returned verbatim (the SDK-validated Tool objects): callers such as
       // `bl mcp tools --output json` keep every standard field the server
       // declares (outputSchema / annotations / title / `_meta`, …), matching
@@ -322,10 +312,8 @@ export class SdkMcpAdapter implements McpConnectedClient {
   async callTool(name: string, args: Record<string, unknown>): Promise<McpToolResult> {
     const client = await this.requireClient();
     try {
-      const result = (await client.callTool(
-        { name, arguments: args },
-        undefined,
-        this.requestOptions(),
+      const result = (await this.withLocalTimeout(
+        client.callTool({ name, arguments: args }, undefined, this.requestOptions()),
       )) as McpToolResult;
       // The SDK already validates the envelope against CallToolResultSchema;
       // only a missing content array is an unexpected shape for our callers.
@@ -359,9 +347,9 @@ export class SdkMcpAdapter implements McpConnectedClient {
 
   // ---- Internal ----
 
-  /** `mapSdkError` with this adapter's captured classic SSE GET failure. */
+  /** `mapSdkError` with this adapter's local transport-close state. */
   private mapTransportError(error: unknown): unknown {
-    return mapSdkError(error, this.sseGetFailure);
+    return mapSdkError(error, this.sseGetFailure, { localCloseFired: this.transportClosed });
   }
 
   private async connect(): Promise<void> {
@@ -375,6 +363,8 @@ export class SdkMcpAdapter implements McpConnectedClient {
       this.sseGetFailure = failure;
     });
     const endpoint = new URL(this.url);
+    this.transportClosed = false;
+
     const transport =
       this.kind === "sse"
         ? new SSEClientTransport(endpoint, { requestInit: { headers }, fetch: mcpFetch })
@@ -383,6 +373,14 @@ export class SdkMcpAdapter implements McpConnectedClient {
             fetch: mcpFetch,
           });
 
+    // Track local transport close so SDK-generated `ConnectionClosed` errors
+    // can be reliably distinguished from server-authored -32000 JSON-RPC errors.
+    // Protocol.connect wraps any pre-existing onclose, so this fires before the
+    // SDK rejects in-flight requests.
+    transport.onclose = () => {
+      this.transportClosed = true;
+    };
+
     const client = new Client(
       { name: this.deps.identity.clientName, version: this.deps.identity.version },
       { capabilities: {} },
@@ -452,6 +450,28 @@ export class SdkMcpAdapter implements McpConnectedClient {
   }
 
   private requestOptions(): { timeout: number } {
-    return { timeout: this.deps.settings.timeout * 1000 };
+    // Disable the SDK's own request timer; the adapter enforces the timeout
+    // locally via `withLocalTimeout` so that timeout failures carry an
+    // unambiguous local source and are not confused with server JSON-RPC
+    // errors that may reuse code -32001 or carry `data.timeout`.
+    // Use Node's maximum setTimeout delay so the SDK timer never wins the race.
+    return { timeout: 2_147_483_647 };
+  }
+
+  private async withLocalTimeout<T>(promise: Promise<T>): Promise<T> {
+    const timeoutSeconds = this.deps.settings.timeout;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new BailianError(`MCP request timed out after ${timeoutSeconds}s.`, ExitCode.TIMEOUT),
+        );
+      }, timeoutSeconds * 1000);
+    });
+    try {
+      return await Promise.race([promise, timeoutPromise]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
   }
 }
@@ -120,14 +120,27 @@ test("bailianMcp 路径与 isStreamableHttpUnsupported", () => {
 
 // ---- mapSdkError ----
 
-test("mapSdkError：超时/连接关闭映射 ExitCode；服务端 JSON-RPC 错透传；BailianError 与原生错原样返回", () => {
+test("mapSdkError：McpError 默认按 GENERAL 透传；localCloseFired 才将 ConnectionClosed 映射为 NETWORK", () => {
+  // SDK-local RequestTimeout is now handled by the adapter's own timer and
+  // reaches mapSdkError as a BailianError; a bare McpError is server-authored.
   const timeout = mapSdkError(new McpError(ErrorCode.RequestTimeout, "Request timed out"));
   expect(timeout).toBeInstanceOf(BailianError);
-  expect((timeout as BailianError).exitCode).toBe(ExitCode.TIMEOUT);
+  expect((timeout as BailianError).exitCode).toBe(ExitCode.GENERAL);
 
+  // ConnectionClosed without the local-close signal is treated as a server
+  // JSON-RPC error (e.g. the server returned -32000).
   const closed = mapSdkError(new McpError(ErrorCode.ConnectionClosed, "Connection closed"));
   expect(closed).toBeInstanceOf(BailianError);
-  expect((closed as BailianError).exitCode).toBe(ExitCode.NETWORK);
+  expect((closed as BailianError).exitCode).toBe(ExitCode.GENERAL);
+
+  // ConnectionClosed after the local transport closed is a network event.
+  const localClosed = mapSdkError(
+    new McpError(ErrorCode.ConnectionClosed, "Connection closed"),
+    undefined,
+    { localCloseFired: true },
+  );
+  expect(localClosed).toBeInstanceOf(BailianError);
+  expect((localClosed as BailianError).exitCode).toBe(ExitCode.NETWORK);
 
   // Server-side JSON-RPC error: passthrough message with the MCP error shape.
   const business = mapSdkError(new McpError(-32601, "Method not found"));
@@ -148,33 +161,23 @@ test("mapSdkError：超时/连接关闭映射 ExitCode；服务端 JSON-RPC 错
   expect(mapSdkError(typeError)).toBe(typeError);
 });
 
-test("mapSdkError：服务端 JSON-RPC 错复用 -32000/-32001 仍按 GENERAL 透传，本地计时器错才判 TIMEOUT/NETWORK", () => {
+test("mapSdkError：服务端 JSON-RPC 错复用 -32000/-32001 按 GENERAL 透传，不再推断本地签名", () => {
   // Server-authored messages on the locally-interpreted codes must stay GENERAL
   // (exit 1) so callers do not retry business errors as network/timeout.
   const serverClosed = mapSdkError(new McpError(-32000, "session expired"));
   expect(serverClosed).toBeInstanceOf(BailianError);
   expect((serverClosed as BailianError).exitCode).toBe(ExitCode.GENERAL);
   expect((serverClosed as BailianError).message).toBe("MCP error (-32000): session expired");
 
-  const serverTimeout = mapSdkError(new McpError(-32001, "tool execution timed out"));
+  // The server can also return -32001 with data.timeout — this must not be
+  // mistaken for the SDK's local request timer.
+  const serverTimeout = mapSdkError(
+    new McpError(-32001, "backend execution expired", { timeout: 5000 }),
+  );
   expect((serverTimeout as BailianError).exitCode).toBe(ExitCode.GENERAL);
   expect((serverTimeout as BailianError).message).toBe(
-    "MCP error (-32001): tool execution timed out",
-  );
-
-  // The SDK protocol timer attaches its payload as `data` — local signature.
-  const timer = mapSdkError(
-    McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout: 5000 }),
-  );
-  expect((timer as BailianError).exitCode).toBe(ExitCode.TIMEOUT);
-
-  const maxTotal = mapSdkError(
-    McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
-      maxTotalTimeout: 1000,
-      totalElapsed: 1200,
-    }),
+    "MCP error (-32001): backend execution expired",
   );
-  expect((maxTotal as BailianError).exitCode).toBe(ExitCode.TIMEOUT);
 });
 
 test("mapSdkError：SseError 结合捕获的 SSE GET 失败重建文案契约；无捕获时原样返回", () => {