@henjicc/ai-sdk 0.2.8

package/dist/llm/providerPresets.d.ts

@@ -0,0 +1,45 @@
+import type { LlmApiProtocol } from './providerProtocol.js';
+import type { LlmModelConfig, LlmProviderConfig, LlmReasoningEffort } from './types.js';
+/**
+ * 内置供应商预设。
+ *
+ * 供应商本身仍然是用户自建的（本项目不像生成模型那样把供应商写成固定枚举），预设只是把
+ * `docs/llm-adaptation/供应商/*.md` 里核对过的 Base URL、思考参数默认值和推荐模型打包好，
+ * 让"添加一个火山引擎"从"自己去翻文档抄 URL、再逐个勾能力"变成选一下。
+ *
+ * 选了预设之后所有字段仍可改——预设是起点不是约束。
+ */
+export interface LlmProviderPreset {
+    providerId: string;
+    displayName: string;
+    adapter: string;
+    apiProtocol: LlmApiProtocol;
+    /** 官方 Base URL；与账号或工作区绑定、无法给出通用值时留空，改用 `baseUrlHint` 指路 */
+    baseUrl: string;
+    baseUrlHint?: string;
+    reasoning: {
+        enabled: boolean;
+        effort: LlmReasoningEffort;
+    };
+    /** 思考模式能否由用户关闭；模型侧写死始终思考的记 false，设置页会隐藏该下拉 */
+    reasoningConfigurable: boolean;
+    /** 添加该供应商时一并建好的推荐模型，能力按内置目录自动标注 */
+    modelIds: readonly string[];
+    /** 这家供应商已确认可走 Responses 的具体模型；未列出的模型继续走 Chat Completions。 */
+    responsesModelIds?: readonly string[];
+    websiteUrl: string;
+    apiKeyUrl: string;
+    /** 该预设的资料出处，仓库内相对路径 */
+    docs: string;
+    note?: string;
+}
+export declare const LLM_PROVIDER_PRESETS: readonly LlmProviderPreset[];
+export declare function findLlmProviderPreset(providerId: string): LlmProviderPreset | null;
+export declare function resolvePresetModelApiProtocol(preset: LlmProviderPreset, modelId: string, endpointProfile?: string): LlmApiProtocol;
+export declare function createProviderFromPreset(preset: LlmProviderPreset, options?: {
+    endpointProfile?: string;
+    providerId?: string;
+    lifecycle?: 'builtin' | 'user';
+}): LlmProviderConfig;
+/** 预设推荐模型；能力全部按内置目录标注，目录里没有的退回纯文本默认值。 */
+export declare function createModelsFromPreset(preset: LlmProviderPreset, provider: LlmProviderConfig): LlmModelConfig[];

package/dist/llm/providerPresets.js

