dominds 1.20.6 → 1.21.0

package/dist/cli/manual.js

@@ -134,19 +134,6 @@ function listAvailableToolsets() {
     }
     console.log(`Available toolsets: ${names.map((name) => `\`${name}\``).join(', ')}`);
 }
-function toAvailableToolNames(toolsetId) {
-    const toolset = (0, registry_1.getToolset)(toolsetId) ?? [];
-    const names = new Set();
-    for (const tool of toolset) {
-        if (tool &&
-            typeof tool === 'object' &&
-            'type' in tool &&
-            tool.type === 'func') {
-            names.add(tool.name);
-        }
-    }
-    return names;
-}
 async function main() {
     try {
         const parsed = parseArgs(process.argv.slice(2));
@@ -160,13 +147,11 @@ async function main() {
             listAvailableToolsets();
             process.exit(1);
         }
-        const availableToolNames = toAvailableToolNames(toolsetId);
         const content = await (0, toolset_manual_1.renderToolsetManualContent)({
             toolsetId,
             language: parsed.language,
             topic: parsed.topic,
             topics: parsed.topics,
-            availableToolNames,
         });
         console.log(content);
     }

package/dist/docs/llm-provider-isolation.md

@@ -8,7 +8,9 @@ This means:
 
 - `apiType: codex` owns Codex-native request fields, stream events, tool semantics, and defaults.
 - `apiType: openai` owns OpenAI Responses request fields, stream events, tool semantics, and defaults.
-- `apiType: openai-compatible` owns Chat Completions semantics, even when it reuses the `model_params.openai.*` namespace.
+- `apiType: openai-compatible` owns Chat Completions semantics, including the `model_params.openai-compatible.*` namespace.
+- `apiType: anthropic` owns official Anthropic Messages semantics, including object-shaped `model_params.anthropic.thinking`.
+- `apiType: anthropic-compatible` owns Anthropic-compatible gateway semantics, including boolean `model_params.anthropic-compatible.thinking` mapped to provider `enabled` / `disabled` request objects.
 
 Similar field names across wrappers do not imply compatibility. For example, `reasoning_effort`, `verbosity`, `parallel_tool_calls`, and web search controls may look similar but can still differ in accepted values, payload shape, lifecycle events, validation rules, and runtime meaning.
 

package/dist/docs/llm-provider-isolation.zh.md

@@ -8,7 +8,9 @@ Dominds 把每个 LLM provider wrapper 视为独立的协议适配器，而不
 
 - `apiType: codex` 只负责 Codex 原生的请求字段、流事件、工具语义和默认行为。
 - `apiType: openai` 只负责 OpenAI Responses 原生的请求字段、流事件、工具语义和默认行为。
-- `apiType: openai-compatible` 虽然复用 `model_params.openai.*` 命名空间，但它负责的是 Chat Completions 语义，不是 Codex，也不是 Responses。
+- `apiType: openai-compatible` 负责 Chat Completions 语义，包括 `model_params.openai-compatible.*` 命名空间，不是 Codex，也不是 Responses。
+- `apiType: anthropic` 只负责 Anthropic 官方 Messages 语义，包括 object 形态的 `model_params.anthropic.thinking`。
+- `apiType: anthropic-compatible` 负责 Anthropic 兼容网关语义，包括 boolean 形态的 `model_params.anthropic-compatible.thinking`，并映射为 provider 请求里的 `enabled` / `disabled` object。
 
 不同 wrapper 下看起来同名的字段，不代表它们可以互相兼容。比如 `reasoning_effort`、`verbosity`、`parallel_tool_calls`、web search 相关开关，名字可能相似，但可接受值、请求载荷形状、流事件生命周期、校验规则和运行时含义都可能不同。
 

package/dist/docs/mcp-support.md

@@ -399,6 +399,14 @@ headers:
 
 This is a Dominds-oriented schema. It is intentionally small and should be easy to validate.
 
+`manual` is optional enhancement configuration, not a requirement for MCP integration. A standard
+MCP server already returns tool names, descriptions, and parameter schemas through `tools/list`;
+Dominds registers that metadata as `FuncTool`s and provides it to the LLM and the WebUI tools list.
+`man({ "toolsetId": "<serverId>" })` does not duplicate that schema; use `manual` for the server's
+overall positioning, use cases, examples, pitfalls, guardrails, failure-handling procedures, and
+team norms. Omitting `manual` is allowed but reported as a warning in Problems because Dominds
+recommends at least a short positioning note.
+
 ```yaml
 version: 1
 servers:
