@hunterzhu/pulse-adapters 0.4.2 → 0.4.4

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;

package/dist/providers/canonical/polyfill.js

@@ -0,0 +1,98 @@
+export class DynamicCapabilityProbe {
+    unsupportedReasoning = new Set();
+    key(provider, model) {
+        return `${provider.toLowerCase()}:${(model ?? '').toLowerCase()}`;
+    }
+    isReasoningUnsupported(provider, model) {
+        return this.unsupportedReasoning.has(this.key(provider, model));
+    }
+    markReasoningUnsupported(provider, model) {
+        this.unsupportedReasoning.add(this.key(provider, model));
+    }
+    reasoningParameterRejected(cause) {
+        if (!(cause instanceof Error))
+            return false;
+        const code = cause.code;
+        if (code !== 'PROVIDER_HTTP_400')
+            return false;
+        return /reasoning_effort/i.test(cause.message);
+    }
+}
+export const globalProbe = new DynamicCapabilityProbe();
+export function adaptCanonicalRequest(original, capability, probe = globalProbe, toolNameAliases = new Map()) {
+    const messages = [...original.messages.map((m) => ({ ...m }))];
+    const request = {
+        ...original,
+        messages,
+        ...(original.tools ? { tools: [...original.tools] } : {}),
+    };
+    let clientSchemaValidationRequired = false;
+    // 1. Structured Output Adaptation
+    if (request.structuredOutput) {
+        if (capability.structuredOutput === 'json_object_only') {
+            const schemaPrompt = `Return only a JSON object matching this schema. The application will validate the result:\n${JSON.stringify(request.structuredOutput.schema)}`;
+            injectSystemInstruction(messages, schemaPrompt);
+            request.structuredOutput = {
+                ...request.structuredOutput,
+                mode: 'json_object',
+            };
+            clientSchemaValidationRequired = true;
+        }
+        else if (capability.structuredOutput === 'unsupported') {
+            const schemaPrompt = `Return only a JSON object matching this schema. The application will validate the result:\n${JSON.stringify(request.structuredOutput.schema)}`;
+            injectSystemInstruction(messages, schemaPrompt);
+            delete request.structuredOutput;
+            clientSchemaValidationRequired = true;
+        }
+        else {
+            request.structuredOutput = {
+                ...request.structuredOutput,
+                mode: 'json_schema',
+            };
+            if (capability.structuredOutput === 'native_loose') {
+                clientSchemaValidationRequired = true;
+            }
+        }
+    }
+    // 2. Reasoning / Thinking Adaptation
+    const reasoningDisabled = probe.isReasoningUnsupported(capability.provider, request.model) ||
+        capability.reasoning === 'unsupported';
+    if (reasoningDisabled || !request.reasoning?.effort) {
+        delete request.reasoning;
+    }
+    else if (capability.reasoning === 'budget_tokens') {
+        const maxTokens = request.maxTokens ?? 4096;
+        const requested = request.reasoning.effort === 'high' ? 8_000 : request.reasoning.effort === 'medium' ? 2_048 : 1_024;
+        const budget = Math.min(requested, maxTokens - 1_024);
+        if (budget >= 1_024 && budget < maxTokens) {
+            request.reasoning = {
+                ...request.reasoning,
+                budgetTokens: budget,
+                enabled: true,
+            };
+            if (capability.constraints.disallowTemperatureWithReasoning) {
+                request.temperature = capability.constraints.defaultTemperatureWithReasoning ?? 1.0;
+            }
+        }
+        else {
+            delete request.reasoning;
+        }
+    }
+    else if (capability.reasoning === 'effort_param') {
+        if (capability.constraints.disallowTemperatureWithReasoning) {
+            delete request.temperature;
+        }
+    }
+    else if (capability.reasoning === 'prompt_mode') {
+        delete request.reasoning;
+    }
+    return {
+        request,
+        capability,
+        clientSchemaValidationRequired,
+        toolNameAliases,
+    };
+}
+function injectSystemInstruction(messages, instruction) {
+    messages.unshift({ role: 'system', content: instruction });
+}

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

