Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

27.7 KB
Raw Blame
import { normalizeProviderRequest } from '@cindy/model-compat';
/**
 * Bridge handler ——
 *
 * 以 anthropic-compat-proxy 的 `RoutingDecision.localHandler` 形态运行(**不是**独立 server):
 * 代理在路由决策命中订阅前缀 model 时,把已收集的请求(parsed body + ctx + res)直接交给本
 * handler,由它:
 *   1. strip model 前缀 → 真实 model id
 *   2. translateRequest → OpenAI Responses 请求
 *   3. 注入 OAuth headers(provider.buildHeaders 拿最新凭证)→ POST 上游 /responses
 *   4. 按调用方的 stream 模式把上游 Responses SSE / JSON 翻译成 Anthropic Messages SSE / JSON
 *
 * 会话态(effort / Fast)由 host 的 routingTransform 在决策点解析后经 `prefs` 闭包传入,
 * 不走任何伪 header。响应是**翻译流**(非字节透传)——这是本包与 compat-proxy 引擎的分工:
 * 引擎守字节级零延迟透传,handler 做协议翻译;逐事件翻译不缓冲整流,流式延迟仍接近零。
 *
 * 错误契约(与引擎 runLocalHandler 对齐):本 handler 内部把可预期错误写成 Anthropic 风格
 * error 响应;意外抛错交给引擎(未写头 → 502 fail-open)。
 */

import type { ServerResponse } from 'node:http';

import { AnthropicMessageCollector } from './anthropic-message-collector.js';
import { translateRequest, type ResponsesReasoningEffort } from './translate-request.js';
import { SseTranslator, type AnthropicSseEvent } from './translate-sse.js';
import { WireDiagnosticsSession } from './wire-diagnostics.js';
import type {
  AnthropicMessagesRequest,
  BridgeLogger,
  BridgeProviderConfig,
  UpstreamRateLimitInfo,
} from './types.js';

/**
 * Higher efforts require an explicit per-model capability; providers without one keep the
 * historical xhigh ceiling. Codex subscription capabilities differ from the public API.
 * 无输入 / 无法识别 → undefined(translateRequest 回退默认档)。
 */
function normalizeReasoningEffort(raw: string | undefined, supported?: readonly string[]): ResponsesReasoningEffort | undefined {
  const effort = (raw ?? '').trim().toLowerCase();
  switch (effort) {
    case 'minimal':
    case 'low':
      return 'low';
    case 'medium':
      return 'medium';
    case 'high':
      return 'high';
    case 'xhigh':
      return 'xhigh';
    case 'max':
    case 'ultra':
      if (supported?.includes(effort)) return effort;
      if (effort === 'ultra' && supported?.includes('max')) return 'max';
      return 'xhigh';
    default:
      return undefined;
  }
}

/**
 * 解析上游响应的 `x-ratelimit-*` 头(标准 OpenAI 风格)。全部字段都解析不出 → null(不回调)。
 * reset 类头(如 "6m0s")格式跨供应商不稳定,不解析 —— 只取确定的数值字段,诚实降级。
 */
function parseRateLimitHeaders(headers: Headers): UpstreamRateLimitInfo | null {
  const num = (name: string): number | undefined => {
    const raw = headers.get(name);
    if (raw == null) return undefined;
    const v = Number(raw);
    return Number.isFinite(v) ? v : undefined;
  };
  const info: UpstreamRateLimitInfo = {
    limitRequests: num('x-ratelimit-limit-requests'),
    remainingRequests: num('x-ratelimit-remaining-requests'),
    limitTokens: num('x-ratelimit-limit-tokens'),
    remainingTokens: num('x-ratelimit-remaining-tokens'),
  };
  return Object.values(info).some((v) => v !== undefined) ? info : null;
}

/** 按 model 前缀匹配 provider 配置(最长前缀优先,防前缀互为子串时歧义)。 */
function matchProvider(model: string, providers: BridgeProviderConfig[]): BridgeProviderConfig | null {
  let best: BridgeProviderConfig | null = null;
  for (const p of providers) {
    if (model.startsWith(p.prefix) && (!best || p.prefix.length > best.prefix.length)) best = p;
  }
  return best;
}