@@ -0,0 +1,208 @@
+import { DEFAULT_DEEPSEEK_BASE_URL, DEFAULT_DEEPSEEK_PROVIDER_ID, DEFAULT_PPIO_BASE_URL, DEFAULT_PPIO_PROVIDER_ID, createLlmCapabilitiesForModel, } from './defaults.js';
+import { findLlmModelCatalogEntry, modelSupportsLlmApiProtocol } from './modelCatalog.js';
+import { GROQ_PROVIDER_PRESET } from './groq/preset.js';
+import { createBigmodelProvider } from './bigmodel/preset.js';
+import { BIGMODEL_ENDPOINT_PROFILE_FAMILY } from './bigmodel/profiles.js';
+import { findProviderMetadata } from '../providers/metadata.js';
+function providerMetadata(providerId) {
+    const metadata = findProviderMetadata(providerId);
+    if (!metadata)
+        throw new Error(`[provider_metadata_missing] provider "${providerId}" is not registered`);
+    return metadata;
+}
+export const LLM_PROVIDER_PRESETS = [
+    GROQ_PROVIDER_PRESET,
+    {
+        providerId: DEFAULT_PPIO_PROVIDER_ID,
+        displayName: '派欧云',
+        adapter: 'openai',
+        apiProtocol: 'openai-compatible',
+        baseUrl: DEFAULT_PPIO_BASE_URL,
+        reasoning: { enabled: false, effort: 'high' },
+        reasoningConfigurable: false,
+        modelIds: [
+            'deepseek/deepseek-v4-pro',
+            'deepseek/deepseek-v4-flash',
+            'moonshotai/kimi-k2.6',
+            'xiaomimimo/mimo-v2.5-pro',
+        ],
+        websiteUrl: providerMetadata(DEFAULT_PPIO_PROVIDER_ID).websiteUrl,
+        apiKeyUrl: providerMetadata(DEFAULT_PPIO_PROVIDER_ID).apiKeyUrl,
+        docs: 'docs/llm-adaptation/README.md',
+        note: '聚合网关，模型 ID 带厂商前缀；留空密钥时会复用主生成设置里的派欧云密钥。',
+    },
+    {
+        providerId: DEFAULT_DEEPSEEK_PROVIDER_ID,
+        displayName: 'DeepSeek',
+        adapter: 'deepseek',
+        apiProtocol: 'openai-compatible',
+        baseUrl: DEFAULT_DEEPSEEK_BASE_URL,
+        reasoning: { enabled: true, effort: 'high' },
+        reasoningConfigurable: true,
+        modelIds: ['deepseek-v4-pro', 'deepseek-v4-flash'],
+        responsesModelIds: ['deepseek-v4-pro', 'deepseek-v4-flash', 'deepseek-v4-flash-vision-exp'],
+        websiteUrl: providerMetadata(DEFAULT_DEEPSEEK_PROVIDER_ID).websiteUrl,
+        apiKeyUrl: providerMetadata(DEFAULT_DEEPSEEK_PROVIDER_ID).apiKeyUrl,
+        docs: 'docs/llm-adaptation/供应商/DeepSeek.md',
+    },
+    {
+        providerId: 'volcengine',
+        displayName: '火山引擎（豆包）',
+        adapter: 'openai',
+        apiProtocol: 'openai-compatible',
+        baseUrl: 'https://ark.cn-beijing.volces.com/api/v3',
+        reasoning: { enabled: true, effort: 'high' },
+        reasoningConfigurable: true,
+        modelIds: ['doubao-seed-evolving', 'doubao-seed-2-1-pro-260628', 'doubao-seed-2-1-turbo-260628'],
+        responsesModelIds: ['doubao-seed-evolving', 'doubao-seed-2-1-pro-260628', 'doubao-seed-2-1-turbo-260628'],
+        websiteUrl: providerMetadata('volcengine').websiteUrl,
+        apiKeyUrl: providerMetadata('volcengine').apiKeyUrl,
+        docs: 'docs/llm-adaptation/供应商/火山引擎.md',
+        note: 'Base URL 与区域相关，其他区域的地址在方舟控制台查看；联网搜索等内置工具只在 Responses API 可用。',
+    },
+    {
+        providerId: 'kimi',
+        displayName: 'Kimi（月之暗面）',
+        adapter: 'openai',
+        apiProtocol: 'openai-compatible',
+        baseUrl: 'https://api.moonshot.cn/v1',
+        // K3 始终思考、无法关闭，只能调强度，所以不给"关闭"这个选项。
+        reasoning: { enabled: true, effort: 'max' },
+        reasoningConfigurable: true,
+        modelIds: ['kimi-k3'],
+        websiteUrl: providerMetadata('kimi').websiteUrl,
+        apiKeyUrl: providerMetadata('kimi').apiKeyUrl,
+        docs: 'docs/llm-adaptation/供应商/Kimi.md',
+        note: '文档站是 platform.kimi.com，但接口域名仍是 moonshot.cn，不要混用；K3 需要充值后才能调用。K3 的思考无法关闭，思考模式选「关闭」时按最低强度发送。',
+    },
+    {
+        providerId: 'bigmodel',
+        displayName: '智谱 GLM',
+        adapter: 'openai',
+        apiProtocol: 'openai-compatible',
+        baseUrl: 'https://open.bigmodel.cn/api/paas/v4',
+        reasoning: { enabled: true, effort: 'max' },
+        reasoningConfigurable: true,
+        modelIds: ['glm-5.3', 'glm-5v-turbo', 'glm-5.3-flash'],
+        responsesModelIds: ['glm-5.3'],
+        websiteUrl: providerMetadata('bigmodel').websiteUrl,
+        apiKeyUrl: providerMetadata('bigmodel').apiKeyUrl,
+        docs: 'docs/llm-adaptation/供应商/智谱GLM.md',
+        note: '默认是中国大陆端点；Global 必须创建独立 endpoint profile 与凭据槽，不会跨区复用或回退密钥。',
+    },
+    {
+        providerId: 'mimo',
+        displayName: '小米 MiMo',
+        adapter: 'openai',
+        apiProtocol: 'openai-compatible',
+        baseUrl: 'https://api.xiaomimimo.com/v1',
+        reasoning: { enabled: true, effort: 'high' },
+        reasoningConfigurable: true,
+        modelIds: ['mimo-v2.5-pro', 'mimo-v2.5'],
+        websiteUrl: providerMetadata('mimo').websiteUrl,
+        apiKeyUrl: providerMetadata('mimo').apiKeyUrl,
+        docs: 'docs/llm-adaptation/供应商/小米MiMo.md',
+        note: '认证头与请求体字段有两处自有约定，已在 providerProtocol.ts 里按 providerId 处理，改这里的 id 会让那两条失效。',
+    },
+    {
+        providerId: 'minimax',
+        displayName: 'MiniMax',
+        adapter: 'openai',
+        apiProtocol: 'openai-compatible',
+        baseUrl: 'https://api.minimaxi.com/v1',
+        reasoning: { enabled: true, effort: 'high' },
+        reasoningConfigurable: true,
+        modelIds: ['MiniMax-M3'],
+        responsesModelIds: ['MiniMax-M3'],
+        websiteUrl: providerMetadata('minimax').websiteUrl,
+        apiKeyUrl: providerMetadata('minimax').apiKeyUrl,
+        docs: 'docs/llm-adaptation/供应商/MiniMax.md',
+    },
+    {
+        providerId: 'bailian',
+        displayName: '阿里云百炼（Qwen）',
+        adapter: 'openai',
+        apiProtocol: 'openai-compatible',
+        // 百炼的兼容接口地址带工作区 ID 和地域，没有可以写死的通用值。
+        baseUrl: '',
+        baseUrlHint: '形如 https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1，在百炼控制台模型页的「查看代码」里复制当前值。',
+        reasoning: { enabled: true, effort: 'high' },
+        reasoningConfigurable: true,
+        modelIds: ['qwen3.8-max'],
+        responsesModelIds: ['qwen3.8-max'],
+        websiteUrl: providerMetadata('bailian').websiteUrl,
+        apiKeyUrl: providerMetadata('bailian').apiKeyUrl,
+        docs: 'docs/llm-adaptation/供应商/百炼Qwen.md',
+        note: 'qwen3.8-max 必须走多模态消息格式，纯文本也要写成内容块数组。',
+    },
+];
+export function findLlmProviderPreset(providerId) {
+    const normalized = providerId.trim().toLowerCase();
+    return LLM_PROVIDER_PRESETS.find(preset => preset.providerId === normalized) ?? null;
+}
+export function resolvePresetModelApiProtocol(preset, modelId, endpointProfile) {
+    if (preset.providerId === 'bigmodel' && (endpointProfile ?? 'cn') !== 'cn') {
+        return 'openai-compatible';
+    }
+    const modelEntry = findLlmModelCatalogEntry(modelId);
+    const normalizedModelId = modelEntry?.id ?? modelId.trim().toLowerCase();
+    const supportsResponses = preset.responsesModelIds?.some(candidate => ((findLlmModelCatalogEntry(candidate)?.id ?? candidate.trim().toLowerCase()) === normalizedModelId)) === true;
+    return supportsResponses && modelEntry && modelSupportsLlmApiProtocol(modelEntry, 'openai-responses')
+        ? 'openai-responses'
+        : 'openai-compatible';
+}
+export function createProviderFromPreset(preset, options = {}) {
+    if (preset.providerId === 'bigmodel') {
+        const endpointProfile = options.endpointProfile;
+        if (endpointProfile !== undefined && endpointProfile !== 'cn' && endpointProfile !== 'global') {
+            throw new Error(`[llm_endpoint_profile_unknown] bigmodel endpoint profile "${endpointProfile}" is unavailable`);
+        }
+        return createBigmodelProvider({
+            endpointProfile,
+            providerId: options.providerId,
+            lifecycle: options.lifecycle,
+        });
+    }
+    return {
+        providerId: options.providerId ?? preset.providerId,
+        credentialId: options.providerId ?? preset.providerId,
+        setup: {
+            kind: 'preset',
+            presetId: preset.providerId,
+            lifecycle: options.lifecycle ?? 'user',
+        },
+        displayName: preset.displayName,
+        adapter: preset.adapter,
+        apiProtocol: preset.apiProtocol,
+        baseUrl: preset.baseUrl || undefined,
+        reasoning: { ...preset.reasoning },
+        reasoningConfigurable: preset.reasoningConfigurable,
+        enabled: true,
+    };
+}
+/** 预设推荐模型；能力全部按内置目录标注，目录里没有的退回纯文本默认值。 */
+export function createModelsFromPreset(preset, provider) {
+    const modelIds = preset.providerId === 'bigmodel'
+        ? BIGMODEL_ENDPOINT_PROFILE_FAMILY.profiles.find(profile => profile.id === (provider.endpointProfile ?? 'cn'))?.modelIds
+        : preset.modelIds;
+    if (!modelIds) {
+        throw new Error(`[llm_endpoint_profile_unknown] bigmodel endpoint profile "${provider.endpointProfile}" is unavailable`);
+    }
+    return modelIds.map((modelId) => {
+        const entry = findLlmModelCatalogEntry(modelId);
+        return {
+            providerId: provider.providerId,
+            providerFamilyId: provider.providerFamilyId,
+            endpointProfile: provider.endpointProfile,
+            credentialId: provider.credentialId,
+            modelId,
+            displayName: entry?.displayName ?? modelId,
+            adapter: provider.adapter,
+            apiProtocol: resolvePresetModelApiProtocol(preset, modelId, provider.endpointProfile),
+            baseUrl: provider.baseUrl,
+            capabilities: createLlmCapabilitiesForModel(modelId),
+            catalogId: entry?.id,
+            enabled: true,
+        };
+    });
+}