@@ -439,10 +447,11 @@ servers:
     # Tool name transforms (optional)
     transform: []
 
-    # Optional manual information
-    # - contentFile: formal runtime manual for man({ "toolsetId": "<serverId>" })
-    # - content/sections: extra inline team-management guidance
-    # (missing manual does NOT make the toolset unavailable)
+    # Optional enhanced manual information; omitting it is allowed but emits a Problems warning.
+    # - contentFile: formal runtime manual for man({ "toolsetId": "<serverId>" });
+    #   supports topic files such as index/principles/tools/scenarios/errors.
+    # - content/sections: inline guidance (use cases, guardrails, failure handling, team norms)
+    # Do not duplicate tool lists/parameter definitions; those come from MCP tools/list.
     manual:
       contentFile: ".minds/manuals/<serverId>"
       content: "What this MCP toolset is for"

package/dist/docs/mcp-support.zh.md

@@ -320,6 +320,13 @@ headers:
 
 这是一个以 Dominds 为中心的模式。它有意设计得很小，应该易于验证。
 
+`manual` 是可选增强配置，不是 MCP 接入的必填项。标准 MCP server 已经通过
+`tools/list` 返回工具名称、描述和参数 schema；Dominds 会把这些元数据注册为
+`FuncTool`，提供给 LLM，并在 WebUI 工具列表中展示。`man({ "toolsetId": "<serverId>" })`
+不再重复罗列这份 schema；`manual` 应用于补充整体定位、使用场景、综合示例、避坑指南、安全边界、
+故障处置流程、团队约定等。省略 `manual` 允许接入和使用，但会在 Problems 中给 warning，因为
+Dominds 建议至少写一段简短整体定位说明。
+
 ```yaml
 version: 1
 servers:
@@ -360,9 +367,13 @@ servers:
     # 工具名称转换（可选）
     transform: []
 
-    # 可选：给智能体看的每个 toolset 手册
-    #（没有手册并不代表 toolset 不可用）
+    # 可选增强手册；省略时仍可接入，但会产生 Problems warning。
+    # - contentFile: 给 man({ "toolsetId": "<serverId>" }) 的正式运行时手册；
+    #   支持 index/principles/tools/scenarios/errors 等 topic 文件。
+    # - content/sections: inline 增强说明（使用场景、安全边界、故障处置、团队约定等）
+    # 不要在 manual 中重复工具列表/参数定义；这些来自 MCP tools/list。
     manual:
+      contentFile: ".minds/manuals/<serverId>"
       content: "该 MCP toolset 的用途说明"
       sections:
         - title: "何时使用"

package/dist/docs/team_mgmt-toolset.md

@@ -325,7 +325,8 @@ used in `.minds/team.yaml` member configurations.
 `apiType` notes (common values):
 
 - `openai`: uses the OpenAI **Responses API** (best for OpenAI official endpoints; requires a `/v1`-style `responses` endpoint)
-- `anthropic`: uses the Anthropic **Messages API** (also used by Anthropic-compatible coding-plan endpoints; e.g. Volcano Engine Coding Plan `.../api/coding`)
+- `anthropic`: uses the official Anthropic **Messages API**. `model_params.anthropic.thinking` uses the official Anthropic object shape.
+- `anthropic-compatible`: uses Anthropic-compatible **Messages API** / coding-plan endpoints, e.g. Volcano Engine Coding Plan `.../api/coding`. `model_params.anthropic-compatible.thinking` uses the Dominds boolean switch: `true` sends `thinking.type=enabled`; `false` sends `thinking.type=disabled`.
 - `openai-compatible`: uses the OpenAI **Chat Completions API** (best for most “OpenAI-compatible” third-party/proxy endpoints; e.g. a manually configured Ark `.../api/v3` endpoint)
   - **Vision support**: if the provider/model supports multimodal Chat Completions, Dominds will pass tool-output images (`func_result_msg.contentItems[].type=input_image`, e.g. from MCP tools) to the model as `image_url` inputs after reading the persisted artifact; unsupported mime types are downgraded to text.
 
@@ -389,22 +390,21 @@ Notes:
   `mcp_disable` disables a server while keeping its zero-tool toolset/manual visible, and
   `mcp_release` releases the current dialog lease.
 - Optional manual information can live in `.minds/mcp.yaml` at `servers.<serverId>.manual`:
-  - `contentFile`: the topic-file directory prefix for the formal runtime manual; the final `man({ "toolsetId": "<serverId>" })` content shown to the LLM is loaded from here
+  - `contentFile`: the topic-file directory prefix for the formal runtime manual; the final `man({ "toolsetId": "<serverId>" })` content shown to the LLM is loaded from here, including handwritten chapters such as `scenarios` and `errors`
   - `content` / `sections`: inline team-management guidance shown in the `team_mgmt` MCP chapter (`sections` supports `[{ title, content }]` or `{ "<title>": "<content>" }`)
-- Missing manual does **not** mean the toolset is unavailable; it means team-manager documentation
-  is incomplete. Agents should continue by reading each tool’s own description/arguments.
-- Team-manager recommendation: after MCP config validation passes, carefully read each exposed tool
-  description, discuss intended rtws usage with the human user, then write the formal manual into
-  `manual.contentFile`; if extra team-management interpretation is still useful, add inline
-  `content + sections` alongside it.
-- Use a semi-structured chapter shape: high-value sections often include `When To Use`,
-  `Guardrails`, and `Business Handling When Unavailable`, but do not force every toolset into one
-  fixed template. Start from the real business goal, then decide which sections deserve depth,
-  which can stay brief, and which should be merged or renamed to fit the scenario.
-- For each MCP toolset, deliberately document unavailable-case business handling rules. At minimum,
-  answer:
+- Missing manual does **not** mean the toolset is unavailable. Standard tool metadata comes from MCP
+  `tools/list`; agents should continue by reading each tool’s own description/arguments. Dominds
+  still reports a warning so the team can add at least a short overall positioning note.
+- Team-manager recommendation: after MCP config validation passes, rely on MCP-provided tool
+  descriptions/arguments first, and still write a short positioning note for each MCP server. Use
+  `manual.contentFile` or inline `content + sections` for richer handwritten guidance such as
+  examples, pitfalls, safety boundaries, failure handling, and coordination norms.
+- Use a semi-structured chapter shape for optional enhancements: high-value sections often include
+  `When To Use`, `Guardrails`, and `Business Handling When Unavailable`, but do not force every
+  toolset into one fixed template.
+- For high-risk MCP toolsets, document unavailable-case business handling rules. At minimum, answer:
   - whether a temporarily unavailable toolset must be escalated to a coordinator or specialist
-  - whether a manual or alternate-tool fallback path is allowed
+  - whether a human-operated or alternate-tool fallback path is allowed
   - which business actions must pause until the toolset recovers
 
 ### File format (template)

package/dist/docs/team_mgmt-toolset.zh.md

@@ -266,7 +266,8 @@
 `apiType` 说明（常见值）：
 
 - `openai`：使用 OpenAI **Responses API**（适用于 OpenAI 官方；需要 `/v1` 语义的 `responses` 端点）
-- `anthropic`：使用 Anthropic **Messages API**（也用于 Anthropic 兼容的 Coding Plan 端点；例如 Volcano Engine Coding Plan `.../api/coding`）
+- `anthropic`：使用 Anthropic 官方 **Messages API**。`model_params.anthropic.thinking` 使用 Anthropic 官方 object 形态。
+- `anthropic-compatible`：使用 Anthropic 兼容的 **Messages API** / Coding Plan 端点（例如 Volcano Engine Coding Plan `.../api/coding`）。`model_params.anthropic-compatible.thinking` 使用 Dominds boolean 开关：`true` 发送 `thinking.type=enabled`，`false` 发送 `thinking.type=disabled`。
 - `openai-compatible`：使用 OpenAI **Chat Completions API**（适用于多数“OpenAI 兼容”第三方/代理；例如手动配置的 Ark `.../api/v3` 端点）
   - **识图支持**：如果该 provider/model 支持 Chat Completions 的多模态输入，Dominds 会把工具输出里的图片（`func_result_msg.contentItems[].type=input_image`，来自 MCP 等工具）读取 artifact 后作为 `image_url` 形式喂给模型；不支持的 mimeType 会降级成文本提示。
 
@@ -325,12 +326,12 @@ members:
 - `mcp_admin` 是 MCP 运维内置工具集：`mcp_restart` 启用/重启 server，`mcp_disable` 禁用
   server 并保留 0 工具 toolset/手册可见性，`mcp_release` 释放当前对话 lease
 - 可选手册：可在 `.minds/mcp.yaml` 的 `servers.<serverId>.manual` 提供手册相关信息：
-  - `contentFile`：正式 runtime 手册的 topic 文件目录前缀；`man({ "toolsetId": "<serverId>" })` 最终给 LLM 看的正文从这里加载
+  - `contentFile`：正式 runtime 手册的 topic 文件目录前缀；`man({ "toolsetId": "<serverId>" })` 最终给 LLM 看的正文从这里加载，包括 `scenarios`、`errors` 等手写章节
   - `content` / `sections`：补充给 `team_mgmt` MCP 章节看的 inline 团队管理说明（`sections` 支持 `[{ title, content }]` 或 `{ "<title>": "<content>" }`）
-- 没有手册 **不代表** 该 toolset 不可用；这只表示团队管理文档覆盖不足。智能体应继续依据每个工具自身的 description/参数来使用。
-- 建议团队管理者在 MCP 配置验证通过后：先精读该 server 暴露的每个工具说明，再与人类用户讨论本 rtws 的使用意图，然后把正式手册沉淀到 `manual.contentFile`；如仍需额外写团队管理层解释，再补 inline `content + sections`。
-- 章节组织建议采用“半结构化”：可优先考虑 `何时使用`、`安全边界`、`不可用时业务处置` 这类高价值章节，但不要求所有 toolset 都照抄同一模板。应从真实业务目标出发，决定哪些章节需要展开、哪些只需一句话、哪些可以合并或改名成更贴切的标题。
-- 对每个 MCP toolset，建议刻意写明“不可用时业务处置规约”，至少回答：
+- 没有手册 **不代表** 该 toolset 不可用；标准工具元数据来自 MCP `tools/list`。智能体应继续依据每个工具自身的 description/参数来使用。Dominds 仍会发出 warning，提醒团队至少补充简短整体定位说明。
+- 建议团队管理者在 MCP 配置验证通过后，优先依赖 MCP server 暴露的工具 description/参数；同时给每个 MCP server 写一段简短定位。若需要更完整的综合示例、避坑指南、安全边界、故障处置或协作规范，再写 `manual.contentFile` 或 inline `content + sections`。
+- 可选增强的章节组织建议采用“半结构化”：可优先考虑 `何时使用`、`安全边界`、`不可用时业务处置` 这类高价值章节，但不要求所有 toolset 都照抄同一模板。
+- 对高风险 MCP toolset，建议明确“不可用时业务处置规约”，至少回答：
   - 当前 toolset 暂不可达时，是否必须找协调者/专员接手
   - 是否允许采用人工流程或其他工具链作为临时降级路径
   - 哪些业务动作在该 toolset 恢复前必须暂停，不能擅自继续

package/dist/llm/api-quirks.d.ts

@@ -42,5 +42,6 @@ export type LlmFailureQuirkHandlerSession = {
     onRequestSucceeded?: () => void;
     onRecoveryActionUsed?: (usage: LlmQuirkRecoveryUsage) => void;
 };
+export declare const XCODE_BEST_STREAM_INTERNAL_ERROR_CODE = "XCODE_BEST_STREAM_INTERNAL_ERROR";
 export declare function normalizeProviderApiQuirks(providerConfig: ProviderConfig): Set<string>;
 export declare function createLlmFailureQuirkHandlerSession(providerConfig: ProviderConfig): LlmFailureQuirkHandlerSession | undefined;

package/dist/llm/api-quirks.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.XCODE_BEST_STREAM_INTERNAL_ERROR_CODE = void 0;
 exports.normalizeProviderApiQuirks = normalizeProviderApiQuirks;
 exports.createLlmFailureQuirkHandlerSession = createLlmFailureQuirkHandlerSession;
 const persistence_errors_1 = require("../persistence-errors");
@@ -9,6 +10,9 @@ const XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD = 5;
 const XCODE_BEST_GATEWAY_HTML_502_RETRY_MESSAGE = 'xcode.best gateway returned an HTML 502 Bad Gateway page; retrying conservatively.';
 const XCODE_BEST_AUTH_UNAVAILABLE_RETRY_MESSAGE = 'xcode.best upstream returned 500 auth_unavailable: no auth available; treating it as an infrastructure failure and retrying conservatively.';
 const XCODE_BEST_UNEXPECTED_EOF_RETRY_MESSAGE = 'xcode.best upstream stream ended unexpectedly (unexpected EOF); retrying conservatively.';
+const XCODE_BEST_MISREPORTED_403_RETRY_MESSAGE = 'xcode.best returned 403 for a transient upstream failure; retrying aggressively.';
+exports.XCODE_BEST_STREAM_INTERNAL_ERROR_CODE = 'XCODE_BEST_STREAM_INTERNAL_ERROR';
+const XCODE_BEST_STREAM_INTERNAL_RETRY_MESSAGE = 'xcode.best upstream stream reported internal_error from peer; retrying aggressively.';
 const LOCAL_FILE_IO_ERROR_CODES = new Set(['ENOENT', 'ENOTDIR', 'EISDIR', 'EACCES', 'EPERM']);
 const LOCAL_FILE_IO_SYSCALLS = new Set([
     'open',
@@ -58,6 +62,88 @@ function isXcodeBestAuthUnavailableFailure(failure, error) {
     }
     return code === 'internal_server_error' && message.includes('no auth available');
 }
+function isXcodeBestStreamInternalFailure(failure, error) {
+    const code = failure.code ?? readErrorCode(error);
+    return code === exports.XCODE_BEST_STREAM_INTERNAL_ERROR_CODE;
+}
+const XCODE_BEST_RETRY_QUIRK_RULES = [
+    {
+        statusPolicy: { kind: 'only_status', status: 403 },
+        retryStrategy: 'aggressive',
+        message: XCODE_BEST_MISREPORTED_403_RETRY_MESSAGE,
+        matches: () => true,
+    },
+    {
+        statusPolicy: { kind: 'exclude_statuses', statuses: [429] },
+        retryStrategy: 'aggressive',
+        message: XCODE_BEST_STREAM_INTERNAL_RETRY_MESSAGE,
+        matches: ({ failure, error }) => isXcodeBestStreamInternalFailure(failure, error),
+    },
+    {
+        statusPolicy: { kind: 'exclude_statuses', statuses: [429] },
+        retryStrategy: 'conservative',
+        message: XCODE_BEST_UNEXPECTED_EOF_RETRY_MESSAGE,
+        matches: ({ failure, error }) => isXcodeBestUnexpectedEofFailure(failure, error),
+    },
+    {
+        statusPolicy: { kind: 'only_status', status: 502 },
+        retryStrategy: 'conservative',
+        message: XCODE_BEST_GATEWAY_HTML_502_RETRY_MESSAGE,
+        matches: ({ failure, error }) => isXcodeBestGatewayHtml502Failure(failure, error),
+    },
+    {
+        statusPolicy: { kind: 'only_status', status: 500 },
+        retryStrategy: 'conservative',
+        message: XCODE_BEST_AUTH_UNAVAILABLE_RETRY_MESSAGE,
+        matches: ({ failure, error }) => isXcodeBestAuthUnavailableFailure(failure, error),
+    },
+];
+function isStatusAllowedByXcodeBestQuirkPolicy(statuses, policy) {
+    switch (policy.kind) {
+        case 'only_status':
+            return statuses.includes(policy.status) && !statuses.includes(429);
+        case 'exclude_statuses':
+            return statuses.every((status) => !policy.statuses.includes(status));
+        default: {
+            const _exhaustive = policy;
+            return _exhaustive;
+        }
+    }
+}
+function readFailureAndErrorStatuses(args) {
+    const statuses = [];
+    const appendStatus = (status) => {
+        if (status === undefined || statuses.includes(status)) {
+            return;
+        }
+        statuses.push(status);
+    };
+    appendStatus(args.failure.status);
+    for (const current of getErrorChain(args.error)) {
+        if (!isRecord(current)) {
+            continue;
+        }
+        if ('status' in current && typeof current.status === 'number') {
+            appendStatus(current.status);
+        }
+        if ('statusCode' in current && typeof current.statusCode === 'number') {
+            appendStatus(current.statusCode);
+        }
+    }
+    return statuses;
+}
+function resolveXcodeBestRetryQuirkRule(args) {
+    const statuses = readFailureAndErrorStatuses(args);
+    for (const rule of XCODE_BEST_RETRY_QUIRK_RULES) {
+        if (!isStatusAllowedByXcodeBestQuirkPolicy(statuses, rule.statusPolicy)) {
+            continue;
+        }
+        if (rule.matches(args)) {
+            return rule;
+        }
+    }
+    return undefined;
+}
 function getErrorChain(error) {
     const queue = [error];
     const visited = new Set();
@@ -78,6 +164,10 @@ function getErrorChain(error) {
         if (nestedError !== undefined) {
             queue.push(nestedError);
         }
+        const nestedResponse = readNestedResponse(current);
+        if (nestedResponse !== undefined) {
+            queue.push(nestedResponse);
+        }
         const cause = readErrorCause(current);
         if (cause !== undefined) {
             queue.push(cause);
@@ -114,6 +204,12 @@ function readNestedError(error) {
     }
     return undefined;
 }
+function readNestedResponse(error) {
+    if (isRecord(error) && 'response' in error && isRecord(error.response)) {
+        return error.response;
+    }
+    return undefined;
+}
 function readErrorPath(error) {
     for (const current of getErrorChain(error)) {
         if (current instanceof Error) {
@@ -308,25 +404,15 @@ function createXcodeBestFailureQuirkHandlerSession(providerConfig) {
                 };
             }
             consecutiveEmptyResponseCount = 0;
-            if (isXcodeBestUnexpectedEofFailure(args.failure, args.error)) {
-                return {
-                    kind: 'retry_strategy',
-                    retryStrategy: 'conservative',
-                    message: XCODE_BEST_UNEXPECTED_EOF_RETRY_MESSAGE,
-                };
-            }
-            if (isXcodeBestGatewayHtml502Failure(args.failure, args.error)) {
-                return {
-                    kind: 'retry_strategy',
-                    retryStrategy: 'conservative',
-                    message: XCODE_BEST_GATEWAY_HTML_502_RETRY_MESSAGE,
-                };
-            }
-            if (isXcodeBestAuthUnavailableFailure(args.failure, args.error)) {
+            const retryQuirkRule = resolveXcodeBestRetryQuirkRule({
+                failure: args.failure,
+                error: args.error,
+            });
+            if (retryQuirkRule) {
                 return {
                     kind: 'retry_strategy',
-                    retryStrategy: 'conservative',
-                    message: XCODE_BEST_AUTH_UNAVAILABLE_RETRY_MESSAGE,
+                    retryStrategy: retryQuirkRule.retryStrategy,
+                    message: retryQuirkRule.message,
                 };
             }
             return { kind: 'default' };

package/dist/llm/client.d.ts

@@ -1,6 +1,8 @@
 export type { ChatMessage, EnvironmentMsg, FuncCallMsg, FuncResultMsg, PromptingMsg, SayingMsg, TellaskCarryoverMsg, TellaskResultMsg, ThinkingMsg, TransientGuideMsg, } from '@longrun-ai/kernel/types/chat-message';
 export interface ModelInfo {
     name?: string;
+    default_thinking?: boolean;
+    supports_thinking?: boolean;
     context_length?: number;
     input_length?: number;
     output_length?: number;
@@ -36,6 +38,8 @@ export type ModelParamOption = (ModelParamOptionBase & {
 }) | (ModelParamOptionBase & {
     type: 'record_number';
     default?: Record<string, number>;
+}) | (ModelParamOptionBase & {
+    type: 'object';
 }) | (ModelParamOptionBase & {
     type: 'enum';
     values: string[];
@@ -45,9 +49,11 @@ export type ModelParamOption = (ModelParamOptionBase & {
 export type ProviderModelParamOptions = {
     codex?: Record<string, ModelParamOption>;
     openai?: Record<string, ModelParamOption>;
+    'openai-compatible'?: Record<string, ModelParamOption>;
     anthropic?: Record<string, ModelParamOption>;
+    'anthropic-compatible'?: Record<string, ModelParamOption>;
 };
-export type ProviderApiType = 'codex' | 'anthropic' | 'mock' | 'openai' | 'openai-compatible';
+export type ProviderApiType = 'codex' | 'anthropic' | 'anthropic-compatible' | 'mock' | 'openai' | 'openai-compatible';
 export type ProviderConfig = {
     name: string;
     apiType: ProviderApiType;