/** upstream 状态码 → Anthropic error type(尽量语义对齐,方便 SDK 分类)。 */
function anthropicErrorType(status: number): string {
  if (status === 401 || status === 403) return 'authentication_error';
  if (status === 429) return 'rate_limit_error';
  if (status === 400) return 'invalid_request_error';
  if (status >= 500) return 'api_error';
  return 'api_error';
}

function writeJson(res: ServerResponse, status: number, body: unknown): void {
  const buf = Buffer.from(JSON.stringify(body), 'utf8');
  res.writeHead(status, { 'content-type': 'application/json', 'content-length': String(buf.length) });
  res.end(buf);
}

/** 与 desktop `OwnerBoundaryPendingError` 对齐:本包不能 import desktop,按 name/code/message 认。 */
const OWNER_BOUNDARY_PENDING_MESSAGE =
  'App session is switching; retry after the owner boundary settles.';

function isOwnerBoundaryPendingError(err: unknown): boolean {
  if (!(err instanceof Error)) return false;
  if (err.name === 'OwnerBoundaryPendingError') return true;
  if ((err as { code?: unknown }).code === 'owner_boundary_pending') return true;
  return err.message === OWNER_BOUNDARY_PENDING_MESSAGE;
}

function writeOwnerBoundaryPending(res: ServerResponse, err: unknown): void {
  const message = err instanceof Error ? err.message : OWNER_BOUNDARY_PENDING_MESSAGE;
  const buf = Buffer.from(JSON.stringify({
    type: 'error',
    error: {
      type: 'owner_boundary_pending',
      code: 'owner_boundary_pending',
      message,
    },
  }), 'utf8');
  res.writeHead(503, {
    'content-type': 'application/json; charset=utf-8',
    'content-length': String(buf.length),
    'cache-control': 'no-store',
    'retry-after': '1',
  });
  res.end(buf);
}

function writeSseEvent(res: ServerResponse, ev: AnthropicSseEvent): void {
  res.write(`event: ${ev.event}\ndata: ${JSON.stringify(ev.data)}\n\n`);
}

const MAX_NON_STREAM_BODY_BYTES = 16 * 1024 * 1024;

async function readBodyWithLimit(response: Response, limitBytes: number): Promise<string> {
  if (!response.body) return '';
  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let body = '';
  let bytesRead = 0;
  try {
    for (;;) {
      const { done, value } = await reader.read();
      if (done) break;
      bytesRead += value.byteLength;
      if (bytesRead > limitBytes) {
        await reader.cancel();
        throw new Error(`upstream response exceeds ${limitBytes} bytes`);
      }
      body += decoder.decode(value, { stream: true });
    }
    body += decoder.decode();
    return body;
  } finally {
    reader.releaseLock();
  }
}

/**
 * 按 SSE 规范切事件:空行分隔事件,**同一事件的多条 `data:` 行先以 `\n` 拼成一个负载**
 * 再解析。逐行独立 JSON.parse 会把「合法但跨多行」的事件当成坏帧,整个非流式 fallback
 * 被判成 502(review 反馈)。与 responses-anthropic-bridge 的 parseSseBlock 同口径。
 */
function parseSsePayloads(body: string): unknown[] {
  const payloads: unknown[] = [];
  for (const block of body.split(/\r?\n\r?\n/)) {
    const data: string[] = [];
    for (const line of block.split(/\r?\n/)) {
      if (line.startsWith('data:')) data.push(line.slice(5).trimStart());
    }
    if (data.length === 0) continue;
    const payload = data.join('\n').trim();
    if (!payload || payload === '[DONE]') continue;
    payloads.push(JSON.parse(payload) as unknown);
  }
  return payloads;
}

/** 缺少 Content-Type 时仅识别 SSE 起始字段;正文已受非流式 16 MiB 上限保护。 */
function looksLikeSse(body: string): boolean {
  return /^(?:(?:event|data|id|retry):|:)/.test(body.trimStart());
}

/** image block 的粗估 token 占位(Anthropic 图像典型 ~1100-1600 tok;粗估用中值,免 stringify 整段 base64)。 */
const IMAGE_BLOCK_ESTIMATE_CHARS = 1400 * 4;