package/dist/llm/providerProtocol.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export { applyProviderRequestBodyQuirks, resolveProviderExtraAuthHeaders, } from './providerProtocolCore.js';
+export type { LlmApiProtocol } from './providerProtocolCore.js';
+export declare const llmApiProtocolSchema: z.ZodEnum<{
+    "openai-compatible": "openai-compatible";
+    "openai-responses": "openai-responses";
+}>;
+/**
+ * 供应商在 OpenAI 协议之上的认证差异，按 providerId 声明。
+ *
+ * 这里放的是**协议层差异**，不是模型行为差异：请求怎么发才能被对方接受。助手的判断逻辑
+ * 一律不许按模型分支，但"这家网关认哪个认证头"没有通用答案，只能如实记下来。
+ *
+ * mimo（小米）：官方文档的认证头是 `api-key`，而通用实现只发 `Authorization: Bearer`。
+ * 两个头同时发是安全的——网关只读它认识的那个——所以这里补发而不是替换，既不依赖对方是否
+ * 兼容 Bearer，也不影响其他供应商。
+ * 见 https://mimo.mi.com/docs/zh-CN/quick-start/summary/first-api-call
+ *
+ * 三条发请求的路径（SDK 模型步、原生流式、模型发现）必须共用这一份，否则改了一处漏两处。
+ */
+/**
+ * 供应商对请求体字段的自有要求，按 providerId 声明。
+ *
+ * mimo：官方文档用 `max_completion_tokens`，而通用 OpenAI 兼容实现发的是 `max_tokens`。
+ * 实测发 `max_tokens` 时六项能力探测全部 400 `Invalid request parameters`——**包括最基础的
+ * text**，所以不是能力不支持，是请求根本不被接受。
+ *
+ * 这里改名而不是两个都发：`max_tokens` 既然被判为非法参数，留着它就还是 400。
+ */

