@hunterzhu/pulse-adapters 0.4.1 → 0.4.3

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './providers/canonical/index.js';
 export * from './providers/types.js';
 export * from './providers/normalize.js';
 export * from './providers/mock.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from './providers/canonical/index.js';
 export * from './providers/types.js';
 export * from './providers/normalize.js';
 export * from './providers/mock.js';

package/dist/providers/canonical/capabilities.d.ts

@@ -0,0 +1,19 @@
+import type { ModelCapabilityProfile } from './types.js';
+export declare const DEFAULT_OPENAI_PROFILE: ModelCapabilityProfile;
+export declare const OPENAI_REASONING_PROFILE: ModelCapabilityProfile;
+export declare const ANTHROPIC_THINKING_PROFILE: ModelCapabilityProfile;
+export declare const DEFAULT_ANTHROPIC_PROFILE: ModelCapabilityProfile;
+export declare const DEEPSEEK_PROFILE: ModelCapabilityProfile;
+export declare const DEFAULT_COMPATIBLE_PROFILE: ModelCapabilityProfile;
+declare class CapabilityRegistry {
+    private readonly customProfiles;
+    registerProfile(pattern: string, profile: Partial<ModelCapabilityProfile>): void;
+    unregisterProfile(pattern: string): void;
+    resolve(model?: string, provider?: string, override?: Partial<ModelCapabilityProfile>): ModelCapabilityProfile;
+    private matchCustom;
+    private resolveBase;
+    private mergeProfile;
+}
+export declare const capabilityRegistry: CapabilityRegistry;
+export declare function resolveModelCapability(model?: string, provider?: string, override?: Partial<ModelCapabilityProfile>): ModelCapabilityProfile;
+export {};

package/dist/providers/canonical/capabilities.js

