@henjicc/ai-sdk 0.2.8

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

@@ -0,0 +1,24 @@
+import type { ProviderOptions } from '@ai-sdk/provider-utils';
+import { type LanguageModel } from 'ai';
+import { type ModelStepEvent, type ModelStepInput, type ModelStepMessage, type ModelStepResult, type ModelStepUsage } from '../modelStep.js';
+/** 任务 4.2 从应用侧 LLM 执行层迁入 SDK，逻辑不变。 */
+export type ModelStepEmitter = (event: ModelStepEvent) => void;
+export interface ModelStepStreamTrace {
+    startedAt: number;
+    firstChunkMs: number | null;
+    totalEventCount: number;
+    textDeltaCount: number;
+    reasoningDeltaCount: number;
+    toolCallCount: number;
+    textCharacters: number;
+    reasoningCharacters: number;
+}
+/**
+ * 修复旧会话或异常截断留下的不完整工具消息组。
+ * 供应商要求 assistant tool-calls 与紧随其后的全部 tool-result 成组出现；
+ * 不能补齐时宁可移除未验证片段，也不能把孤立 role=tool 发给模型。
+ */
+export declare function normalizeModelToolMessagePairs(messages: ModelStepMessage[]): ModelStepMessage[];
+export declare function buildModelStepProviderOptions(input: ModelStepInput): ProviderOptions | undefined;
+export declare function calculateModelStepKnownCostUsd(usage: Omit<ModelStepUsage, 'knownCostUsd'>, pricing: ModelStepInput['pricing']): number | null;
+export declare function executeModelStepWithModel(rawInput: ModelStepInput, model: LanguageModel, emit: ModelStepEmitter, signal: AbortSignal, streamTrace?: ModelStepStreamTrace): Promise<ModelStepResult>;

package/dist/llm/sdk/modelStep.js