/** chars/4 粗估 token —— 给 count_tokens 用(codex 后端无 count 端点)。 */
function estimateTokens(req: AnthropicMessagesRequest): number {
  let chars = 0;
  const sys = req.system;
  if (typeof sys === 'string') chars += sys.length;
  else if (Array.isArray(sys)) for (const b of sys) chars += (b?.text ?? '').length;
  // tools 的 JSON schema 是 prompt 的大头(Claude Code 常带几十 KB 工具定义),不算会让
  // /context 上下文表严重偏小、compaction 迟触发。
  for (const t of req.tools ?? []) {
    chars += (t.name?.length ?? 0) + (t.description?.length ?? 0);
    if (t.input_schema) {
      try {
        chars += JSON.stringify(t.input_schema).length;
      } catch {
        /* 环引用等异常 schema:跳过,不影响其余估算 */
      }
    }
  }
  for (const m of req.messages ?? []) {
    if (typeof m.content === 'string') chars += m.content.length;
    else if (Array.isArray(m.content)) {
      for (const block of m.content) {
        const rec = block as Record<string, unknown>;
        if (typeof rec.text === 'string') chars += rec.text.length;
        // 图像 block:base64 字节数与 token 数无关(vision 按分辨率计),且 stringify 整段
        // base64 会为一个 /4 粗估分配数 MB 临时串 —— 用固定占位。
        else if (rec.type === 'image') chars += IMAGE_BLOCK_ESTIMATE_CHARS;
        else chars += JSON.stringify(rec).length;
      }
    }
  }
  return Math.max(1, Math.ceil(chars / 4));
}

function isPlainObject(v: unknown): v is Record<string, unknown> {
  return typeof v === 'object' && v !== null && !Array.isArray(v);
}

/** host 在路由决策点解析出的会话态偏好(经闭包传入,不走伪 header)。 */
export interface BridgeSessionPrefs {
  /** 用户选定的思维深度档(maker 6 档,handler 内收敛到 Responses 4 档);缺省走默认档。 */
  reasoningEffort?: string;
  /** Fast 模式;仅 provider 声明了 fastServiceTier 时映射成 service_tier。 */
  fast?: boolean | 'ultrafast';
}

/** createResponsesHandler 的 handle 入参 —— 与 compat-proxy LocalRequestHandler 的 args 同形 + prefs。 */
export interface BridgeHandleArgs {
  parsedBody: unknown;
  ctx: {
    /** compat-proxy reqId; optional for direct handler tests and non-proxy callers. */
    readonly reqId?: number;
    readonly method: string;
    readonly url: string;
    readonly headers: Readonly<Record<string, string>>;
  };
  res: ServerResponse;
  prefs?: BridgeSessionPrefs;
}

export interface ResponsesBridgeHandler {
  handle(args: BridgeHandleArgs): Promise<void>;
}

export interface ResponsesHandlerOptions {
  /** 供应商配置列表(按 model 前缀路由)。前缀需互不为前缀关系,避免歧义。 */
  providers: BridgeProviderConfig[];
  logger?: BridgeLogger;
  /**
   * 上游 fetch。默认全局 fetch(undici)—— 它**不吃系统代理**,宿主在「系统代理」模式
   * 下必须注入自己的代理感知实现(desktop 注入 maker-host/outbound-fetch),否则
   * chatgpt.com / api.x.ai 这类境外上游会裸直连失败。形态与
   * responses-chat-bridge 的同名选项一致。
   */
  fetchImpl?: typeof fetch;
  /** Explicit, temporary, xAI/Grok-only shape probe. Disabled by default. */
  wireDiagnostics?: boolean;
  /** Explicit, temporary strict-tool spike; only meaningful with wireDiagnostics. */
  wireDiagnosticsStrict?: boolean;
}

// 去尾部斜杠。不用 /\/+$/ 正则——超长 '/' 串上会 O(n²) 回溯(CodeQL js/polynomial-redos)。
function trimTrailingSlashes(s: string): string {
  let end = s.length;
  while (end > 0 && s.charCodeAt(end - 1) === 0x2f) end -= 1;
  return s.slice(0, end);
}

/**
 * 创建订阅直连 handler。host 把它包进 compat-proxy 的 `RoutingDecision.localHandler`:
 * `{ localHandler: (a) => handler.handle({ ...a, prefs }) }`。
 */
