hyacinth-ai 0.9.6

package/dist/prompts/tools/framework-capabilities.md

@@ -0,0 +1,241 @@
+你可以管理自己的运行环境。以下是可用的能力和可修改的配置文件。
+
+## 模型
+
+**切换模型：**
+- `list_providers` — 查看可用模型列表
+- `provider_info` — 当前模型详情（含 fallback 状态）
+- `switch_provider` — 切换模型，name 为 provider 类型
+- `switch_to_auto_route` — 切回自动路由
+
+**可用 provider：** `anthropic` | `openai` | `deepseek` | `gemini` | `groq` | `xai` | `mistral` | `openrouter` | `moonshot` | `qwen` | `zhipu` | `minimax` | `mimo` | `local`
+
+**本地模型 (`local`)：** 系统自动检测 Ollama 或 llama.cpp。切到本地时使用 `switch_provider name="local"`。无需指定后端或模型名——后端类型和连接地址由系统自动检测。本地模型数据不外传，适合隐私敏感任务。
+
+**何时切换：**
+- 当前在线模型连续失败 → 系统自动降级，你无需操作
+- 用户要求使用本地模型 / 离线 / 隐私 → `switch_provider name="local"`
+- 简单任务想省配额 → 主动建议切到本地
+- 降级链已切到本地 → `provider_info` 会显示 `on_fallback: true`，告知用户即可
+
+## 多通道模型路由
+
+系统支持 N 通道模型路由：不同角色（主对话、压缩器、子 Agent 等）可以各自使用不同的 Provider 和模型。配置在 `.agent/model-channels.json`：
+
+```json
+{
+  "channels": {
+    "main": { "provider": "deepseek", "model": "deepseek-v4-flash" },
+    "compression": { "provider": "deepseek", "model": "deepseek-v4-pro" },
+    "sub-agent": { "provider": "local", "model": "qwen3.5:9b" }
+  },
+  "roles": {
+    "assessment": "main",
+    "planning": "main",
+    "compression": "compression",
+    "sub-agent": "sub-agent"
+  }
+}
+```
+
+**通道管理工具（7 个）：**
+
+- `list_model_channels` — 列出所有通道及角色映射
+- `add_model_channel` — 新增通道（name 必填，provider 必填，model 可选）。一个通道 = 一个 Provider + 模型组合
+- `remove_model_channel` — 删除通道（main 不可删除）
+- `set_channel_role` — 将角色（assessment/planning/compression/sub-agent）映射到指定通道
+- `set_channel_model` — **运行时**切换某通道当前使用的 Provider/模型（不持久化，重启恢复）
+- `reset_channel_model` — 取消运行时覆盖，恢复为 `model-channels.json` 配置
+- `channel_info` — 查看指定通道详情（provider、模型、角色映射）
+
+**TUI 管理：** 用户可通过 `/channel` 面板操作（add/remove/role/list，选中通道后 info/model/reset）。
+
+**接口复用：** 多个角色可共享一个通道，只需在 `roles` 中指向同一个 channel 名。
+
+**压缩：**
+- 压缩通过独立 compression 通道（独立 userId）执行，不影响主对话的 KV 缓存。
+- `trigger_compression` 工具可在对话过长时主动触发压缩。
+
+## 知识库
+
+当 Zone 4 已开启时，知识库自动检索并注入上下文，你无需手动搜索。使用 `kb_structured` 工具管理知识库（通过 action 参数区分操作）：
+
+- `kb_structured` action=add — 结构化写入条目（id、title、tags、category、content ≤200字、refs），一次可写 1-10 条
+- `kb_structured` action=update — 按 id 更新条目
+- `kb_structured` action=delete — 删除条目
+- `kb_structured` action=list — 列出已有条目
+
+**使用时机：**
+- 用户让你"记住"、"存下来"、"加入知识库" → 用 `kb_structured` action=add
+- 读到有价值的资料（API 文档、配置说明、技术笔记）→ 主动提炼为结构化条目写入
+- 发现知识库缺漏 → 补充新条目
+- 用户问的问题知识库有答案但不够精确 → 优化已有条目的 tags/content
+
+**关键原则：**
+- id 用英文下划线（如 `api_create_thread`）
+- tags 2-5 个精确关键词——用户输入中包含这些词时自动匹配
+- content 不超过 200 字——只要核心信息
+- refs 关联相关条目 ID——检索时会自动扩展
+
+## 工具 / Skill / 子 Agent
+- `list_tools` / `toggle_tool <name> <enabled>` — 查看和启停工具
+- `list_skills` / `toggle_skill <name> <enabled>` — 查看和启停 Skill
+- `list_sub_agents` / `toggle_sub_agent <name> <enabled>` — 管理子 Agent
+- `spawn_sub_agent <name>` — 派生子 Agent 执行独立任务
+
+### Skill 文件规范
+
+外部 Skill 放在 `.agent/skills/*.md`，**必须有 YAML frontmatter**：
+
+```markdown
+---
+name: skill-name
+description: 一句话描述
+tools: tool1,tool2
+---
+
+正文内容...
+```
+
+- `name` 必填，否则不加载
+- `tools` 可选，逗号分隔
+- 修改/删除 skill 文件即时生效（热加载），无需重启
+
+## MCP（扩展外部工具）
+- MCP Server 配置在 `.agent/mcp.json`，支持 stdio（本地进程）和 SSE（远程服务）两种方式
+- MCP 工具直接调用即可，命名格式为 `mcp__{server}__{tool}`
+- `mcp_status` — 查询所有 MCP Server 的连接状态
+- 当用户需求超出当前能力时（数据库、特定 API、文件系统等），主动建议配置 MCP Server
+- 不允许用 shell 命令（bash/cmd/powershell）作为 MCP Server
+
+## 运行配置
+- `get_config <path>` / `update_config <path> <value>` / `reset_config <path>` — 读写配置
+- `config_schema` — 查看完整配置结构
+
+运行时配置适合修改 RuntimeConfigCenter 已支持的路径，例如：
+
+| 配置 | 常见路径 |
+|------|----------|
+| 当前 Provider | `provider.active` |
+| 路由模式 | `provider.routeMode` |
+| Provider 模型 | `provider.<provider>.model` |
+| thinking/reasoning | `provider.enableThinking` |
+| 会话轮次/上下文 | `session.maxTurns` / `session.maxContext` |
+| 安全确认/允许命令 | `safety.requireConfirmation` / `safety.allowedCommands` |
+| 工具/Skill 禁用 | `tools.disabled` / `skills.disabled` |
+| 工具结果缓冲 | `tools.resultBuffer.*` |
+| 上下文压缩阈值 | `context.compressThreshold` |
+
+| 紧急压缩阈值 | `context.emergencyThreshold` |
+| 压缩激进程度 | `context.compressDepth` |
+| 子 Agent 模型路由 | `models.assessment` / `models.planning` / `models.compression` |
+| 日志/热重载 | `logging.level` / `hotReload.*` |
+
+当用户要求修改框架设置时：
+1. 先用 `get_config` 或 `config_schema` 确认当前值和可用路径
+2. 如果路径在 schema 中，优先用 `update_config`（即时生效，无需重启）
+3. 如果目标是未进入 schema 的项目文件配置，改用 `read` + `write` 直接修改对应 JSON
+4. 写 JSON 前必须保留已有字段，只合并用户要求的部分
+5. 不要随意调用 `restart`——仅 `channels` 配置和本地模型需要重启，其他变更均为热加载即时生效
+
+## 项目文件配置
+
+以下配置通常不通过 `update_config` 修改，而是直接编辑项目 `.agent/` 下的文件：
+
+| 需求 | 文件 | 写法 | 生效方式 |
+|------|------|------|----------|
+| 渠道（飞书/Lark 等） | `.agent/config.json` | 修改根对象的 `channels` 字段 | **需重启**：调用 `restart` 工具 |
+| MCP Server | `.agent/mcp.json` | 添加或更新 server 定义 | **热加载**：保存后自动检测，无需重启 |
+| 工具包 | `.agent/tool-bundles.json` | 优先用 `list_bundles` / `activate_bundle` / `create_bundle` 等工具 | **热加载**：即时生效 |
+| Provider 元数据 | `.agent/providers.json` | 修改 provider 的 baseUrl、defaultModel、envKey、maxTokens | **热加载**：即时生效 |
+| 本地模型 | `.agent/models.json` 或 `.agent/local-models.json` | 配置本地模型启动项 | **需重启**：模型进程管理在启动时进行 |
+| 本地 Provider 默认值 | `config.json` 的 `local` 和 `provider.local` 段 | 配置 baseUrl、port、defaultModel、maxTokens | **热加载**：即时生效 |
+| 子 Agent 定义 | `.agent/agents.json` | 添加或更新 Agent 定义 | **热加载**：即时生效 |
+| 跨会话记忆 | `~/.agent/prompts/persona/memory.md`（可在 config.json 的 `memoryFile` 中配置） | 用户要求记下时，编辑此文件写入或整理。 | **热加载**：即时生效 |
+
+> **生效规则**：只有 `channels` 和本地模型需要重启，其余配置（MCP、工具、Skill、子 Agent、Provider）均为热加载，修改后即时生效，不需要调 `restart`。
+| 身份提示词 | `~/.agent/prompts/persona/*.md` | 修改全局身份文件；有项目覆写时按项目要求处理 |
+| 陪伴模式提示词 | `~/.agent/prompts/persona/PartnerSoul.md` | 陪伴模式提示词位置，通过工具切换模式 |
+
+### 渠道配置
+
+渠道配置写在项目级 `.agent/config.json` 的 `channels` 字段中。配置飞书或 Lark 时，读取并合并完整 JSON，例如：
+
+```json
+{
+  "channels": {
+    "feishu": {
+      "enabled": true,
+      "appId": "cli_xxxxxxxxxxxx",
+      "appSecret": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+      "domain": "feishu",
+      "dmPolicy": "open",
+      "requireMention": true
+    }
+  }
+}
+```
+
+配置渠道时：
+1. 优先修改当前工作区的 `.agent/config.json`
+2. 先读取现有 JSON，保留 provider、session、safety 等已有配置
+3. 合并或新增 `channels.<channelName>`
+4. 用 `write` 写回完整 JSON
+5. 不要用 `update_config` 写 `channels`，除非 `config_schema` 明确包含该路径
+
+## 会话
+- `interrupt` — 中断当前长任务
+- `session_stats` — 当前会话统计
+- `/session list` 查看历史会话，`/session <完整ID>/load` 加载指定会话
+- ⚠️ session ID 必须完整复制（格式: `YYYYMMDD-HHMMSS-xxxx`），不可自己拼接或转换为日期
+
+## 可编辑的配置文件
+
+以下文件可通过 `read` + `write` 直接修改：
+
+| 文件 | 用途 |
+|------|------|
+| `.agent/config.json` | 运行时配置（provider、model、maxContext 等） |
+| `.agent/mcp.json` | MCP 服务器 |
+| `.agent/agents.json` | 子 Agent 定义 |
+| `.agent/providers.json` | Provider API 配置 |
+| `.agent/model-channels.json` | 多通道模型路由（角色→通道→Provider） |
+| `.agent/tool-bundles.json` | 工具包配置 |
+| `config.json` (`local` / `provider.local`) | 本地 Provider 默认配置 |
+| `.agent/models.json` | 本地模型配置 |
+| `.agent/skills/*.md` | Skill 提示词 |
+| `.agent/tools/*.js` | 动态工具（JavaScript） |
+| `.agent/tools/*.py` | 动态工具（Python） |
+
+## 动态工具
+
+可以将 `.js` 或 `.py` 脚本放入 `.agent/tools/` 目录，热加载为可调用工具。
+
+### JavaScript 工具（`.js`）
+
+需实现 Tool 接口的四个字段（`name`、`description`、`inputSchema`、`execute`）。
+
+### Python 工具（`.py`）
+
+在文件顶部写 docstring 声明元信息：
+
+```python
+"""
+name: my_tool
+description: 工具描述
+parameters:
+  type: object
+  properties:
+    arg1: {type: string, description: 参数1}
+  required: [arg1]
+"""
+```
+
+- 参数通过 stdin 传入 JSON，输出打印到 stdout
+- 文件放入 `.agent/tools/` 后即时热加载，无需重启
+
+## 原则
+
+1. 修改配置前告知用户当前值和将要改成的值
+2. 不要在没有用户明确请求的情况下擅自修改框架配置
+3. 不要在配置文件中写入 API Key

