@lqc123qwe/car-runtime 1.3.0 → 1.5.0

package/src/mcp/stdioClient.ts

@@ -0,0 +1,75 @@
+/**
+ * 1.4-S7 · MCP stdio 客户端传输（W1 MCP 工具进 turn）：spawn 子进程 + JSON-RPC 换行分隔 JSON
+ *
+ * 口径（1.4 规划 W1 MCP 块 / D-18）：
+ *  - CAR → 外部 MCP Server 方向（gateway.ts ClientTransport 的真实通道实装——此前仅测试替身）；
+ *    server 侧对偶（宿主 → CAR）见 src/host/stdio.ts；
+ *  - 行协议：请求一行 JSON 写入 server stdin；响应按 id 匹配 pending 表（行解析容错跳过非 JSON 行）；
+ *  - send 内建 30s 超时（fail-visible——gateway.register 的 tools/list 无外层 race，防挂死）；
+ *  - stderr 不透传（server 诊断输出与协议通道隔离）；close = kill（car run 收口调用）。
+ */
+import { spawn, type ChildProcess } from 'node:child_process'
+import type { ClientTransport, JsonRpcResponse } from './gateway.ts'
+
+export interface StdioServerSpec {
+  command: string
+  args?: string[]
+}
+
+export function createStdioClientTransport(spec: StdioServerSpec): ClientTransport & { readonly alive: () => boolean } {
+  const child: ChildProcess = spawn(spec.command, spec.args ?? [], { stdio: ['pipe', 'pipe', 'pipe'] })
+  const pending = new Map<number, (res: JsonRpcResponse) => void>()
+  let buffer = ''
+  let exited = false
+  child.on('exit', () => { exited = true })
+  child.stdout!.on('data', chunk => {
+    buffer += chunk.toString('utf-8')
+    let nl: number
+    while ((nl = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, nl).trim()
+      buffer = buffer.slice(nl + 1)
+      if (!line) continue
+      try {
+        const res = JSON.parse(line) as JsonRpcResponse
+        const settle = pending.get(res.id as number)
+        if (settle) {
+          pending.delete(res.id as number)
+          settle(res)
+        }
+      } catch { /* 非 JSON 行容错跳过（server 诊断污染 stdin 协议通道时不断链） */ }
+    }
+  })
+  child.stderr!.on('data', () => { /* 隔离（见头注释） */ })
+  child.on('error', () => { exited = true })
+
+  const transport: ClientTransport & { readonly alive: () => boolean } = {
+    send(req) {
+      return new Promise((resolve, reject) => {
+        if (!transport.alive()) {
+          reject(new Error('CAR-E-MCP: stdio transport not alive（server 进程已退出）'))
+          return
+        }
+        const timer = setTimeout(() => {
+          pending.delete(req.id as number)
+          reject(new Error('CAR-E-MCP: stdio send timeout (30s)'))
+        }, 30_000)
+        pending.set(req.id as number, res => {
+          clearTimeout(timer)
+          resolve(res)
+        })
+        try {
+          child.stdin!.write(JSON.stringify(req) + '\n')
+        } catch (e) {
+          clearTimeout(timer)
+          pending.delete(req.id as number)
+          reject(e)
+        }
+      })
+    },
+    alive: () => !exited && child.exitCode === null && !child.killed,
+    close: () => {
+      try { child.kill() } catch { /* 已退出 */ }
+    },
+  }
+  return transport
+}

package/src/ptc/runCode.ts