@@ -0,0 +1,164 @@
+export const DEFAULT_OPENAI_PROFILE = {
+    id: 'openai-default',
+    provider: 'openai',
+    structuredOutput: 'native_strict',
+    reasoning: 'effort_param',
+    constraints: {
+        disallowTemperatureWithReasoning: false,
+        maxTokensParamName: 'max_tokens',
+        supportsSystemMessage: true,
+        supportsParallelTools: true,
+    },
+};
+export const OPENAI_REASONING_PROFILE = {
+    id: 'openai-reasoning',
+    provider: 'openai',
+    structuredOutput: 'native_strict',
+    reasoning: 'effort_param',
+    constraints: {
+        disallowTemperatureWithReasoning: true,
+        defaultTemperatureWithReasoning: 1.0,
+        maxTokensParamName: 'max_completion_tokens',
+        supportsSystemMessage: true,
+        supportsParallelTools: true,
+    },
+};
+export const ANTHROPIC_THINKING_PROFILE = {
+    id: 'anthropic-thinking',
+    provider: 'anthropic',
+    structuredOutput: 'native_loose',
+    reasoning: 'budget_tokens',
+    constraints: {
+        disallowTemperatureWithReasoning: true,
+        defaultTemperatureWithReasoning: 1.0,
+        maxTokensParamName: 'max_tokens',
+        supportsSystemMessage: true,
+        supportsParallelTools: true,
+    },
+};
+export const DEFAULT_ANTHROPIC_PROFILE = {
+    id: 'anthropic-default',
+    provider: 'anthropic',
+    structuredOutput: 'native_loose',
+    reasoning: 'unsupported',
+    constraints: {
+        disallowTemperatureWithReasoning: false,
+        maxTokensParamName: 'max_tokens',
+        supportsSystemMessage: true,
+        supportsParallelTools: true,
+    },
+};
+export const DEEPSEEK_PROFILE = {
+    id: 'deepseek-default',
+    provider: 'deepseek',
+    structuredOutput: 'json_object_only',
+    reasoning: 'effort_param',
+    constraints: {
+        disallowTemperatureWithReasoning: false,
+        maxTokensParamName: 'max_tokens',
+        supportsSystemMessage: true,
+        supportsParallelTools: true,
+    },
+};
+export const DEFAULT_COMPATIBLE_PROFILE = {
+    id: 'openai-compatible-default',
+    provider: 'openai-compatible',
+    structuredOutput: 'native_strict',
+    reasoning: 'effort_param',
+    constraints: {
+        disallowTemperatureWithReasoning: false,
+        maxTokensParamName: 'max_tokens',
+        supportsSystemMessage: true,
+        supportsParallelTools: true,
+    },
+};
+class CapabilityRegistry {
+    customProfiles = new Map();
+    registerProfile(pattern, profile) {
+        const key = pattern.trim().toLowerCase();
+        if (!key)
+            return;
+        this.customProfiles.set(key, profile);
+    }
+    unregisterProfile(pattern) {
+        this.customProfiles.delete(pattern.trim().toLowerCase());
+    }
+    resolve(model, provider, override) {
+        const normProvider = (provider ?? 'openai').toLowerCase();
+        const normModel = (model ?? '').toLowerCase();
+        const custom = this.matchCustom(normProvider, normModel);
+        const base = this.resolveBase(normModel, normProvider);
+        return this.mergeProfile(base, custom, override);
+    }
+    matchCustom(normProvider, normModel) {
+        let best;
+        for (const [pattern, profile] of this.customProfiles) {
+            if (!profileMatches(normProvider, normModel, pattern))
+                continue;
+            if (!best || pattern.length > best.length)
+                best = { length: pattern.length, profile };
+        }
+        return best?.profile;
+    }
+    resolveBase(normModel, normProvider) {
+        if (normProvider === 'anthropic') {
+            if (normModel.includes('claude-3-7') || normModel.includes('thinking')) {
+                return { ...ANTHROPIC_THINKING_PROFILE, provider: normProvider, id: `anthropic:${normModel}` };
+            }
+            return { ...DEFAULT_ANTHROPIC_PROFILE, provider: normProvider, id: `anthropic:${normModel || 'default'}` };
+        }
+        // DeepSeek json_object mode follows the protocol id. A model name that
+        // merely contains "deepseek" keeps the caller's structured-output contract.
+        if (normProvider === 'deepseek') {
+            return { ...DEEPSEEK_PROFILE, provider: normProvider, id: `deepseek:${normModel || 'default'}` };
+        }
+        if (normProvider === 'openai' || normProvider === 'openai-compatible') {
+            if (isOpenAIReasoningModel(normModel)) {
+                return { ...OPENAI_REASONING_PROFILE, provider: normProvider, id: `${normProvider}:${normModel}` };
+            }
+            return { ...DEFAULT_OPENAI_PROFILE, provider: normProvider, id: `${normProvider}:${normModel || 'default'}` };
+        }
+        return { ...DEFAULT_COMPATIBLE_PROFILE, provider: normProvider, id: `${normProvider}:${normModel || 'default'}` };
+    }
+    mergeProfile(base, ...overrides) {
+        let result = { ...base, constraints: { ...base.constraints } };
+        for (const over of overrides) {
+            if (!over)
+                continue;
+            result = {
+                ...result,
+                ...over,
+                constraints: {
+                    ...result.constraints,
+                    ...(over.constraints ?? {}),
+                },
+            };
+        }
+        return result;
+    }
+}
+export const capabilityRegistry = new CapabilityRegistry();
+export function resolveModelCapability(model, provider, override) {
+    return capabilityRegistry.resolve(model, provider, override);
+}
+/** o1/o3 and their suffixed ids. `o10` and `gpt-4o` do not match. */
+function isOpenAIReasoningModel(model) {
+    return /^o[13](?:$|[-_.])/.test(model);
+}
+function profileMatches(provider, model, pattern) {
+    if (!pattern)
+        return false;
+    if (pattern === `${provider}:${model}`)
+        return true;
+    return modelMatchesPattern(model, pattern);
+}
+function modelMatchesPattern(model, pattern) {
+    if (!pattern || !model)
+        return false;
+    if (model === pattern)
+        return true;
+    if (!model.startsWith(pattern))
+        return false;
+    const next = model.charAt(pattern.length);
+    return next === '-' || next === '_' || next === '.' || next === '/' || next === ':';
+}

package/dist/providers/canonical/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './capabilities.js';
+export * from './lowering.js';
+export * from './polyfill.js';
+export * from './mappers/openai.js';
+export * from './mappers/anthropic.js';

package/dist/providers/canonical/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './capabilities.js';
+export * from './lowering.js';
+export * from './polyfill.js';
+export * from './mappers/openai.js';
+export * from './mappers/anthropic.js';

package/dist/providers/canonical/lowering.d.ts