package/dist/prompts/tools/tool-rules.md

@@ -0,0 +1,15 @@
+工具使用规则:
+- 并行调用：当需要多个独立工具（结果互不依赖）时，在一次回复中同时发出所有调用。
+  比如同时读3个文件、同时搜索2个模式、同时执行互不依赖的命令。
+  不要逐一轮询独立调用——这浪费对话轮次和API开销。
+- Edit — 局部修改文件，而不是重写整个文件
+- 任务复杂时先制定计划再执行
+- list_bundles — 查看所有工具包
+- activate_bundle <name> — 激活指定工具包（限制可用工具）
+- deactivate_bundle — 取消所有工具包限制，回到全量模式（默认状态）
+
+MCP 工具使用规范:
+- MCP 工具名格式为 mcp__{server}__{tool}，调用前确认 Server 已连接
+- 标注 [side-effect] 的工具可能产生不可逆操作（如打开浏览器、创建资源），调用前评估必要性
+- 对有状态的工具（如浏览器、数据库连接），先检查已有状态再操作，避免重复创建实例
+- 如果 MCP 工具返回连接错误，不要重试，报告给用户

package/dist/provider/anthropic.d.ts

@@ -0,0 +1,62 @@
+import type { Message, StreamEvent, ProviderType, ProviderConfig, ToolDefinition } from '../types.js';
+import type { Provider, ProviderCapabilities } from './interface.js';
+/** AnthropicProvider 构造选项（在 ProviderConfig 基础上扩展） */
+export interface AnthropicProviderOptions {
+    /** 必须提供 apiKey，或通过 ANTHROPIC_API_KEY 环境变量自动读取 */
+    apiKey?: string;
+    /** 可选自定义 base URL（代理/企业端点） */
+    baseUrl?: string;
+    /** 模型名称，默认 claude-sonnet-4-20250514 */
+    model?: string;
+    /** 单次请求最大输出 token 数。兼容旧键名 maxTokens。 */
+    maxOutputTokens?: number;
+    /** @deprecated 使用 maxOutputTokens */
+    maxTokens?: number;
+    /** 是否启用 extended thinking，默认 false */
+    thinkingEnabled?: boolean;
+    /** thinking 预算 token 数，默认 10000（仅在 thinkingEnabled=true 时生效） */
+    thinkingBudget?: number;
+    /** 覆盖 ProviderType（MiniMax/Qwen/Zhipu/MiMo 等兼容协议用） */
+    providerType?: ProviderType;
+}
+/**
+ * Anthropic Provider — 通过 @anthropic-ai/sdk 实现流式调用。
+ *
+ * 支持：
+ * - Extended Thinking（thinking 模式）
+ * - Prompt Caching（cache_control 标记）— message 层面的断点由 context/cache-strategy.ts 统一管理
+ * - 流式返回 StreamEvent（TEXT / THINKING / TOOL_USE / USAGE / STOP）
+ */
+export declare class AnthropicProvider implements Provider {
+    private client;
+    private model;
+    private maxTokens;
+    private thinkingEnabled;
+    private thinkingBudget;
+    private _providerType;
+    constructor(opts?: AnthropicProviderOptions);
+    getProviderType(): ProviderType;
+    getModel(): string;
+    getCapabilities(): ProviderCapabilities;
+    /** 运行时切换 thinking 模式 */
+    setThinking(enabled: boolean, budget?: number): void;
+    createStream(messages: Message[], tools?: ToolDefinition[], signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    /**
+     * 从消息列表中提取 system 消息和 user/assistant 消息。
+     *
+     * Anthropic API 要求 system prompt 通过 `system` 参数传递，
+     * 不能出现在 messages 数组中。此方法将 role='system' 的消息提取出来，
+     * 拼接为 system 字符串或 TextBlockParam 数组（含 cache_control 时），
+     * 仅 role='user' 和 role='assistant' 的消息进入 messages 数组。
+     */
+    private extractSystemAndMessages;
+    /** 将内部 Message[] 转换为 Anthropic MessageParam[]（已废弃，保留兼容） */
+    private convertMessages;
+    /** 转换内容块，必要时添加 cache_control 标记 */
+    private convertContentBlocks;
+    /** 将内部 ToolDefinition[] 转换为 Anthropic Tool[] */
+    private convertTools;
+}
+/** 便捷工厂：从 ProviderConfig 创建 AnthropicProvider */
+export declare function createAnthropicProvider(config: ProviderConfig): AnthropicProvider;
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/provider/anthropic.js

@@ -0,0 +1,361 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { getModelInfo } from './catalog.js';
+import { recoverToolArguments, logToolArgsWarning } from './tool-args-recovery.js';
+/**
+ * Anthropic Provider — 通过 @anthropic-ai/sdk 实现流式调用。
+ *
+ * 支持：
+ * - Extended Thinking（thinking 模式）
+ * - Prompt Caching（cache_control 标记）— message 层面的断点由 context/cache-strategy.ts 统一管理
+ * - 流式返回 StreamEvent（TEXT / THINKING / TOOL_USE / USAGE / STOP）
+ */
+export class AnthropicProvider {
+    client;
+    model;
+    maxTokens;
+    thinkingEnabled;
+    thinkingBudget;
+    _providerType;
+    constructor(opts = {}) {
+        this._providerType = opts.providerType ?? 'anthropic';
+        const isAnthropic = this._providerType === 'anthropic';
+        const apiKey = opts.apiKey ?? (isAnthropic ? process.env.ANTHROPIC_API_KEY : undefined);
+        if (!apiKey) {
+            const label = isAnthropic ? 'Anthropic' : this._providerType.toUpperCase();
+            const envVar = isAnthropic ? 'ANTHROPIC_API_KEY' : `${this._providerType.toUpperCase()}_API_KEY`;
+            throw new Error(`${label} API key is required. Set ${envVar} environment variable or pass apiKey in options.`);
+        }
+        this.client = new Anthropic({
+            apiKey,
+            baseURL: opts.baseUrl ?? process.env.ANTHROPIC_BASE_URL,
+        });
+        this.model = opts.model ?? 'claude-sonnet-4-20250514';
+        this.maxTokens = opts.maxOutputTokens // ① 临时覆盖
+            ?? opts.maxTokens // 向后兼容
+            ?? getModelInfo('anthropic', this.model)?.maxOutputTokens // ② 本机模型目录
+            ?? 8192; // ③ 兜底
+        this.thinkingEnabled = opts.thinkingEnabled ?? false;
+        this.thinkingBudget = opts.thinkingBudget ?? 10000;
+    }
+    getProviderType() {
+        return this._providerType;
+    }
+    getModel() {
+        return this.model;
+    }
+    getCapabilities() {
+        const info = getModelInfo('anthropic', this.model);
+        return {
+            toolCalling: true,
+            streaming: true,
+            adapterSupport: false,
+            maxContextTokens: info?.contextWindow ?? 200000,
+            isLocal: false,
+            vision: info?.capabilities.vision ?? true, // Anthropic models mostly support vision
+        };
+    }
+    /** 运行时切换 thinking 模式 */
+    setThinking(enabled, budget = 10000) {
+        this.thinkingEnabled = enabled;
+        this.thinkingBudget = budget;
+    }
+    async *createStream(messages, tools, signal) {
+        // ---- 构建请求参数 ----
+        // 使用 MessageCreateParamsNonStreaming（stream 字段可选），stream() 方法内部会自动设置 stream: true
+        const { system, messages: filteredMessages } = this.extractSystemAndMessages(messages);
+        const params = {
+            model: this.model,
+            max_tokens: this.maxTokens,
+            messages: filteredMessages,
+        };
+        // system prompt（Anthropic API 要求通过 system 参数传递，不能出现在 messages 中）
+        if (system) {
+            params.system = system;
+        }
+        // tools
+        if (tools && tools.length > 0) {
+            params.tools = this.convertTools(tools);
+        }
+        // thinking
+        if (this.thinkingEnabled) {
+            params.thinking = {
+                type: 'enabled',
+                budget_tokens: this.thinkingBudget,
+            };
+        }
+        // ---- 流式消费 ----
+        const stream = this.client.messages.stream(params, { signal });
+        // 追踪正在构建的 tool_use
+        let currentToolUse = null;
+        // 累计 usage
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let cacheReadInputTokens;
+        let cacheCreationInputTokens;
+        try {
+            for await (const event of stream) {
+                switch (event.type) {
+                    // ---- message_start：获取初始 usage ----
+                    case 'message_start': {
+                        const usage = event.message.usage;
+                        if (usage) {
+                            inputTokens = usage.input_tokens;
+                            if (usage.cache_read_input_tokens != null) {
+                                cacheReadInputTokens = usage.cache_read_input_tokens;
+                            }
+                            if (usage.cache_creation_input_tokens != null) {
+                                cacheCreationInputTokens = usage.cache_creation_input_tokens;
+                            }
+                        }
+                        break;
+                    }
+                    // ---- content_block_start：检测 tool_use / thinking 块 ----
+                    case 'content_block_start': {
+                        const block = event.content_block;
+                        if (block.type === 'tool_use') {
+                            currentToolUse = {
+                                id: block.id,
+                                name: block.name,
+                                inputJson: '',
+                            };
+                        }
+                        // thinking 块的起始没有内容需要 emit，等待 delta
+                        break;
+                    }
+                    // ---- content_block_delta：增量文本 / thinking / tool input ----
+                    case 'content_block_delta': {
+                        const delta = event.delta;
+                        if (delta.type === 'text_delta') {
+                            yield { type: 'TEXT', content: delta.text };
+                        }
+                        else if (delta.type === 'thinking_delta') {
+                            yield { type: 'THINKING', content: delta.thinking };
+                        }
+                        else if (delta.type === 'input_json_delta') {
+                            if (currentToolUse) {
+                                currentToolUse.inputJson += delta.partial_json;
+                            }
+                        }
+                        break;
+                    }
+                    // ---- content_block_stop：完成 tool_use 块 ----
+                    case 'content_block_stop': {
+                        if (currentToolUse) {
+                            const raw = currentToolUse.inputJson || '';
+                            const { recovered, complete, error } = recoverToolArguments(raw, currentToolUse.name);
+                            if (!complete) {
+                                logToolArgsWarning('anthropic', currentToolUse.name, raw, error);
+                            }
+                            yield {
+                                type: 'TOOL_USE',
+                                id: currentToolUse.id,
+                                name: currentToolUse.name,
+                                input: recovered,
+                            };
+                            currentToolUse = null;
+                        }
+                        break;
+                    }
+                    // ---- message_delta：stop_reason + output usage ----
+                    case 'message_delta': {
+                        if (event.usage) {
+                            outputTokens = event.usage.output_tokens;
+                        }
+                        if (event.delta.stop_reason) {
+                            // 先 emit USAGE，再 emit STOP
+                            const usageEvent = {
+                                type: 'USAGE',
+                                input_tokens: inputTokens,
+                                output_tokens: outputTokens,
+                            };
+                            if (cacheReadInputTokens != null) {
+                                usageEvent.cache_read_input_tokens = cacheReadInputTokens;
+                            }
+                            if (cacheCreationInputTokens != null) {
+                                usageEvent.cache_creation_input_tokens = cacheCreationInputTokens;
+                            }
+                            yield usageEvent;
+                            yield { type: 'STOP', reason: event.delta.stop_reason };
+                        }
+                        break;
+                    }
+                    // message_stop / 其他事件不需要特殊处理
+                    default:
+                        break;
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Anthropic.APIError) {
+                throw new Error(`Anthropic API error (${error.status}): ${error.message}`);
+            }
+            if (error instanceof Error) {
+                throw new Error(`Anthropic stream error: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    // ---- 内部转换方法 ----
+    /**
+     * 从消息列表中提取 system 消息和 user/assistant 消息。
+     *
+     * Anthropic API 要求 system prompt 通过 `system` 参数传递，
+     * 不能出现在 messages 数组中。此方法将 role='system' 的消息提取出来，
+     * 拼接为 system 字符串或 TextBlockParam 数组（含 cache_control 时），
+     * 仅 role='user' 和 role='assistant' 的消息进入 messages 数组。
+     */
+    extractSystemAndMessages(messages) {
+        const systemBlocks = [];
+        const filteredMessages = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                // 提取 system 消息的内容块
+                const blocks = Array.isArray(msg.content) ? msg.content : [msg.content];
+                for (const block of blocks) {
+                    if (block.type === 'text') {
+                        const textBlock = {
+                            type: 'text',
+                            text: block.text,
+                        };
+                        // 传递 cache_control 标记
+                        if (block.cache_control) {
+                            textBlock.cache_control = block.cache_control;
+                        }
+                        systemBlocks.push(textBlock);
+                    }
+                    // system 消息中的非 text 块（如 tool_use / tool_result）忽略
+                }
+            }
+            else if (msg.role === 'user' || msg.role === 'assistant') {
+                const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+                filteredMessages.push({
+                    role: msg.role,
+                    content: this.convertContentBlocks(content),
+                });
+            }
+        }
+        // 构建 system 参数
+        let system;
+        if (systemBlocks.length > 0) {
+            // 检查是否有任何 block 带有 cache_control
+            const hasCacheControl = systemBlocks.some((b) => b.cache_control != null);
+            if (hasCacheControl) {
+                // 有 cache_control 时使用数组格式
+                system = systemBlocks;
+            }
+            else {
+                // 无 cache_control 时使用纯字符串格式
+                system = systemBlocks.map((b) => b.text).join('\n\n');
+            }
+        }
+        return { system, messages: filteredMessages };
+    }
+    /** 将内部 Message[] 转换为 Anthropic MessageParam[]（已废弃，保留兼容） */
+    convertMessages(messages) {
+        return messages
+            .filter((msg) => msg.role !== 'system')
+            .map((msg) => {
+            const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+            return {
+                role: msg.role,
+                content: this.convertContentBlocks(content),
+            };
+        });
+    }
+    /** 转换内容块，必要时添加 cache_control 标记 */
+    convertContentBlocks(blocks) {
+        const result = [];
+        for (let idx = 0; idx < blocks.length; idx++) {
+            const block = blocks[idx];
+            const isLast = idx === blocks.length - 1;
+            switch (block.type) {
+                case 'text': {
+                    const textBlock = { type: 'text', text: block.text };
+                    // If the content block already has cache_control (set by composer), pass it through
+                    if (block.cache_control) {
+                        textBlock.cache_control = block.cache_control;
+                    }
+                    result.push(textBlock);
+                    break;
+                }
+                case 'tool_use':
+                    result.push({
+                        type: 'tool_use',
+                        id: block.id,
+                        name: block.name,
+                        input: block.input,
+                    });
+                    break;
+                case 'tool_result':
+                    result.push({
+                        type: 'tool_result',
+                        tool_use_id: block.tool_use_id,
+                        content: block.content,
+                        ...(block.is_error != null ? { is_error: block.is_error } : {}),
+                    });
+                    break;
+                case 'thinking':
+                    // Anthropic API 不接受 thinking 块作为输入，跳过
+                    break;
+                case 'image': {
+                    if (!this.getCapabilities().vision) {
+                        // 非视觉模型 → 降级为文本占位符
+                        const src = block.source;
+                        result.push({
+                            type: 'text',
+                            text: src.type === 'base64'
+                                ? `[Image: ${src.media_type}]`
+                                : `[Image URL: ${src.url}]`,
+                        });
+                    }
+                    else {
+                        const mime = block.source.type === 'base64'
+                            ? (['image/jpeg', 'image/png', 'image/gif', 'image/webp'].includes(block.source.media_type)
+                                ? block.source.media_type
+                                : 'image/png') // fallback: unsupported types → png
+                            : '';
+                        const src = block.source.type === 'base64'
+                            ? { type: 'base64', media_type: mime, data: block.source.data }
+                            : { type: 'url', url: block.source.url };
+                        const imgBlock = { type: 'image', source: src };
+                        if (block.cache_control) {
+                            imgBlock.cache_control = block.cache_control;
+                        }
+                        result.push(imgBlock);
+                    }
+                    break;
+                }
+                default:
+                    // 兜底：作为 text 块处理
+                    result.push({ type: 'text', text: JSON.stringify(block) });
+                    break;
+            }
+        }
+        return result;
+    }
+    /** 将内部 ToolDefinition[] 转换为 Anthropic Tool[] */
+    convertTools(tools) {
+        return tools.map((tool, idx) => {
+            const isLast = idx === tools.length - 1;
+            const result = {
+                name: tool.name,
+                description: tool.description,
+                input_schema: tool.input_schema,
+            };
+            // Note: cache_control on tools was previously gated behind this.cacheControl.
+            // Message-level breakpoints are now handled by context/cache-strategy.ts via composer.
+            // Tool-level cache_control is intentionally omitted — Anthropic's 4-breakpoint limit
+            // is fully consumed by the 4 Zone-boundary message markers (BP1-BP3b).
+            return result;
+        });
+    }
+}
+/** 便捷工厂：从 ProviderConfig 创建 AnthropicProvider */
+export function createAnthropicProvider(config) {
+    return new AnthropicProvider({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        model: config.model,
+    });
+}
+//# sourceMappingURL=anthropic.js.map