package/dist/llm/providerProtocol.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export { applyProviderRequestBodyQuirks, resolveProviderExtraAuthHeaders, } from './providerProtocolCore.js';
+export const llmApiProtocolSchema = z.enum(['openai-compatible', 'openai-responses']);
+/**
+ * 供应商在 OpenAI 协议之上的认证差异，按 providerId 声明。
+ *
+ * 这里放的是**协议层差异**，不是模型行为差异：请求怎么发才能被对方接受。助手的判断逻辑
+ * 一律不许按模型分支，但"这家网关认哪个认证头"没有通用答案，只能如实记下来。
+ *
+ * mimo（小米）：官方文档的认证头是 `api-key`，而通用实现只发 `Authorization: Bearer`。
+ * 两个头同时发是安全的——网关只读它认识的那个——所以这里补发而不是替换，既不依赖对方是否
+ * 兼容 Bearer，也不影响其他供应商。
+ * 见 https://mimo.mi.com/docs/zh-CN/quick-start/summary/first-api-call
+ *
+ * 三条发请求的路径（SDK 模型步、原生流式、模型发现）必须共用这一份，否则改了一处漏两处。
+ */
+/**
+ * 供应商对请求体字段的自有要求，按 providerId 声明。
+ *
+ * mimo：官方文档用 `max_completion_tokens`，而通用 OpenAI 兼容实现发的是 `max_tokens`。
+ * 实测发 `max_tokens` 时六项能力探测全部 400 `Invalid request parameters`——**包括最基础的
+ * text**，所以不是能力不支持，是请求根本不被接受。
+ *
+ * 这里改名而不是两个都发：`max_tokens` 既然被判为非法参数，留着它就还是 400。
+ */

package/dist/llm/providerProtocolCore.d.ts