@@ -0,0 +1,109 @@
+import type { JsonValue } from '@hunterzhu/pulse-runtime';
+import type { ProviderToolChoice } from '../types.js';
+export type CanonicalRole = 'system' | 'user' | 'assistant' | 'tool';
+export interface CanonicalTextContent {
+    type: 'text';
+    text: string;
+}
+export interface CanonicalImageContent {
+    type: 'image';
+    source: {
+        type: 'base64' | 'url';
+        mediaType: string;
+        data: string;
+    };
+}
+export type CanonicalContentPart = CanonicalTextContent | CanonicalImageContent;
+export interface CanonicalToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+export interface CanonicalMessage {
+    role: CanonicalRole;
+    content: string | null | CanonicalContentPart[];
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: CanonicalToolCall[];
+    reasoningContent?: string;
+}
+export interface CanonicalToolDefinition {
+    name: string;
+    description?: string;
+    parameters: JsonValue;
+}
+export type CanonicalToolChoice = ProviderToolChoice;
+export interface CanonicalStructuredOutput {
+    name?: string;
+    schema: JsonValue;
+    strict?: boolean;
+    description?: string;
+    mode?: 'json_schema' | 'json_object';
+}
+export interface CanonicalReasoningConfig {
+    effort?: 'low' | 'medium' | 'high';
+    budgetTokens?: number;
+    enabled?: boolean;
+}
+export interface CanonicalLLMRequest {
+    model?: string;
+    messages: CanonicalMessage[];
+    tools?: CanonicalToolDefinition[];
+    toolChoice?: CanonicalToolChoice;
+    temperature?: number;
+    topP?: number;
+    maxTokens?: number;
+    stop?: string[];
+    reasoning?: CanonicalReasoningConfig;
+    structuredOutput?: CanonicalStructuredOutput;
+    stream?: boolean;
+}
+export type CanonicalStreamEvent = {
+    type: 'text_delta';
+    text: string;
+} | {
+    type: 'reasoning_delta';
+    text: string;
+} | {
+    type: 'tool_call_delta';
+    index: number;
+    id?: string;
+    name?: string;
+    argumentsDelta: string;
+} | {
+    type: 'refusal_delta';
+    refusal: string;
+} | {
+    type: 'usage';
+    usage: {
+        inputTokens?: number;
+        outputTokens?: number;
+        reasoningTokens?: number;
+        cachedInputTokens?: number;
+    };
+} | {
+    type: 'finish';
+    reason: string;
+};
+export type StructuredOutputCapability = 'native_strict' | 'native_loose' | 'json_object_only' | 'unsupported';
+export type ReasoningCapability = 'effort_param' | 'budget_tokens' | 'prompt_mode' | 'unsupported';
+export interface ModelCapabilityConstraints {
+    disallowTemperatureWithReasoning?: boolean;
+    defaultTemperatureWithReasoning?: number;
+    maxTokensParamName?: 'max_tokens' | 'max_completion_tokens';
+    supportsSystemMessage?: boolean;
+    supportsParallelTools?: boolean;
+}
+export interface ModelCapabilityProfile {
+    id: string;
+    provider: string;
+    structuredOutput: StructuredOutputCapability;
+    reasoning: ReasoningCapability;
+    constraints: ModelCapabilityConstraints;
+}
+export interface AdaptedCanonicalRequest {
+    request: CanonicalLLMRequest;
+    capability: ModelCapabilityProfile;
+    clientSchemaValidationRequired: boolean;
+    toolNameAliases: ReadonlyMap<string, string>;
+}

package/dist/providers/canonical/types.js

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

package/dist/providers/normalize.js

@@ -232,23 +232,81 @@ function parseDsmlJson(value) {
         return undefined;
     }
 }