@@ -116,6 +116,16 @@ export function makePtcToolDefinition(opts: { tools: Map<string, ToolBridge>; au
   return {
     name: 'run_code',
     description: '执行一段 erasable TypeScript 程序（PTC）——程序体内经 tools.<name>(args) 调用已注册工具',
+    // 1.4-S7：run_code 入参 schema（进模型声明面——此前无 parameters，模型看不到 code/description 形状）
+    parameters: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'erasable TS 程序体（async 函数体；经 tools.<name>(args) 调用已注册工具）' },
+        description: { type: 'string', description: '本段程序的一句话描述（审计留痕）' },
+      },
+      required: ['code', 'description'],
+      additionalProperties: false,
+    },
     // T-22 语义：PTC 与 bash 同信任级别 → 强制 write 最高约束（不可声明为 readonly）
     declaredSideEffect: 'write' as const,
     run: async (args: { code: string; description: string; toolCallId?: string }) => {

package/src/runtime-core/chatStep.ts

@@ -15,7 +15,7 @@
  *     由 runTurn 落 turnEnd）；工具调用事件由 runTurn executeBatch 落（本层不重复）。
  */
 import type { SessionLog } from '../session/log.ts'
-import type { ModelStep, ToolCall } from '../loop/stop.ts'
+import { TurnAborted, type ModelStep, type ToolCall } from '../loop/stop.ts'
 import type { RuntimeCore } from './llm.ts'
 import type { ToolDefinition } from './types.ts'
 import { StreamRedactor } from './redaction.ts'
@@ -32,6 +32,8 @@ export interface ChatStepOptions {
   tools: ToolDefinition[]
   maxTokens?: number
   adapterId?: string
+  /** 1.4-S4（D-19）：turn 取消信号——chunk 间隙与流结束后（finish 检查前）检查，命中抛 TurnAborted */
+  signal?: { aborted: boolean }
 }
 
 /** ModelStep 加法扩展：脱敏计数留痕（S15 secretsRedacted 同名口径） */
@@ -46,11 +48,17 @@ export async function chatStep(opts: ChatStepOptions): Promise<ChatStepResult> {
     throw new Error(`CAR-E-N1: 模型请求前快照与日志投影失配 @ atSeq=${asserted.failedAt}（Model-visible means logged 违规）`)
   }
 
-  // 2. 请求消息 = 投影（角色系统：user/assistant/toolResult 与 LlmRequest 对齐；
-  //    assistant 工具调用以 { toolCall } content 形态原样透传——deriveMessages 投影即模型可见流）
+  // 2. 请求消息 = 投影（角色系统：user/assistant/toolResult 与 LlmRequest 对齐）；
+  //    toolCall 事件投影形态为 { role:'assistant', toolCall }（log.ts 口径）——此处归一化为
+  //    content {toolCall} 载荷（适配器历史回路映射的唯一消费源）。
+  //    1.5-BUG-1：此前仅透传 m.content，toolCall 属性被丢弃——工具调用历史在后续请求
+  //    静默消失（真实 provider 对无 tool_calls 前驱的 tool 消息直接 400）；anthropic E2E
+  //    生产调用点核查（1.5-GO-5）暴露，openai-compat 同样受益。
   const messages = log.deriveMessages().map(m => ({
-    role: m.role as 'user' | 'assistant' | 'toolResult',
-    content: m.content,
+    role: m.role as 'system' | 'user' | 'assistant' | 'toolResult',
+    content: (m as unknown as { toolCall?: unknown }).toolCall !== undefined
+      ? { toolCall: (m as unknown as { toolCall: unknown }).toolCall }
+      : m.content,
   }))
 
   // 4. 流式消费（3. 凭据解析在适配器首块前，A080001 由此传播）
@@ -66,9 +74,12 @@ export async function chatStep(opts: ChatStepOptions): Promise<ChatStepResult> {
     tools,
     ...(maxTokens != null ? { maxTokens } : {}),
     ...(adapterId ? { adapterId } : {}),
+    ...(opts.signal ? { signal: opts.signal } : {}),
     ...(opts.log.sessionId ? { metadata: { sessionId: opts.log.sessionId, turnId, traceId: `${opts.log.sessionId}:${turnId}` } } : {}),
   })
   for await (const chunk of stream) {
+    // 1.4-S4（D-19）：chunk 间隙取消——此刻 assistant 尚未落链（流完才 append），无半截消息
+    if (opts.signal?.aborted) throw new TurnAborted()
     if (chunk.delta !== undefined) text += redactor.push(chunk.delta)
     if (chunk.toolCallDelta) {
       const idx = chunk.toolCallDelta.index ?? 0
@@ -81,6 +92,9 @@ export async function chatStep(opts: ChatStepOptions): Promise<ChatStepResult> {
     if (chunk.error) errorDetail = chunk.error.message
     if (chunk.finishReason !== undefined) stopReason = chunk.finishReason === 'aborted' ? 'error' : chunk.finishReason
   }
+  // 1.4-S4（D-19）：finish 检查前先查取消（适配器取消路径静默收口无 finishReason——
+  // 必须先于此处的契约兜底，否则取消被误判为适配器违规）
+  if (opts.signal?.aborted) throw new TurnAborted()
   if (stopReason === undefined) {
     // 适配器层已保证首 finishReason（AL-05）；防御性兜底显式化
     throw new Error('CAR-E-LLM-FINISH: 流结束无 finishReason（适配器契约违规）')

package/src/runtime-core/credentials.ts

@@ -37,6 +37,11 @@ const PROVIDER_ENV_VARS: Record<string, string[]> = {
 }
 const GENERIC_ENV_VARS = ['CAR_LLM_API_KEY']
 
+/** provider 候选 env 变量（doctor 存在性探测等诊断面复用；值永不打印） */
+export function providerEnvVars(provider: string): string[] {
+  return [...(PROVIDER_ENV_VARS[provider] ?? []), ...GENERIC_ENV_VARS]
+}
+
 /** keychain 服务名（命名空间隔离：car-runtime/<provider>） */
 export function keychainService(provider: string): string {
   return `car-runtime/${provider}`
@@ -102,7 +107,7 @@ export class CredentialService {
 
     const allowEnv = opts.allowEnvFallback === true || env.CAR_ALLOW_ENV_CREDENTIALS === '1'
     if (allowEnv) {
-      const candidates = [...(PROVIDER_ENV_VARS[provider] ?? []), ...GENERIC_ENV_VARS]
+      const candidates = providerEnvVars(provider)
       for (const name of candidates) {
         searched.push(`env:${name}`)
         if (env[name]) {

package/src/runtime-core/llm.ts

@@ -9,8 +9,12 @@
  *  - 重试基线（§3.5.4）：仅网络错误/429/5xx、≤2 次、指数退避 1s/2s；**首块前失败才可重试**
  *    （已消费的 chunk 不可重放——重试不产生额外副作用）；重试耗尽 = CarM8Error B080001
  *    （BD-04 error 收口由消费方 runTurn 落 turnEnd）；流中途失败 = finishReason 'error' chunk；
- *  - 超时基线：总 120s / 首字节 30s（均可注入缩短供测试）；TLS 强制（https-only）；
- *  - declaredSideEffect 不出站（权限面只进权限门，不进模型请求体）。
+ *  - 超时基线：总 120s / 首字节 30s（均可注入缩短供测试）；TLS 强制（https-only，D-12a
+ *    loopback 豁免共用 assertTlsOrLoopback）；重试/超时/取消引擎单点共用（1.5-S1 streamSsePost
+ *    ——openai-compat / anthropic 语义不漂移，parse 为唯一 provider 差异点）；
+ *  - declaredSideEffect 不出站（权限面只进权限门，不进模型请求体）；
+ *  - 1.5-S1（D-20）：内置 anthropic 适配器（Messages API 流式；max_tokens 必填缺省 4096；
+ *    system 顶层化；凭据 provider='anthropic'）。
  */
 import { CarM8Error, providerUnreachable } from './errors.ts'
 import { CredentialService } from './credentials.ts'
@@ -107,6 +111,101 @@ export class RuntimeCore {
   }
 }
 
+// ==================== 适配器共用基线（1.5-S1 抽取：D-12a TLS 门 + §3.5.4 流式引擎） ====================
+
+/**
+ * D-12a TLS 强制门（openai-compat / anthropic 共用，口径不变）：https 直接通过；
+ * http 仅豁免 loopback——本地模型服务（Ollama 等）与本地 E2E；非回环地址维持 TLS 强制
+ * （§3.2.M8.4）。豁免集显式列举，不扩大到局域网。
+ */
+export function assertTlsOrLoopback(baseUrl: string): void {
+  if (baseUrl.startsWith('https://')) return
+  let loopback = false
+  try { const host = new URL(baseUrl).hostname.replace(/^\[|\]$/g, ''); loopback = host === '127.0.0.1' || host === 'localhost' || host === '::1' } catch { /* 解析失败 = 非法 URL，按非回环拒绝 */ }
+  if (!loopback) {
+    throw new Error(`CAR-E-LLM-TLS: baseUrl 必须 https（TLS 强制，§3.2.M8.4）；http 仅豁免 loopback（127.0.0.1/[::1]/localhost，D-12a）——远程明文部署请经 TLS 代理或自建适配器`)
+  }
+}
+
+/** 流式 POST 请求规格（凭据解析在 buildRequest 内——A080001 首块前抛出，runTurn 可 error 收口） */
+interface SsePostSpec {
+  url: string
+  buildRequest: () => Promise<{ method: 'POST'; headers: Record<string, string>; body: string }>
+  fetchImpl: typeof fetch
+  signal?: { aborted: boolean }
+  timeoutMs: number
+  firstByteMs: number
+  retries: number
+  backoffMs: number[]
+  sleep: (ms: number) => Promise<void>
+}
+
+/**
+ * §3.5.4 流式 POST 引擎（openai-compat / anthropic 单点共用，1.5-S1 抽取——两适配器重试/
+ * 超时/取消语义不漂移）：仅网络错误/429/5xx、≤2 次、指数退避 1s/2s；首块前失败才可重试
+ * （已消费 chunk 不可重放）；重试耗尽 = CarM8Error B080001；外部取消 ≠ 失败（D-19：静默
+ * 收口不 retry 不 error chunk）；流自然结束未携带 finishReason = AL-05 显式 error chunk。
+ * `parse` 为唯一 provider 差异点（SSE 字节流 → LlmChunk）。
+ */
+async function* streamSsePost(spec: SsePostSpec, parse: (body: AsyncIterable<Uint8Array>) => AsyncIterable<LlmChunk>): AsyncIterable<LlmChunk> {
+  const payload = await spec.buildRequest()
+  for (let attempt = 0; ; attempt++) {
+    // D-19：外部取消 ≠ 失败——attempt 前检查，静默收口（无 chunk、无 retry）
+    if (spec.signal?.aborted) return
+    const controller = new AbortController()
+    const started = Date.now()
+    let firstByteSeen = false
+    const firstByteTimer = setTimeout(() => controller.abort(), spec.firstByteMs)
+    const overallTimer = setTimeout(() => controller.abort(), spec.timeoutMs)
+    try {
+      const res = await spec.fetchImpl(spec.url, { ...payload, signal: controller.signal })
+      if (res.status === 429 || res.status >= 500) throw new Retryable(`HTTP ${res.status}`)
+      if (!res.ok) {
+        const text = await res.text().catch(() => '')
+        // 4xx 业务错不重试（§3.5.4）；错误信息不含凭据（凭据值不进错误路径）
+        yield { finishReason: 'error', error: { code: 'B080001', message: `provider HTTP ${res.status}${text ? `：${text.slice(0, 200)}` : ''}` } }
+        return
+      }
+      if (!res.body) throw new Retryable('响应无 body 流')
+      let sawFinish = false
+      for await (const chunk of parse(res.body)) {
+        // D-19：chunk 间隙检查取消——abort 连接并静默收口（不产 error chunk，不违反
+        // finishReason 不可变；上层 chatStep 以自身 signal 检查抛 TurnAborted）
+        if (spec.signal?.aborted) { controller.abort(); return }
+        if (!firstByteSeen) { firstByteSeen = true; clearTimeout(firstByteTimer) }
+        if (chunk.finishReason !== undefined) sawFinish = true
+        yield chunk
+      }
+      // 流自然结束但未给 finishReason = 异常终止（AL-05 口径：缺失显式化，禁吞没）；
+      // 已携带 finishReason 的流原样收口——兜底不得追加（M8-BUG-1 口径延续）
+      if (!sawFinish) {
+        yield { finishReason: 'error', error: { code: 'B080001', message: '流结束未携带 finish_reason（AL-05）' } }
+      }
+      return
+    } catch (e) {
+      // D-19：外部取消（abort 连锁的 fetch 异常）≠ 失败——静默收口，不走 retry
+      if (spec.signal?.aborted) return
+      const beforeFirstByte = !firstByteSeen
+      clearTimeout(firstByteTimer)
+      // 首块前失败 = 网络错误/429/5xx/首字节超时（§3.5.4 重试条件全集）——未消费任何 chunk
+      if (beforeFirstByte && attempt < spec.retries) {
+        await spec.sleep(spec.backoffMs[Math.min(attempt, spec.backoffMs.length - 1)]!)
+        continue
+      }
+      if (beforeFirstByte) {
+        // 重试耗尽 → B080001（BD-04：消费方 runTurn 以 error 收口）
+        throw providerUnreachable(`${(e as Error).name}: ${(e as Error).message}（尝试 ${attempt + 1}/${spec.retries + 1}，${Date.now() - started}ms）`)
+      }
+      // 流中途失败：已消费 chunk 不可重放 → error chunk 收口
+      yield { finishReason: 'error', error: { code: 'B080001', message: `流中途失败：${(e as Error).message}` } }
+      return
+    } finally {
+      clearTimeout(firstByteTimer)
+      clearTimeout(overallTimer)
+    }
+  }
+}
+
 // ==================== 内置 openai-compat 适配器（流式 SSE） ====================
 
 export interface OpenAICompatOptions {
@@ -198,9 +297,8 @@ async function* parseSseStream(body: AsyncIterable<Uint8Array>): AsyncIterable<L
 export function createOpenAICompatAdapter(opts: OpenAICompatOptions): LlmAdapter & { id: string } {
   const id = opts.id ?? 'openai-compat'
   const baseUrl = opts.baseUrl.replace(/\/+$/, '')
-  if (!baseUrl.startsWith('https://')) {
-    throw new Error(`CAR-E-LLM-TLS: baseUrl 必须 https（TLS 强制，§3.2.M8.4；本地明文部署请经 TLS 代理或自建适配器）`)
-  }
+  // 1.4-S4（D-12a，1.2 规划期裁决）：TLS 门 1.5-S1 抽取共用（口径与报错文案不变）
+  assertTlsOrLoopback(baseUrl)
   const url = `${baseUrl}/chat/completions`
   const fetchImpl = opts.fetchImpl ?? fetch
   const sleep = opts.sleep ?? (ms => new Promise<void>(r => setTimeout(r, ms)))
@@ -210,6 +308,9 @@ export function createOpenAICompatAdapter(opts: OpenAICompatOptions): LlmAdapter
   const backoffMs = opts.backoffMs ?? [1_000, 2_000]
 
   const toOpenAI = (req: LlmRequest, apiKey: string) => ({
+    // 1.4-BUG-1：method: 'POST' 缺失——M8 最小实现潜伏缺陷（注入式 fetch 的单测忽略 method，
+    // 真 undici 对 GET+body 直接拒绝）；car run 真路径接线时暴露（生产调用点核查产出）
+    method: 'POST' as const,
     headers: {
       'content-type': 'application/json',
       authorization: `Bearer ${apiKey}`,
@@ -240,65 +341,194 @@ export function createOpenAICompatAdapter(opts: OpenAICompatOptions): LlmAdapter
 
   return {
     id,
-    async *chat(req: LlmRequest): AsyncIterable<LlmChunk> {
-      // 凭据门：resolve → reveal（SQ-07 凭据解析；A080001 在此抛出——首块前，runTurn 可 error 收口）
-      let apiKey = ''
-      if (opts.credentials) {
-        const ref = opts.credentials.resolve(opts.provider ?? id, {})
-        apiKey = opts.credentials.reveal(ref, {})
-      }
-      const payload = toOpenAI(req, apiKey)
-
-      for (let attempt = 0; ; attempt++) {
-        const controller = new AbortController()
-        const started = Date.now()
-        let firstByteSeen = false
-        const firstByteTimer = setTimeout(() => controller.abort(), firstByteMs)
-        const overallTimer = setTimeout(() => controller.abort(), timeoutMs)
-        try {
-          const res = await fetchImpl(url, { ...payload, signal: controller.signal })
-          if (res.status === 429 || res.status >= 500) throw new Retryable(`HTTP ${res.status}`)
-          if (!res.ok) {
-            const text = await res.text().catch(() => '')
-            // 4xx 业务错不重试（§3.5.4）；错误信息不含凭据（Bearer 值不进错误路径）
-            yield { finishReason: 'error', error: { code: 'B080001', message: `provider HTTP ${res.status}${text ? `：${text.slice(0, 200)}` : ''}` } }
-            return
-          }
-          if (!res.body) throw new Retryable('响应无 body 流')
-          let sawFinish = false
-          for await (const chunk of parseSseStream(res.body)) {
-            if (!firstByteSeen) { firstByteSeen = true; clearTimeout(firstByteTimer) }
-            if (chunk.finishReason !== undefined) sawFinish = true
-            yield chunk
-          }
-          // 流自然结束但未给 finishReason = 异常终止（AL-05 口径：缺失显式化，禁吞没）；
-          // 已携带 finishReason 的流原样收口——兜底不得追加（M8-BUG-1：无条件 error chunk
-          // 会污染成功流并触发 finishReason 守卫冲突；成功流零 error chunk 由 s25 断言钉死）
-          if (!sawFinish) {
-            yield { finishReason: 'error', error: { code: 'B080001', message: '流结束未携带 finish_reason（AL-05）' } }
-          }
-          return
-        } catch (e) {
-          const beforeFirstByte = !firstByteSeen
-          clearTimeout(firstByteTimer)
-          // 首块前失败 = 网络错误/429/5xx/首字节超时（§3.5.4 重试条件全集）——未消费任何
-          // chunk，请求体可重放，重试不产生额外副作用；流中途失败不可重放（chunk 已消费）
-          if (beforeFirstByte && attempt < retries) {
-            await sleep(backoffMs[Math.min(attempt, backoffMs.length - 1)]!)
-            continue
+    chat(req: LlmRequest): AsyncIterable<LlmChunk> {
+      return streamSsePost({
+        url,
+        // 凭据门：resolve → reveal（SQ-07 凭据解析；A080001 在此抛出——首块前，runTurn 可 error 收口）
+        buildRequest: async () => {
+          let apiKey = ''
+          if (opts.credentials) {
+            const ref = opts.credentials.resolve(opts.provider ?? id, {})
+            apiKey = opts.credentials.reveal(ref, {})
           }
-          if (beforeFirstByte) {
-            // 重试耗尽 → B080001（BD-04：消费方 runTurn 以 error 收口）
-            throw providerUnreachable(`${(e as Error).name}: ${(e as Error).message}（尝试 ${attempt + 1}/${retries + 1}，${Date.now() - started}ms）`)
-          }
-          // 流中途失败：已消费 chunk 不可重放 → error chunk 收口
-          yield { finishReason: 'error', error: { code: 'B080001', message: `流中途失败：${(e as Error).message}` } }
-          return
-        } finally {
-          clearTimeout(firstByteTimer)
-          clearTimeout(overallTimer)
+          return toOpenAI(req, apiKey)
+        },
+        fetchImpl,
+        signal: req.signal,
+        timeoutMs, firstByteMs, retries, backoffMs, sleep,
+      }, parseSseStream)
+    },
+  }
+}
+
+// ==================== 内置 anthropic 适配器（Messages API 流式 SSE，1.5-S1 / D-20） ====================
+
+export interface AnthropicAdapterOptions {
+  id?: string
+  /** API 源（如 https://api.anthropic.com；请求路径 = {baseUrl}/v1/messages，与官方 SDK base_url 同约定） */
+  baseUrl: string
+  /** 凭据服务与 provider 名（x-api-key 来源；provider 缺省 'anthropic' → ANTHROPIC_API_KEY） */
+  credentials?: CredentialService
+  provider?: string
+  fetchImpl?: typeof fetch
+  /** §3.5.4 基线：总 120s / 首字节 30s / 2 次退避 1s-2s（与 openai-compat 同款） */
+  timeoutMs?: number
+  firstByteMs?: number
+  retries?: number
+  backoffMs?: number[]
+  sleep?: (ms: number) => Promise<void>
+  /** D-20：Anthropic API max_tokens 必填——req.maxTokens 缺席时取此缺省（provider 差异登记，缺省 4096） */
+  defaultMaxTokens?: number
+}
+
+/** stop_reason → CAR finishReason（未映射 fail-visible——openai FINISH_MAP 同纪律） */
+const ANTHROPIC_STOP_REASON_MAP: Record<string, LlmChunk['finishReason']> = {
+  end_turn: 'stop',
+  stop_sequence: 'stop',
+  max_tokens: 'length',
+  tool_use: 'toolUse',
+  refusal: 'aborted',
+}
+
+/**
+ * Anthropic Messages API 请求体（D-20）：system 消息提升为顶层 `system`（多条 \n\n 连接）；
+ * toolResult 收敛进 user 消息 content（连续多条合并为单 user 多 tool_result 块——Anthropic
+ * 消息序列约束）；assistant 工具调用 = content:[{type:'tool_use',id,name,input}]；
+ * declaredSideEffect 不出站（与 openai-compat 同红线）。
+ */
+function toAnthropic(req: LlmRequest, apiKey: string) {
+  const system: string[] = []
+  const turns: Array<{ role: 'user' | 'assistant'; content: unknown }> = []
+  let pendingToolResults: Array<Record<string, unknown>> = []
+  const flushToolResults = () => {
+    if (!pendingToolResults.length) return
+    turns.push({ role: 'user', content: pendingToolResults })
+    pendingToolResults = []
+  }
+  for (const m of req.messages) {
+    if (m.role === 'system') {
+      system.push(typeof m.content === 'string' ? m.content : JSON.stringify(m.content))
+      continue
+    }
+    if (m.role === 'toolResult') {
+      const p = m.content as { id?: string; result?: unknown; error?: string }
+      pendingToolResults.push({
+        type: 'tool_result',
+        tool_use_id: p?.id ?? '',
+        content: p?.error ?? JSON.stringify(p?.result ?? null),
+        ...(p?.error ? { is_error: true } : {}),
+      })
+      continue
+    }
+    flushToolResults()
+    if (m.role === 'assistant' && m.content != null && typeof m.content === 'object' && 'toolCall' in (m.content as object)) {
+      const tc = (m.content as { toolCall: { id: string; tool: string; args: unknown } }).toolCall
+      turns.push({ role: 'assistant', content: [{ type: 'tool_use', id: tc.id, name: tc.tool, input: tc.args ?? {} }] })
+    } else {
+      turns.push({ role: m.role, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) })
+    }
+  }
+  flushToolResults()
+  return {
+    method: 'POST' as const,
+    headers: {
+      'content-type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      model: req.model,
+      stream: true,
+      max_tokens: req.maxTokens ?? 4096,
+      ...(system.length ? { system: system.join('\n\n') } : {}),
+      messages: turns,
+      ...(req.tools.length
+        ? { tools: req.tools.map(t => ({ name: t.name, description: t.description, input_schema: t.parameters })) }
+        : {}),
+    }),
+  }
+}
+
+/**
+ * Anthropic SSE → LlmChunk 流解析（data-only：data JSON 自带 `type` 字段，`event:` 行不依赖）。
+ * content_block_start(tool_use) → toolCallDelta{id,name}；input_json_delta → toolCallDelta{argumentsDelta}；
+ * message_delta.stop_reason → finishReason（终态信号，单次）；ping/message_stop/未知事件容错跳过。
+ */
+async function* parseAnthropicSseStream(body: AsyncIterable<Uint8Array>): AsyncIterable<LlmChunk> {
+  const decoder = new TextDecoder()
+  let buf = ''
+  for await (const bytes of body) {
+    buf += decoder.decode(bytes, { stream: true })
+    let nl: number
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).replace(/\r$/, '')
+      buf = buf.slice(nl + 1)
+      if (!line.startsWith('data:')) continue
+      const data = line.slice(5).trim()
+      if (!data) continue
+      let evt: any
+      try { evt = JSON.parse(data) } catch { continue } // 心跳/注释行容错跳过
+      const type = evt?.type
+      if (type === 'content_block_start') {
+        const block = evt.content_block
+        if (block?.type === 'tool_use') {
+          yield { toolCallDelta: { index: evt.index, id: block.id, name: block.name } }
         }
+      } else if (type === 'content_block_delta') {
+        const d = evt.delta
+        if (d?.type === 'text_delta' && typeof d.text === 'string' && d.text.length) {
+          yield { delta: d.text }
+        } else if (d?.type === 'input_json_delta' && typeof d.partial_json === 'string' && d.partial_json.length) {
+          yield { toolCallDelta: { index: evt.index, argumentsDelta: d.partial_json } }
+        }
+        // thinking_delta / citations_delta 等非 CAR 消费面：容错跳过
+      } else if (type === 'message_delta') {
+        const raw = evt.delta?.stop_reason
+        if (raw != null) {
+          const finish = ANTHROPIC_STOP_REASON_MAP[String(raw)]
+          yield finish
+            ? { finishReason: finish }
+            : { finishReason: 'error', error: { code: 'B080001', message: `未映射的 stop_reason "${raw}"` } }
+        }
+      } else if (type === 'error') {
+        // 流内 error 事件（overloaded_error 等）→ error chunk 收口（后续 message_delta 由守卫拦冲突）
+        yield { finishReason: 'error', error: { code: 'B080001', message: `provider 流错误：${evt.error?.message ?? JSON.stringify(evt).slice(0, 200)}` } }
       }
+    }
+  }
+}
+
+export function createAnthropicAdapter(opts: AnthropicAdapterOptions): LlmAdapter & { id: string } {
+  const id = opts.id ?? 'anthropic'
+  const baseUrl = opts.baseUrl.replace(/\/+$/, '')
+  assertTlsOrLoopback(baseUrl)
+  const url = `${baseUrl}/v1/messages`
+  const fetchImpl = opts.fetchImpl ?? fetch
+  const sleep = opts.sleep ?? (ms => new Promise<void>(r => setTimeout(r, ms)))
+  const timeoutMs = opts.timeoutMs ?? 120_000
+  const firstByteMs = opts.firstByteMs ?? 30_000
+  const retries = opts.retries ?? 2
+  const backoffMs = opts.backoffMs ?? [1_000, 2_000]
+
+  return {
+    id,
+    chat(req: LlmRequest): AsyncIterable<LlmChunk> {
+      return streamSsePost({
+        url,
+        // 凭据门：resolve → reveal（provider='anthropic' → keychain car-runtime/anthropic →
+        // env ANTHROPIC_API_KEY——credentials.ts 1.4 既有登记；A080001 首块前抛出）
+        buildRequest: async () => {
+          let apiKey = ''
+          if (opts.credentials) {
+            const ref = opts.credentials.resolve(opts.provider ?? id, {})
+            apiKey = opts.credentials.reveal(ref, {})
+          }
+          return toAnthropic(req, apiKey)
+        },
+        fetchImpl,
+        signal: req.signal,
+        timeoutMs, firstByteMs, retries, backoffMs, sleep,
+      }, parseAnthropicSseStream)
     },
   }
 }