@@ -0,0 +1,4 @@
+/** UXP 可安全打包的 OpenAI 协议族；schema 留在兼容入口。 */
+export type LlmApiProtocol = 'openai-compatible' | 'openai-responses';
+export declare function resolveProviderExtraAuthHeaders(providerId: string, apiKey: string): Record<string, string>;
+export declare function applyProviderRequestBodyQuirks(providerId: string, body: Record<string, unknown>): Record<string, unknown>;

package/dist/llm/providerProtocolCore.js

@@ -0,0 +1,35 @@
+const PROVIDER_EXTRA_AUTH_HEADERS = {
+    mimo: 'api-key',
+};
+export function resolveProviderExtraAuthHeaders(providerId, apiKey) {
+    const headerName = PROVIDER_EXTRA_AUTH_HEADERS[providerId.trim().toLowerCase()];
+    return headerName && apiKey ? { [headerName]: apiKey } : {};
+}
+export function applyProviderRequestBodyQuirks(providerId, body) {
+    const normalizedProviderId = providerId.trim().toLowerCase();
+    if (normalizedProviderId === 'mimo')
+        return renameMaxCompletionTokens(body);
+    if (normalizedProviderId !== 'groq')
+        return body;
+    const withTokenLimit = renameMaxCompletionTokens(body);
+    if (!Array.isArray(withTokenLimit.messages))
+        return withTokenLimit;
+    return {
+        ...withTokenLimit,
+        // Groq 的 OpenAI 兼容接口明确不支持 messages[].name；在唯一协议边界剔除，
+        // 避免流式路径与 Vercel AI SDK 模型步各复制一份供应商判断。
+        messages: withTokenLimit.messages.map(stripMessageName),
+    };
+}
+function renameMaxCompletionTokens(body) {
+    if (!('max_tokens' in body))
+        return body;
+    const { max_tokens: maxTokens, ...rest } = body;
+    return { ...rest, max_completion_tokens: maxTokens };
+}
+function stripMessageName(message) {
+    if (!message || typeof message !== 'object' || Array.isArray(message))
+        return message;
+    const { name: _unsupportedName, ...rest } = message;
+    return rest;
+}

package/dist/llm/providerReasoningRequest.d.ts

@@ -0,0 +1,4 @@
+import type { LlmReasoningConfig } from './reasoning.js';
+/** 该供应商是否有专门登记的思考参数写法；false 表示走通用兜底。 */
+export declare function hasProviderReasoningRule(providerId: string, adapter?: string): boolean;
+export declare function applyProviderReasoningRequestBody(providerId: string, adapter: string | undefined, body: Record<string, unknown>, reasoning: LlmReasoningConfig | undefined): Record<string, unknown>;

package/dist/llm/providerReasoningRequest.js

