@x-otto/provider 0.1.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,2129 @@
+/// <reference types="node" />
+import { URL, URLSearchParams as URLSearchParams$1 } from "node:url";
+import { Duplex, Readable, Writable } from "node:stream";
+import { EventEmitter } from "node:events";
+import { Blob, File } from "node:buffer";
+import { ConnectionOptions, TLSSocket } from "node:tls";
+import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from "node:net";
+
+//#region ../interchange/dist/index.d.ts
+//#region src/message.d.ts
+/** Message: AgentMessage/UserMessage/SystemMessage interchange types. */
+type Timestamp = number;
+type KnownApi = 'openai-completions' | 'openai-responses' | 'azure-openai-responses' | 'openai-codex-responses' | 'anthropic-messages' | 'bedrock-converse-stream' | 'google-generative-ai' | 'google-gemini-cli' | 'google-vertex';
+type Api = KnownApi | (string & {});
+type KnownProvider = 'anthropic' | 'openai' | 'google' | 'amazon-bedrock' | 'github-copilot' | 'xai' | 'groq' | 'openrouter' | 'deepseek' | 'ollama' | 'moonshot' | 'custom';
+type Provider = KnownProvider | (string & {});
+type StopReason = 'end_turn' | 'max_tokens' | 'tool_use' | 'stop_sequence' | 'refusal';
+interface Usage {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+}
+/**
+ * 结构化的 zod 兼容垫片——协议层不直接依赖 zod，靠结构类型让 provider/工具定义喂入真 zod schema。
+ */
+interface ZodType<T = unknown> {
+  parse(data: unknown): T;
+  safeParse(data: unknown): {
+    success: boolean;
+    data?: T;
+    error?: unknown;
+  };
+  toJSONSchema?: () => unknown;
+}
+interface TextContent {
+  type: 'text';
+  text: string;
+  signature?: string;
+}
+interface ImageContent {
+  type: 'image';
+  mime: string;
+  source: string;
+}
+interface ThinkingContent {
+  type: 'thinking';
+  text: string;
+  signature?: string;
+}
+interface ToolCall {
+  type: 'tool_call';
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+  /**
+   * 流式参数 JSON 解析失败标记（RFC-142 D4）——`stopReason: max_tokens` 截断半截
+   * JSON 时 `parseToolArguments` 置位，runtime 责任链据此把该调用转为明确错误
+   * tool_result 而非带空参数进入 zod 校验（与污染类错误分离错误通道）。
+   *
+   * **进程内标记，不进 wire**：各 provider 序列化发给模型时均为显式字段拾取
+   * （`{type, id, name, input: arguments}`，无 spread），本字段天然剥除——有测试钉住
+   * （RFC-142 重要事项规则4）。
+   */
+  argumentsParseFailed?: boolean;
+}
+/**
+ * A2UI content block（RFC-105 D6/M105-5b）：agent 生成的声明式 UI payload。
+ * 对齐 a2ui-project/a2ui（v0.9）的核心哲学——扁平组件列表 + ID 引用 + 受信组件 catalog、
+ * 纯数据非代码、未知组件类型文本降级。
+ *
+ * 组件类型（TUI 终端安全子集，首阶段只读 display）：
+ * - Text：纯文本（text 字段）。
+ * - Card：带标题容器（title + children ID 引用）。
+ * - List：条目列表（items ID 引用 + ordered 标志）。
+ * - Progress：ASCII 进度条（value 0-100，label 可选）。
+ * - Chip：内联彩色标签（text + color）。
+ * - Button：交互按钮（RFC-105 D6 F5/M105-5c，数字键触发 a2ui action；只读 display 通过
+ *   renderA2uiBlock 提取为 A2uiButtonInfo 元数据）。
+ * - Form：交互式表单（RFC-211 M1：字段定义 + TUI 弹窗填写 + web-ui 原生表单）。
+ *   字段类型 text/select/toggle，payload 原样回流，不可执行代码。
+ * 未知 type → 文本摘要表示（不崩，fail-soft，R7）。
+ */
+interface A2uiComponent {
+  id: string;
+  type: 'Text' | 'Card' | 'List' | 'Progress' | 'Chip' | 'Button' | 'Form' | (string & {});
+  text?: string;
+  title?: string;
+  children?: string[];
+  items?: string[];
+  ordered?: boolean;
+  value?: number;
+  max?: number;
+  label?: string;
+  color?: 'accent' | 'green' | 'amber' | 'red' | 'gray';
+  action?: string;
+  shortcut?: string;
+  /** 表单标题（弹窗标题 + 对话流摘要标题）。 */
+  formTitle?: string;
+  /** 表单字段定义。 */
+  fields?: A2uiFormField[];
+}
+/** 单个表单字段（`A2uiComponent.type === 'Form'` 时使用）。 */
+interface A2uiFormField {
+  /** 字段 id（Form 内唯一，submit payload 的 key）。 */
+  id: string;
+  /** 字段类型。 */
+  type: 'text' | 'select' | 'toggle';
+  /** 显示标签。 */
+  label: string;
+  /** 默认值（text=字符串, select=option id, toggle=boolean）。 */
+  defaultValue?: string | boolean;
+  /** 占位符（text 类型）。 */
+  placeholder?: string;
+  /** 选项列表（select 类型必填）。 */
+  options?: Array<{
+    id: string;
+    label: string;
+  }>;
+  /** 是否必填（渲染提示，不做前端校验——非目标）。 */
+  required?: boolean;
+}
+interface A2uiContent {
+  type: 'a2ui';
+  /** A2UI 协议版本（v0.9 snapshot），供未来版本迁移用。 */
+  version: string;
+  /** 扁平组件列表，ID 引用构建组件树，增量子集可追加/替换。 */
+  components: A2uiComponent[];
+}
+type ContentPart = TextContent | ImageContent | ThinkingContent | ToolCall | A2uiContent;
+interface UserMessage {
+  role: 'user';
+  content: string | ContentPart[];
+  timestamp: Timestamp;
+  uuid?: string;
+  /**
+   * RFC-050 REV-1：引擎注入的内部消息（如预算收尾 steering、截断续写提示），模型需要看到、
+   * 但**不应渲染给用户**（否则 resume 时显示成用户从未输入的发言）。provider 序列化忽略此字段。
+   */
+  internal?: boolean;
+}
+interface AssistantMessage {
+  role: 'assistant';
+  /**
+   * 消息内容。A2uiContent 是前向兼容新增（RFC-155 M2 结案后的协议层收口）：
+   * provider 序列化层仅消费 text/tool_call/thinking，a2ui 块被静默跳过不出进 LLM 请求体；
+   * 渲染层（message-lines.ts）经 `renderA2uiBlock` 渲染。
+   */
+  content: (TextContent | ThinkingContent | ToolCall | A2uiContent)[];
+  api: Api;
+  provider: Provider;
+  model: string;
+  usage: Usage;
+  stopReason: StopReason;
+  uuid?: string;
+}
+interface ToolResultMessage<T extends unknown = unknown> {
+  role: 'tool_result';
+  toolCallId: string;
+  toolName: string;
+  /**
+   * 工具结果内容。A2uiContent 是前向兼容新增（RFC-155 M2 结案后的协议层收口）：
+   * provider 序列化仅消费 text，a2ui 块被静默跳过；渲染层（message-lines.ts）经
+   * `renderA2uiBlock` 渲染为终端卡片。
+   */
+  content: (TextContent | ImageContent | A2uiContent)[];
+  details: T;
+  isError: boolean;
+  timestamp: Timestamp;
+  uuid?: string;
+  /** RFC-050 REV-1：引擎合成的内部 tool_result（如预算耗尽未执行的占位），不渲染给用户。 */
+  internal?: boolean;
+}
+/**
+ * RFC-144 M1：mid-conversation system 通知消息——**真正进 provider 请求**的协议消息类型
+ * （区别于 `@otto/hook-contracts` 的 `SystemAgentMessage`，后者是 hooks/UI 域、
+ * convertToLLM 类型边界显式过滤、绝不进 provider 请求）。
+ *
+ * 用途：lifecycleAsync 工具（RFC-144）真正完成时，追加一条独立消息告知 LLM"运营方观察到
+ * 的状态变化"（Anthropic mid-conversation system message 官方场景之一），不修改/替换任何
+ * 历史消息（纯追加语义），LLM 在下一轮推理中作为权威事实处理。
+ *
+ * provider 序列化：
+ * - Anthropic（原生支持，Claude Opus 4.8+）→ `{role: 'system', content}` 追加进 messages 数组，
+ *   放置规则见 RFC-144 重要事项规则 5（必须紧跟携带 tool_result 的 user turn 之后）。
+ * - 不支持该特性的模型/provider（如 OpenAI，或 Anthropic 旧模型）→ 降级为等价的
+ *   `role: 'user'` 消息 + 显式文本前缀（牺牲"运营方权威"语义，保留基本可用性），
+ *   降级逻辑归属 provider adapter 层（本类型定义不关心降级细节）。
+ *
+ * 不可变性（RFC-144 禁区）：一旦追加，绝不编辑或删除已发送的 system 通知——结果更新一律
+ * 追加新消息，不改写旧消息（Anthropic 官方限制：编辑会使该点之后的 prompt cache 失效）。
+ */
+interface SystemNotificationMessage {
+  role: 'system_notification';
+  /** 通知正文（如 "[Tool completion] pnpm build finished: exit 0"）。 */
+  content: string;
+  /**
+   * 该通知对应的工具执行是否失败——显式字段，供消费方（渲染层/审计）直接读取，不必解析
+   * `content` 文案判断状态（RFC-144 M2：文案格式可能演进，靠字符串匹配脆弱且易误判）。
+   */
+  isError?: boolean;
+  /** 关联的 lifecycleAsync 工具调用 id，供消费方（渲染层/审计）溯源。 */
+  relatedToolCallId?: string;
+  timestamp: Timestamp;
+  uuid?: string;
+}
+type Message = UserMessage | AssistantMessage | ToolResultMessage | SystemNotificationMessage;
+/**
+ * 历史压缩摘要消息的标记前缀——单一真相源（跨包协议常量）。
+ * 生产者 @otto/memory 注入摘要消息时用、压缩去重(isSummaryMessage)时识别；消费者
+ * @otto/agent 的 ContextPipeline 从会话树恢复摘要时用同一前缀重建摘要消息。放在协议叶子，
+ * 避免双份字面量漂移导致 isSummaryMessage 失配。
+ */
+//#endregion
+//#region src/stream.d.ts
+/**
+ * 供应商 usage 快照（状态栏「周/小时额度」展示，RFC 无编号临时功能——状态栏 provider usage）。
+ *
+ * 仅 Anthropic OAuth 订阅计划（Claude Pro/Max）请求会带 anthropic-ratelimit-unified-* 响应头族；
+ * API key 走标准 RPM/TPM 限流不带此头族，故 provider/ai 层解析不到时返回 null，调用方天然
+ * 实现"API key 不显示"（见 packages/ai/src/provider-usage.ts extractProviderUsageFromHeaders
+ * 与 packages/ai/src/auth-store.ts getAuthSource）。
+ *
+ * usedPercent 未经 Anthropic 官方文档确认（仅有 status/representative-claim/reset 三个字段有
+ * SDK 源码级证据），探测不到时为 undefined——UI 侧绝不显示猜测/编造的百分比数字。
+ */
+interface ProviderUsageSnapshot {
+  /**
+   * 订阅配额状态。'allowed'/'allowed_warning'/'rejected' 来自 Anthropic unified 头族的
+   * 真实语义；**'unknown' = 无订阅配额数据**（RFC-118 小修 S11：OpenAI 只有标准
+   * x-ratelimit-* 头无配额语义，此前重载 'allowed' 造成同字段双语义——UI 按
+   * status!=='rejected' 判「额度 OK」会让 OpenAI 用户永远看不到预警）。
+   * 消费端对 'unknown' 应展示中性态（不判额度充足也不报警）。
+   */
+  status: 'allowed' | 'allowed_warning' | 'rejected' | 'unknown';
+  limitType?: 'five_hour' | 'seven_day' | 'seven_day_opus' | 'seven_day_sonnet' | 'seven_day_overage_included';
+  /** Unix 时间戳（秒）——配额重置时刻。 */
+  resetsAt?: number;
+  /** 已用百分比（0-100）。未探测到时 undefined。 */
+  usedPercent?: number;
+  /**
+   * Overage（额外用量池）状态。
+   * 仅当标准额度已耗尽（status='rejected'）且 overage 可用（overageStatus='allowed'/'allowed_warning'）
+   * 时有意义——此时 isUsingOverage = true，状态栏应展示 overage 标识而非 rejected 错误态。
+   * 无 overage 头族的请求（API key / 未开通 overage）此字段为 undefined。
+   */
+  overageStatus?: 'allowed' | 'allowed_warning' | 'rejected';
+  /** Overage 池重置时刻（Unix 秒）。 */
+  overageResetsAt?: number;
+  /** Overage 不可用原因（仅在 overageStatus='rejected' 时可能有值）。 */
+  overageDisabledReason?: string;
+  /**
+   * 标准 API 限流快照（x-ratelimit-* 头族，有官方文档）。与 Anthropic unified 订阅配额
+   * 不同——这里表示的是分钟级请求/Token 的 token bucket 限流，任何认证方式的请求都返回
+   * （Anthropic API key + OpenAI API key + OAuth 订阅）。undefined = 没有标准限流头。
+   *
+   * 格式来自 OpenAI Rate Limits 文档（x-ratelimit-limit-requests/remaining-requests/
+   * reset-requests/-limit-tokens/-remaining-tokens/-reset-tokens），Anthropic 也用
+   * 同名头族但加上 `anthropic-` 前缀。
+   */
+  standardLimits?: {
+    remainingRequests?: number;
+    remainingTokens?: number;
+    limitRequests?: number;
+    limitTokens?: number;
+    resetRequestsMs?: number;
+    resetTokensMs?: number;
+  };
+}
+/**
+ * 流式增量事件——provider converse() 的统一产物面。RFC-067 M111(A5)：所有 provider 都必须
+ * 发齐 text/thinking/tool_call 的 start/delta/end 包络（end 带累积 content），否则下游
+ * 「完成通知」会丢内容。单一真相源避免 anthropic 全发 12 变体而 OpenAI 系发不全的漂移。
+ */
+type StreamEvent = {
+  type: 'start';
+  partial: AssistantMessage;
+} | {
+  type: 'text_start';
+  index: number;
+  partial: AssistantMessage;
+} | {
+  type: 'text_delta';
+  index: number;
+  delta: string;
+  partial: AssistantMessage;
+} | {
+  type: 'text_end';
+  index: number;
+  content: string;
+  partial: AssistantMessage;
+} | {
+  type: 'thinking_start';
+  index: number;
+  partial: AssistantMessage;
+} | {
+  type: 'thinking_delta';
+  index: number;
+  delta: string;
+  partial: AssistantMessage;
+} | {
+  type: 'thinking_end';
+  index: number;
+  content: string;
+  partial: AssistantMessage;
+} | {
+  type: 'tool_call_start';
+  index: number;
+  partial: AssistantMessage;
+} | {
+  type: 'tool_call_delta';
+  index: number;
+  delta: string;
+  partial: AssistantMessage;
+} | {
+  type: 'tool_call_end';
+  index: number;
+  toolCall: ToolCall;
+  partial: AssistantMessage;
+} | {
+  type: 'done';
+  reason: StopReason;
+  message: AssistantMessage; /** 本轮成功响应解析出的供应商 usage 快照（仅 Anthropic OAuth 订阅计划非 null）。 */
+  providerUsage?: ProviderUsageSnapshot | null;
+} | {
+  type: 'error';
+  error: Error;
+}; //#endregion
+//#region src/model.d.ts
+/**
+ * 推理投入档（reasoning effort）——RFC-235 对齐 Claude Code 词表：`low/medium/high/xhigh/max`。
+ * 去除历史遗留的 `minimal`（无对应厂商语义，存量配置载入时迁移为 `low`），新增 `max`（Claude
+ * Code 最高档 + DeepSeek `reasoning_effort:'max'` 顶档）。各模型真实支持的子集由 manifest 的
+ * `Model.thinkingLevels` 声明，provider 组装请求体时按"≤该档最高支持档"降级（见 RFC-235 §3.3）。
+ */
+type ThinkingLevel = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+/**
+ * 模型能力优势标签（供大模型为 subagent 选型）。非 /models API 返回——由
+ * model-capabilities 据「精选家族图 + 启发式」推导。
+ *  planning=方案/架构 · knowledge=知识/通识 · coding=编码 · reasoning=深度推理
+ *  · vision=视觉 · speed=低延迟 · long-context=长上下文
+ */
+type ModelStrength = 'planning' | 'knowledge' | 'coding' | 'reasoning' | 'vision' | 'speed' | 'long-context';
+interface Cost {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+interface Model<T = Api> {
+  id: string;
+  name: string;
+  api: T;
+  provider: Provider;
+  baseUrl: string;
+  reasoning: boolean;
+  input: ('text' | 'image')[];
+  /**
+   * 美元 / 百万 token 定价（终局修复：改为可选，不再强制归零）。三家主流供应商
+   * （Anthropic/OpenAI/GitHub Copilot，逐一核实过官方文档+SDK 源码）的 `/models` 列表接口
+   * 均不返回定价——这不是接口设计缺陷，是行业普遍现状：`/models` 回答"能用哪些模型"，
+   * 定价只写在面向人类阅读的文档页（会随时间调整），没有供应商把它做成程序化查询接口。
+   * 缺省（`undefined`）= 该模型没有已知定价来源（如运行时从供应商接口动态发现的新型号），
+   * UI 层应据此不显示开销估算，而非显示误导性的 $0（用户可能误以为模型免费，实际正常计费）。
+   * 有值 = 人工核实过的真实历史定价（当前来自各插件 manifest 声明）。
+   */
+  cost?: Cost;
+  contextWindow: number;
+  maxOutputTokens: number;
+  thinkingLevels?: ThinkingLevel[];
+  /**
+   * thinking 配置格式声明：
+   * - 'enabled'（缺省）：标准 Anthropic `{ type: 'enabled', budget_tokens: N }`
+   * - 'adaptive'：`{ type: 'adaptive' }` + 顶层 `output_config.effort`（部分网关要求此格式）
+   */
+  thinkingMode?: 'enabled' | 'adaptive';
+  /** 能力优势标签（供 subagent 选型）；由 model-capabilities 推导，非内置硬编码真源。 */
+  strengths?: ModelStrength[];
+  /**
+   * 图片约束声明（RFC-148 M5）：单请求最大图片数 + 超阈值后的单图最大边长约束。
+   * 由插件 manifest 的模型条目声明（供应商专属约束，如 Anthropic 官方规则"单请求
+   * >maxImagesPerRequest 张图时单图任一边 > maxDimensionPxIfOverLimit 即 400"，
+   * 见 `packages/agent/src/image-degradation.ts` 消费方）。缺省 = 无已知约束
+   * （引擎侧不主动截断，行为等价于约束不存在——不臆造保守默认值）。
+   */
+  imageConstraints?: {
+    maxImagesPerRequest: number;
+    maxDimensionPxIfOverLimit?: number;
+  };
+  /**
+   * 工具调用支持声明（RFC-130 M131-2，同 `imageConstraints` 声明化模式）：该模型/provider
+   * 是否支持客户端工具委托。缺省 `undefined` = 支持（向后兼容——绝大多数 provider 支持工具，
+   * 不臆造保守默认值破坏存量行为）。仅当 provider 协议层明确不支持工具委托时（如 Cursor
+   * agent API 只服务端自跑内置工具，M131-3-00b 已证伪双向映射可行性）声明 `false`，宿主
+   * （`session-config-resolver.ts`）据此剥离工具集，避免 provider 抛协议错误——引擎侧
+   * 只读布尔声明，不识别具体厂商字符串（终局判据，同 RFC-148 系列的 zero-vendor-knowledge
+   * 原则）。
+   */
+  supportsTools?: boolean;
+  /**
+   * Responses API 请求体策略声明（RFC-213）：供 `openai-responses` 协议实现按声明覆盖
+   * 标准请求体字段，替代此前失效的 `model.api === 'openai-codex-responses'` 字符串判断
+   * （RFC-122 provider 插件化迁移后该字面量已物理不可达，是死代码——见 RFC-213 背景的
+   * 逐层源码追溯）。缺省 = 标准行为（不设置 `store`、按
+   * `context.maxTokens ?? model.maxOutputTokens` 发送 `max_output_tokens`）。
+   */
+  responseBodyPolicy?: {
+    /** 显式设置 body.store（如 ZDR 合规场景需要 false）。缺省不设置该字段（沿用 API 默认）。 */store?: boolean;
+    /**
+     * false = 不发送 max_output_tokens 字段。官方 `openai/codex` CLI 源码（`ResponsesApiRequest`
+     * 结构体）从不发送该字段（用 `reasoning`/`text` 控制输出），且社区证据（reasoning 模型
+     * 系列经 Responses API 收到该字段会被 400 拒绝）表明这不是可选的风格差异。缺省 true（发送）。
+     */
+    sendMaxOutputTokens?: boolean;
+  };
+}
+//#endregion
+//#region src/types.d.ts
+type StreamFunction = (context: StreamContext, signal: AbortSignal) => AsyncIterable<StreamEvent> & {
+  result(): Promise<AssistantMessage>;
+};
+interface ToolDefinition<TArgs = unknown> {
+  name: string;
+  description: string;
+  parameters: ZodType<TArgs>;
+}
+/**
+ * system prompt 的缓存稳定性分层段。仅用于 Anthropic 动态断点定位——
+ * provider 在「最后一个 stable 段」之后挂 cache_control，volatile 段照发但不进缓存前缀。
+ * content 的真相源仍是 StreamContext.systemPrompt（完整扁平串，供其它 provider 消费）。
+ */
+interface SystemPromptSegment {
+  text: string;
+  /** 'stable'（默认）=会话内冻结、进缓存前缀；'volatile'=每轮可变、落在断点之后。 */
+  cache?: 'stable' | 'volatile';
+}
+/**
+ * prompt cache 保留档（决定 Anthropic ephemeral 断点的 TTL）：
+ * - 'none'：不放任何缓存断点（一次性/eval 请求，省去缓存写开销）；
+ * - 'short'（缺省语义）：5 分钟 TTL；
+ * - 'long'：1 小时 TTL（长会话——思考久/工具轮多/有交互空档时命中率更高）。
+ */
+type CacheRetention = 'none' | 'short' | 'long';
+interface StreamContext {
+  model: Model;
+  /** 完整 system 文本（stable + volatile 已拼接）。所有 provider 的 content 真相源。 */
+  systemPrompt: string;
+  /**
+   * 可选的缓存分层视图。仅 Anthropic 据此动态放断点；省略时退化为单块尾部断点（旧行为）。
+   * 各段 text 拼接应等价于 systemPrompt。
+   */
+  systemPromptSegments?: SystemPromptSegment[];
+  messages: Message[];
+  tools?: ToolDefinition[];
+  thinkingLevel?: ThinkingLevel;
+  maxTokens?: number;
+  temperature?: number;
+  cacheRetention?: CacheRetention;
+}
+interface StreamOptions {
+  signal?: AbortSignal;
+  timeout?: number;
+  /**
+   * SSE 流的**空闲**超时（毫秒，仅 stream()）：每收到一个 chunk 重置；连续此 ms 内无任何
+   * 字节到达即 abort。与 `timeout`（整请求墙钟上限）不同——专治「连接活着但 provider
+   * 静默不再吐字节」的挂死。缺省 120s。
+   *
+   * RFC-XX reasoning-thinking：reasoning 模型（kimi-k3/GLM-5.2 等）的 thinking 阶段可
+   * 长达分钟级零 visible token——中间无任何 SSE chunk，默认 120s idle 会无差别单边坑
+   * 所有 reasoning 模型（实测 turn 3 触发：thinking_start → 零输出 → stream.retry×2 →
+   * 崩）。调用方应据此在转产 conversational function 具调用（work-loop 等里）显式加大。
+   */
+  idleTimeout?: number;
+}
+interface ProviderStream {
+  readonly id: string;
+  readonly displayName: string;
+  /**
+   * 统一鉴权解析（RFC-140 D5）：此前 4 个 provider 实现（当时在本包，RFC-148 M2 后
+   * anthropic-messages/openai-responses/openai-completions 已迁至
+   * extensions/plugin-otto-wire-protocols/src/，github-copilot 在
+   * extensions/plugin-github-copilot/src/provider.ts）各自的凭据解析签名各不相同——
+   * anthropic 是 `resolveAuthCredential(): Promise<ResolvedAuth>`（唯一带 mode/beta 的
+   * 完整版，未走接口声明的 `resolveKey`），其余三个各自实现
+   * `resolveKey(): Promise<string>` 但入参/来源不统一。新 provider 作者（含第三方代码式
+   * 插件）不知道该实现哪一个。统一为单一签名：`ResolvedAuth` 已含 token/mode/beta，语义
+   * 完整，解析失败时 reject（不返回 null——沿用各实现既有的 PROVIDER_AUTH_MISSING
+   * 错误纹理）。
+   *
+   * 可选（`?`）保留是因为 `ProviderRegistry`/`AuthStore` 侧的调用路径本就允许 provider
+   * 不声明鉴权解析（极少数场景，如未来的零凭据本地 provider）；四个内置 wire 实现全部
+   * 实现该方法。
+   */
+  resolveAuth?(model: Model): Promise<ResolvedAuth>;
+  converse(model: Model<Api>, context: StreamContext, options: StreamOptions, signal: AbortSignal): AsyncIterable<StreamEvent>;
+  /**
+   * 可选清理钩子（RFC-105 D2/评审 F8）：卸载时释放 HTTP 连接池/流等资源。
+   * 内置 provider 目前均无持久资源，可不实现；插件 provider 卸载时
+   * `ProviderRegistry.unregisterBySource` 会调用（存在则调用）。
+   */
+  dispose?(): void | Promise<void>;
+}
+type ProviderFactory = () => ProviderStream;
+/**
+ * JWT claim 派生 header 配置（RFC-122 D3）。结构对齐 openai-responses/openai-completions
+ * 各自的同名本地定义——本类型仅供 `WireProtocolFactoryInput` 使用（RFC-148 新增的协议中立层
+ * 入口）；两个协议实现随 RFC-148 M2 物理迁移至 extensions/plugin-otto-wire-protocols/src/。
+ */
+interface TokenDerivedHeader {
+  header: string;
+  source: {
+    kind: 'jwt-claim';
+    claim: string;
+    namespace?: string;
+    tokenSources?: Array<'id_token' | 'access_token'>;
+  };
+}
+/**
+ * Wire 协议实现的注册契约（RFC-148 D1）——`@otto/ai` 的 `WireProtocolRegistry` 与
+ * `@otto/plugin` 的 `PluginModule.wireProtocols` 轴共用同一份类型定义，避免跨包重复。
+ * 定义在协议中立层（`@otto/provider`）而非 `@otto/ai`：两个消费方（宿主注册表 + 插件 SDK）
+ * 都已 type-only 依赖本包，符合既有 `AnthropicRequestCustomizeInput` 的分层先例。
+ */
+interface WireRequestCustomizeInput {
+  auth: {
+    mode: 'api_key' | 'oauth';
+    beta?: string;
+  };
+  sessionId: string;
+}
+/** 通用 system 文本块最小结构（`Anthropic.TextBlockParam` 的子集，SDK 无关，见 WireRequestCustomization.transformSystemBlocks）。 */
+interface WireSystemTextBlock {
+  type: 'text';
+  text: string;
+  cache_control?: unknown;
+}
+interface WireRequestCustomization {
+  defaultHeaders?: Record<string, string>;
+  /** system 数组变换（如插入身份前缀块）；非全部协议都支持——不支持的协议实现忽略该字段。 */
+  transformSystemBlocks?: (blocks: WireSystemTextBlock[] | undefined) => WireSystemTextBlock[] | undefined;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * 插件侧协议实现的日志端口（RFC-185 D3）。宿主注入（走宿主进程的单一 pino 单例 →
+ * 日志总线/文件），插件源码**禁止**自建 `createLogger`——esbuild bundle 会把
+ * `@otto/shared` logger 整体复制成第二份单例，宿主的级别/通道控制够不着它，直写
+ * stderr 破坏 TUI（findings-backlog「2026-07-13 TUI 残影回归」根因环 2）。
+ * `debug` 档是宿主↔协议实现的内部约定（`PluginContext.logger` 对外仍是
+ * info/warn/error 三档 + 可选 debug）。
+ */
+interface WireProtocolLogger {
+  /** 首参兼容 pino 两种惯用形态：结构化对象（mergingObject）或格式化字符串。 */
+  debug: (objOrMsg: string | Record<string, unknown>, ...args: unknown[]) => void;
+  info: (objOrMsg: string | Record<string, unknown>, ...args: unknown[]) => void;
+  warn: (objOrMsg: string | Record<string, unknown>, ...args: unknown[]) => void;
+  error: (objOrMsg: string | Record<string, unknown>, ...args: unknown[]) => void;
+}
+interface WireProtocolFactoryInput {
+  resolveAuth: () => Promise<{
+    token: string;
+    mode: 'api_key' | 'oauth';
+    beta?: string;
+  } | undefined>;
+  resolveBaseUrl: () => Promise<string | undefined>;
+  headers?: Record<string, string>;
+  tokenDerivedHeaders?: TokenDerivedHeader[];
+  /** 请求定制点——厂商个性注入唯一通道（如 plugin-anthropic 的 Claude Code 伪装）。 */
+  customizeRequest?: (input: WireRequestCustomizeInput) => WireRequestCustomization;
+  /**
+   * RFC-270 D3：允许 manifest 静态头/JWT 派生头/拦截器覆盖鉴权头（`authorization`/`x-api-key`）。
+   * 缺省 `undefined` = 不允许（默认丢弃 + warn）——otto 的 manifest 可由第三方插件分发，
+   * 静默替换 Authorization 等于把用户凭据路由到任意端点。企业网关确需换鉴权时由 provider
+   * 在 manifest 显式声明 `allowAuthHeaderOverride: true`，装载期 warn 一条保证可审计。
+   */
+  allowAuthHeaderOverride?: boolean;
+  sessionId?: string;
+  /**
+   * RFC-185 D3：宿主注入的日志端口。可选字段（向后兼容，不 bump PLUGIN_API_VERSION）；
+   * 缺省时协议实现必须 fallback 到 no-op——绝不 fallback 到 createLogger（复活第二单例）。
+   */
+  logger?: WireProtocolLogger;
+}
+/** 协议注册携带的能力元数据（RFC-147 B-1：替代 `CACHE_REPORTING_APIS` 硬编码白名单）。 */
+interface WireProtocolMeta {
+  /** 该协议的 usage 是否携带 cache token 字段。缺省 = false（不上报）。 */
+  reportsCacheTokens?: boolean;
+}
+interface WireProtocolRegistration {
+  create: (input: WireProtocolFactoryInput) => ProviderStream;
+  meta?: WireProtocolMeta;
+}
+type OAuthCredentials = {
+  refresh: string;
+  access: string;
+  expires: number; /** GitHub Enterprise host（如 company.ghe.com）；持久化以便后续刷新仍打到企业域而非默认 github.com。 */
+  domain?: string;
+  [key: string]: unknown;
+};
+type OAuthProviderId = string;
+interface OAuthInfo {
+  url: string;
+  code?: string;
+  instructions?: string;
+}
+interface OAuthPrompt {
+  message: string;
+  placeholder?: string;
+  allowEmpty?: boolean;
+}
+interface OAuthLoginOptions {
+  onAuth: (info: OAuthInfo) => void;
+  onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+  onProgress?: (message: string) => void;
+  /**
+   * 手动粘贴授权码兜底通道。`signal` 由 provider 在自动通道（loopback 回调）
+   * 先完成时触发——实现方应据此关闭粘贴输入框并 resolve 空串。
+   */
+  onManualCode?: (signal?: AbortSignal) => Promise<string>;
+  signal?: AbortSignal;
+}
+interface OAuthRefreshTokenOptions extends OAuthCredentials {
+  domain?: string;
+}
+interface OAuthProvider {
+  readonly id: OAuthProviderId;
+  readonly name: string;
+  usesCallbackServer?: boolean;
+  /**
+   * 以 OAuth token 调用对应 API 时必带的 beta 头（如 Anthropic 的 `oauth-2025-04-20`）。
+   * provider 据此在 oauth 模式下附加 `anthropic-beta`（M8-04/05）。
+   */
+  readonly oauthBeta?: string;
+  /**
+   * 此 OAuth 令牌是否绑定到某个**产品订阅**（如 Anthropic 的 Claude Code 订阅 token
+   * `sk-ant-oat`）。这类令牌在用于该产品自身 system prompt 之外的请求时会被服务端限流
+   * （HTTP 429），因此**不适合**用作 subagent 委派的可用模型来源（RFC-061 §3 D2）。
+   * 由 usability gate（`@otto/ai/model-usability`）消费；供 api_key 凭证不受此影响——
+   * provider 一旦持有真 API key，`getAuthSource` 返回 `api_key`，此标志即不被查询。
+   */
+  readonly subscriptionScoped?: boolean;
+  login(options: OAuthLoginOptions): Promise<OAuthCredentials>;
+  refreshToken(options: OAuthRefreshTokenOptions): Promise<OAuthCredentials>;
+  getAccessKey(credentials: OAuthCredentials): string;
+}
+type OAuthProviderFactory = () => OAuthProvider;
+type AuthMode = 'api_key' | 'oauth';
+interface ResolvedAuth {
+  /** 实际用于鉴权的令牌（API key 或 OAuth access token）。 */
+  token: string;
+  /** 鉴权模式。 */
+  mode: AuthMode;
+  /** OAuth 模式下需附带的 beta 头（来源于 OAuthProvider.oauthBeta）。 */
+  beta?: string;
+}
+//#endregion
+//#region src/provider/chat-completions.d.ts
+declare function buildChatCompletionsMessages(context: StreamContext): unknown[];
+declare function buildChatCompletionsBody(model: Model, context: StreamContext, opts?: {
+  modelName?: string;
+}): Record<string, unknown>;
+//#endregion
+//#region src/provider/thinking-effort.d.ts
+/**
+ * 把用户请求的档位降级到模型真实支持的档位子集里"≤请求档的最高档"。
+ *
+ * - `supported` 未声明/为空 → 原样返回 `requested`（无约束，向后兼容：模型没声明支持集时
+ *   不主动改写用户意图，交给协议翻译表兜底）。
+ * - `requested` 已在 `supported` 里 → 原样返回。
+ * - 否则返回 `supported` 中 order ≤ requested 的最高档；若没有更低的支持档（如模型只支持
+ *   `max` 而用户选 `low`），返回 `supported` 中的最低档（不臆造更低值）。
+ */
+declare function clampThinkingLevel(requested: ThinkingLevel, supported: readonly ThinkingLevel[] | undefined): ThinkingLevel;
+//#endregion
+//#region src/provider/chat-completions-stream.d.ts
+/**
+ * chat-completions-stream.ts — OpenAI Chat-Completions 兼容 SSE 流的单一实现（RFC-074 R-AICHAT）。
+ *
+ * openai-completions 与 github-copilot 此前各自维护一份 ~95% 相同的 SSE 解析循环且已漂移
+ * （finish_reason 映射、`!delta` 早返位置不一致 → B5 类 bug）。本模块收敛为唯一发射器：
+ * 各 provider 只提供 url/headers/body 与消息身份（api/provider/model），循环逻辑只此一处。
+ */
+/** finish_reason → StopReason 的单一映射（取代两份漂移的 switch）。未知值兜底 end_turn 并告警。 */
+declare function mapChatFinishReason(reason: string): StopReason;
+interface ChatCompletionsStreamParams {
+  url: string;
+  headers: Record<string, string>;
+  body: Record<string, unknown>;
+  /** 组装 partial/最终 AssistantMessage 的身份（各 provider 不同）。 */
+  identity: {
+    api: Api;
+    provider: Provider;
+    model: string;
+  };
+  signal: AbortSignal;
+  timeout?: number;
+  /**
+   * SSE **空闲**超时（毫秒）——每收到一个 chunk 重置；连续此 ms 无字节即 abort。
+   * 缺省 120s。对 reasoning 模型（thinking 阶段可能长达分钟级零 visible token）应加大。
+   */
+  idleTimeout?: number;
+  /**
+   * 可选旁路回调（RFC-140 D5）：SSE 建流成功后同步收到响应 Headers，供调用方做额外的
+   * 旁路观测（如日志/埋点）。`streamChatCompletions` 自身**始终**内部捕获响应头并通过
+   * `extractStandardRateLimitHeaders` 计算标准 `x-ratelimit-*` 限流快照，随 `done`
+   * 事件的 `providerUsage` 字段透出——此前 chat-completions 形（copilot/openai-completions/
+   * deepseek）走本函数但从未暴露响应头，用户在这些 provider 下永远看不到任何 usage 信息，
+   * 现已零调用方改动自动闭合（`extractStandardRateLimitHeaders` 对非 OpenAI 厂商的
+   * 兼容响应头一样适用——它只解析标准 `x-ratelimit-*` 头族，无厂商专属逻辑）。
+   */
+  onResponse?: (headers: Headers) => void;
+  /**
+   * RFC-232（终局修正）：已注册工具名集合，供 `recoverLiteralInvokeToolCalls` 在 `done`
+   * 事件前救回"模型把工具调用写成字面文本 XML"的违约响应（见 stream-state.ts 头注释）。
+   * 可选字段——未传入（如历史调用方/replay-provider 快照重放）时该救回步骤原样跳过
+   * （registeredToolNames(undefined) 派生空集合，函数内部白名单校验天然不命中，零行为
+   * 变化，向后兼容）。
+   */
+  registeredToolNames?: ReadonlySet<string>;
+}
+/**
+ * 驱动一条 Chat-Completions SSE 流，产出标准 StreamEvent 序列
+ * （start → text/thinking/tool_call 的 start/delta/end → done；异常 → error）。
+ */
+declare function streamChatCompletions(params: ChatCompletionsStreamParams): AsyncIterable<StreamEvent>;
+//#endregion
+//#region src/provider/sanitize-tool-roundtrips.d.ts
+/**
+ * Provider 无关的工具往返配对修复——这条不变量的单一真源。
+ *
+ * OpenAI/DeepSeek/Anthropic 等聊天线协议都要求:每条工具结果必须应答前一条 assistant
+ * 宣告的 tool_call,且每个 tool_call 必须被应答,否则 400(例如 DeepSeek 的
+ * "Messages with role 'tool' must be a response to a preceding message with 'tool_calls'")。
+ * 会话历史在 abort、流式解析丢块、非压缩硬截断等路径下可能产生:
+ *   - 孤儿 tool_result——toolCallId 指向的 assistant tool_call 已不在窗口内;
+ *   - 悬空 tool_call——assistant 宣告了工具调用但其结果被丢。
+ * 把这种序列直接发给 provider 就会 400。各 provider 在构建自己的线格式前先过本函数归一。
+ *
+ * 修复策略:
+ *   - 丢弃孤儿 tool_result(toolCallId 不在前驱 assistant 的 tool_call 集合中)。
+ *   - 为悬空 tool_call 合成占位 tool_result(isError=true),插在下一条 user/assistant 之前。
+ *   - 任一修复触发都打 warn——这是兜底,但必须发声;否则它会静默掩盖"上游为什么产生
+ *     无效序列"的真正 bug。真出问题时,warn 里的 toolCallId 是定位上游来源的唯一线索。
+ *
+ * 幂等:已配对的输入原样返回(无 warn)。
+ */
+declare function sanitizeToolRoundtrips(messages: Message[]): Message[];
+/**
+ * RFC-144 M2：system_notification 消息的降级序列化文本——不支持原生 mid-conversation
+ * system message 的 provider/模型统一走 `role:'user'` + 本前缀（决策 1 已述权衡：牺牲
+ * "运营方权威"语义，保留基本可用性）。Provider 无关的单一真源，供
+ * extensions/plugin-otto-wire-protocols 的 anthropic-messages/openai-responses 与本包
+ * chat-completions.ts 三处共同导入复用（不各自重复定义）。
+ */
+declare function degradedSystemNotificationText(content: string): string;
+/**
+ * RFC-144 M2 遗留 bug 修复（2026-07 真机日志核实）：Anthropic 官方文档明确写明
+ * "Consecutive system messages are not allowed; merge instructions into one message or
+ * wait for the next user turn before appending"（docs.anthropic.com/en/docs/build-with-
+ * claude/mid-conversation-system-messages）——原设计"多个 lifecycleAsync 工具同时完成时
+ * 按完成顺序追加多条 system 消息，不合并"直接违反该硬约束，会被 Anthropic 400 拒绝
+ * （原实现只把 `assertSystemNotificationPlacement` 的 successor 检查限定"必须是末尾或紧
+ * 跟 assistant"，从未检查过"两条 system_notification 相邻"这一违规本身，只告警不修复）。
+ *
+ * 本函数在原生 mid-conversation system message 序列化前合并相邻的
+ * `system_notification` 消息为一条（content 用换行拼接、isError 取任一为真、
+ * relatedToolCallId 保留首条——仅供审计溯源，非强约束）。仅原生路径需要（降级路径每条
+ * system_notification 各自变成独立 `role:'user'` 消息，Anthropic 对连续 user 消息无此
+ * 限制，不需要合并）。
+ */
+declare function mergeConsecutiveSystemNotifications(messages: Message[]): Message[];
+/**
+ * RFC-144 M2：mid-conversation system message 放置规则断言——Provider 无关的共享检查。
+ *
+ * Anthropic 官方约束（docs.anthropic.com/en/docs/build-with-claude/
+ * mid-conversation-system-messages）：`system` 消息必须紧跟在携带 tool_result 的 user
+ * turn 之后（或以 server tool use 结尾的 assistant turn 之后），且必须是 messages 数组
+ * 最后一条或紧跟一个 assistant turn；不能插在 assistant tool_use 与其 tool_result 之间。
+ *
+ * **层次纠正（独立评审发现，2026-07-11）**：原实现检查 `prev.role === 'user'`——这是错的。
+ * Anthropic 的规则是对**序列化后的 wire 格式**而言（"user turn carrying tool_result
+ * blocks"），而 otto 内部消息模型里 `tool_result` 是独立的顶层 role（非嵌入 user 消息内）。
+ * `buildAnthropicMessages`（extensions/plugin-otto-wire-protocols/src/anthropic-messages.ts）
+ * 把 otto 的 `role:'tool_result'` 序列化为
+ * Anthropic wire 的 `{role:'user', content:[{type:'tool_result',...}]}`——这才是规则里
+ * "携带 tool_result 的 user turn"。otto 内部的纯文本 `role:'user'` 消息序列化后同样是
+ * wire `role:'user'`，但**不携带 tool_result block**，理论上不满足严格放置规则（真实运行
+ * 路径中不会发生——system_notification 只在 work-loop.ts 的 lifecycleAsync 完成回调里追加，
+ * 其直接前驱恒为本轮已推入的 tool_result（占位符或其他同轮工具结果）或 assistant——但
+ * 断言的检查目标必须是 otto 内部层的真实等价物，不能对 wire 层描述做字面照抄）。
+ *
+ * 因此本函数检查 `prev.role === 'tool_result' || prev.role === 'assistant'`（otto 内部
+ * role），而非 `'user'`——`tool_result` 是唯一序列化后携带 tool_result block 的内部角色。
+ *
+ * 本仓的追加时机（work-loop.ts 的 runTools 内，工具 promise resolve 时 push）天然满足
+ * 该约束——落库固定发生在下一次 runTurn 前的静默期，不会插在 tool_use↔tool_result 之间。
+ * 本函数是**防御性断言**（RFC-144 M2 TODO 拆解要求）：不满足则告警但不阻断请求（宁可
+ * 尝试失败被 provider 拒绝并记录，也不能静默丢弃工具完成通知，见 RFC-144 M2 TODO 拆解原文）。
+ *
+ * 同时检查后继约束（Anthropic 规则的第二半）：`system_notification` 必须是数组末尾，
+ * 或紧跟一个 assistant turn——否则同样告警不阻断。
+ *
+ * 检查数组内**每一条** `system_notification` 消息（而非仅末尾）——每条都需独立满足放置约束。
+ *
+ * 2026-07 修正：一轮 `runTools` 可能有多个 lifecycleAsync 工具先后完成、在持久数组里连续
+ * 追加多条通知消息，但 Anthropic 官方文档明确写明 "Consecutive system messages are not
+ * allowed"——原 M2 TODO 拆解"不合并、每条独立追加"的设计违反该约束，会被真实 API 拒绝
+ * （非仅本函数的告警误报）。现原生路径在调用本函数前先经 `mergeConsecutiveSystemNotifications`
+ * 合并相邻通知（见 extensions/plugin-otto-wire-protocols 的 `buildAnthropicMessages`），
+ * 故本函数运行时**不会再遇到**两条相邻
+ * `system_notification` 的输入——但检查逻辑本身保留（防御纵深：万一未来有调用方跳过合并
+ * 直接调用本函数，仍能捕获该违规并告警）。
+ */
+declare function assertSystemNotificationPlacement(messages: readonly Message[]): void;
+//#endregion
+//#region src/provider/stream-state.d.ts
+/**
+ * 公共流式状态机基座（M7-05）。
+ *
+ * 4 个 provider（anthropic / github-copilot / openai-completions / openai-responses）
+ * 此前各持一份「累积态 + buildAssistantMessage」，此处收敛出"累积 → AssistantMessage"的
+ * 共同语义（扁平累积/块累积两种形态 + 半截 JSON 容忍解析 + usage 计数 + 末段组装）。
+ * RFC-148 M2 后 anthropic-messages/openai-responses 已物理迁至
+ * extensions/plugin-otto-wire-protocols/src/（各自内联累积逻辑，不再引用本文件）；本文件当前
+ * 唯一真实消费方是同包 `chat-completions.ts`（Chat Completions 扁平累积形，供
+ * openai-completions 与 github-copilot 复用）。
+ */
+type AssistantContent = (TextContent | ThinkingContent | ToolCall)[];
+interface StreamUsage {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+}
+declare function initStreamUsage(): StreamUsage;
+/**
+ * 流式工具参数 JSON 解析（RFC-142 D4 修订）。
+ *
+ * 旧行为：解析失败静默返回 `{}`——半截 JSON（max_tokens 截断）产出的空参数流到
+ * zod 层报出与上下文污染类错误（RFC-142 事故）同文案的 `Invalid arguments`，两个
+ * 根因正交的问题共享同一错误表象，诊断成本极高。
+ *
+ * 新行为：返回显式解析状态。**必须区分"合法空对象 `{}`"与"解析失败返回的 `{}`"**
+ * （RFC-142 重要事项规则9）——仅凭 arguments 为空判断会误伤真实的无参工具调用。
+ * 消费方据 `parseFailed` 在 ToolCall 上置 `argumentsParseFailed` 进程内标记，
+ * runtime 责任链（handleMaxTokensWithBrokenToolCall）拦截转为明确错误 tool_result。
+ */
+declare function parseToolArgumentsWithStatus(json: string, toolName?: string): {
+  args: Record<string, unknown>;
+  parseFailed: boolean;
+};
+declare function parseToolArguments(json: string, toolName?: string): Record<string, unknown>;
+/** 从解析状态构造 ToolCall（parseFailed 时附加进程内标记，序列化发给模型前天然剥除）。 */
+/** 从 `StreamContext.tools`（`ToolDefinition[] | undefined`）派生名字集合——4 个 wire 协议
+ *  实现调用 `recoverLiteralInvokeToolCalls` 前的共同准备步骤，避免各自重复映射。 */
+declare function registeredToolNames(tools: readonly ToolDefinition[] | undefined): ReadonlySet<string>;
+declare function toolCallFromParsed(id: string, name: string, argumentsJson: string): ToolCall;
+/**
+ * RFC-232（终局修正，2026-07-25）：跨 wire 协议救回"模型把工具调用写成字面文本 XML"的
+ * 违约响应（`<invoke name="X"><parameter name="Y">Z</parameter>...</invoke>`，事故会话
+ * f9bab4c0 复现 8+ 次）。
+ *
+ * **为何是协议中立公共函数，不下沉到单个 provider 插件**：复现证据显示该行为跨两个完全
+ * 不同的 wire 协议（anthropic-messages 的 Claude Opus 4.8、openai-completions 的 GLM-5.2）
+ * ——多个厂商/协议出现同一种字面量格式，是模型侧对 Claude 系工具调用 XML 语法（早期/部分
+ * 微调格式）的训练残留泄漏，不是任一协议解析器的 bug，也不是任一厂商的专属怪癖。凡跨
+ * provider 相似的行为都是公共逻辑，不应重复放进每个 provider 插件各自声明一遍（会导致
+ * 声明式插件——如本仓 plugin-oxygen 纯 manifest 无代码——完全没有地方挂这类修正）。
+ * 修复层级必须匹配问题层级：`@otto/provider` 是全部 4 个 wire 协议实现
+ * （anthropic-messages/openai-responses/chat-completions-stream[openai-completions+
+ * copilot+deepseek]/cursor）共同依赖的协议中立层，本函数是它们组装 `done` 事件 message
+ * 前的对称接入点——一次实现、全协议生效。
+ *
+ * **判据**（不依赖 stopReason，provider-agnostic）：content 内最后一个 text block 的
+ * 文本（trimEnd 后）以结构完整的 `<invoke name="X">...</invoke>` 块收尾（允许内部任意个
+ * `<parameter name="Y">Z</parameter>` 子块），且 X 在调用方传入的已注册工具名集合内。
+ * 8 条真实复现样本 100% 符合"消息以裸露 XML 块收尾"（非讨论引用中间提及诸如"应该调用
+ * edit 工具"这类正常文本），白名单排除模型讨论不存在工具名的误伤（如虚构/占位工具名）。
+ *
+ * **救回而非仅报错**：解析成功时把提取的调用追加为 `tool_call` content block（原 text
+ * block 保留但截掉尾部的 XML 片段，避免同一调用同时以文本和结构化两种形式重复出现在
+ * 上下文里），使消费方 `hasToolCalls()` 变为 true，走正常工具执行路径而非兜底重试——
+ * 零额外轮次、模型/wire 协议切换均不受影响。
+ *
+ * 不满足判据（无 XML、工具名不在白名单、XML 结构不完整）→ 原样返回 message，不做任何
+ * 修改；判据不满足时的兜底（重试/终止）由引擎层 `handleToolCallProtocolMismatch`
+ * （`@otto/agent` work-loop-turn-outcome.ts，RFC-232 D1）接管——两层纵深防御。
+ */
+declare function recoverLiteralInvokeToolCalls(message: AssistantMessage, registeredToolNames: ReadonlySet<string>): AssistantMessage;
+/**
+ * 检测文本是否以完整闭合的 `<invoke name="X">...</invoke>` 块收尾并提取参数。
+ * 不满足（无匹配、工具名不在白名单）返回 null。协议/厂商无关的纯字符串解析，无 I/O。
+ */
+/**
+ * 检测文本是否以完整闭合的 `<invoke name="X">...</invoke>` 块收尾（不提取参数，纯判定）。
+ * 供引擎层次级兜底复用同一判据（`@otto/agent` work-loop-turn-outcome.ts 的
+ * `handleToolCallProtocolMismatch`，RFC-232 D1）——wire 层 `recoverLiteralInvokeToolCalls`
+ * 救回失败（XML 不完整/工具名不在白名单）时的残留违约态，由引擎层注入纠正提示重试。
+ */
+declare function hasTrailingInvokeXml(text: string, registeredToolNames: ReadonlySet<string>): boolean;
+interface FlatToolCallAcc {
+  id: string;
+  name: string;
+  argumentsJson: string;
+}
+interface FlatStreamState extends StreamUsage {
+  textContent: string;
+  thinkingText: string;
+  toolCalls: Map<number, FlatToolCallAcc>;
+  stopReason: StopReason;
+}
+declare function initFlatStreamState(): FlatStreamState;
+declare function flatContent(state: FlatStreamState, final?: boolean): AssistantContent;
+type StreamBlock = {
+  kind: 'text';
+  text: string;
+} | {
+  kind: 'thinking';
+  text: string;
+  signature?: string;
+} | {
+  kind: 'tool_call';
+  id: string;
+  name: string;
+  argumentsJson: string;
+};
+declare function blocksContent(blocks: Map<number, StreamBlock>, final?: boolean): AssistantContent;
+interface AssistantMessageMeta {
+  api: Api;
+  provider: Provider;
+  model: string;
+}
+declare function assembleAssistantMessage(meta: AssistantMessageMeta, content: AssistantContent, usage: StreamUsage, stopReason: StopReason): AssistantMessage;
+//#endregion
+//#region src/provider/encoding.d.ts
+/**
+ * Provider 载荷编码工具——多个 provider 在构造请求体时共用的纯函数。
+ *
+ * 收敛镜像债：sanitizeSurrogates / toJsonSchema 原先在 chat-completions 与
+ * openai-responses 各抄一份（字节一致），统一为单源以防分叉漂移。
+ */
+/**
+ * 将落单的 UTF-16 代理项（lone surrogate）替换为 U+FFFD。
+ *
+ * JSON 序列化前必须做：模型流式输出可能在多字节字符中途切片，留下落单高/低代理，
+ * 直接 `JSON.stringify` 会产出非法 UTF-8 被服务端 400 拒。
+ */
+declare function sanitizeSurrogates(text: string): string;
+/** 把带可选 `toJSONSchema()` 的 schema 对象转为 JSON Schema；无该方法时退回空对象。 */
+declare function toJsonSchema(schema: {
+  toJSONSchema?: () => unknown;
+}): unknown;
+//#endregion
+//#region src/request-headers.d.ts
+interface RequestHeaderSources {
+  /** ① 协议实现自身的默认头。 */
+  protocolDefaults?: Record<string, string>;
+  /** ② manifest 声明的静态头（`PluginProviderEntry.headers`）。 */
+  staticHeaders?: Record<string, string>;
+  /** ③ JWT claim 派生头（RFC-122 D3）。`token` 为待扫描的凭据。 */
+  tokenDerived?: {
+    headers: readonly TokenDerivedHeader[];
+    token: string;
+  };
+  /** ④ 程序化拦截器产出（`WireRequestCustomization.defaultHeaders`）。 */
+  customized?: Record<string, string>;
+  /**
+   * ⑤ 鉴权头。**裸 fetch 协议**传入（write-last 形态）；**SDK 托管协议**省略
+   * （filter-output 形态，鉴权由 SDK 构造参数承担）。两种形态下 ②③④ 的鉴权族过滤都照常执行。
+   */
+  auth?: Record<string, string>;
+  /**
+   * RFC-270 D3 逃生口：manifest 显式声明 `allowAuthHeaderOverride: true` 后，
+   * 允许 ②③④ 覆盖鉴权族头（企业网关换鉴权的真实场景），装载期与此处各 warn 一条（可审计）。
+   */
+  allowAuthHeaderOverride?: boolean;
+  /** 诊断日志端口（缺省静默）。 */
+  logger?: WireProtocolLogger;
+  /** 日志上下文标识（provider id / 协议名），仅用于 warn 文案定位。 */
+  diagnosticLabel?: string;
+}
+/**
+ * 按五档优先级合并出站请求头，统一消毒并保护鉴权族头。
+ *
+ * @returns 最终请求头（键为各来源书写的原始大小写；内部按小写判定覆盖，HTTP 头名大小写不敏感）
+ */
+declare function buildRequestHeaders(sources: RequestHeaderSources): Record<string, string>;
+//#endregion
+//#region ../../node_modules/.pnpm/undici@8.7.0/node_modules/undici/types/utility.d.ts
+type AutocompletePrimitiveBaseType<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : never;
+type Autocomplete<T> = T | (AutocompletePrimitiveBaseType<T> & Record<never, never>);
+//#endregion
+//#region ../../node_modules/.pnpm/undici@8.7.0/node_modules/undici/types/header.d.ts
+/**
+ * The header type declaration of `undici`.
+ */
+type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
+/**
+ * The header type declaration of `undici` for outgoing requests.
+ */
+type OutgoingHttpHeaders = Record<string, number | string | string[] | undefined>;
+type HeaderNames = Autocomplete<'Accept' | 'Accept-CH' | 'Accept-Charset' | 'Accept-Encoding' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Age' | 'Allow' | 'Alt-Svc' | 'Alt-Used' | 'Authorization' | 'Cache-Control' | 'Clear-Site-Data' | 'Connection' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Type' | 'Cookie' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Resource-Policy' | 'Date' | 'Device-Memory' | 'ETag' | 'Expect' | 'Expect-CT' | 'Expires' | 'Forwarded' | 'From' | 'Host' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Unmodified-Since' | 'Keep-Alive' | 'Last-Modified' | 'Link' | 'Location' | 'Max-Forwards' | 'Origin' | 'Permissions-Policy' | 'Priority' | 'Proxy-Authenticate' | 'Proxy-Authorization' | 'Range' | 'Referer' | 'Referrer-Policy' | 'Retry-After' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-User' | 'Sec-Purpose' | 'Sec-WebSocket-Accept' | 'Server' | 'Server-Timing' | 'Service-Worker-Navigation-Preload' | 'Set-Cookie' | 'SourceMap' | 'Strict-Transport-Security' | 'TE' | 'Timing-Allow-Origin' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'Upgrade-Insecure-Requests' | 'User-Agent' | 'Vary' | 'Via' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options'>;
+type IANARegisteredMimeType = Autocomplete<'audio/aac' | 'video/x-msvideo' | 'image/avif' | 'video/av1' | 'application/octet-stream' | 'image/bmp' | 'text/css' | 'text/csv' | 'application/vnd.ms-fontobject' | 'application/epub+zip' | 'image/gif' | 'application/gzip' | 'text/html' | 'image/x-icon' | 'text/calendar' | 'image/jpeg' | 'text/javascript' | 'application/json' | 'application/ld+json' | 'audio/x-midi' | 'audio/mpeg' | 'video/mp4' | 'video/mpeg' | 'audio/ogg' | 'video/ogg' | 'application/ogg' | 'audio/opus' | 'font/otf' | 'application/pdf' | 'image/png' | 'application/rtf' | 'image/svg+xml' | 'image/tiff' | 'video/mp2t' | 'font/ttf' | 'text/plain' | 'application/wasm' | 'video/webm' | 'audio/webm' | 'image/webp' | 'font/woff' | 'font/woff2' | 'application/xhtml+xml' | 'application/xml' | 'application/zip' | 'video/3gpp' | 'video/3gpp2' | 'model/gltf+json' | 'model/gltf-binary'>;
+type KnownHeaderValues = {
+  'content-type': IANARegisteredMimeType;
+};
+type HeaderRecord = { [K in HeaderNames | Lowercase<HeaderNames>]?: Lowercase<K> extends keyof KnownHeaderValues ? KnownHeaderValues[Lowercase<K>] : string };
+//#endregion
+//#region ../../node_modules/.pnpm/undici@8.7.0/node_modules/undici/types/readable.d.ts
+declare class BodyReadable extends Readable {
+  constructor(opts: {
+    resume: (this: Readable, size: number) => void | null;
+    abort: () => void | null;
+    contentType?: string;
+    contentLength?: number;
+    highWaterMark?: number;
+  });
+  /** Consumes and returns the body as a string
+   *  https://fetch.spec.whatwg.org/#dom-body-text
+   */
+  text(): Promise<string>;
+  /** Consumes and returns the body as a JavaScript Object
+   *  https://fetch.spec.whatwg.org/#dom-body-json
+   */
+  json(): Promise<unknown>;
+  /** Consumes and returns the body as a Blob
+   *  https://fetch.spec.whatwg.org/#dom-body-blob
+   */
+  blob(): Promise<Blob>;
+  /** Consumes and returns the body as an Uint8Array
+   *  https://fetch.spec.whatwg.org/#dom-body-bytes
+   */
+  bytes(): Promise<Uint8Array>;
+  /** Consumes and returns the body as an ArrayBuffer
+   *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+   */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /** Not implemented
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-formdata
+   */
+  formData(): Promise<never>;
+  /** Returns true if the body is not null and the body has been consumed
+   *
+   *  Otherwise, returns false
+   *
+   * https://fetch.spec.whatwg.org/#dom-body-bodyused
+   */
+  readonly bodyUsed: boolean;
+  /**
+   * If body is null, it should return null as the body
+   *
+   *  If body is not null, should return the body as a ReadableStream
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-body
+   */
+  readonly body: never | undefined;
+  /** Dumps the response body by reading `limit` number of bytes.
+   * @param opts.limit Number of bytes to read (optional) - Default: 131072
+   * @param opts.signal AbortSignal to cancel the operation (optional)
+   */
+  dump(opts?: {
+    limit: number;
+    signal?: AbortSignal;
+  }): Promise<void>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/undici@8.7.0/node_modules/undici/types/fetch.d.ts
+type BodyInit = ArrayBuffer | AsyncIterable<Uint8Array> | Blob | FormData | Iterable<Uint8Array> | NodeJS.ArrayBufferView | URLSearchParams$1 | null | string;
+interface SpecIterator<T, TReturn = any, TNext = undefined> {
+  next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+}
+interface SpecIteratorObject<T, TReturn = undefined, TNext = unknown> extends SpecIterator<T, TReturn, TNext> {
+  [Symbol.iterator](): SpecIteratorObject<T, TReturn, TNext>;
+  map<U>(callbackfn: (value: T, index: number) => U): SpecIteratorObject<U>;
+  filter<S extends T>(predicate: (value: T, index: number) => value is S): SpecIteratorObject<S>;
+  filter(predicate: (value: T, index: number) => unknown): SpecIteratorObject<T>;
+  take(limit: number): SpecIteratorObject<T>;
+  drop(count: number): SpecIteratorObject<T>;
+  flatMap<U>(callbackfn: (value: T, index: number) => Iterator<U> | Iterable<U>): SpecIteratorObject<U>;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T): T;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T, initialValue: T): T;
+  reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number) => U, initialValue: U): U;
+  toArray(): T[];
+  forEach(callbackfn: (value: T, index: number) => void): void;
+  some(predicate: (value: T, index: number) => unknown): boolean;
+  every(predicate: (value: T, index: number) => unknown): boolean;
+  find<S extends T>(predicate: (value: T, index: number) => value is S): S | undefined;
+  find(predicate: (value: T, index: number) => unknown): T | undefined;
+  readonly [Symbol.toStringTag]: string;
+}
+interface SpecIterableIterator<T> extends SpecIteratorObject<T> {
+  [Symbol.iterator](): SpecIterableIterator<T>;
+}
+interface SpecIterable<T> {
+  [Symbol.iterator](): SpecIterableIterator<T>;
+}
+type HeadersInit = [string, string][] | HeaderRecord | Headers$1;
+declare class Headers$1 implements SpecIterable<[string, string]> {
+  constructor(init?: HeadersInit);
+  readonly append: (name: string, value: string) => void;
+  readonly delete: (name: string) => void;
+  readonly get: (name: string) => string | null;
+  readonly has: (name: string) => boolean;
+  readonly set: (name: string, value: string) => void;
+  readonly getSetCookie: () => string[];
+  readonly forEach: (callbackfn: (value: string, key: string, iterable: Headers$1) => void, thisArg?: unknown) => void;
+  readonly keys: () => SpecIterableIterator<string>;
+  readonly values: () => SpecIterableIterator<string>;
+  readonly entries: () => SpecIterableIterator<[string, string]>;
+  readonly [Symbol.iterator]: () => SpecIterableIterator<[string, string]>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/undici@8.7.0/node_modules/undici/types/formdata.d.ts
+/**
+ * A `string` or `File` that represents a single value from a set of `FormData` key-value pairs.
+ */
+declare type FormDataEntryValue = string | File;
+/**
+ * Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using fetch().
+ */
+declare class FormData {
+  /**
+   * Appends a new value onto an existing key inside a FormData object,
+   * or adds the key if it does not already exist.
+   *
+   * The difference between `set()` and `append()` is that if the specified key already exists, `set()` will overwrite all existing values with the new one, whereas `append()` will append the new value onto the end of the existing set of values.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   */
+  append(name: string, value: unknown, fileName?: string): void;
+  /**
+   * Set a new value for an existing key inside FormData,
+   * or add the new field if it does not already exist.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   *
+   */
+  set(name: string, value: unknown, fileName?: string): void;
+  /**
+   * Returns the first value associated with a given key from within a `FormData` object.
+   * If you expect multiple values and want all of them, use the `getAll()` method instead.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns A `FormDataEntryValue` containing the value. If the key doesn't exist, the method returns null.
+   */
+  get(name: string): FormDataEntryValue | null;
+  /**
+   * Returns all the values associated with a given key from within a `FormData` object.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns An array of `FormDataEntryValue` whose key matches the value passed in the `name` parameter. If the key doesn't exist, the method returns an empty list.
+   */
+  getAll(name: string): FormDataEntryValue[];
+  /**
+   * Returns a boolean stating whether a `FormData` object contains a certain key.
+   *
+   * @param name A string representing the name of the key you want to test for.
+   *
+   * @return A boolean value.
+   */
+  has(name: string): boolean;
+  /**
+   * Deletes a key and its value(s) from a `FormData` object.
+   *
+   * @param name The name of the key you want to delete.
+   */
+  delete(name: string): void;
+  /**
+   * Executes given callback function for each field of the FormData instance
+   */
+  forEach: (callbackfn: (value: FormDataEntryValue, key: string, iterable: FormData) => void, thisArg?: unknown) => void;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all keys contained in this `FormData` object.
+   * Each key is a `string`.
+   */
+  keys: () => SpecIterableIterator<string>;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all values contained in this object `FormData` object.
+   * Each value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  values: () => SpecIterableIterator<FormDataEntryValue>;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through the `FormData` key/value pairs.
+   * The key of each pair is a string; the value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  entries: () => SpecIterableIterator<[string, FormDataEntryValue]>;
+  /**
+   * An alias for FormData#entries()
+   */
+  [Symbol.iterator]: () => SpecIterableIterator<[string, FormDataEntryValue]>;
+  readonly [Symbol.toStringTag]: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/undici@8.7.0/node_modules/undici/types/connector.d.ts
+declare function buildConnector(options?: buildConnector.BuildOptions): buildConnector.connector;
+declare namespace buildConnector {
+  export type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
+    allowH2?: boolean;
+    preferH2?: boolean;
+    maxCachedSessions?: number | null;
+    socketPath?: string | null;
+    timeout?: number | null;
+    port?: number;
+    keepAlive?: boolean | null;
+    keepAliveInitialDelay?: number | null;
+    typeOfService?: number | null;
+  };
+  export interface Options {
+    hostname: string;
+    host?: string;
+    protocol: string;
+    port: string;
+    servername?: string;
+    localAddress?: string | null;
+    socketPath?: string | null;
+    httpSocket?: Socket;
+  }
+  export type Callback = (...args: CallbackArgs) => void;
+  type CallbackArgs = [null, Socket | TLSSocket] | [Error, null];
+  export interface connector {
+    (options: buildConnector.Options, callback: buildConnector.Callback): void;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/undici@8.7.0/node_modules/undici/types/client-stats.d.ts
+declare class ClientStats {
+  constructor(pool: Client);
+  /** If socket has open connection. */
+  connected: boolean;
+  /** Number of open socket connections in this client that do not have an active request. */
+  pending: number;
+  /** Number of currently active requests of this client. */
+  running: number;
+  /** Number of active, pending, or queued requests of this client. */
+  size: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/undici@8.7.0/node_modules/undici/types/client.d.ts
+type ClientConnectOptions<TOpaque = null> = Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin'>;
+/**
+ * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
+ */
+declare class Client extends Dispatcher {
+  constructor(url: string | URL, options?: Client.Options);
+  /** Property to get and set the pipelining factor. */
+  pipelining: number;
+  /** `true` after `client.close()` has been called. */
+  closed: boolean;
+  /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
+  destroyed: boolean;
+  /** Aggregate stats for a Client. */
+  readonly stats: ClientStats; // Override dispatcher APIs.
+  override connect<TOpaque = null>(options: ClientConnectOptions<TOpaque>): Promise<Dispatcher.ConnectData<TOpaque>>;
+  override connect<TOpaque = null>(options: ClientConnectOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void): void;
+}
+declare namespace Client {
+  export interface Options {
+    /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
+    maxHeaderSize?: number;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+    headersTimeout?: number;
+    /** @deprecated unsupported socketTimeout, use headersTimeout & bodyTimeout instead */
+    socketTimeout?: never;
+    /** @deprecated unsupported requestTimeout, use headersTimeout & bodyTimeout instead */
+    requestTimeout?: never;
+    /** The timeout for establishing a socket connection, in milliseconds. Use `0` to disable it entirely. Default: `10e3` milliseconds (10s). */
+    connectTimeout?: number;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
+    bodyTimeout?: number;
+    /** @deprecated unsupported idleTimeout, use keepAliveTimeout instead */
+    idleTimeout?: never;
+    /** @deprecated unsupported keepAlive, use pipelining=0 instead */
+    keepAlive?: never;
+    /** the timeout, in milliseconds, after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+    keepAliveTimeout?: number;
+    /** @deprecated unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead */
+    maxKeepAliveTimeout?: never;
+    /** the maximum allowed `idleTimeout`, in milliseconds, when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+    keepAliveMaxTimeout?: number;
+    /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+    keepAliveTimeoutThreshold?: number;
+    /** An IPC endpoint, either a Unix domain socket or Windows named pipe. Default: `null`. */
+    socketPath?: string;
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Only enable values greater than `1` when the remote server is trusted. Default: `1`. */
+    pipelining?: number;
+    /** @deprecated use the connect option instead */
+    tls?: never;
+    /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
+    strictContentLength?: boolean;
+    /** Maximum number of TLS cached sessions used by the built-in connector. Use `0` to disable TLS session caching. Default: `100`. */
+    maxCachedSessions?: number;
+    /** Connector options passed to `buildConnector`, or a custom connector function. Default: `null`. */
+    connect?: Partial<buildConnector.BuildOptions> | buildConnector.connector;
+    /** The maximum number of requests to send over a single connection before it is reset. Use `0` to disable this limit. Default: `null`. */
+    maxRequestsPerClient?: number;
+    /** Local IP address the socket should connect from. */
+    localAddress?: string;
+    /** Max response body size in bytes, -1 is disabled */
+    maxResponseSize?: number;
+    /** WebSocket-specific options */
+    webSocket?: Client.WebSocketOptions;
+    /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
+    autoSelectFamily?: boolean;
+    /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
+    autoSelectFamilyAttemptTimeout?: number;
+    /**
+     * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
+     * @default true
+     */
+    allowH2?: boolean;
+    /**
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @default 100
+     */
+    maxConcurrentStreams?: number;
+    /**
+     * @description Sets the HTTP/2 stream-level flow-control window size (SETTINGS_INITIAL_WINDOW_SIZE).
+     * @default 262144
+     */
+    initialWindowSize?: number;
+    /**
+     * @description Sets the HTTP/2 connection-level flow-control window size (ClientHttp2Session.setLocalWindowSize).
+     * @default 524288
+     */
+    connectionWindowSize?: number;
+    /**
+     * @description Time interval between PING frames dispatch
+     * @default 60000
+     */
+    pingInterval?: number;
+  }
+  export interface SocketInfo {
+    localAddress?: string;
+    localPort?: number;
+    remoteAddress?: string;
+    remotePort?: number;
+    remoteFamily?: string;
+    timeout?: number;
+    bytesWritten?: number;
+    bytesRead?: number;
+  }
+  export interface WebSocketOptions {
+    /**
+     * Maximum number of fragments in a message. Set to 0 to disable the limit.
+     * @default 131072
+     */
+    maxFragments?: number;
+    /**
+     * Maximum allowed payload size in bytes for WebSocket messages.
+     * Applied to uncompressed messages, compressed frame payloads, and decompressed (permessage-deflate) messages.
+     * Set to 0 to disable the limit.
+     * @default 134217728 (128 MB)
+     */
+    maxPayloadSize?: number;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/undici@8.7.0/node_modules/undici/types/errors.d.ts
+declare namespace Errors {
+  export class UndiciError extends Error {
+    name: string;
+    code: string;
+  }
+  /** Connect timeout error. */
+  export class ConnectTimeoutError extends UndiciError {
+    name: 'ConnectTimeoutError';
+    code: 'UND_ERR_CONNECT_TIMEOUT';
+  }
+  /** A header exceeds the `headersTimeout` option. */
+  export class HeadersTimeoutError extends UndiciError {
+    name: 'HeadersTimeoutError';
+    code: 'UND_ERR_HEADERS_TIMEOUT';
+  }
+  /** Headers overflow error. */
+  export class HeadersOverflowError extends UndiciError {
+    name: 'HeadersOverflowError';
+    code: 'UND_ERR_HEADERS_OVERFLOW';
+  }
+  /** A body exceeds the `bodyTimeout` option. */
+  export class BodyTimeoutError extends UndiciError {
+    name: 'BodyTimeoutError';
+    code: 'UND_ERR_BODY_TIMEOUT';
+  }
+  export class ResponseError extends UndiciError {
+    constructor(message: string, code: number, options: {
+      headers?: IncomingHttpHeaders | string[] | null;
+      body?: null | Record<string, any> | string;
+    });
+    name: 'ResponseError';
+    code: 'UND_ERR_RESPONSE';
+    statusCode: number;
+    body: null | Record<string, any> | string;
+    headers: IncomingHttpHeaders | string[] | null;
+  }
+  /** Passed an invalid argument. */
+  export class InvalidArgumentError extends UndiciError {
+    name: 'InvalidArgumentError';
+    code: 'UND_ERR_INVALID_ARG';
+  }
+  /** Returned an invalid value. */
+  export class InvalidReturnValueError extends UndiciError {
+    name: 'InvalidReturnValueError';
+    code: 'UND_ERR_INVALID_RETURN_VALUE';
+  }
+  /** The request has been aborted by the user. */
+  export class RequestAbortedError extends UndiciError {
+    name: 'AbortError';
+    code: 'UND_ERR_ABORTED';
+  }
+  /** Expected error with reason. */
+  export class InformationalError extends UndiciError {
+    name: 'InformationalError';
+    code: 'UND_ERR_INFO';
+  }
+  /** Request body length does not match content-length header. */
+  export class RequestContentLengthMismatchError extends UndiciError {
+    name: 'RequestContentLengthMismatchError';
+    code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH';
+  }
+  /** Response body length does not match content-length header. */
+  export class ResponseContentLengthMismatchError extends UndiciError {
+    name: 'ResponseContentLengthMismatchError';
+    code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH';
+  }
+  /** Trying to use a destroyed client. */
+  export class ClientDestroyedError extends UndiciError {
+    name: 'ClientDestroyedError';
+    code: 'UND_ERR_DESTROYED';
+  }
+  /** Trying to use a closed client. */
+  export class ClientClosedError extends UndiciError {
+    name: 'ClientClosedError';
+    code: 'UND_ERR_CLOSED';
+  }
+  /** There is an error with the socket. */
+  export class SocketError extends UndiciError {
+    name: 'SocketError';
+    code: 'UND_ERR_SOCKET';
+    socket: Client.SocketInfo | null;
+  }
+  /** Encountered unsupported functionality. */
+  export class NotSupportedError extends UndiciError {
+    name: 'NotSupportedError';
+    code: 'UND_ERR_NOT_SUPPORTED';
+  }
+  /** No upstream has been added to the BalancedPool. */
+  export class BalancedPoolMissingUpstreamError extends UndiciError {
+    name: 'MissingUpstreamError';
+    code: 'UND_ERR_BPL_MISSING_UPSTREAM';
+  }
+  export class HTTPParserError extends UndiciError {
+    name: 'HTTPParserError';
+    code: string;
+  }
+  /** The response exceed the length allowed. */
+  export class ResponseExceededMaxSizeError extends UndiciError {
+    name: 'ResponseExceededMaxSizeError';
+    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
+  }
+  export class RequestRetryError extends UndiciError {
+    constructor(message: string, statusCode: number, headers?: IncomingHttpHeaders | string[] | null, body?: null | Record<string, any> | string);
+    name: 'RequestRetryError';
+    code: 'UND_ERR_REQ_RETRY';
+    statusCode: number;
+    data: {
+      count: number;
+    };
+    headers: Record<string, string | string[]>;
+  }
+  export class SecureProxyConnectionError extends UndiciError {
+    constructor(cause?: Error, message?: string, options?: Record<any, any>);
+    name: 'SecureProxyConnectionError';
+    code: 'UND_ERR_PRX_TLS';
+  }
+  export class ProxyConnectionError extends UndiciError {
+    constructor(cause?: Error, message?: string, options?: Record<any, any>);
+    name: 'ProxyConnectionError';
+    code: 'UND_ERR_PRX_CONN';
+  }
+  export class MaxOriginsReachedError extends UndiciError {
+    name: 'MaxOriginsReachedError';
+    code: 'UND_ERR_MAX_ORIGINS_REACHED';
+  }
+  /** SOCKS5 proxy related error. */
+  export class Socks5ProxyError extends UndiciError {
+    constructor(message?: string, code?: string);
+    name: 'Socks5ProxyError';
+    code: string;
+  }
+  /** WebSocket decompressed message exceeded maximum size. */
+  export class MessageSizeExceededError extends UndiciError {
+    name: 'MessageSizeExceededError';
+    code: 'UND_ERR_WS_MESSAGE_SIZE_EXCEEDED';
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/undici@8.7.0/node_modules/undici/types/dispatcher.d.ts
+type UndiciHeaders = OutgoingHttpHeaders | string[] | Iterable<[string, string | string[] | undefined]> | null;
+/** Dispatcher is the core API used to dispatch requests. */
+declare class Dispatcher extends EventEmitter {
+  /** Dispatches a request. This API is expected to evolve through semver-major versions and is less stable than the preceding higher level APIs. It is primarily intended for library developers who implement higher level APIs on top of this. */
+  dispatch(options: Dispatcher.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean;
+  /** Starts two-way communications with the requested resource. */
+  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void): void;
+  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>): Promise<Dispatcher.ConnectData<TOpaque>>;
+  /** Compose a chain of dispatchers */
+  compose(dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher;
+  compose(...dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher;
+  /** Performs an HTTP request. */
+  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ResponseData<TOpaque>) => void): void;
+  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>): Promise<Dispatcher.ResponseData<TOpaque>>;
+  /** For easy use with `stream.pipeline`. */
+  pipeline<TOpaque = null>(options: Dispatcher.PipelineOptions<TOpaque>, handler: Dispatcher.PipelineHandler<TOpaque>): Duplex;
+  /** A faster version of `Dispatcher.request`. */
+  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>, callback: (err: Error | null, data: Dispatcher.StreamData<TOpaque>) => void): void;
+  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>): Promise<Dispatcher.StreamData<TOpaque>>;
+  /** Upgrade to a different protocol. */
+  upgrade(options: Dispatcher.UpgradeOptions, callback: (err: Error | null, data: Dispatcher.UpgradeData) => void): void;
+  upgrade(options: Dispatcher.UpgradeOptions): Promise<Dispatcher.UpgradeData>;
+  /** Closes the client and gracefully waits for enqueued requests to complete before invoking the callback (or returning a promise if no callback is provided). */
+  close(callback: () => void): void;
+  close(): Promise<void>;
+  /** Destroy the client abruptly with the given err. All the pending and running requests will be asynchronously aborted and error. Waits until socket is closed before invoking the callback (or returning a promise if no callback is provided). Since this operation is asynchronously dispatched there might still be some progress on dispatched requests. */
+  destroy(err: Error | null, callback: () => void): void;
+  destroy(callback: () => void): void;
+  destroy(err: Error | null): Promise<void>;
+  destroy(): Promise<void>;
+  on(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+  on(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  on(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  on(eventName: 'drain', callback: (origin: URL) => void): this;
+  once(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+  once(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  once(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  once(eventName: 'drain', callback: (origin: URL) => void): this;
+  off(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+  off(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  off(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  off(eventName: 'drain', callback: (origin: URL) => void): this;
+  addListener(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+  addListener(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  addListener(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  addListener(eventName: 'drain', callback: (origin: URL) => void): this;
+  removeListener(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+  removeListener(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  removeListener(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  removeListener(eventName: 'drain', callback: (origin: URL) => void): this;
+  prependListener(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+  prependListener(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependListener(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependListener(eventName: 'drain', callback: (origin: URL) => void): this;
+  prependOnceListener(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+  prependOnceListener(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependOnceListener(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependOnceListener(eventName: 'drain', callback: (origin: URL) => void): this;
+  listeners(eventName: 'connect'): ((origin: URL, targets: readonly Dispatcher[]) => void)[];
+  listeners(eventName: 'disconnect'): ((origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  listeners(eventName: 'connectionError'): ((origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  listeners(eventName: 'drain'): ((origin: URL) => void)[];
+  rawListeners(eventName: 'connect'): ((origin: URL, targets: readonly Dispatcher[]) => void)[];
+  rawListeners(eventName: 'disconnect'): ((origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  rawListeners(eventName: 'connectionError'): ((origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  rawListeners(eventName: 'drain'): ((origin: URL) => void)[];
+  emit(eventName: 'connect', origin: URL, targets: readonly Dispatcher[]): boolean;
+  emit(eventName: 'disconnect', origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+  emit(eventName: 'connectionError', origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+  emit(eventName: 'drain', origin: URL): boolean;
+}
+declare namespace Dispatcher {
+  export interface ComposedDispatcher extends Dispatcher {}
+  export type Dispatch = Dispatcher['dispatch'];
+  export type DispatcherComposeInterceptor = (dispatch: Dispatch) => Dispatch;
+  export interface DispatchOptions {
+    origin?: string | URL;
+    path: string;
+    method: HttpMethod;
+    /** Default: `null` */
+    body?: string | Buffer | Uint8Array | Readable | null | FormData;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** Query string params to be embedded in the request URL. Default: `null` */
+    query?: Record<string, any>;
+    /** Whether the requests can be safely retried or not. If `false` the request won't be sent until all preceding requests in the pipeline have completed. Default: `true` if `method` is `HEAD` or `GET`. */
+    idempotent?: boolean;
+    /** Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received. Defaults to `method !== 'HEAD'`. */
+    blocking?: boolean;
+    /** The IP Type of Service (ToS) value for the request socket. Must be an integer between 0 and 255. Default: `0` */
+    typeOfService?: number | null;
+    /** Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`. Default: `method === 'CONNECT' || null`. */
+    upgrade?: boolean | string | null;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. */
+    headersTimeout?: number | null;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use 0 to disable it entirely. Defaults to 300 seconds. */
+    bodyTimeout?: number | null;
+    /** Whether the request should stablish a keep-alive or not. Default `false` */
+    reset?: boolean;
+    /** For H2, it appends the expect: 100-continue header, and halts the request body until a 100-continue is received from the remote server */
+    expectContinue?: boolean;
+  }
+  export interface ConnectOptions<TOpaque = null> {
+    origin: string | URL;
+    path: string;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** Default: `null` */
+    signal?: AbortSignal | EventEmitter | null;
+    /** This argument parameter is passed through to `ConnectData` */
+    opaque?: TOpaque;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+  }
+  export interface RequestOptions<TOpaque = null> extends DispatchOptions {
+    /** Default: `null` */
+    opaque?: TOpaque;
+    /** Default: `null` */
+    signal?: AbortSignal | EventEmitter | null;
+    /** Default: `null` */
+    onInfo?: (info: {
+      statusCode: number;
+      headers: Record<string, string | string[]>;
+    }) => void;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+    /** Default: `64 KiB` */
+    highWaterMark?: number;
+  }
+  export interface PipelineOptions<TOpaque = null> extends RequestOptions<TOpaque> {
+    /** `true` if the `handler` will return an object stream. Default: `false` */
+    objectMode?: boolean;
+  }
+  export interface UpgradeOptions {
+    path: string;
+    /** Default: `'GET'` */
+    method?: string;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** A string of comma separated protocols, in descending preference order. Default: `'Websocket'` */
+    protocol?: string;
+    /** Default: `null` */
+    signal?: AbortSignal | EventEmitter | null;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+  }
+  export interface ConnectData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    socket: Duplex;
+    opaque: TOpaque;
+  }
+  export interface ResponseData<TOpaque = null> {
+    statusCode: number;
+    statusText: string;
+    headers: IncomingHttpHeaders;
+    body: BodyReadable & BodyMixin;
+    trailers: Record<string, string>;
+    opaque: TOpaque;
+    context: object;
+  }
+  export interface PipelineHandlerData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    opaque: TOpaque;
+    body: BodyReadable;
+    context: object;
+  }
+  export interface StreamData<TOpaque = null> {
+    opaque: TOpaque;
+    trailers: Record<string, string>;
+  }
+  export interface UpgradeData<TOpaque = null> {
+    headers: IncomingHttpHeaders;
+    socket: Duplex;
+    opaque: TOpaque;
+  }
+  export interface StreamFactoryData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    opaque: TOpaque;
+    context: object;
+  }
+  export type StreamFactory<TOpaque = null> = (data: StreamFactoryData<TOpaque>) => Writable;
+  export interface DispatchController {
+    get aborted(): boolean;
+    get paused(): boolean;
+    get reason(): Error | null;
+    rawHeaders?: Buffer[] | string[] | IncomingHttpHeaders | null;
+    rawTrailers?: Buffer[] | string[] | IncomingHttpHeaders | null;
+    abort(reason: Error): void;
+    pause(): void;
+    resume(): void;
+  }
+  export interface DispatchHandler {
+    onRequestStart?(controller: DispatchController, context: any): void;
+    onRequestUpgrade?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders, socket: Duplex): void;
+    onResponseStart?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders, statusMessage?: string): void;
+    onResponseData?(controller: DispatchController, chunk: Buffer): void;
+    onResponseEnd?(controller: DispatchController, trailers: IncomingHttpHeaders): void;
+    onResponseError?(controller: DispatchController, error: Error): void;
+    /** Invoked when response is received, before headers have been read. **/
+    onResponseStarted?(): void;
+    /** Invoked when a body chunk is sent to the server. May be invoked multiple times for chunked requests */
+    onBodySent?(chunk: Buffer): void;
+    /** Invoked after the request body is fully sent. */
+    onRequestSent?(): void;
+  }
+  export type PipelineHandler<TOpaque = null> = (data: PipelineHandlerData<TOpaque>) => Readable;
+  export type HttpMethod = Autocomplete<'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH'>;
+  /**
+   * @link https://fetch.spec.whatwg.org/#body-mixin
+   */
+  interface BodyMixin {
+    readonly body?: never;
+    readonly bodyUsed: boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    bytes(): Promise<Uint8Array>;
+    formData(): Promise<never>;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+  }
+  export interface DispatchInterceptor {
+    (dispatch: Dispatch): Dispatch;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/undici@8.7.0/node_modules/undici/types/mock-interceptor.d.ts
+/** The scope associated with a mock dispatch. */
+declare class MockScope<TData extends object = object> {
+  constructor(mockDispatch: MockInterceptor.MockDispatch<TData>);
+  /** Delay a reply by a set amount of time in ms. */
+  delay(waitInMs: number): MockScope<TData>;
+  /** Persist the defined mock data for the associated reply. It will return the defined mock data indefinitely. */
+  persist(): MockScope<TData>;
+  /** Define a reply for a set amount of matching requests. */
+  times(repeatTimes: number): MockScope<TData>;
+}
+/** The interceptor for a Mock. */
+declare class MockInterceptor {
+  constructor(options: MockInterceptor.Options, mockDispatches: MockInterceptor.MockDispatch[]);
+  /** Mock an undici request with the defined reply. */
+  reply<TData extends object = object>(replyOptionsCallback: MockInterceptor.MockReplyOptionsCallback<TData>): MockScope<TData>;
+  reply<TData extends object = object>(statusCode: number, data?: TData | Buffer | string | MockInterceptor.MockResponseDataHandler<TData>, responseOptions?: MockInterceptor.MockResponseOptions): MockScope<TData>;
+  /** Mock an undici request by throwing the defined reply error. */
+  replyWithError<TError extends Error = Error>(error: TError): MockScope;
+  /** Set default reply headers on the interceptor for subsequent mocked replies. */
+  defaultReplyHeaders(headers: IncomingHttpHeaders): MockInterceptor;
+  /** Set default reply trailers on the interceptor for subsequent mocked replies. */
+  defaultReplyTrailers(trailers: Record<string, string>): MockInterceptor;
+  /** Set automatically calculated content-length header on subsequent mocked replies. */
+  replyContentLength(): MockInterceptor;
+}
+declare namespace MockInterceptor {
+  /** MockInterceptor options. */
+  export interface Options {
+    /** Path to intercept on. */
+    path: string | RegExp | ((path: string) => boolean);
+    /** Method to intercept on. Defaults to GET. */
+    method?: string | RegExp | ((method: string) => boolean);
+    /** Body to intercept on. */
+    body?: string | RegExp | ((body: string) => boolean);
+    /** Headers to intercept on. */
+    headers?: Record<string, string | RegExp | ((body: string) => boolean)> | ((headers: Record<string, string>) => boolean);
+    /** Query params to intercept on */
+    query?: Record<string, any>;
+  }
+  export interface MockDispatch<TData extends object = object, TError extends Error = Error> extends Options {
+    times: number | null;
+    persist: boolean;
+    consumed: boolean;
+    data: MockDispatchData<TData, TError>;
+  }
+  export interface MockDispatchData<TData extends object = object, TError extends Error = Error> extends MockResponseOptions {
+    error: TError | null;
+    statusCode?: number;
+    data?: TData | string;
+  }
+  export interface MockResponseOptions {
+    headers?: IncomingHttpHeaders;
+    trailers?: Record<string, string>;
+  }
+  export interface MockResponseCallbackOptions {
+    path: string;
+    method: string;
+    headers?: Headers$1 | Record<string, string>;
+    origin?: string;
+    body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
+  }
+  export type MockResponseDataHandler<TData extends object = object> = (opts: MockResponseCallbackOptions) => TData | Buffer | string;
+  export type MockReplyOptionsCallback<TData extends object = object> = (opts: MockResponseCallbackOptions) => {
+    statusCode: number;
+    data?: TData | Buffer | string;
+    responseOptions?: MockResponseOptions;
+  };
+}
+//#endregion
+//#region ../shared/dist/index.d.ts
+//#endregion
+//#region src/oauth/pkce.d.ts
+interface PkcePair {
+  /** code_verifier：token 交换时回传，向 server 证明授权码的持有者。 */
+  verifier: string;
+  /** code_challenge：S256(verifier)，随 authorize 请求发出。 */
+  challenge: string;
+  /** challenge 方法，固定 'S256'。 */
+  method: 'S256';
+}
+/**
+ * 生成 code_verifier：32 字节随机熵 → base64url（43 字符，
+ * 落在 RFC 7636 要求的 43–128 字符区间内）。
+ */
+declare function generateVerifier(): string;
+declare function generateChallenge(verifier: string): string;
+declare function createPkcePair(): PkcePair;
+declare function generateState(): string; //#endregion
+//#region src/oauth/loopback-server.d.ts
+interface LoopbackServerOptions {
+  ports?: number[];
+  callbackPath?: string;
+  expectedState?: string;
+  host?: string;
+  signal?: AbortSignal;
+}
+interface LoopbackCallback {
+  code: string;
+  state?: string;
+}
+interface LoopbackServer {
+  readonly port: number;
+  readonly redirectUri: string;
+  waitForCallback(): Promise<LoopbackCallback>;
+  close(): Promise<void>;
+}
+declare function startLoopbackServer(options?: LoopbackServerOptions): Promise<LoopbackServer>; //#endregion
+//#region src/oauth/browser.d.ts
+/**
+ * 用操作系统默认浏览器打开 URL。
+ * 跨平台：macOS→`open`、Windows→`start`、Linux→`xdg-open`。
+ * 失败静默吞错（不抛），返回 boolean 表示是否成功启动。
+ */
+//#endregion
+//#region src/oauth/jwt.d.ts
+/**
+ * JWT claim 提取：独立于 PKCE/device-flow/loopback 的通用编码原语。
+ */
+/**
+ * 从多个 JWT token 中提取某个字符串 claim。
+ *
+ * 提取规则：
+ * - 先查命名空间 `claims[namespace]?.[claim]`，未命中回退顶层 `claims[claim]`
+ * - 按 `tokenSources` 数组顺序逐个 token 尝试，任一命中即返回
+ * - 解析失败（非 JWT 格式/不透明 token）静默返回 `undefined`
+ *
+ * @param tokens - 待扫描的 JWT token 数组（如 `[idToken, accessToken]`）
+ * @param claim - 目标 claim key
+ * @param namespace - 可选命名空间前缀（如 `https://api.openai.com/auth`）
+ * @returns 提取到的 claim 值，或 `undefined`
+ */
+declare function extractJwtClaim(tokens: Array<string | undefined>, claim: string, namespace?: string): string | undefined;
+//#endregion
+//#region src/oauth/templates.d.ts
+interface PKCEOAuthTemplateParams {
+  /** OAuth provider id（同 `OAuthProvider.id`）。 */
+  id: string;
+  /** 显示名（同 `OAuthProvider.name`）。 */
+  name: string;
+  clientId: string;
+  authorizeUrl: string;
+  tokenUrl: string;
+  redirectUri: string;
+  scope: string;
+  /**
+   * loopback 自动回填端口列表（按序回退）；缺省/空 → 纯手动粘贴。
+   * 对齐 Anthropic 的 54545 白名单端口机制与 Codex 的 [1455,1457] 多端口。
+   */
+  loopbackPorts?: number[];
+  /**
+   * loopback 是否假定始终可用、不提供手动粘贴兜底。
+   * `false`（缺省，对齐 Anthropic）= 端口被占时降级手动粘贴框；
+   * `true`（对齐 Codex）= 假设 loopback 始终可用，要求 `loopbackPorts` 非空。
+   */
+  assumesLoopbackAlways?: boolean;
+  /** authorize URL 额外的 query 参数（如 Codex 的 `id_token_add_organizations`）。 */
+  extraAuthParams?: Record<string, string>;
+  /** token 端点请求体编码：'json'（对齐 Anthropic）| 'form'（对齐 Codex，缺省）。 */
+  tokenExchangeEncoding?: 'json' | 'form';
+  /** 该 OAuth token 是否绑定产品订阅。 */
+  subscriptionScoped?: boolean;
+  /** 以 OAuth token 调用 API 时附带的 beta 头。 */
+  oauthBeta?: string;
+}
+interface DeviceFlowOAuthTemplateParams {
+  /** OAuth provider id。 */
+  id: string;
+  /** 显示名。 */
+  name: string;
+  clientId: string;
+  /**
+   * 设备授权码端点 URL 模板，`{domain}` 占位符在运行时替换为用户输入的域名。
+   * 示例：`https://{domain}/login/device/code`
+   */
+  deviceCodeUrlTemplate: string;
+  /**
+   * 轮询 access token 端点 URL 模板，`{domain}` 替换规则同上。
+   * 示例：`https://{domain}/login/oauth/access_token`
+   */
+  tokenUrlTemplate: string;
+  /**
+   * refresh token 端点 URL 模板（可选：不存在时使用内置默认推导）。
+   * 示例：`https://api.{domain}/copilot_internal/v2/token`
+   */
+  refreshUrlTemplate?: string;
+  scope: string;
+  /** 是否提示用户输入自定义域名（对齐 Copilot 企业域覆盖）。 */
+  allowCustomDomain?: boolean;
+  /** 请求头 User-Agent（部分厂商强制校验）。 */
+  userAgent?: string;
+}
+/**
+ * `PKCEOAuthTemplate(params)` 返回一个 PKCE S256 OAuth 实例。
+ *
+ * 行为与终态参数由 `PKCEOAuthTemplateParams` 完全控制：
+ * - loopback 端口按列表顺序回退（`assumesLoopbackAlways:true` 时不提供手动粘贴兜底）
+ * - authorize URL 上拼装额外 query 参数（`extraAuthParams`）
+ * - token 端点请求体编码由 `tokenExchangeEncoding` 决定（`json` vs `form`）
+ *
+ * 插件声明式 OAuth（`kind: 'pkce'`，如 anthropic/openai-codex）与内置 provider 均委托本模板。
+ */
+declare function PKCEOAuthTemplate(params: PKCEOAuthTemplateParams): OAuthProvider;
+/**
+ * `DeviceFlowOAuthTemplate(params)` 返回一个 Device Flow OAuth 实例。
+ *
+ * 行为由 `DeviceFlowOAuthTemplateParams` 控制：
+ * - `allowCustomDomain:true` 时登录流程提示用户输入域名（企业域覆盖）
+ * - 三处端点模板各自独立 `{domain}` 插值（device code / access token / refresh）
+ * - 可选 `userAgent` 头（部分厂商校验）
+ *
+ * 插件声明式 OAuth（`kind: 'device-flow'`，如 GitHub Copilot）委托本模板。
+ */
+declare function DeviceFlowOAuthTemplate(params: DeviceFlowOAuthTemplateParams): OAuthProvider;
+//#endregion
+//#region src/openai-usage.d.ts
+/**
+ * 从标准 `x-ratelimit-*` 响应头中解析 usage 快照——**厂商无关**（终局架构 review
+ * 2026-07-21：函数名历史上带 "OpenAi" 后缀，但实现只解析 RFC 标准头族，对任何
+ * OpenAI 兼容 provider（DeepSeek/groq/openrouter 等）同样适用，无厂商专属逻辑）。
+ *
+ * 可靠部分（有官方文档）：
+ *   - standardLimits：x-ratelimit-* 标准 API 限流头（任何认证方式都返回）
+ *
+ * 不可靠（无 HTTP 头对应）：
+ *   - 订阅池 status/resetsAt/usedPercent/limitType — 全设为 undefined / 'unknown'
+ *   - overage — OpenAI 无此概念，undefined
+ *
+ * Header dump：debug 级别输出全部响应头 key+value，供实证分析。
+ */
+declare function extractStandardRateLimitHeaders(headers: Headers | undefined): ProviderUsageSnapshot | null;
+/**
+ * @deprecated 改名为 {@link extractStandardRateLimitHeaders}（终局架构 review
+ * 2026-07-21：函数只解析厂商无关的标准 x-ratelimit-* 头族，"OpenAi" 后缀具有误导性）。
+ * 保留别名过渡，下个大版本移除。
+ */
+declare const extractProviderUsageFromOpenAiHeaders: typeof extractStandardRateLimitHeaders;
+//#endregion
+//#region src/stream-errors.d.ts
+/**
+ * 上下文溢出（413 / "prompt too long" 类）——本轮请求因上下文超限被服务端拒绝。
+ * 与一般可重试错误（429/5xx/断连）不同：重发同样请求仍会失败，必须先压缩上下文。
+ */
+declare function isContextOverflowError(error: unknown): boolean;
+type StreamErrorClass = 'context-overflow' | 'image-constraint' | 'retryable' | 'fatal';
+/**
+ * Anthropic unified rate limit 头族解析。
+ * 从 429 响应的 anthropic-ratelimit-unified-* 头族判定是否硬额度耗尽（rejected）。
+ * 瞬时 429（无 unified 头）返回 null——仍可退避重试。
+ *
+ * RFC-148 M4 已知边界（原计划迁出 extensions/plugin-otto-wire-protocols，执行时发现不可行）：
+ * `packages/agent/src/work-loop-stream-error.ts` 与本文件的 `classifyStreamError` 均
+ * 直接调用本函数——`packages/agent` 是引擎最核心包，不可依赖 `extensions/` 插件目录
+ * （会破坏"引擎核心零外部插件依赖"的分层边界，比厂商知识残留更严重的架构违例）。
+ * 保留在协议中立层的依据：本函数是纯 HTTP 头名解析（零 SDK 依赖、零网络调用），符合
+ * "多方可复用的协议中立原语"判据的弱形式——即便目前只有 Anthropic 一家使用这个
+ * `anthropic-ratelimit-unified-*` 头族约定，它不携带任何 SDK 调用或厂商专属业务逻辑，
+ * 与已随协议实现迁出的 `anthropic-usage.ts`（`extractProviderUsageFromHeaders`，
+ * 同头族的成功路径解析）不同——那个只被单一协议实现消费，此函数被引擎核心跨包直接消费。
+ */
+declare function extractAnthropicRateLimit(error: unknown): {
+  status: 'rejected' | 'allowed_warning';
+  type?: 'five_hour' | 'seven_day' | 'seven_day_opus' | 'seven_day_sonnet' | 'seven_day_overage_included';
+  resetsAt?: number;
+} | null;
+/**
+ * 流错误分类，决定 work-loop 的恢复策略。
+ * - `image-constraint`：400 + 图片维度/数量/大小超限（D7）——图片降级后重试。
+ * - `context-overflow`：先压缩再重试（见 isContextOverflowError / H3）。
+ * - `retryable`：429 / 5xx / 网络断连——丢弃 partial、退避后**重发整请求**。
+ * - `fatal`：其它 4xx（鉴权/无效参数等）——重发无益，直接上抛。
+ *
+ * 顺序：先判 image-constraint（400+文案）→ overflow（413 / 400+文案）→ retryable → fatal。
+ * image-constraint 必须在 isContextOverflowError 之前检查，防未来 Anthropic 文案改成
+ * "exceeds the maximum..." 被 overflow 正则抢分类。
+ */
+/**
+ * 是否为「网络断连」子类的可重试错误（ECONNRESET/socket hang up/terminated 等，或
+ * PROVIDER_INCOMPLETE_STREAM/PROVIDER_STREAM_ERROR 传输层代码）——不含 429/5xx 状态码类。
+ * 用于 work-loop-stream-error.ts 按错误子类选择重试节奏：网络断连走固定间隔（给对端/代理
+ * 恢复时间），429/5xx 保留指数退避 + Retry-After 头（限流场景需要快速恢复，不应被拖慢）。
+ * 仅在 classifyStreamError(error) === 'retryable' 时调用才有意义。
+ *
+ * 范围说明（终局 review 澄清）：本判定复用整个 TRANSIENT_NETWORK_PATTERNS（不止新增的
+ * terminated/other side closed）——econnreset/socket hang up/fetch failed/premature close/
+ * connection closed 等均属于同一「连接被动中断」语义类别，一并归入固定 30s 节奏是有意的架构
+ * 决策（而非本次改动的范围蔓延），回归测试见 stream-errors.test.ts 对多个既有模式的覆盖。
+ * 有明确 4xx/5xx 状态码的错误（含 overloaded 类，多数 provider 会带 529/503）永远不会走到这里
+ * ——上方 status 门控优先短路返回 false，继续用调用方的指数退避 retryCfg。
+ *
+ * 例外（review 发现的 bug 修复）：流内（mid-stream SSE `event: error`）限流/过载帧 status 为
+ * undefined，若不特殊处理会被 TRANSIENT_NETWORK_PATTERNS 的 `/overloaded/i` 误收编成"网络断连"，
+ * 错误地走 30s 固定节奏——这类错误语义上是「服务端限流信号」，应沿用调用方传入的指数退避
+ * retryCfg（classifyStreamError 已将其分类为 retryable）。故此处优先检查
+ * IN_STREAM_RATE_LIMIT_PATTERNS，命中则直接返回 false（非网络断连）。
+ */
+declare function isNetworkDisconnectError(error: unknown): boolean;
+/**
+ * 是否为鉴权失败类错误（本地无凭据 / 服务端 401 拒绝 / OAuth 刷新失败）——`fatal` 分类下的
+ * 一个子类，供上层（work-loop-stream-error.ts）区分"认证失效"与其他不可重试错误，记录专门的
+ * 结构化事件（供用户事后追溯"什么时候、哪个 provider、失效了几次"，此前完全零记录）。
+ *
+ * 三种触发源：
+ * - `code === 'PROVIDER_AUTH_MISSING'`：本地压根没有可用凭据（resolveKey/resolveAuthCredential
+ *   在请求发起前就抛出，具体 resolveKey 实现见各协议插件——RFC-148 M2 后 anthropic-messages/
+ *   openai-responses/openai-completions 已迁至 extensions/plugin-otto-wire-protocols/src/，
+ *   github-copilot 在 extensions/plugin-github-copilot/src/provider.ts）。
+ * - `code === 'PROVIDER_AUTH_REFRESH_FAILED'`（RFC-137 D5）：本地**确实持有** oauth 类型
+ *   凭据，但 OAuth token 刷新流程本身失败（含跨进程锁等待超时后的失败，见
+ *   `auth-store.ts` 的 `refreshOAuthWithCrossProcessLock`）——与"从未配置凭据"是完全不同
+ *   的语义，但同样需要走 auth 错误的记录+自动重试路径（RFC-137 D4，`work-loop-stream-error.ts`
+ *   据此对"首次遇到"的这类错误自动重试一次）。**遗漏这一行会让 D4 的自动重试逻辑永远不会
+ *   被触发**——`classifyStreamError` 会把未识别的错误码归为普通 `'fatal'`，直接 rethrow，
+ *   跳过下面的记录与重试分支（RFC-137 独立评审 C1 finding）。
+ * - `status === 401`：服务端拒绝了已提供的凭据（token 过期/被吊销/权限不足），这是真实的
+ *   "登录态失效"场景——请求已经发出，服务端明确回了 401。
+ */
+declare function isAuthError(error: unknown): boolean;
+/**
+ * RFC-139 D3：鉴权失效根因分类（供 `stream.auth-failed` trace 事件记录机器可读细分）。
+ * 与 `isAuthError` 同源判别（同一 code/status 提取），避免两处分类漂移。
+ *
+ * - `credential-missing`：本地无可用凭据（PROVIDER_AUTH_MISSING）——包括"凭据条目被
+ *   外部删除后经 fs.watch 传播"的场景（RFC-139 事故根因正是此类，65/65 条 trace）。
+ * - `refresh-failed`：本地持有 oauth 凭据但刷新失败（PROVIDER_AUTH_REFRESH_FAILED，RFC-137）。
+ * - `server-rejected`：服务端拒绝已提供的凭据（401）；**无 code 的 raw 401**（如
+ *   Anthropic SDK 直抛的 AuthenticationError，不经 ProviderError 包装）也归此类
+ *   （RFC-139 对抗评审 P1：extractCode 返回 undefined 时的回退分支）。
+ *
+ * 前置约定：调用方已用 `isAuthError` 判真后才调用本函数；对非 auth 错误返回
+ * `server-rejected` 兜底（不抛错，分类器不承担守卫职责）。
+ */
+type AuthErrorType = 'credential-missing' | 'refresh-failed' | 'server-rejected';
+declare function classifyAuthErrorType(error: unknown): AuthErrorType;
+declare function classifyStreamError(error: unknown): StreamErrorClass;
+/**
+ * 从错误链上取 `Retry-After`（秒）或 `retry-after-ms`（毫秒）头，返回毫秒。
+ * 仅处理数值形式（最常见）；HTTP-date 形式返回 undefined 交由退避计算。
+ */
+declare function extractRetryAfterMs(error: unknown): number | undefined;
+//#endregion
+//#region src/recording/stream-recording.d.ts
+interface RecordingHeader {
+  version: 1;
+  modelId: string;
+  api: string;
+  recordedAt: string;
+  contextWindow: number;
+}
+interface RecordingLine {
+  /** 相对首事件的毫秒偏移。 */
+  t: number;
+  e: StreamEvent;
+}
+interface Recording {
+  header: RecordingHeader;
+  events: RecordingLine[];
+}
+/** 录制目录（OTTO_HOME/recordings；权限 0o700——含对话内容的敏感数据）。 */
+declare function recordingsDir(ottoHome: string): string;
+/**
+ * 包装一个 StreamEvent 异步迭代器，把事件透传的同时 append 到 JSONL 录制文件。
+ * 透传零延迟——写盘是 fire-and-forget（WriteStream 内部缓冲），不阻塞流消费。
+ */
+declare function recordStream(source: AsyncIterable<StreamEvent>, model: Model, filePath: string): AsyncIterable<StreamEvent>;
+/** 读取并解析录制文件（header + 事件序列）。 */
+declare function loadRecording(filePath: string): Promise<Recording>;
+interface ReplayOptions {
+  /**
+   * true = 零间隔快放（测引擎开销的正确模式——原相对间隔含录制时 LLM 推理延迟的幽灵，
+   * 只适合端到端对照，不适合引擎开销基准；RFC-200 评审修订 7）。
+   */
+  fast?: boolean;
+}
+/** 按录制内容重放 StreamEvent 序列（默认按原相对间隔；fast 模式零间隔）。 */
+declare function replayStream(recording: Recording, options?: ReplayOptions, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+//#endregion
+//#region src/recording/replay-provider.d.ts
+declare const REPLAY_API = "replay";
+/** 从录制 header 派生重放 Model 条目（与 factory 成对注册进 registry）。 */
+declare function buildReplayModel(recording: Recording): Model;
+declare class ReplayProviderStream implements ProviderStream {
+  private readonly filePath;
+  private readonly options;
+  readonly id = "replay";
+  readonly displayName = "Replay Provider (RFC-200)";
+  private recording;
+  constructor(filePath: string, options?: ReplayOptions);
+  /** 预载录制（可选——converse 首次调用也会惰性加载；bench 场景预载可把 IO 摘出计时窗）。 */
+  preload(): Promise<Recording>;
+  converse(_model: Model, _context: StreamContext, options: StreamOptions, signal: AbortSignal): AsyncIterable<StreamEvent>;
+}
+declare function createReplayProviderFactory(filePath: string, options?: ReplayOptions): () => ProviderStream;
+//#endregion
+export { type Api, type AssistantContent, type AssistantMessage, type AssistantMessageMeta, type AuthErrorType, type AuthMode, type CacheRetention, type ChatCompletionsStreamParams, type ContentPart, DeviceFlowOAuthTemplate, type DeviceFlowOAuthTemplateParams, type FlatStreamState, type FlatToolCallAcc, type ImageContent, type LoopbackCallback, type LoopbackServer, type LoopbackServerOptions, type Message, type Model, type OAuthCredentials, type OAuthInfo, type OAuthLoginOptions, type OAuthPrompt, type OAuthProvider, type OAuthProviderFactory, type OAuthProviderId, type OAuthRefreshTokenOptions, PKCEOAuthTemplate, type PKCEOAuthTemplateParams, type PkcePair, type Provider, type ProviderFactory, type ProviderStream, REPLAY_API, type Recording, type RecordingHeader, type RecordingLine, type ReplayOptions, ReplayProviderStream, type RequestHeaderSources, type ResolvedAuth, type StopReason, type StreamBlock, type StreamContext, type StreamErrorClass, type StreamEvent, type StreamFunction, type StreamOptions, type StreamUsage, type SystemPromptSegment, type TextContent, type ThinkingContent, type TokenDerivedHeader, type ToolCall, type ToolDefinition, type ToolResultMessage, type UserMessage, type WireProtocolFactoryInput, type WireProtocolLogger, type WireProtocolMeta, type WireProtocolRegistration, type WireRequestCustomization, type WireRequestCustomizeInput, type WireSystemTextBlock, assembleAssistantMessage, assertSystemNotificationPlacement, blocksContent, buildChatCompletionsBody, buildChatCompletionsMessages, buildReplayModel, buildRequestHeaders, clampThinkingLevel, classifyAuthErrorType, classifyStreamError, createPkcePair, createReplayProviderFactory, degradedSystemNotificationText, extractAnthropicRateLimit, extractJwtClaim, extractProviderUsageFromOpenAiHeaders, extractRetryAfterMs, extractStandardRateLimitHeaders, flatContent, generateChallenge, generateState, generateVerifier, hasTrailingInvokeXml, initFlatStreamState, initStreamUsage, isAuthError, isContextOverflowError, isNetworkDisconnectError, loadRecording, mapChatFinishReason, mergeConsecutiveSystemNotifications, parseToolArguments, parseToolArgumentsWithStatus, recordStream, recordingsDir, recoverLiteralInvokeToolCalls, registeredToolNames, replayStream, sanitizeSurrogates, sanitizeToolRoundtrips, startLoopbackServer, streamChatCompletions, toJsonSchema, toolCallFromParsed };
+//# sourceMappingURL=index.d.ts.map