@@ -0,0 +1,254 @@
+import { Output, jsonSchema, streamText, tool, } from 'ai';
+import { assertModelStepInputCapabilities, detectModelStepInputModalities, modelStepInputSchema, modelStepMessageSchema, modelStepResultSchema, modelStepToolCallSchema, } from '../modelStep.js';
+import { normalizeProviderToolSchema } from './toolSchema.js';
+function contentParts(message) {
+    return Array.isArray(message.content) ? message.content : [];
+}
+function toolCallIds(message) {
+    if (message.role !== 'assistant')
+        return [];
+    return contentParts(message).flatMap((part) => (part.type === 'tool-call' && typeof part.toolCallId === 'string'
+        ? [part.toolCallId]
+        : []));
+}
+function toolResultIds(messages) {
+    return messages.flatMap((message) => (message.role !== 'tool'
+        ? []
+        : contentParts(message).flatMap((part) => (part.type === 'tool-result' && typeof part.toolCallId === 'string'
+            ? [part.toolCallId]
+            : []))));
+}
+function withoutToolCalls(message) {
+    if (message.role !== 'assistant' || !Array.isArray(message.content))
+        return message;
+    const content = message.content.filter((part) => part.type !== 'tool-call');
+    return content.length > 0 ? { ...message, content } : null;
+}
+/**
+ * 修复旧会话或异常截断留下的不完整工具消息组。
+ * 供应商要求 assistant tool-calls 与紧随其后的全部 tool-result 成组出现；
+ * 不能补齐时宁可移除未验证片段，也不能把孤立 role=tool 发给模型。
+ */
+export function normalizeModelToolMessagePairs(messages) {
+    const normalized = [];
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = modelStepMessageSchema.parse(messages[index]);
+        if (message.role === 'tool')
+            continue;
+        const callIds = toolCallIds(message);
+        if (callIds.length === 0) {
+            normalized.push(message);
+            continue;
+        }
+        const followingTools = [];
+        let cursor = index + 1;
+        while (cursor < messages.length && messages[cursor]?.role === 'tool') {
+            followingTools.push(modelStepMessageSchema.parse(messages[cursor]));
+            cursor += 1;
+        }
+        const expected = new Set(callIds);
+        const results = toolResultIds(followingTools);
+        const complete = expected.size === callIds.length
+            && results.length === expected.size
+            && results.every((id) => expected.has(id));
+        if (complete) {
+            normalized.push(message, ...followingTools);
+        }
+        else {
+            const retained = withoutToolCalls(message);
+            if (retained)
+                normalized.push(retained);
+        }
+        index = cursor - 1;
+    }
+    return normalized;
+}
+function toAiMessages(messages) {
+    return normalizeModelToolMessagePairs(messages);
+}
+function buildTools(input) {
+    if (!input.tools?.length)
+        return undefined;
+    if (!input.capabilities.toolCall)
+        throw new Error('[unsupported_capability] Model does not support tool calling');
+    return Object.fromEntries(input.tools.map((definition) => {
+        // strict 只能如实声明：schema 不满足 strict 子集时降级，不为了凑格式篡改语义。
+        const normalized = normalizeProviderToolSchema(definition.inputSchema, definition.strict);
+        return [
+            definition.name,
+            tool({
+                description: definition.description,
+                inputSchema: jsonSchema(normalized.schema),
+                strict: normalized.strict,
+            }),
+        ];
+    }));
+}
+export function buildModelStepProviderOptions(input) {
+    /*
+     * 思考参数不再从这里下发。
+     *
+     * 原来非 deepseek 的供应商在这里塞 `openaiCompatible.reasoningEffort`，发出去的是用户选的原始档位，
+     * 而各家支持的取值集合不同（Kimi/GLM 只有 low/high/max，没有 medium/xhigh），还缺少 `thinking`、
+     * `enable_thinking` 这类开关。现在统一由 `applyProviderReasoningRequestBody` 在 `provider.ts` 的
+     * `transformRequestBody` 里按供应商翻译，和原生流式路径共用一份映射，这里只透传调用方显式给的选项。
+     */
+    const options = { ...input.providerOptions };
+    if (input.apiProtocol === 'openai-responses') {
+        const openai = options.openai && typeof options.openai === 'object'
+            ? options.openai
+            : {};
+        // 助手始终自行保存完整会话；关闭供应商侧托管也兼容 DeepSeek 的无状态 Responses 实现。
+        options.openai = { ...openai, store: false };
+    }
+    return Object.keys(options).length > 0 ? options : undefined;
+}
+export function calculateModelStepKnownCostUsd(usage, pricing) {
+    if (!pricing || usage.inputTokens === null || usage.outputTokens === null)
+        return null;
+    const cacheRead = usage.cacheReadTokens ?? 0;
+    const cacheWrite = usage.cacheWriteTokens ?? 0;
+    const inputNoCache = usage.inputNoCacheTokens
+        ?? Math.max(0, usage.inputTokens - cacheRead - cacheWrite);
+    const cost = (inputNoCache * pricing.inputPerMillionTokens
+        + cacheRead * (pricing.cacheReadPerMillionTokens ?? pricing.inputPerMillionTokens)
+        + cacheWrite * (pricing.cacheWritePerMillionTokens ?? pricing.inputPerMillionTokens)
+        + usage.outputTokens * pricing.outputPerMillionTokens) / 1_000_000;
+    return Number(cost.toFixed(12));
+}
+function normalizeUsage(usage, pricing) {
+    const normalized = {
+        inputTokens: usage.inputTokens ?? null,
+        inputNoCacheTokens: usage.inputTokenDetails.noCacheTokens ?? null,
+        cacheReadTokens: usage.inputTokenDetails.cacheReadTokens ?? null,
+        cacheWriteTokens: usage.inputTokenDetails.cacheWriteTokens ?? null,
+        outputTokens: usage.outputTokens ?? null,
+        textTokens: usage.outputTokenDetails.textTokens ?? null,
+        reasoningTokens: usage.outputTokenDetails.reasoningTokens ?? null,
+        totalTokens: usage.totalTokens ?? null,
+    };
+    return { ...normalized, knownCostUsd: calculateModelStepKnownCostUsd(normalized, pricing) };
+}
+function normalizeToolCall(call) {
+    return modelStepToolCallSchema.parse({
+        toolCallId: call.toolCallId,
+        toolName: call.toolName,
+        input: call.input,
+        dynamic: call.dynamic ?? false,
+    });
+}
+function toResponseMessages(value) {
+    const serialized = JSON.parse(JSON.stringify(value));
+    if (!Array.isArray(serialized))
+        throw new Error('[invalid_response] SDK response messages are not an array');
+    return serialized.map((message) => modelStepMessageSchema.parse(message));
+}
+function summarizeProviderMetadata(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const summary = {};
+    for (const [provider, metadata] of Object.entries(value)) {
+        summary[provider] = metadata && typeof metadata === 'object' && !Array.isArray(metadata)
+            ? Object.keys(metadata)
+            : [];
+    }
+    return summary;
+}
+function createOutput(input) {
+    if (input.output.mode === 'text')
+        return Output.text();
+    if (input.capabilities.structuredOutputMode === 'none') {
+        throw new Error('[unsupported_capability] Model does not support structured output');
+    }
+    return Output.object({
+        schema: jsonSchema(input.output.schema),
+        name: input.output.name,
+        description: input.output.description,
+    });
+}
+function isDeepSeekThinkingEnabled(input) {
+    return input.adapter?.trim().toLowerCase() === 'deepseek'
+        && input.capabilities.reasoning
+        && input.reasoning?.enabled === true;
+}
+export async function executeModelStepWithModel(rawInput, model, emit, signal, streamTrace) {
+    const input = modelStepInputSchema.parse(rawInput);
+    assertModelStepInputCapabilities(input);
+    if (input.trace)
+        input.trace.inputModalities = detectModelStepInputModalities(input.messages);
+    const startedAt = Date.now();
+    const settings = input.settings ?? {};
+    const result = streamText({
+        model,
+        system: input.system,
+        messages: toAiMessages(input.messages),
+        allowSystemInMessages: false,
+        tools: buildTools(input),
+        output: createOutput(input),
+        abortSignal: signal,
+        timeout: settings.timeoutMs,
+        // 请求重试统一由 runtime 的结构化策略负责，避免 SDK 与 Agent 双重重试。
+        maxRetries: 0,
+        maxOutputTokens: settings.maxOutputTokens,
+        // DeepSeek 思考模式不支持采样参数；明确省略以避免“看似生效但实际被忽略”。
+        temperature: input.capabilities.sampling && !isDeepSeekThinkingEnabled(input) ? settings.temperature : undefined,
+        topP: input.capabilities.sampling && !isDeepSeekThinkingEnabled(input) ? settings.topP : undefined,
+        providerOptions: buildModelStepProviderOptions(input),
+    });
+    for await (const part of result.fullStream) {
+        if (streamTrace) {
+            streamTrace.totalEventCount += 1;
+            if (streamTrace.firstChunkMs === null)
+                streamTrace.firstChunkMs = Date.now() - streamTrace.startedAt;
+        }
+        if (part.type === 'text-delta')
+            emit({ type: 'TextDelta', text: part.text });
+        else if (part.type === 'reasoning-delta')
+            emit({ type: 'ReasoningDelta', text: part.text });
+        else if (part.type === 'tool-call')
+            emit({ type: 'ToolCall', toolCall: normalizeToolCall(part) });
+        else if (part.type === 'error')
+            throw part.error;
+        else if (part.type === 'abort')
+            throw new Error('[task_cancelled] Model step aborted');
+        if (streamTrace && part.type === 'text-delta') {
+            streamTrace.textDeltaCount += 1;
+            streamTrace.textCharacters += part.text.length;
+        }
+        else if (streamTrace && part.type === 'reasoning-delta') {
+            streamTrace.reasoningDeltaCount += 1;
+            streamTrace.reasoningCharacters += part.text.length;
+        }
+        else if (streamTrace && part.type === 'tool-call') {
+            streamTrace.toolCallCount += 1;
+        }
+    }
+    const [text, reasoningText, structuredOutput, toolCalls, response, finishReason, usage, providerMetadata, warnings] = await Promise.all([
+        result.text,
+        result.reasoningText,
+        result.output,
+        result.toolCalls,
+        result.response,
+        result.finishReason,
+        result.usage,
+        result.providerMetadata,
+        result.warnings,
+    ]);
+    return modelStepResultSchema.parse({
+        requestId: input.requestId,
+        runId: input.runId,
+        stepId: input.stepId,
+        providerId: input.providerId,
+        modelId: input.modelId,
+        text,
+        reasoningText: reasoningText ?? '',
+        structuredOutput: input.output.mode === 'object' ? structuredOutput : null,
+        toolCalls: toolCalls.map(normalizeToolCall),
+        responseMessages: toResponseMessages(response.messages),
+        finishReason,
+        usage: normalizeUsage(usage, input.pricing),
+        providerMetadataSummary: summarizeProviderMetadata(providerMetadata),
+        warnings: (warnings ?? []).map((warning) => JSON.stringify(warning)),
+        elapsedMs: Date.now() - startedAt,
+    });
+}

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