@@ -0,0 +1,101 @@
+/**
+ * 把项目统一的「思考模式」设置翻译成各供应商实际接受的请求字段。
+ *
+ * 为什么需要这一层：项目对用户只暴露一个「关闭 / 低 / 中 / 高 / 极高 / 最高」的下拉，但七家
+ * 供应商的写法各不相同——字段名有 `reasoning_effort`、`thinking`、`enable_thinking` 三种，
+ * 取值集合从 3 档到 7 档不等，能不能关也不一样（Kimi K3、GLM-5.3 写死始终思考）。
+ * 资料出处见 `docs/llm-adaptation/README.md` 的「思考参数速查」表与各供应商文档。
+ *
+ * 在此之前，两条发请求的路径都只对 DeepSeek 做了处理，其余供应商的思考模式下拉**发出去的请求里
+ * 根本没有对应字段**，改了没有任何效果；而且两条路径给 DeepSeek 发的字段还不一致（原生流式发的是
+ * `reasoning: true`，不是官方文档要求的 `thinking` + `reasoning_effort`）。这里收成一份，
+ * 两条路径共用。
+ *
+ * 没登记的供应商走通用兜底：只发 OpenAI 事实标准的 `reasoning_effort`，不发任何某一家的私有字段
+ * （`thinking`、`enable_thinking` 都是私有写法，发给不认识它的网关可能直接 400）。
+ * 两条路径都在调用前用模型的 `capabilities.reasoning` 兜一层，所以兜底只会命中用户明确标了
+ * 「支持思考」的模型。
+ */
+/** 用户可选强度，从低到高。 */
+const EFFORT_SCALE = ['low', 'medium', 'high', 'xhigh', 'max'];
+/**
+ * 把统一强度落到某家实际支持的档位上：取不超过用户选择的最高一档，
+ * 用户选得比对方最低档还低时取最低档。这样"调高一定不会变低"的直觉始终成立。
+ */
+function pickEffort(effort, supported) {
+    const target = EFFORT_SCALE.indexOf(effort);
+    let picked = supported[0];
+    for (const candidate of supported) {
+        if (EFFORT_SCALE.indexOf(candidate) <= target)
+            picked = candidate;
+    }
+    return picked;
+}
+const PROVIDER_REASONING_BODY = {
+    // DeepSeek：官方要求 thinking 与 reasoning_effort 同时传；文档没有列举离散档位，
+    // 沿用此前 SDK 路径已有的 high / max 两档映射。
+    deepseek: reasoning => (reasoning.enabled
+        ? { thinking: { type: 'enabled' }, reasoning_effort: pickEffort(reasoning.effort, ['high', 'max']) }
+        : { thinking: { type: 'disabled' } }),
+    // Kimi K3：始终思考、官方没有关闭开关，只有 low / high / max 三档。
+    // 用户选「关闭」时退到最低档，而不是假装关掉——这一点在供应商预设的说明里也写了。
+    kimi: reasoning => ({
+        reasoning_effort: reasoning.enabled ? pickEffort(reasoning.effort, ['low', 'high', 'max']) : 'low',
+    }),
+    // 智谱 GLM：GLM-5.3 传 thinking.type='disabled' 会直接请求失败（官方迁移说明写明），
+    // 而 GLM-5V-Turbo 不传即为关闭。所以关闭时整段不发，让两个模型各自走默认，
+    // 而不是发一个会让旗舰模型 400 的字段。
+    bigmodel: reasoning => (reasoning.enabled
+        ? { thinking: { type: 'enabled' }, reasoning_effort: pickEffort(reasoning.effort, ['low', 'high', 'max']) }
+        : {}),
+    // 火山引擎：reasoning_effort 有 none/minimal/low/medium/high/xhigh/max 七档，
+    // 与项目档位重合的五档直接透传，关闭时用 thinking 开关。
+    volcengine: reasoning => (reasoning.enabled
+        ? {
+            thinking: { type: 'enabled' },
+            reasoning_effort: pickEffort(reasoning.effort, ['low', 'medium', 'high', 'xhigh', 'max']),
+        }
+        : { thinking: { type: 'disabled' } }),
+    // 阿里云百炼：布尔开关，没有强度分级。
+    bailian: reasoning => ({ enable_thinking: reasoning.enabled }),
+    // Groq GPT-OSS：只接受 low / medium / high；不支持 reasoning_format。
+    // include_reasoning 是独立的返回控制开关，关闭时不再发送 reasoning_effort。
+    groq: reasoning => (reasoning.enabled
+        ? {
+            reasoning_effort: pickEffort(reasoning.effort, ['low', 'medium', 'high']),
+            include_reasoning: true,
+        }
+        : { include_reasoning: false }),
+    // 小米 MiMo、MiniMax：官方文档只约定了思考内容怎么回传，没有给出请求侧的开关或强度字段，
+    // 因此不下发任何字段。等文档补齐再加，不要凭字段名相似猜。
+};
+/**
+ * 未登记供应商的兜底：只发 OpenAI 事实标准字段，关闭时什么都不发。
+ *
+ * 关闭时不发 `reasoning_effort: 'none'` 之类的值——那是火山引擎的私有取值，不是通用约定。
+ */
+const defaultReasoningBody = reasoning => (reasoning.enabled ? { reasoning_effort: reasoning.effort } : {});
+/**
+ * 供应商登记键：先认 `providerId`，再退回 `adapter`。
+ *
+ * 退回 adapter 是为了保住既有行为——用户可以把 DeepSeek 供应商命名成别的 id，
+ * 只要适配器仍选 deepseek，思考参数就该照旧生效。
+ */
+function resolveReasoningKey(providerId, adapter) {
+    const normalizedProviderId = providerId.trim().toLowerCase();
+    if (normalizedProviderId in PROVIDER_REASONING_BODY)
+        return normalizedProviderId;
+    const normalizedAdapter = adapter?.trim().toLowerCase() ?? '';
+    return normalizedAdapter in PROVIDER_REASONING_BODY ? normalizedAdapter : null;
+}
+/** 该供应商是否有专门登记的思考参数写法；false 表示走通用兜底。 */
+export function hasProviderReasoningRule(providerId, adapter) {
+    return resolveReasoningKey(providerId, adapter) !== null;
+}
+export function applyProviderReasoningRequestBody(providerId, adapter, body, reasoning) {
+    if (!reasoning)
+        return body;
+    const key = resolveReasoningKey(providerId, adapter);
+    const build = key ? PROVIDER_REASONING_BODY[key] : defaultReasoningBody;
+    return { ...body, ...build(reasoning) };
+}

package/dist/llm/providerSetup.d.ts