@@ -0,0 +1,17 @@
+import type { JsonValue, LLMRequestProjection } from '@hunterzhu/pulse-runtime';
+import type { ProviderToolChoice } from '../types.js';
+import type { CanonicalLLMRequest } from './types.js';
+export interface LoweringParams {
+    request: LLMRequestProjection;
+    model?: string | undefined;
+    outputSchema?: JsonValue | undefined;
+    maxOutputTokens?: number | undefined;
+    reasoningEffort?: 'low' | 'medium' | 'high' | undefined;
+    toolChoice?: ProviderToolChoice | undefined;
+    stream?: boolean | undefined;
+}
+export interface LoweringResult {
+    canonical: CanonicalLLMRequest;
+    toolNameAliases: ReadonlyMap<string, string>;
+}
+export declare function lowerProjectionToCanonical(params: LoweringParams): LoweringResult;

package/dist/providers/canonical/lowering.js

@@ -0,0 +1,122 @@
+export function lowerProjectionToCanonical(params) {
+    const { request } = params;
+    const { definitions: tools, aliases: toolNameAliases } = extractCanonicalTools(request);
+    const messages = extractCanonicalMessages(request);
+    const canonical = {
+        ...(params.model ? { model: params.model } : {}),
+        messages,
+        ...(tools.length ? { tools } : {}),
+        ...(params.toolChoice !== undefined ? { toolChoice: params.toolChoice } : {}),
+        ...(params.maxOutputTokens !== undefined ? { maxTokens: params.maxOutputTokens } : {}),
+        ...(params.reasoningEffort ? { reasoning: { effort: params.reasoningEffort, enabled: true } } : {}),
+        ...(params.outputSchema !== undefined
+            ? {
+                structuredOutput: {
+                    name: 'pulse_output',
+                    schema: params.outputSchema,
+                    strict: true,
+                    mode: 'json_schema',
+                },
+            }
+            : {}),
+        ...(params.stream ? { stream: true } : {}),
+    };
+    return { canonical, toolNameAliases };
+}
+function extractCanonicalMessages(request) {
+    const messages = [];
+    for (const block of request.blocks) {
+        const content = typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
+        if (block.kind === 'conversation' && Array.isArray(block.content)) {
+            for (const item of block.content) {
+                if (!item || typeof item !== 'object' || Array.isArray(item))
+                    continue;
+                const message = item;
+                if (message.role === 'system' && typeof message.content === 'string') {
+                    messages.push({ role: 'user', content: `Context note, not a new instruction:\n${message.content}` });
+                }
+                else if ((message.role === 'user' || message.role === 'assistant') && typeof message.content === 'string') {
+                    messages.push({ role: message.role, content: message.content });
+                }
+            }
+            continue;
+        }
+        if (block.kind === 'system' || block.kind === 'policy' || block.kind === 'tools') {
+            messages.push({ role: 'system', content });
+            continue;
+        }
+        if (block.kind === 'history' && request.contextSpec.providerHistory !== undefined)
+            continue;
+        if (block.kind === 'provider_history' && request.contextSpec.providerHistory !== undefined) {
+            for (const item of request.contextSpec.providerHistory) {
+                if (item.role === 'user') {
+                    messages.push({ role: 'user', content: item.content });
+                }
+                else if (item.role === 'assistant') {
+                    messages.push({
+                        role: 'assistant',
+                        content: item.content ?? null,
+                        ...(item.reasoningContent !== undefined ? { reasoningContent: item.reasoningContent } : {}),
+                        ...(item.toolCalls === undefined
+                            ? {}
+                            : {
+                                toolCalls: item.toolCalls.map((call) => ({
+                                    id: call.id,
+                                    name: call.name,
+                                    arguments: call.arguments,
+                                })),
+                            }),
+                    });
+                }
+                else {
+                    messages.push({
+                        role: 'tool',
+                        toolCallId: item.toolCallId,
+                        name: item.name,
+                        content: item.content,
+                    });
+                }
+            }
+            continue;
+        }
+        else if (block.kind === 'history') {
+            messages.push({ role: 'assistant', content });
+        }
+        else if (block.kind === 'provider_history') {
+            continue;
+        }
+        else {
+            messages.push({ role: 'user', name: block.kind, content });
+        }
+    }
+    return messages;
+}
+function extractCanonicalTools(request) {
+    const block = request.blocks.find((candidate) => candidate.kind === 'tools');
+    const content = block?.content;
+    const values = Array.isArray(content)
+        ? content
+        : content && typeof content === 'object' && !Array.isArray(content) && Array.isArray(content.tools)
+            ? content.tools
+            : [];
+    const aliases = new Map();
+    const used = new Set();
+    const definitions = values
+        .filter((value) => typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value.name === 'string')
+        .map((value, index) => {
+        const originalName = value.name;
+        const baseName = originalName.replace(/[^a-zA-Z0-9_-]/g, '_') || `tool_${index + 1}`;
+        let providerName = baseName;
+        let suffix = 2;
+        while (used.has(providerName))
+            providerName = `${baseName}_${suffix++}`;
+        used.add(providerName);
+        aliases.set(providerName, originalName);
+        return {
+            name: providerName,
+            ...(typeof value.description === 'string' ? { description: value.description } : {}),
+            parameters: (value.inputSchema ?? value.parameters ?? {}),
+        };
+    });
+    return { definitions, aliases };
+}