-/** DeepSeek sometimes writes only JSON tool objects instead of tool_calls. Each object needs an explicit tool name; argument-shaped JSON and trailing prose stay text. */
+/** DeepSeek sometimes writes tool calls as JSON or markdown fences instead of tool_calls. A bare object still needs an explicit tool name. Argument-shaped JSON, a single tool object after prose, and any trailing prose stay text. */
 function recoverDeepSeekJsonToolCalls(text, toolNameAliases) {
-    const leading = takeLeadingJsonValues(text.trim());
+    const trimmed = text.trim();
+    return recoverStrictJsonToolCalls(trimmed, toolNameAliases) ?? recoverMarkdownToolFences(trimmed, toolNameAliases);
+}
+function recoverStrictJsonToolCalls(text, toolNameAliases) {
+    const leading = takeLeadingJsonValues(text);
     if (leading === undefined || leading.values.length === 0 || leading.rest.trim().length > 0)
         return undefined;
     const objects = leading.values.filter((value) => !isEmptyJsonValue(value));
     if (objects.length === 0)
         return undefined;
+    if (objects.length === 1 && Array.isArray(objects[0]) && objects[0].every((item) => argumentObject(item) !== undefined))
+        return toolCallsFrom(objects[0], toolNameAliases);
     if (objects.length === 1 && objects[0] && typeof objects[0] === 'object' && !Array.isArray(objects[0])) {
         const batch = objects[0].tool_calls ?? objects[0].toolCalls;
-        if (Array.isArray(batch)) {
-            const calls = batch.map((item) => jsonToolCall(item, toolNameAliases));
-            return calls.every((call) => call !== undefined) && calls.length > 0 ? calls : undefined;
+        if (Array.isArray(batch))
+            return toolCallsFrom(batch, toolNameAliases);
+    }
+    return toolCallsFrom(objects, toolNameAliases);
+}
+/** A message that is only `tool.name` headings followed by JSON fences is a tool batch, not a finished answer. */
+function recoverMarkdownToolFences(text, toolNameAliases) {
+    const lines = text.split(/\r?\n/);
+    const calls = [];
+    let index = 0;
+    const skipBlank = () => { while (index < lines.length && lines[index].trim() === '')
+        index++; };
+    skipBlank();
+    if (index >= lines.length)
+        return undefined;
+    while (index < lines.length) {
+        skipBlank();
+        if (index >= lines.length)
+            break;
+        const providerToolName = lines[index].trim();
+        if (!/^[A-Za-z][\w-]*(?:\.[\w-]+)+$/.test(providerToolName))
+            return undefined;
+        index++;
+        if (lines[index]?.trim() !== '```json' && lines[index]?.trim() !== '```')
+            return undefined;
+        index++;
+        const body = [];
+        while (index < lines.length && lines[index].trim() !== '```')
+            body.push(lines[index++]);
+        if (index >= lines.length)
+            return undefined;
+        index++;
+        let parsed;
+        try {
+            parsed = JSON.parse(body.join('\n'));
         }
+        catch {
+            return undefined;
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return undefined;
+        const input = parsed;
+        calls.push({ providerToolName, name: toolNameAliases?.get(providerToolName) ?? providerToolName, input, providerToolArguments: JSON.stringify(input) });
     }
-    const calls = objects.map((value) => jsonToolCall(value, toolNameAliases));
-    return calls.every((call) => call !== undefined) ? calls : undefined;
+    return calls.length > 0 ? calls : undefined;
+}
+function toolCallsFrom(values, toolNameAliases) {
+    const calls = values.map((value) => jsonToolCall(value, toolNameAliases));
+    return calls.every((call) => call !== undefined) && calls.length > 0 ? calls : undefined;
+}
+function argumentObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const named = typeof record.tool === 'string' && record.tool.length > 0 ? record.tool : typeof record.name === 'string' && record.name.length > 0 ? record.name : undefined;
+    const raw = record.arguments ?? record.input ?? record.parameters ?? record.args;
+    if (named === undefined || !raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    return raw;
 }
 function isEmptyJsonValue(value) {
     if (Array.isArray(value))
@@ -263,7 +321,7 @@ function jsonToolCall(value, toolNameAliases) {
     const providerToolName = named;
     if (providerToolName === undefined)
         return undefined;
-    const raw = record.arguments ?? record.input ?? record.parameters;
+    const raw = record.arguments ?? record.input ?? record.parameters ?? record.args;
     const input = raw && typeof raw === 'object' && !Array.isArray(raw) ? { ...raw } : { ...record };
     if (raw === undefined) {
         delete input.tool;

package/dist/providers/openai-compat.d.ts

@@ -5,7 +5,7 @@ export declare class OpenAICompatibleAdapter implements ProviderAdapter {
     private readonly config;
     readonly name = "OpenAI Compatible";
     private readonly baseURL;
-    private reasoningUnsupported;
+    private readonly probe;
     constructor(id: string, config: ProviderPresetConfig);
     executeAttempt(params: {
         request: LLMRequestProjection;

package/dist/providers/openai-compat.js

@@ -1,18 +1,11 @@
 import { consumeProviderSse, normalizeOpenAIResponse, parseProviderJson, providerHttpErrorFromResponse, providerNetworkError } from './normalize.js';
-function reasoningParameterRejected(cause) {
-    if (!(cause instanceof Error))
-        return false;
-    const code = cause.code;
-    if (code !== 'PROVIDER_HTTP_400')
-        return false;
-    return /reasoning_effort|unknown parameter|unrecognized (?:request )?argument|extra fields? not permitted/i.test(cause.message);
-}
+import { adaptCanonicalRequest, DynamicCapabilityProbe, lowerProjectionToCanonical, parseOpenAISseEvents, resolveModelCapability, toOpenAIPayload } from './canonical/index.js';
 export class OpenAICompatibleAdapter {
     id;
     config;
     name = 'OpenAI Compatible';
     baseURL;
-    reasoningUnsupported = false;
+    probe = new DynamicCapabilityProbe();
     constructor(id, config) {
         this.id = id;
         this.config = config;
@@ -20,16 +13,19 @@ export class OpenAICompatibleAdapter {
     }
     async executeAttempt(params) {
         const streaming = params.onObservation !== undefined;
-        const { definitions: tools, aliases: toolNameAliases } = toolDefinitions(params.request);
-        const includeReasoning = Boolean(this.config.reasoningEffort) && !this.reasoningUnsupported;
-        const messages = toMessages(params.request, this.config.provider);
-        const deepSeekJsonMode = params.outputSchema !== undefined && this.config.provider === 'deepseek';
-        if (deepSeekJsonMode)
-            messages.unshift({ role: 'system', content: `Return only a JSON object matching this schema. The application will validate the result:\n${JSON.stringify(params.outputSchema)}` });
-        const responseFormat = params.outputSchema === undefined ? undefined : deepSeekJsonMode
-            ? { type: 'json_object' }
-            : { type: 'json_schema', json_schema: { name: 'pulse_output', strict: true, schema: params.outputSchema } };
-        const body = { ...(params.model ?? this.config.defaultModel ? { model: params.model ?? this.config.defaultModel } : {}), ...((params.maxOutputTokens ?? this.config.maxOutputTokens) === undefined ? {} : { max_tokens: params.maxOutputTokens ?? this.config.maxOutputTokens }), ...(includeReasoning ? { reasoning_effort: this.config.reasoningEffort } : {}), messages, ...(tools.length ? { tools, ...(this.config.toolChoice === undefined ? {} : { tool_choice: this.config.toolChoice }) } : {}), ...(responseFormat === undefined ? {} : { response_format: responseFormat }), ...(streaming ? { stream: true, stream_options: { include_usage: true } } : {}) };
+        const { canonical, toolNameAliases } = lowerProjectionToCanonical({
+            request: params.request,
+            model: params.model ?? this.config.defaultModel,
+            outputSchema: params.outputSchema,
+            maxOutputTokens: params.maxOutputTokens ?? this.config.maxOutputTokens,
+            reasoningEffort: this.config.reasoningEffort,
+            toolChoice: this.config.toolChoice,
+            stream: streaming,
+        });
+        const capability = resolveModelCapability(canonical.model, this.config.provider);
+        const { request: adapted } = adaptCanonicalRequest(canonical, capability, this.probe, toolNameAliases);
+        const sentReasoning = Boolean(adapted.reasoning?.effort);
+        const body = toOpenAIPayload(adapted, capability, this.config.provider);
         try {
             const response = await fetch(`${this.baseURL.replace(/\/$/, '')}/chat/completions`, { method: 'POST', signal: params.signal, headers: { 'content-type': 'application/json', ...(this.config.apiKey ? { authorization: `Bearer ${this.config.apiKey}` } : {}), ...(this.config.extraHeaders ?? {}) }, body: JSON.stringify(body) });
             if (!response.ok)
@@ -37,11 +33,13 @@ export class OpenAICompatibleAdapter {
             if (!streaming || !response.headers.get('content-type')?.includes('text/event-stream'))
                 return normalizeOpenAIResponse(await parseProviderJson(response), toolNameAliases, this.config.provider);
             const events = await consumeProviderSse(response, (event) => {
-                const delta = event.data?.choices?.[0]?.delta;
-                if (typeof delta?.content === 'string')
-                    params.onObservation?.(delta.content);
-                if (typeof delta?.refusal === 'string')
-                    params.onObservation?.(delta.refusal);
+                const streamEvents = parseOpenAISseEvents(event.data);
+                for (const ev of streamEvents) {
+                    if (ev.type === 'text_delta')
+                        params.onObservation?.(ev.text);
+                    if (ev.type === 'refusal_delta')
+                        params.onObservation?.(ev.refusal);
+                }
             });
             const content = [];
             const reasoningContent = [];
@@ -75,8 +73,8 @@ export class OpenAICompatibleAdapter {
         catch (cause) {
             if (params.signal.aborted)
                 throw Object.assign(new Error('Provider request was cancelled.'), { code: 'PROVIDER_REQUEST_CANCELLED', retryable: false, cause });
-            if (includeReasoning && reasoningParameterRejected(cause)) {
-                this.reasoningUnsupported = true;
+            if (sentReasoning && this.probe.reasoningParameterRejected(cause)) {
+                this.probe.markReasoningUnsupported(this.config.provider, canonical.model);
                 return this.executeAttempt(params);
             }
             if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string' && 'retryable' in cause && typeof cause.retryable === 'boolean')
@@ -86,49 +84,9 @@ export class OpenAICompatibleAdapter {
     }
 }
 export function toOpenAIMessages(request, provider = 'openai') {
-    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, ...(provider === 'deepseek' && item.reasoningContent !== undefined ? { reasoning_content: item.reasoningContent } : {}), ...(item.toolCalls === undefined ? {} : { tool_calls: item.toolCalls.map((call) => ({ id: call.id, type: 'function', function: { name: call.name, arguments: call.arguments } })) }) });
-                else
-                    messages.push({ role: 'tool', tool_call_id: 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 toMessages(request, provider) {
-    return toOpenAIMessages(request, provider);
+    const { canonical } = lowerProjectionToCanonical({ request });
+    const payload = toOpenAIPayload(canonical, resolveModelCapability(canonical.model, provider), provider);
+    return Array.isArray(payload.messages) ? payload.messages : [];
 }
 function nextToolIndex(toolCalls) {
     let next = 0;
@@ -183,22 +141,3 @@ function accumulateStreamToolCall(toolCalls, call) {
         current.arguments += args;
     toolCalls.set(index, current);
 }
-function toolDefinitions(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 { type: 'function', function: { name: providerName, ...(typeof value.description === 'string' ? { description: value.description } : {}), parameters: (value.inputSchema ?? value.parameters ?? {}) } };
-    });
-    return { definitions, aliases };
-}

package/dist/providers/runtime-executor.js

@@ -47,6 +47,53 @@ class SlotPool {
         this.slots.set(key, slot);
     } ; return slot; }
 }
+function jsonCandidates(text) {
+    const found = [];
+    const push = (value) => {
+        try {
+            const parsed = JSON.parse(value);
+            found.push(parsed);
+            if (typeof parsed === 'string' && parsed !== value)
+                push(parsed);
+        }
+        catch { /* keep scanning */ }
+    };
+    const trimmed = text.trim();
+    if (trimmed)
+        push(trimmed);
+    for (let start = 0; start < text.length; start++) {
+        if (text[start] !== '{')
+            continue;
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        for (let end = start; end < text.length; end++) {
+            const char = text[end];
+            if (inString) {
+                if (escaped)
+                    escaped = false;
+                else if (char === '\\')
+                    escaped = true;
+                else if (char === '"')
+                    inString = false;
+                continue;
+            }
+            if (char === '"')
+                inString = true;
+            else if (char === '{')
+                depth++;
+            else if (char === '}') {
+                depth--;
+                if (depth === 0) {
+                    push(text.slice(start, end + 1));
+                    start = end;
+                    break;
+                }
+            }
+        }
+    }
+    return found;
+}
 function toJson(value, seen = new Set()) {
     if (value === null || typeof value === 'string' || typeof value === 'boolean')
         return value;
@@ -172,13 +219,15 @@ export function createModelEffectExecutor(config) {
                     throw new OutputValidationError('adapter', 'MODEL_REFUSAL', output.refusal ?? 'Provider refused the request.');
                 }
                 if (input.outputSchema !== undefined) {
-                    const candidateValue = output.structured ?? output.text;
-                    if (!validateJsonSchema(candidateValue, input.outputSchema)) {
-                        lastSchemaViolation = toJson(candidateValue);
+                    const candidates = output.structured === undefined ? jsonCandidates(output.text) : [output.structured, ...jsonCandidates(output.text)];
+                    const matched = candidates.find((candidate) => validateJsonSchema(candidate, input.outputSchema));
+                    if (matched === undefined) {
+                        lastSchemaViolation = toJson(candidates[0] ?? output.text);
                         failedForSchema = true;
                         recordFeedback('schema_rejected', 0);
                         throw new OutputValidationError('structured', 'OUTPUT_SCHEMA_VIOLATION', 'Provider output did not match the declared schema');
                     }
+                    output.structured = matched;
                 }
                 failedForSchema = false;
                 recordFeedback('succeeded', 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hunterzhu/pulse-adapters",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "license": "PolyForm-Noncommercial-1.0.0",
   "repository": {
     "type": "git",
@@ -18,8 +18,8 @@
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "0.0.77",
-    "@hunterzhu/pulse-runtime": "0.4.2",
-    "@hunterzhu/pulse-tool-sdk": "0.4.2",
+    "@hunterzhu/pulse-runtime": "0.4.4",
+    "@hunterzhu/pulse-tool-sdk": "0.4.4",
     "exceljs": "4.4.0",
     "pdfjs-dist": "4.10.38"
   }