@@ -0,0 +1,6 @@
+import type { LlmProviderConfig, LlmProviderSetup } from './types.js';
+export declare const LLM_API_KEY_URL_MAX_LENGTH = 2048;
+export declare function normalizeLlmApiKeyManagementUrl(value: string): string;
+export declare function normalizeLlmProviderSetup(setup: LlmProviderSetup): LlmProviderSetup;
+/** endpoint profile 官方地址优先，其次 preset，最后才是 custom URL。 */
+export declare function resolveLlmProviderApiKeyUrl(provider: LlmProviderConfig): string | null;

package/dist/llm/providerSetup.js

@@ -0,0 +1,89 @@
+import { getLlmEndpointProfileFamily, resolveLlmEndpointIdentity } from './endpointProfiles.js';
+import { findLlmProviderPreset, LLM_PROVIDER_PRESETS } from './providerPresets.js';
+export const LLM_API_KEY_URL_MAX_LENGTH = 2_048;
+export function normalizeLlmApiKeyManagementUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new Error('[llm_api_key_url_invalid] API key management URL must not be empty');
+    if (trimmed.length > LLM_API_KEY_URL_MAX_LENGTH) {
+        throw new Error(`[llm_api_key_url_invalid] API key management URL exceeds ${LLM_API_KEY_URL_MAX_LENGTH} characters`);
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        throw new Error('[llm_api_key_url_invalid] API key management URL must be an absolute HTTP(S) URL');
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        throw new Error(`[llm_api_key_url_invalid] unsupported protocol "${parsed.protocol}"; use https:// or http://`);
+    }
+    if (parsed.username || parsed.password) {
+        throw new Error('[llm_api_key_url_invalid] API key management URL must not contain embedded credentials');
+    }
+    return parsed.toString();
+}
+export function normalizeLlmProviderSetup(setup) {
+    if (setup.kind === 'custom') {
+        if (setup.apiKeyManagementUrl !== undefined && typeof setup.apiKeyManagementUrl !== 'string') {
+            throw new Error('[llm_api_key_url_invalid] API key management URL must be a string');
+        }
+        return {
+            kind: 'custom',
+            ...(setup.apiKeyManagementUrl
+                ? { apiKeyManagementUrl: normalizeLlmApiKeyManagementUrl(setup.apiKeyManagementUrl) }
+                : {}),
+        };
+    }
+    if (setup.kind !== 'preset') {
+        throw new Error('[llm_provider_setup_invalid] setup kind must be "preset" or "custom"');
+    }
+    if (typeof setup.presetId !== 'string') {
+        throw new Error('[llm_provider_preset_unknown] preset id must be a string');
+    }
+    if (setup.lifecycle !== 'builtin' && setup.lifecycle !== 'user') {
+        throw new Error('[llm_provider_lifecycle_invalid] preset lifecycle must be "builtin" or "user"');
+    }
+    const presetId = setup.presetId.trim().toLowerCase();
+    if (!findLlmProviderPreset(presetId)) {
+        throw new Error(`[llm_provider_preset_unknown] preset "${presetId || '(empty)'}" is unavailable; choose one of: ${LLM_PROVIDER_PRESETS.map(item => item.providerId).join(', ')}`);
+    }
+    const overrides = setup.connectionOverrides;
+    if (overrides !== undefined && (typeof overrides !== 'object' || overrides === null)) {
+        throw new Error('[llm_provider_connection_override_invalid] preset connection overrides must be an object');
+    }
+    if (overrides?.baseUrl !== undefined && typeof overrides.baseUrl !== 'string') {
+        throw new Error('[llm_provider_connection_override_invalid] preset baseUrl override must be a string');
+    }
+    const baseUrl = overrides?.baseUrl?.trim();
+    const apiProtocol = overrides?.apiProtocol;
+    if (apiProtocol !== undefined && apiProtocol !== 'openai-compatible' && apiProtocol !== 'openai-responses') {
+        throw new Error('[llm_provider_connection_override_invalid] unsupported preset API protocol override');
+    }
+    const connectionOverrides = {
+        ...(baseUrl ? { baseUrl } : {}),
+        ...(apiProtocol ? { apiProtocol } : {}),
+    };
+    return {
+        kind: 'preset',
+        presetId,
+        lifecycle: setup.lifecycle,
+        ...(Object.keys(connectionOverrides).length > 0 ? { connectionOverrides } : {}),
+    };
+}
+/** endpoint profile 官方地址优先，其次 preset，最后才是 custom URL。 */
+export function resolveLlmProviderApiKeyUrl(provider) {
+    const identity = resolveLlmEndpointIdentity(provider);
+    const family = getLlmEndpointProfileFamily(identity.providerFamilyId);
+    const profile = family?.profiles.find(item => item.id === identity.endpointProfile);
+    if (profile)
+        return normalizeLlmApiKeyManagementUrl(profile.apiKeyUrl);
+    const setup = provider.setup ? normalizeLlmProviderSetup(provider.setup) : undefined;
+    if (setup?.kind === 'preset') {
+        const preset = findLlmProviderPreset(setup.presetId);
+        return preset ? normalizeLlmApiKeyManagementUrl(preset.apiKeyUrl) : null;
+    }
+    return setup?.kind === 'custom' && setup.apiKeyManagementUrl
+        ? normalizeLlmApiKeyManagementUrl(setup.apiKeyManagementUrl)
+        : null;
+}