@@ -0,0 +1,38 @@
+import type { LanguageModel } from 'ai';
+import type { Transport } from '../../runtime/index.js';
+import type { ModelStepInput, ModelStepUsage } from '../modelStep.js';
+import { type ModelStepHttpTrace, type ModelStepProviderAdapter } from './providerAdapter.js';
+/**
+ * 任务 4.2 从应用侧 LLM 执行层迁入 SDK。
+ *
+ * `createTraceFetch` 原来在捕获 HTTP 请求/响应时立即调用痕迹AI 助手侧的
+ * `sanitizeAgentTraceHttpRequest`/`sanitizeAgentTraceHttpResponse` 做脱敏。这里改成只捕获
+ * 原始值——脱敏只应该在"数据即将被持久化/展示"的那一刻做一次，而下游
+ * `electron/main/services/llm/sdk/trace.ts`（留在痕迹AI，见重要记录.md 记录 014）的
+ * `buildModelStepTraceDetail` 本来就会对 `httpTrace.request`/`.response` 再脱敏一遍——
+ * 原实现因此对同一份数据脱敏了两次。去掉这里的脱敏调用后：
+ * 1. 脱敏只发生一次（在真正落盘前），行为不变；
+ * 2. SDK 不再需要依赖痕迹AI 应用侧的脱敏实现，满足 SDK 不能 `@/` 引用的约束。
+ *
+ * 任务 4.3 把 Vercel AI SDK 模型步的 fetch 接到统一的 `fetchProvider` 网络入口。
+ * `transport` 作为第 4 个可选参数追加，前三个位置参数保持不变，因此痕迹AI utility 子进程的
+ * 既有调用无需改签名；公共 `runModelStep` 路径会始终显式传入宿主 `Transport`。只有直接调用
+ * `createModelStepLanguageModel` 且没有传 Transport 的 Electron 兼容路径才退回全局 fetch，
+ * 该退回仍然经过 `fetchProvider` 的安全预连接策略，不再另写一套网络判断。
+ */
+interface DeepSeekUsage {
+    prompt_cache_hit_tokens?: unknown;
+    prompt_cache_miss_tokens?: unknown;
+    prompt_tokens?: unknown;
+}
+export declare function resolveModelStepBaseUrl(input: Pick<ModelStepInput, 'providerId' | 'providerFamilyId' | 'endpointProfile' | 'credentialId' | 'adapter' | 'apiProtocol' | 'baseUrl'>): string;
+/**
+ * 显式解析模型步 adapter，并在首次使用时惰性装入内置 openai-compatible 实现。
+ * 不在模块加载阶段注册，确保发布包可以如实声明 `sideEffects: false`。
+ */
+export declare function resolveModelStepProviderAdapter(protocol: ModelStepProviderAdapter['protocol']): ModelStepProviderAdapter;
+export declare function createModelStepLanguageModel(input: ModelStepInput, apiKey: string, httpTrace?: ModelStepHttpTrace, transport?: Transport): LanguageModel;
+export declare function usesNativeJsonSchema(input: Pick<ModelStepInput, 'capabilities'>): boolean;
+/** 将 DeepSeek 独有的缓存用量字段规范成统一的模型步骤统计。 */
+export declare function applyDeepSeekUsage(usage: ModelStepUsage, rawUsage: DeepSeekUsage | undefined): ModelStepUsage;
+export {};

