@hunterzhu/pulse-adapters 0.4.1 → 0.4.3

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

@@ -116,10 +116,31 @@ export function normalizeOpenAIResponse(response, toolNameAliases, provider = 'o
         throw providerResponseError('OpenAI response must contain at least one choice');
     const choice = providerRecord(root.choices[0], 'OpenAI choice');
     const message = providerRecord(choice.message, 'OpenAI message');
-    const toolCalls = choice.finish_reason === 'length' || message.tool_calls === undefined ? [] : normalizeOpenAIToolCalls(message.tool_calls, toolNameAliases);
+    const nativeToolCalls = choice.finish_reason === 'length' || message.tool_calls === undefined ? [] : normalizeOpenAIToolCalls(message.tool_calls, toolNameAliases);
     const refusal = message.refusal == null ? undefined : requiredProviderString(message.refusal, 'OpenAI refusal');
-    const text = providerText(message.content, 'OpenAI message content');
-    const finishReason = normalizeOpenAIFinishReason(choice.finish_reason, refusal, toolCalls.length > 0);
+    let text = providerText(message.content, 'OpenAI message content');
+    let finishReason = normalizeOpenAIFinishReason(choice.finish_reason, refusal, nativeToolCalls.length > 0);
+    let toolCalls = nativeToolCalls;
+    if (provider === 'deepseek' && (finishReason === 'stop' || nativeToolCalls.length > 0)) {
+        const recovered = recoverDeepSeekDsml(text, toolNameAliases, nativeToolCalls.length === 0);
+        text = recovered.text;
+        if (nativeToolCalls.length === 0 && recovered.truncated) {
+            toolCalls = [];
+            finishReason = 'length';
+        }
+        else if (nativeToolCalls.length === 0 && recovered.calls.length > 0) {
+            toolCalls = recovered.calls.map((call, index) => ({ toolCallId: `pulse-tool-${index + 1}`, providerToolCallId: `dsml-${index + 1}`, providerToolName: call.providerToolName, providerToolArguments: call.providerToolArguments, name: call.name, input: call.input }));
+            finishReason = 'tool_calls';
+        }
+    }
+    if (provider === 'deepseek' && nativeToolCalls.length === 0 && finishReason === 'stop' && toolCalls.length === 0) {
+        const jsonCalls = recoverDeepSeekJsonToolCalls(text, toolNameAliases);
+        if (jsonCalls !== undefined) {
+            text = '';
+            toolCalls = jsonCalls.map((call, index) => ({ toolCallId: `pulse-tool-${index + 1}`, providerToolCallId: `json-${index + 1}`, providerToolName: call.providerToolName, providerToolArguments: call.providerToolArguments, name: call.name, input: call.input }));
+            finishReason = 'tool_calls';
+        }
+    }
     const rawUsage = root.usage === undefined ? undefined : providerRecord(root.usage, 'OpenAI usage');
     const promptDetails = rawUsage?.prompt_tokens_details === undefined ? undefined : providerRecord(rawUsage.prompt_tokens_details, 'OpenAI prompt token details');
     const usage = normalizeUsage(rawUsage === undefined ? undefined : { ...rawUsage, cached_tokens: rawUsage.cached_tokens ?? promptDetails?.cached_tokens ?? rawUsage.cache_read_input_tokens, reasoning_tokens: rawUsage.completion_tokens_details?.reasoning_tokens ?? rawUsage.reasoning_tokens }, { input: 'prompt_tokens', output: 'completion_tokens', cached: 'cached_tokens', reasoning: 'reasoning_tokens' }, 'OpenAI');
@@ -127,6 +148,202 @@ export function normalizeOpenAIResponse(response, toolNameAliases, provider = 'o
     const measuredUsage = usage === undefined ? undefined : { ...usage, visibleOutputChars: text.length };
     return { text, ...(parseStructured(text) === undefined ? {} : { structured: parseStructured(text) }), toolCalls, ...(refusal === undefined ? {} : { refusal }), finishReason, ...(measuredUsage === undefined ? {} : { usage: measuredUsage }), ...(provider !== 'deepseek' || reasoningContent === undefined ? {} : { providerContinuation: { provider, reasoningContent } }) };
 }
+/** DeepSeek V4/V4.1 may emit DSML tool markup in content instead of tool_calls. One or more U+FF5C bars are accepted. */
+function recoverDeepSeekDsml(text, toolNameAliases, parseCalls) {
+    const blocks = takeDsmlBlocks(text);
+    if (!blocks.changed)
+        return { text, calls: [], truncated: false };
+    if (blocks.truncated || !parseCalls)
+        return { text: blocks.text, calls: [], truncated: blocks.truncated };
+    const calls = [];
+    for (const inner of blocks.inners) {
+        const parsed = parseDsmlInvokes(inner, toolNameAliases);
+        if (parsed === undefined)
+            return { text: blocks.text, calls: [], truncated: true };
+        calls.push(...parsed);
+    }
+    return { text: blocks.text, calls, truncated: false };
+}
+function takeDsmlBlocks(text) {
+    const inners = [];
+    let cursor = 0;
+    let cleaned = '';
+    let changed = false;
+    while (cursor < text.length) {
+        const open = nextDsmlMatch(DSML_BLOCK_OPEN, text, cursor);
+        if (open === undefined)
+            break;
+        const close = nextDsmlMatch(DSML_BLOCK_CLOSE, text, open.end);
+        const nested = nextDsmlMatch(DSML_BLOCK_OPEN, text, open.end);
+        cleaned += text.slice(cursor, open.start);
+        changed = true;
+        if (close === undefined || (nested !== undefined && nested.start < close.start)) {
+            return { text: cleaned.trim(), inners: [], truncated: true, changed: true };
+        }
+        inners.push(text.slice(open.end, close.start));
+        cursor = close.end;
+    }
+    if (!changed)
+        return { text, inners, truncated: false, changed: false };
+    cleaned += text.slice(cursor);
+    return { text: cleaned.trim(), inners, truncated: false, changed: true };
+}
+function parseDsmlInvokes(inner, toolNameAliases) {
+    const opened = countDsmlTags(DSML_INVOKE_OPEN, inner);
+    if (opened !== countDsmlTags(DSML_INVOKE_CLOSE, inner))
+        return undefined;
+    const calls = [];
+    const invoke = new RegExp(DSML_INVOKE_PATTERN.source, 'g');
+    let match;
+    while ((match = invoke.exec(inner)) !== null) {
+        const providerToolName = requiredProviderString(match[1], 'OpenAI tool name');
+        const parameters = parseDsmlParameters(match[2] ?? '');
+        if (parameters === undefined)
+            return undefined;
+        calls.push({ providerToolName, name: toolNameAliases?.get(providerToolName) ?? providerToolName, input: parameters, providerToolArguments: JSON.stringify(parameters) });
+    }
+    return calls.length === opened ? calls : undefined;
+}
+function parseDsmlParameters(body) {
+    const opened = countDsmlTags(DSML_PARAMETER_OPEN, body);
+    if (opened !== countDsmlTags(DSML_PARAMETER_CLOSE, body))
+        return undefined;
+    const input = {};
+    const parameter = new RegExp(DSML_PARAMETER_PATTERN.source, 'g');
+    let match;
+    while ((match = parameter.exec(body)) !== null) {
+        const name = requiredProviderString(match[1], 'OpenAI tool name');
+        if (match[2] === 'true')
+            input[name] = match[3] ?? '';
+        else {
+            const parsed = parseDsmlJson(match[3] ?? '');
+            if (parsed === undefined)
+                return undefined;
+            input[name] = parsed;
+        }
+    }
+    return Object.keys(input).length === opened ? input : undefined;
+}
+function parseDsmlJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        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. */
+function recoverDeepSeekJsonToolCalls(text, toolNameAliases) {
+    const leading = takeLeadingJsonValues(text.trim());
+    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 && 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;
+        }
+    }
+    const calls = objects.map((value) => jsonToolCall(value, toolNameAliases));
+    return calls.every((call) => call !== undefined) ? calls : undefined;
+}
+function isEmptyJsonValue(value) {
+    if (Array.isArray(value))
+        return value.length === 0;
+    return value !== null && typeof value === 'object' && Object.keys(value).length === 0;
+}
+function jsonToolCall(value, toolNameAliases) {
+    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 providerToolName = named;
+    if (providerToolName === undefined)
+        return undefined;
+    const raw = record.arguments ?? record.input ?? record.parameters;
+    const input = raw && typeof raw === 'object' && !Array.isArray(raw) ? { ...raw } : { ...record };
+    if (raw === undefined) {
+        delete input.tool;
+        delete input.name;
+    }
+    return { providerToolName, name: toolNameAliases?.get(providerToolName) ?? providerToolName, input, providerToolArguments: JSON.stringify(input) };
+}
+function takeLeadingJsonValues(text) {
+    if (!text.startsWith('{') && !text.startsWith('['))
+        return undefined;
+    const values = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        while (cursor < text.length && /\s/.test(text[cursor]))
+            cursor++;
+        if (cursor >= text.length)
+            break;
+        if (text[cursor] !== '{' && text[cursor] !== '[')
+            break;
+        const end = jsonValueEnd(text, cursor);
+        if (end === undefined)
+            return undefined;
+        try {
+            values.push(JSON.parse(text.slice(cursor, end)));
+        }
+        catch {
+            return undefined;
+        }
+        cursor = end;
+    }
+    return values.length > 0 ? { values, rest: text.slice(cursor) } : undefined;
+}
+function jsonValueEnd(text, start) {
+    const opening = text[start];
+    if (opening !== '{' && opening !== '[')
+        return undefined;
+    const stack = [];
+    let inString = false;
+    let escaped = false;
+    for (let index = start; index < text.length; index++) {
+        const char = text[index];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === '"')
+                inString = false;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === '{' || char === '[')
+            stack.push(char === '{' ? '}' : ']');
+        else if (char === '}' || char === ']') {
+            if (stack.pop() !== char)
+                return undefined;
+            if (stack.length === 0)
+                return index + 1;
+        }
+    }
+    return undefined;
+}
+function countDsmlTags(pattern, value) {
+    return value.match(new RegExp(pattern.source, 'g'))?.length ?? 0;
+}
+function nextDsmlMatch(pattern, value, from) {
+    const match = new RegExp(pattern.source, 'g').exec(value.slice(from));
+    return match === null ? undefined : { start: from + match.index, end: from + match.index + match[0].length };
+}
+const DSML_BLOCK_OPEN = /<\uFF5C+DSML\uFF5C+\s*(?:tool_calls|calls)>/;
+const DSML_BLOCK_CLOSE = /<\/\uFF5C+DSML\uFF5C+\s*(?:tool_calls|calls)>/;
+const DSML_INVOKE_OPEN = /<\uFF5C+DSML\uFF5C+\s*invoke\b/;
+const DSML_INVOKE_CLOSE = /<\/\uFF5C+DSML\uFF5C+\s*invoke>/;
+const DSML_INVOKE_PATTERN = /<\uFF5C+DSML\uFF5C+\s*invoke\s+name="([^"]+)"\s*\/?>([\s\S]*?)<\/\uFF5C+DSML\uFF5C+\s*invoke>/;
+const DSML_PARAMETER_OPEN = /<\uFF5C+DSML\uFF5C+\s*parameter\b/;
+const DSML_PARAMETER_CLOSE = /<\/\uFF5C+DSML\uFF5C+\s*parameter>/;
+const DSML_PARAMETER_PATTERN = /<\uFF5C+DSML\uFF5C+\s*parameter\s+name="([^"]+)"\s+string="(true|false)"\s*>([\s\S]*?)<\/\uFF5C+DSML\uFF5C+\s*parameter>/;
 export function normalizeAnthropicResponse(response) {
     const root = providerRecord(response, 'Anthropic response');
     if (!Array.isArray(root.content))

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/tools/filesystem.js

@@ -31,8 +31,14 @@ export class FilesystemTool {
         this.root = root;
         this.lockTimeoutMs = lockTimeoutMs;
     }
-    safe(path) { const target = resolve(this.root, path); if (isAbsolute(path) || relative(resolve(this.root), target).startsWith('..'))
-        throw filesystemError('PATH_OUTSIDE_SANDBOX'); return target; }
+    safe(path) {
+        const root = resolve(this.root);
+        const target = resolve(root, path);
+        const within = relative(root, target);
+        if (within.startsWith('..') || isAbsolute(within))
+            throw filesystemError('PATH_OUTSIDE_SANDBOX');
+        return target;
+    }
     async existing(path) {
         const target = this.safe(path);
         const [root, resolved] = await Promise.all([realpath(this.root), realpath(target)]);
@@ -122,8 +128,11 @@ export class FilesystemTool {
             await handle.close();
         }
     }
-    async list(path = '.', signal) { if (signal?.aborted)
-        throw filesystemError('ABORTED'); return readdir(await this.existing(path)); }
+    async list(path = '.', signal) {
+        if (signal?.aborted)
+            throw filesystemError('ABORTED');
+        return readdir(await this.existing(path));
+    }
     async write(path, content, signal) { if (signal?.aborted)
         throw filesystemError('ABORTED'); await writeFile(await this.writable(path), content, 'utf8'); }
     async move(source, destination, expectedHash, signal) {