package/dist/llm/reasoning.d.ts

@@ -0,0 +1,5 @@
+export type LlmReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export interface LlmReasoningConfig {
+    enabled: boolean;
+    effort: LlmReasoningEffort;
+}

package/dist/llm/reasoning.js

@@ -0,0 +1 @@
+export {};

package/dist/llm/requestContract.d.ts

@@ -0,0 +1,6 @@
+import type { LlmReasoningConfig } from './reasoning.js';
+/**
+ * 统一解析 renderer → main 的推理配置。
+ * 新契约保留 enabled/effort；旧版布尔值继续兼容，避免升级中的在途调用被拒绝。
+ */
+export declare function parseLlmReasoningConfig(value: unknown): LlmReasoningConfig | undefined;

package/dist/llm/requestContract.js

@@ -0,0 +1,35 @@
+/**
+ * 任务 4.2 从 `electron/main/services/llm/request-contract.ts` 迁入，逻辑不变。
+ * 文件名不叫 `request-contract.ts` 是为了避免与仓库既有的 kebab-case/camelCase 混用习惯
+ * 冲突——本目录下 4.1 迁入的文件（`providerProtocol.ts`、`modelCatalog.ts` 等）统一用
+ * camelCase，这里保持一致。
+ */
+const REASONING_EFFORTS = [
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max',
+];
+function isReasoningEffort(value) {
+    return typeof value === 'string' && REASONING_EFFORTS.includes(value);
+}
+/**
+ * 统一解析 renderer → main 的推理配置。
+ * 新契约保留 enabled/effort；旧版布尔值继续兼容，避免升级中的在途调用被拒绝。
+ */
+export function parseLlmReasoningConfig(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'boolean') {
+        return { enabled: value, effort: 'high' };
+    }
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error('Expected reasoning to be a boolean or an object with enabled and effort fields');
+    }
+    const record = value;
+    if (typeof record.enabled !== 'boolean' || !isReasoningEffort(record.effort)) {
+        throw new Error('Expected reasoning.enabled to be boolean and reasoning.effort to be low, medium, high, xhigh, or max');
+    }
+    return { enabled: record.enabled, effort: record.effort };
+}

package/dist/llm/sdk/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Vercel AI SDK 模型步路径（`llm:modelStep`）的供应商无关执行层。
+ * 任务 4.2 从 `electron/main/services/llm/sdk/` 迁入（trace/capability-smoke/
+ * scripted-model-step 三处按重要记录.md 记录 014 决定留在痕迹AI，不在此列）。
+ *
+ * openai-compatible adapter 由 `resolveModelStepProviderAdapter` / `createModelStepLanguageModel`
+ * 首次使用时惰性装入，不依赖模块加载副作用，确保发布包可安全声明 `sideEffects: false`。
+ */
+export * from './toolSchema.js';
+export * from './retryPolicy.js';
+export * from './providerAdapter.js';
+export * from './provider.js';
+export * from './modelStep.js';
+export * from './runtime.js';

package/dist/llm/sdk/index.js

@@ -0,0 +1,14 @@
+/**
+ * Vercel AI SDK 模型步路径（`llm:modelStep`）的供应商无关执行层。
+ * 任务 4.2 从 `electron/main/services/llm/sdk/` 迁入（trace/capability-smoke/
+ * scripted-model-step 三处按重要记录.md 记录 014 决定留在痕迹AI，不在此列）。
+ *
+ * openai-compatible adapter 由 `resolveModelStepProviderAdapter` / `createModelStepLanguageModel`
+ * 首次使用时惰性装入，不依赖模块加载副作用，确保发布包可安全声明 `sideEffects: false`。
+ */
+export * from './toolSchema.js';
+export * from './retryPolicy.js';
+export * from './providerAdapter.js';
+export * from './provider.js';
+export * from './modelStep.js';
+export * from './runtime.js';