package/dist/llm/sdk/provider.js

@@ -0,0 +1,335 @@
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { createOpenAI } from '@ai-sdk/openai';
+import { fetchProvider } from '../../providers/provider-fetch.js';
+import { applyProviderRequestBodyQuirks, resolveProviderExtraAuthHeaders, } from '../providerProtocol.js';
+import { applyProviderReasoningRequestBody } from '../providerReasoningRequest.js';
+import { resolveOpenAiCompatibleEndpoint, resolvePpioChatEndpoint } from '../streaming.js';
+import { modelStepProviderAdapters, } from './providerAdapter.js';
+import { getLlmEndpointProfileFamily, resolveLlmEndpointIdentity } from '../endpointProfiles.js';
+function stripProtocolEndpoint(endpoint) {
+    return endpoint.replace(/\/(?:chat\/completions|responses)\/?$/, '');
+}
+export function resolveModelStepBaseUrl(input) {
+    const protocol = input.apiProtocol ?? 'openai-compatible';
+    const identityWithoutBaseUrl = resolveLlmEndpointIdentity({ ...input, baseUrl: undefined });
+    const family = getLlmEndpointProfileFamily(identityWithoutBaseUrl.providerFamilyId);
+    const profile = family?.profiles.find(item => item.id === identityWithoutBaseUrl.endpointProfile);
+    const suppliedBaseUrl = input.baseUrl ? stripProtocolEndpoint(input.baseUrl.replace(/\/+$/, '')) : undefined;
+    const profileBaseUrl = profile ? stripProtocolEndpoint(profile.baseUrl.replace(/\/+$/, '')) : undefined;
+    const selectedProtocolBaseUrl = profile?.protocolBaseUrls?.[protocol]
+        ? stripProtocolEndpoint(profile.protocolBaseUrls[protocol].replace(/\/+$/, ''))
+        : undefined;
+    const hasExplicitBaseUrlOverride = Boolean(suppliedBaseUrl
+        && suppliedBaseUrl !== profileBaseUrl
+        && suppliedBaseUrl !== selectedProtocolBaseUrl);
+    const identity = hasExplicitBaseUrlOverride
+        ? identityWithoutBaseUrl
+        : resolveLlmEndpointIdentity(input);
+    const normalizedInput = {
+        ...input,
+        providerId: identity.providerFamilyId,
+        baseUrl: hasExplicitBaseUrlOverride
+            ? suppliedBaseUrl
+            : selectedProtocolBaseUrl
+                ? selectedProtocolBaseUrl
+                : identity.baseUrl ? stripProtocolEndpoint(identity.baseUrl.replace(/\/+$/, '')) : undefined,
+    };
+    if (protocol === 'openai-responses') {
+        const baseUrl = normalizedInput.baseUrl
+            ?? (identity.providerFamilyId === 'openai' ? 'https://api.openai.com/v1' : undefined);
+        if (!baseUrl)
+            throw new Error('[llm_base_url_required] Responses API requires an explicit baseUrl');
+        return baseUrl;
+    }
+    const endpoint = identity.providerFamilyId === 'ppio'
+        ? resolvePpioChatEndpoint(normalizedInput.baseUrl)
+        : resolveOpenAiCompatibleEndpoint({
+            providerId: normalizedInput.providerId,
+            modelId: 'placeholder',
+            adapter: normalizedInput.adapter,
+            baseUrl: normalizedInput.baseUrl,
+            messages: [],
+        });
+    return stripProtocolEndpoint(endpoint);
+}
+function createOpenAiCompatibleLanguageModel(input, apiKey, httpTrace, transport) {
+    const adapter = input.adapter?.trim().toLowerCase();
+    const identity = resolveLlmEndpointIdentity(input);
+    const reasoning = input.reasoning;
+    const provider = createOpenAICompatible({
+        name: 'openai-compatible',
+        apiKey,
+        headers: resolveProviderExtraAuthHeaders(identity.providerFamilyId, apiKey),
+        baseURL: resolveModelStepBaseUrl(input),
+        includeUsage: input.capabilities.usage,
+        supportsStructuredOutputs: usesNativeJsonSchema(input),
+        fetch: createModelStepFetch(identity.providerFamilyId, httpTrace, transport, {
+            captureHttp: httpTrace?.captureHttp === true,
+            captureDeepSeekUsage: adapter === 'deepseek',
+        }),
+        // 两类差异叠加：各供应商的思考参数写法，以及各家对请求体字段的自有要求。
+        transformRequestBody: (body) => applyProviderRequestBodyQuirks(identity.providerFamilyId, input.capabilities.reasoning
+            ? applyProviderReasoningRequestBody(identity.providerFamilyId, adapter, body, reasoning)
+            : body),
+    });
+    return provider.chatModel(input.modelId);
+}
+const openAiCompatibleAdapter = {
+    protocol: 'openai-compatible',
+    // 当前 AI SDK 转换器支持图片与内联 wav/mp3，不支持视频文件。
+    supportedInputModalities: ['image', 'audio'],
+    createLanguageModel: createOpenAiCompatibleLanguageModel,
+};
+function createOpenAiResponsesLanguageModel(input, apiKey, httpTrace, transport) {
+    const identity = resolveLlmEndpointIdentity(input);
+    const adapter = input.adapter?.trim().toLowerCase();
+    const provider = createOpenAI({
+        name: 'openai',
+        apiKey,
+        headers: resolveProviderExtraAuthHeaders(identity.providerFamilyId, apiKey),
+        baseURL: resolveModelStepBaseUrl(input),
+        fetch: createModelStepFetch(identity.providerFamilyId, httpTrace, transport, {
+            captureHttp: httpTrace?.captureHttp === true,
+            captureDeepSeekUsage: adapter === 'deepseek',
+            transformRequestBody: body => applyProviderRequestBodyQuirks(identity.providerFamilyId, input.capabilities.reasoning
+                ? applyProviderReasoningRequestBody(identity.providerFamilyId, adapter, body, input.reasoning)
+                : body),
+        }),
+    });
+    return provider.responses(input.modelId);
+}
+const openAiResponsesAdapter = {
+    protocol: 'openai-responses',
+    supportedInputModalities: ['image', 'audio'],
+    createLanguageModel: createOpenAiResponsesLanguageModel,
+};
+let builtInAdaptersInitialized = false;
+function ensureOpenAiCompatibleAdapterInitialized() {
+    if (builtInAdaptersInitialized)
+        return;
+    modelStepProviderAdapters.register(openAiCompatibleAdapter);
+    modelStepProviderAdapters.register(openAiResponsesAdapter);
+    builtInAdaptersInitialized = true;
+}
+/**
+ * 显式解析模型步 adapter，并在首次使用时惰性装入内置 openai-compatible 实现。
+ * 不在模块加载阶段注册，确保发布包可以如实声明 `sideEffects: false`。
+ */
+export function resolveModelStepProviderAdapter(protocol) {
+    ensureOpenAiCompatibleAdapterInitialized();
+    return modelStepProviderAdapters.resolve(protocol);
+}
+export function createModelStepLanguageModel(input, apiKey, httpTrace, transport) {
+    const protocol = input.apiProtocol ?? 'openai-compatible';
+    const adapter = resolveModelStepProviderAdapter(protocol);
+    modelStepProviderAdapters.assertInputModalities(protocol, input);
+    return adapter.createLanguageModel(input, apiKey, httpTrace, transport);
+}
+function createModelStepFetch(providerId, trace, transport, options) {
+    return async (input, init) => {
+        try {
+            const request = applyFetchRequestBodyTransform(await normalizeFetchRequest(input, init), options.transformRequestBody);
+            if (options.captureHttp && trace) {
+                trace.request = await buildTraceRequest(request.url, request.init);
+            }
+            const response = await fetchProvider(providerId, request.url, request.init ?? {}, {
+                transport: transport ?? globalFetchTransport(),
+                retryPreconnectOnce: true,
+            });
+            if (options.captureHttp && trace) {
+                const responseTrace = {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: headersToRecord(response.headers),
+                };
+                if (!response.ok) {
+                    try {
+                        const body = await response.clone().text();
+                        responseTrace.errorBody = body.slice(0, 64 * 1024);
+                    }
+                    catch {
+                        // 某些供应商的错误响应无法克隆，不影响原请求返回。
+                    }
+                }
+                trace.response = responseTrace;
+            }
+            if (options.captureDeepSeekUsage && response.ok && trace) {
+                trace.usageCapture = captureDeepSeekUsage(response).then((usage) => {
+                    if (usage)
+                        trace.deepSeekUsage = usage;
+                }).catch(() => undefined);
+            }
+            return response;
+        }
+        catch (error) {
+            if (options.captureHttp && trace) {
+                trace.response = {
+                    errorBody: error instanceof Error ? error.message : String(error),
+                };
+            }
+            throw error;
+        }
+    };
+}
+function applyFetchRequestBodyTransform(request, transform) {
+    if (!transform || typeof request.init?.body !== 'string')
+        return request;
+    try {
+        const parsed = JSON.parse(request.init.body);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return request;
+        return {
+            ...request,
+            init: { ...request.init, body: JSON.stringify(transform(parsed)) },
+        };
+    }
+    catch {
+        return request;
+    }
+}
+function globalFetchTransport() {
+    if (typeof globalThis.fetch !== 'function') {
+        throw new Error('[TRANSPORT_REQUIRED] createModelStepLanguageModel requires a Transport in this runtime');
+    }
+    return { fetch: (url, init) => globalThis.fetch(url, init) };
+}
+async function normalizeFetchRequest(input, init) {
+    if (!isRequest(input))
+        return { url: String(input), init };
+    if (init)
+        return { url: input.url, init };
+    const method = input.method || 'GET';
+    const body = method === 'GET' || method === 'HEAD'
+        ? undefined
+        : await input.clone().arrayBuffer();
+    return {
+        url: input.url,
+        init: {
+            method,
+            headers: input.headers,
+            body,
+            signal: input.signal,
+        },
+    };
+}
+async function buildTraceRequest(input, init) {
+    const requestHeaders = init?.headers ?? (isRequest(input) ? input.headers : undefined);
+    let body = null;
+    if (typeof init?.body === 'string') {
+        body = parseBody(init.body);
+    }
+    else if (isRequest(input) && init?.body === undefined) {
+        try {
+            body = parseBody(await input.clone().text());
+        }
+        catch {
+            body = null;
+        }
+    }
+    else if (init?.body !== undefined && init.body !== null) {
+        body = String(init.body);
+    }
+    return {
+        method: init?.method ?? (isRequest(input) ? input.method : 'GET'),
+        url: isRequest(input) ? input.url : String(input),
+        headers: headersToRecord(requestHeaders),
+        body,
+    };
+}
+function headersToRecord(headers) {
+    if (!headers)
+        return {};
+    if (headers instanceof Headers) {
+        // `Headers.entries()`/`[Symbol.iterator]` 需要 `DOM.Iterable` lib，SDK 的 tsconfig
+        // 刻意只含 `["ES2022", "DOM"]`（见 tsconfig.json 顶部注释），不额外引入。`forEach` 是
+        // 基础 `Headers` 接口自带的常规方法，不依赖迭代协议，三个目标运行时都能用。
+        const record = {};
+        headers.forEach((value, key) => { record[key] = value; });
+        return record;
+    }
+    if (Array.isArray(headers))
+        return Object.fromEntries(headers.map((entry) => [String(entry[0]), String(entry[1])]));
+    if (typeof headers === 'object')
+        return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, String(value)]));
+    return {};
+}
+function parseBody(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function isRequest(value) {
+    return typeof value === 'object' && value !== null && 'url' in value && 'clone' in value;
+}
+export function usesNativeJsonSchema(input) {
+    return input.capabilities.structuredOutputMode === 'schema';
+}
+function toNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0
+        ? Math.trunc(value)
+        : null;
+}
+/** 将 DeepSeek 独有的缓存用量字段规范成统一的模型步骤统计。 */
+export function applyDeepSeekUsage(usage, rawUsage) {
+    if (!rawUsage)
+        return usage;
+    const cacheReadTokens = toNonNegativeInteger(rawUsage.prompt_cache_hit_tokens);
+    const inputNoCacheTokens = toNonNegativeInteger(rawUsage.prompt_cache_miss_tokens);
+    const promptTokens = toNonNegativeInteger(rawUsage.prompt_tokens);
+    if (cacheReadTokens === null && inputNoCacheTokens === null && promptTokens === null)
+        return usage;
+    return {
+        ...usage,
+        inputTokens: promptTokens ?? usage.inputTokens ?? (cacheReadTokens !== null && inputNoCacheTokens !== null ? cacheReadTokens + inputNoCacheTokens : null),
+        inputNoCacheTokens: inputNoCacheTokens ?? usage.inputNoCacheTokens,
+        cacheReadTokens: cacheReadTokens ?? usage.cacheReadTokens,
+    };
+}
+async function captureDeepSeekUsage(response) {
+    const body = response.clone().body;
+    if (!body)
+        return undefined;
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let pending = '';
+    let usage;
+    let completed = false;
+    try {
+        while (!completed) {
+            const next = await reader.read();
+            if (next.done) {
+                completed = true;
+                continue;
+            }
+            pending += decoder.decode(next.value, { stream: true });
+            const lines = pending.split(/\r?\n/);
+            pending = lines.pop() ?? '';
+            for (const line of lines) {
+                const parsed = parseSseUsage(line);
+                if (parsed)
+                    usage = parsed;
+            }
+        }
+        const final = pending + decoder.decode();
+        const parsed = parseSseUsage(final);
+        return parsed ?? usage;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function parseSseUsage(line) {
+    const data = line.trim().replace(/^data:\s*/, '');
+    if (!data || data === '[DONE]')
+        return undefined;
+    try {
+        const value = JSON.parse(data);
+        return value.usage;
+    }
+    catch {
+        return undefined;
+    }
+}