export function createResponsesHandler(opts: ResponsesHandlerOptions): ResponsesBridgeHandler {
  // 协议标识 fail-fast:注册了未实现的 wireProtocol 直接抛,不让它静默注册成不可用的源。
  for (const p of opts.providers) {
    if (p.wireProtocol !== undefined && p.wireProtocol !== 'openai-responses') {
      throw new Error(`bridge provider '${p.prefix}' 声明了未实现的 wireProtocol: ${String(p.wireProtocol)}`);
    }
  }
  const providers = opts.providers.map((p) => ({ ...p, upstreamBase: trimTrailingSlashes(p.upstreamBase) }));
  const log = opts.logger ?? {};
  const fetchImpl = opts.fetchImpl ?? fetch;
  let reqSeq = 0;

  async function handle({ parsedBody, ctx, res, prefs }: BridgeHandleArgs): Promise<void> {
    const reqId = ++reqSeq;

    if (!isPlainObject(parsedBody)) {
      writeJson(res, 400, { type: 'error', error: { type: 'invalid_request_error', message: 'invalid JSON body' } });
      return;
    }
    const parsed = parsedBody as AnthropicMessagesRequest;

    // 按 model 前缀匹配 provider(count_tokens 请求 body 也带 model)。
    const wireModel = typeof parsed.model === 'string' ? parsed.model : '';
    const provider = matchProvider(wireModel, providers);
    if (!provider) {
      // compat-proxy 只把匹配前缀的请求交到这;没匹配上说明配置/路由不一致。
      writeJson(res, 400, {
        type: 'error',
        error: { type: 'invalid_request_error', message: `no bridge provider for model '${wireModel}'` },
      });
      return;
    }
    // [1m] 是 cc 侧 wire 约定(目录窗口 ≥1M 的模型会带,见 maker-core toSdkModelString);
    // bridge 上游(chatgpt backend / api.x.ai)不认识这个后缀,必须剥掉。
    const realModel = wireModel.slice(provider.prefix.length).replace(/\[1m\]$/, '');

    // count_tokens:上游无对应端点,本地估算返回。
    if (ctx.url.includes('count_tokens')) {
      writeJson(res, 200, { input_tokens: estimateTokens(parsed) });
      return;
    }

    const sessionId =
      ctx.headers['x-claude-code-session-id'] ??
      parsed.metadata?.user_id ??
      undefined;

    // 鉴权:每请求让 provider 构造最新 headers(内部负责取 token / 懒刷新)。
    let providerHeaders: Record<string, string>;
    try {
      providerHeaders = await provider.buildHeaders({ sessionId });
    } catch (err) {
      if (isOwnerBoundaryPendingError(err)) {
        writeOwnerBoundaryPending(res, err);
        return;
      }
      log.error?.('buildHeaders failed', { reqId, prefix: provider.prefix, err: err instanceof Error ? err.message : String(err) });
      writeJson(res, 502, {
        type: 'error',
        error: { type: 'authentication_error', message: `bridge auth unavailable for ${provider.prefix} (订阅登录可能已失效,请重新登录)` },
      });
      return;
    }

    // reasoning 档:host 经 prefs 闭包传入用户选定 effort(CC 不会把非 Anthropic 模型的 effort
    // 放进请求体,由 host 从会话态解析);模型不支持 reasoning → 'none'。
    const reasoningSupported = provider.supportsReasoning ? provider.supportsReasoning(realModel) : true;
    const prefEffort = normalizeReasoningEffort(prefs?.reasoningEffort, provider.supportedReasoningEfforts?.(realModel));
    const reasoningEffort = !reasoningSupported ? 'none' : prefEffort;

    // Fast 模式:prefs.fast × provider.fastServiceTier(codex='priority')。
    const fastModel = prefs?.fast === true ? provider.fastModel?.(realModel) : undefined;
    const serviceTier = !fastModel && prefs?.fast === true ? provider.fastServiceTier : undefined;
    // Cindy's existing usage variant uses priority for Fast pricing, independently of wire service_tier.
    const priceTier = fastModel ? 'priority' : serviceTier ?? 'default';

    // 上游服务端工具(如 xAI x_search):只由 provider 按 model 静态声明,不受会话态影响,
    // 保证同一会话逐轮请求带同一份工具列表(前缀稳定)。
    const serverSideTools = provider.serverSideTools?.(realModel);

    // Anthropic Messages 语义:**只有显式 `stream:true` 才是 SSE**,字段缺失等同非流式。
    // Claude Code 的非流式 fallback 走 SDK 的 `messages.create()`,它**不带 stream 字段**
    // (2026-08-10 用随包 cc 二进制实测),按 `stream !== false` 判会把 fallback 误当流式、
    // 回一个 SSE,CLI 随即报 "empty or malformed response (HTTP 200)"。
    const downstreamStreaming = parsed.stream === true;
    const wireDiagnosticsEnabled = opts.wireDiagnostics === true
      && provider.prefix === 'xai/'
      && realModel === 'grok-4.6';
    const responsesReq = translateRequest(parsed, {
      model: fastModel ?? realModel,
      promptCacheKey: sessionId,
      maxOutputTokensSupported: provider.maxOutputTokensSupported,
      reasoningEffort,
      serviceTier,
      providerPrefix: provider.reasoningNamespace ?? provider.prefix,
      preserveReasoningState: provider.preserveReasoningState,
      serverSideTools,
      // 生产控制面 = provider 配置(按 model 恒定,前缀稳定);dev-only strict spike
      // 仅作诊断证据路径叠加,默认关闭,不得当生产开关用。
      strictFunctionTools: provider.strictFunctionTools?.(realModel) === true
        || (wireDiagnosticsEnabled && opts.wireDiagnosticsStrict === true),
    });
    let finalRequest: unknown;
    try {
      finalRequest = normalizeProviderRequest(responsesReq, { harness: 'claude-code', protocol: 'openai-responses', upstreamBase: provider.upstreamBase, model: responsesReq.model });
    } catch {
      writeJson(res, 400, { type: 'error', error: { type: 'invalid_request_error', message: 'request cannot be represented by the selected provider protocol' } });
      return;
    }
    const diagnostics = wireDiagnosticsEnabled
      ? new WireDiagnosticsSession(log, {
        requestId: ctx.reqId ?? reqId,
        bridgeReqId: reqId,
        wireModel,
        realModel,
        providerPrefix: provider.reasoningNamespace ?? provider.prefix,
        downstreamStreaming,
      })
      : null;
    diagnostics?.recordRequest(parsed, responsesReq);

    const abort = new AbortController();
    res.on('close', () => abort.abort());

    let upstream: Response;
    try {
      upstream = await fetchImpl(`${provider.upstreamBase}/responses`, {
        method: 'POST',
        headers: {
          ...providerHeaders,
          'content-type': 'application/json',
          // 恒 SSE:上游只接受流式(见 translateRequest 的 stream 注释),非流式调用方
          // 由下游缓冲满足。
          accept: 'text/event-stream',
        },
        body: JSON.stringify(finalRequest),
        signal: abort.signal,
      });
    } catch (err) {
      if (abort.signal.aborted) {
        diagnostics?.finish({ reason: 'client-aborted-before-upstream-response' });
        return;
      }
      diagnostics?.finish({ reason: 'upstream-fetch-error' });
      log.error?.('upstream fetch failed', { reqId, err: err instanceof Error ? err.message : String(err) });
      writeJson(res, 502, { type: 'error', error: { type: 'api_error', message: `upstream unreachable: ${String(err)}` } });
      return;
    }

    if (!upstream.ok || !upstream.body) {
      const text = upstream.body ? await upstream.text().catch(() => '') : '';
      const status = upstream.ok ? 502 : upstream.status;
      diagnostics?.finish({ status, reason: upstream.ok ? 'upstream-2xx-without-body' : 'upstream-http-error' });
      log.warn?.(upstream.ok ? 'upstream 2xx without response body' : 'upstream non-2xx', {
        reqId,
        status: upstream.status,
        body: text.slice(0, 2000),
      });
      if (!upstream.ok && provider.onUpstreamError) {
        try {
          await provider.onUpstreamError({
            status: upstream.status,
            body: text,
            requestHeaders: providerHeaders,
          });
        } catch (err) {
          // Provider 状态收口失败不能吞掉或改写真实上游错误;调用方仍需看到原始状态码/正文。
          log.warn?.('onUpstreamError failed', {
            reqId,
            prefix: provider.prefix,
            err: err instanceof Error ? err.message : String(err),
          });
        }
      }
      writeJson(res, status, {
        type: 'error',
        error: {
          type: anthropicErrorType(status),
          message: text.slice(0, 2000) || (
            upstream.ok
              ? 'provider returned a successful response without a body'
              : `upstream ${upstream.status}`
          ),
        },
      });
      return;
    }

    // 上游限流头(api.x.ai 返 x-ratelimit-*;codex 后端不返)→ 尽力回调给 host 做额度展示。
    if (provider.onRateLimit) {
      const rateLimit = parseRateLimitHeaders(upstream.headers);
      if (rateLimit) {
        try {
          provider.onRateLimit(rateLimit, providerHeaders);
        } catch {
          /* 回调异常不影响流转发 */
        }
      }
    }

    const upstreamContentType = upstream.headers.get('content-type') ?? '';
    const upstreamIsSse = upstreamContentType.toLowerCase().includes('event-stream');

    // 非流式调用方(Claude Code 流式失败后的 fallback,请求体不带 stream 字段)要求一个
    // 完整的 Anthropic Message JSON。上游恒回 SSE(只接受流式),所以这里缓冲整流后组装;
    // 同时兼容个别上游直接给 Responses JSON 的情况。
    if (!downstreamStreaming) {
      const translator = new SseTranslator(wireModel, priceTier, provider.reasoningNamespace);
      const collector = new AnthropicMessageCollector();
      const collect = (event: AnthropicSseEvent): void => {
        diagnostics?.recordDownstreamEvent(event);
        collector.push(event);
      };
      try {
        const body = await readBodyWithLimit(upstream, MAX_NON_STREAM_BODY_BYTES);
        if (!body.trim()) throw new Error('provider returned an empty response body');
        if (upstreamIsSse || (!upstreamContentType && looksLikeSse(body))) {
          for (const event of parseSsePayloads(body)) {
            diagnostics?.recordUpstreamEvent(event);
            for (const output of translator.push(event)) collect(output);
          }
          for (const output of translator.finish()) collect(output);
        } else {
          const responseJson = JSON.parse(body) as unknown;
          for (const output of translator.pushJson(responseJson)) collect(output);
        }
      } catch (err) {
        // 客户端已断开(res close → abort):上游读取抛错只是取消的副作用,不写响应。
        if (abort.signal.aborted) {
          diagnostics?.finish({ status: upstream.status, reason: 'client-aborted-while-buffering' });
          return;
        }
        const message = err instanceof Error ? err.message : String(err);
        diagnostics?.finish({ status: upstream.status, reason: 'invalid-upstream-non-stream-response' });
        log.warn?.('upstream non-stream response invalid', { reqId, error: message });
        writeJson(res, 502, {
          type: 'error',
          error: { type: 'api_error', message: `invalid upstream response: ${message}` },
        });
        return;
      }

      const result = collector.finish();
      diagnostics?.finish({ status: 200, reason: result.ok ? 'completed-non-stream' : 'collector-error' });
      if (!result.ok) {
        writeJson(res, 502, { type: 'error', error: result.error });
        return;
      }
      writeJson(res, 200, result.message);
      return;
    }

    // 上游 2xx 但 content-type 不是 SSE(反代/网关吐 JSON 或 HTML):大概率整流翻不出
    // 任何事件,先留一条 warn ——零事件收尾时的合成 error 会带上正文前缀(#941)。
    // 判定大小写不敏感(HTTP header 值的 media type 不区分大小写);真实状态码进日志,
    // 本路径接受任意 2xx,不硬编码 200(review 反馈)。
    if (!upstreamIsSse) {
      log.warn?.('upstream 2xx with non-SSE content-type', {
        reqId,
        status: upstream.status,
        contentType: upstreamContentType || '(missing)',
      });
    }

    // 开始流式回写。
    res.writeHead(200, {
      'content-type': 'text/event-stream; charset=utf-8',
      'cache-control': 'no-cache',
      connection: 'keep-alive',
    });

    // 用 wireModel(带前缀,如 chatgpt/gpt-5.5)而非 realModel 构造 —— message_start 回显带前缀 id,
    // CC 的 modelUsage 据此记账,下游 usage 可按前缀区分订阅轮,不与真网关同名裸模型混淆。
    const translator = new SseTranslator(wireModel, priceTier, provider.reasoningNamespace);
    const reader = upstream.body.getReader();
    const decoder = new TextDecoder();
    let buf = '';
    // 零事件诊断:整流一条 Anthropic 事件都没写回时,CLI 只能报
    // "empty or malformed response (HTTP 200)" 并盲目重试,真实错误被完全掩盖(#941)。
    // 记录写回事件数与上游正文前缀,收尾时合成一条带上游信息的 error 事件 + warn 日志。
    let eventsWritten = 0;
    let rawPrefix = '';
    const RAW_PREFIX_LIMIT = 500;
    const writeOut = (ev: AnthropicSseEvent): void => {
      eventsWritten += 1;
      diagnostics?.recordDownstreamEvent(ev);
      writeSseEvent(res, ev);
    };
    const finalizeStream = (): void => {
      if (eventsWritten === 0) {
        const bodyPrefix = rawPrefix.trim().slice(0, 300);
        log.warn?.('upstream stream yielded no translatable events', {
          reqId,
          contentType: upstreamContentType || '(missing)',
          bodyPrefix,
        });
        writeOut({
          event: 'error',
          data: {
            type: 'error',
            error: {
              type: 'api_error',
              message:
                `upstream returned HTTP ${upstream.status} but produced no translatable SSE events ` +
                `(content-type: ${upstreamContentType || 'missing'}${bodyPrefix ? `; body: ${bodyPrefix}` : ''})`,
            },
          },
        });
        return;
      }
      // 至少有一个事件但没有 response.completed / response.incomplete:finish() 产出
      // stream_truncated error,绝不把 clean EOF 伪装成正常 message_stop。
      for (const outEv of translator.finish()) writeOut(outEv);
    };
    try {
      for (;;) {
        const { done, value } = await reader.read();
        if (done) break;
        const chunkText = decoder.decode(value, { stream: true });
        if (rawPrefix.length < RAW_PREFIX_LIMIT) {
          rawPrefix = (rawPrefix + chunkText).slice(0, RAW_PREFIX_LIMIT);
        }
        buf += chunkText;
        // SSE 事件以空行分隔;逐行取 `data:` 负载。用游标扫描、chunk 末尾一次性 slice ——
        // 避免每行 slice 整个剩余缓冲(大 chunk 数百行时是 O(n²) 拷贝,这是每 token 热路径)。
        let start = 0;
        let nl: number;
        while ((nl = buf.indexOf('\n', start)) >= 0) {
          const line = buf.slice(start, nl).replace(/\r$/, '');
          start = nl + 1;
          if (!line.startsWith('data:')) continue;
          const payload = line.slice(5).trim();
          if (!payload || payload === '[DONE]') continue;
          let ev: unknown;
          try {
            ev = JSON.parse(payload);
          } catch {
            continue;
          }
          diagnostics?.recordUpstreamEvent(ev);
          for (const outEv of translator.push(ev)) writeOut(outEv);
        }
        if (start > 0) buf = buf.slice(start);
      }
      // 上游干净结束:零事件时合成带上游信息的 error 事件;有事件但没走
      // response.completed 时按截断报错。两条路径都绝不以空 200 / 伪装完成收尾。
      finalizeStream();
    } catch (err) {
      if (!abort.signal.aborted) {
        const errMsg = err instanceof Error ? err.message : String(err);
        log.warn?.('upstream stream error', { reqId, err: errMsg });
        // 断流不走 finalizeStream:已写出部分事件后再补 message_stop,Claude Code 会
        // 把截断响应当正常完成、上游读取错误被掩盖(review 反馈 P1)。fail() 关块后
        // 发 error 事件收尾(错误帧已收尾时返回空,不重复报错);流失败于任何事件
        // 之前时 error 事件同样成立,零事件合成诊断只服务「干净结束却零事件」路径。
        for (const outEv of translator.fail(`upstream stream error: ${errMsg}`)) writeOut(outEv);
      }
    } finally {
      diagnostics?.finish({ status: upstream.status, reason: 'stream-finished' });
      res.end();
    }
  }

  log.debug?.('anthropic-responses-bridge handler ready', { providers: providers.map((p) => p.prefix) });
  return { handle };
}