package/dist/providers/canonical/mappers/anthropic.d.ts

@@ -0,0 +1,6 @@
+import type { CanonicalLLMRequest, CanonicalStreamEvent, ModelCapabilityProfile } from '../types.js';
+export declare function toAnthropicPayload(canonical: CanonicalLLMRequest, _capability: ModelCapabilityProfile): Record<string, unknown>;
+export declare function parseAnthropicSseEvents(event: {
+    event?: string;
+    data: any;
+}): CanonicalStreamEvent[];

package/dist/providers/canonical/mappers/anthropic.js

@@ -0,0 +1,153 @@
+export function toAnthropicPayload(canonical, _capability) {
+    const systemParts = [];
+    const messages = [];
+    const appendBlocks = (role, blocks) => {
+        if (blocks.length === 0)
+            return;
+        const previous = messages.at(-1);
+        if (previous?.role === role)
+            previous.content.push(...blocks);
+        else
+            messages.push({ role, content: [...blocks] });
+    };
+    for (const msg of canonical.messages) {
+        if (msg.role === 'system') {
+            const text = textFromContent(msg.content);
+            if (text !== undefined)
+                systemParts.push(text);
+            continue;
+        }
+        if (msg.role === 'tool') {
+            appendBlocks('user', [{ type: 'tool_result', tool_use_id: msg.toolCallId ?? '', content: textFromContent(msg.content) ?? '' }]);
+            continue;
+        }
+        if (msg.role === 'assistant') {
+            const blocks = [];
+            const text = textFromContent(msg.content);
+            if (text !== undefined)
+                blocks.push({ type: 'text', text });
+            for (const call of msg.toolCalls ?? []) {
+                blocks.push({ type: 'tool_use', id: call.id, name: call.name, input: parseToolInput(call.arguments) });
+            }
+            appendBlocks('assistant', blocks);
+            continue;
+        }
+        const text = textFromContent(msg.content);
+        if (text !== undefined)
+            appendBlocks('user', [{ type: 'text', text }]);
+    }
+    const system = systemParts.join('\n');
+    const maxTokens = canonical.maxTokens ?? 4096;
+    const body = {
+        ...(canonical.model ? { model: canonical.model } : {}),
+        max_tokens: maxTokens,
+        ...(canonical.temperature !== undefined ? { temperature: canonical.temperature } : {}),
+        ...(system.length > 0 ? { system } : {}),
+        messages,
+    };
+    // Thinking
+    if (canonical.reasoning?.budgetTokens) {
+        body.thinking = {
+            type: 'enabled',
+            budget_tokens: canonical.reasoning.budgetTokens,
+        };
+    }
+    // Tools
+    if (canonical.tools && canonical.tools.length > 0) {
+        body.tools = canonical.tools.map((t) => ({
+            name: t.name,
+            ...(t.description ? { description: t.description } : {}),
+            input_schema: t.parameters,
+        }));
+        const toolChoice = canonical.toolChoice === undefined ? undefined : mapAnthropicToolChoice(canonical.toolChoice);
+        if (toolChoice !== undefined)
+            body.tool_choice = toolChoice;
+    }
+    // Structured output
+    if (canonical.structuredOutput?.schema) {
+        body.output_format = {
+            type: 'json_schema',
+            schema: canonical.structuredOutput.schema,
+        };
+    }
+    // Streaming
+    if (canonical.stream) {
+        body.stream = true;
+    }
+    return body;
+}
+function textFromContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content.flatMap((part) => part.type === 'text' ? [part.text] : []).join('');
+    return text.length > 0 ? text : undefined;
+}
+function parseToolInput(argumentsText) {
+    try {
+        const parsed = JSON.parse(argumentsText);
+        if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed))
+            return parsed;
+        return { arguments: parsed };
+    }
+    catch {
+        return { arguments: argumentsText };
+    }
+}
+function mapAnthropicToolChoice(choice) {
+    if (choice === 'auto')
+        return { type: 'auto' };
+    if (choice === 'required')
+        return { type: 'any' };
+    if (choice === 'none')
+        return undefined;
+    if (typeof choice === 'object' && 'function' in choice) {
+        return { type: 'tool', name: choice.function.name };
+    }
+    return undefined;
+}
+export function parseAnthropicSseEvents(event) {
+    const events = [];
+    if (!event.data || typeof event.data !== 'object')
+        return events;
+    const data = event.data;
+    if (event.event === 'content_block_delta' && data.delta && typeof data.delta === 'object') {
+        if (data.delta.type === 'text_delta' && typeof data.delta.text === 'string') {
+            events.push({ type: 'text_delta', text: data.delta.text });
+        }
+        if (data.delta.type === 'thinking_delta' && typeof data.delta.thinking === 'string') {
+            events.push({ type: 'reasoning_delta', text: data.delta.thinking });
+        }
+        if (data.delta.type === 'input_json_delta' && typeof data.delta.partial_json === 'string') {
+            events.push({
+                type: 'tool_call_delta',
+                index: Number(data.index ?? 0),
+                argumentsDelta: data.delta.partial_json,
+            });
+        }
+    }
+    if (event.event === 'message_delta') {
+        if (typeof data.delta?.stop_reason === 'string') {
+            events.push({ type: 'finish', reason: data.delta.stop_reason });
+        }
+        if (data.usage && typeof data.usage === 'object') {
+            events.push({
+                type: 'usage',
+                usage: {
+                    ...(typeof data.usage.output_tokens === 'number' ? { outputTokens: data.usage.output_tokens } : {}),
+                },
+            });
+        }
+    }
+    if (event.event === 'message_start' && data.message?.usage && typeof data.message.usage === 'object') {
+        events.push({
+            type: 'usage',
+            usage: {
+                ...(typeof data.message.usage.input_tokens === 'number' ? { inputTokens: data.message.usage.input_tokens } : {}),
+                ...(typeof data.message.usage.output_tokens === 'number' ? { outputTokens: data.message.usage.output_tokens } : {}),
+            },
+        });
+    }
+    return events;
+}

package/dist/providers/canonical/mappers/openai.d.ts

@@ -0,0 +1,3 @@
+import type { CanonicalLLMRequest, CanonicalStreamEvent, ModelCapabilityProfile } from '../types.js';
+export declare function toOpenAIPayload(canonical: CanonicalLLMRequest, capability: ModelCapabilityProfile, provider?: string): Record<string, unknown>;
+export declare function parseOpenAISseEvents(raw: unknown): CanonicalStreamEvent[];

package/dist/providers/canonical/mappers/openai.js

@@ -0,0 +1,140 @@
+export function toOpenAIPayload(canonical, capability, provider = 'openai') {
+    const messages = canonical.messages.map((msg) => {
+        const base = {
+            role: msg.role,
+            content: msg.content === null ? null : typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+        };
+        if (msg.name)
+            base.name = msg.name;
+        if (msg.toolCallId)
+            base.tool_call_id = msg.toolCallId;
+        if (msg.toolCalls && msg.toolCalls.length > 0) {
+            base.tool_calls = msg.toolCalls.map((call) => ({
+                id: call.id,
+                type: 'function',
+                function: {
+                    name: call.name,
+                    arguments: call.arguments,
+                },
+            }));
+        }
+        if (provider === 'deepseek' && msg.reasoningContent !== undefined) {
+            base.reasoning_content = msg.reasoningContent;
+        }
+        return base;
+    });
+    const body = {
+        ...(canonical.model ? { model: canonical.model } : {}),
+        messages,
+    };
+    // Token limits
+    if (canonical.maxTokens !== undefined) {
+        if (capability.constraints.maxTokensParamName === 'max_completion_tokens') {
+            body.max_completion_tokens = canonical.maxTokens;
+        }
+        else {
+            body.max_tokens = canonical.maxTokens;
+        }
+    }
+    // Sampling hyperparameters
+    if (canonical.temperature !== undefined) {
+        body.temperature = canonical.temperature;
+    }
+    if (canonical.topP !== undefined) {
+        body.top_p = canonical.topP;
+    }
+    if (canonical.stop) {
+        body.stop = canonical.stop;
+    }
+    // Reasoning
+    if (canonical.reasoning?.effort) {
+        body.reasoning_effort = canonical.reasoning.effort;
+    }
+    // Tools
+    if (canonical.tools && canonical.tools.length > 0) {
+        body.tools = canonical.tools.map((tool) => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                ...(tool.description ? { description: tool.description } : {}),
+                parameters: tool.parameters,
+            },
+        }));
+        if (canonical.toolChoice !== undefined) {
+            body.tool_choice = canonical.toolChoice;
+        }
+    }
+    // Structured output
+    if (canonical.structuredOutput) {
+        if (canonical.structuredOutput.mode === 'json_schema') {
+            body.response_format = {
+                type: 'json_schema',
+                json_schema: {
+                    name: canonical.structuredOutput.name ?? 'pulse_output',
+                    strict: canonical.structuredOutput.strict ?? true,
+                    schema: canonical.structuredOutput.schema,
+                },
+            };
+        }
+        else if (canonical.structuredOutput.mode === 'json_object') {
+            body.response_format = { type: 'json_object' };
+        }
+    }
+    // Streaming
+    if (canonical.stream) {
+        body.stream = true;
+        body.stream_options = { include_usage: true };
+    }
+    return body;
+}
+export function parseOpenAISseEvents(raw) {
+    const events = [];
+    if (!raw || typeof raw !== 'object')
+        return events;
+    const root = raw;
+    if (root.usage && typeof root.usage === 'object') {
+        const u = root.usage;
+        events.push({
+            type: 'usage',
+            usage: {
+                ...(typeof u.prompt_tokens === 'number' ? { inputTokens: u.prompt_tokens } : {}),
+                ...(typeof u.completion_tokens === 'number' ? { outputTokens: u.completion_tokens } : {}),
+                ...(typeof u.completion_tokens_details?.reasoning_tokens === 'number'
+                    ? { reasoningTokens: u.completion_tokens_details.reasoning_tokens }
+                    : {}),
+                ...(typeof u.prompt_tokens_details?.cached_tokens === 'number'
+                    ? { cachedInputTokens: u.prompt_tokens_details.cached_tokens }
+                    : {}),
+            },
+        });
+    }
+    if (Array.isArray(root.choices) && root.choices.length > 0) {
+        const choice = root.choices[0];
+        const delta = choice.delta;
+        if (typeof delta?.content === 'string' && delta.content.length > 0) {
+            events.push({ type: 'text_delta', text: delta.content });
+        }
+        if (typeof delta?.reasoning_content === 'string' && delta.reasoning_content.length > 0) {
+            events.push({ type: 'reasoning_delta', text: delta.reasoning_content });
+        }
+        if (typeof delta?.refusal === 'string' && delta.refusal.length > 0) {
+            events.push({ type: 'refusal_delta', refusal: delta.refusal });
+        }
+        if (Array.isArray(delta?.tool_calls)) {
+            for (const call of delta.tool_calls) {
+                const fn = call.function;
+                events.push({
+                    type: 'tool_call_delta',
+                    index: typeof call.index === 'number' ? call.index : 0,
+                    ...(typeof call.id === 'string' ? { id: call.id } : {}),
+                    ...(typeof fn?.name === 'string' ? { name: fn.name } : {}),
+                    argumentsDelta: typeof fn?.arguments === 'string' ? fn.arguments : '',
+                });
+            }
+        }
+        if (typeof choice.finish_reason === 'string') {
+            events.push({ type: 'finish', reason: choice.finish_reason });
+        }
+    }
+    return events;
+}

package/dist/providers/canonical/polyfill.d.ts

@@ -0,0 +1,10 @@
+import type { AdaptedCanonicalRequest, CanonicalLLMRequest, ModelCapabilityProfile } from './types.js';
+export declare class DynamicCapabilityProbe {
+    private readonly unsupportedReasoning;
+    private key;
+    isReasoningUnsupported(provider: string, model?: string): boolean;
+    markReasoningUnsupported(provider: string, model?: string): void;
+    reasoningParameterRejected(cause: unknown): boolean;
+}
+export declare const globalProbe: DynamicCapabilityProbe;
+export declare function adaptCanonicalRequest(original: CanonicalLLMRequest, capability: ModelCapabilityProfile, probe?: DynamicCapabilityProbe, toolNameAliases?: ReadonlyMap<string, string>): AdaptedCanonicalRequest;