@hunterzhu/pulse-adapters 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './providers/types.js';
+export * from './providers/normalize.js';
+export * from './providers/mock.js';
+export * from './providers/openai-compat.js';
+export * from './providers/anthropic.js';
+export * from './providers/factory.js';
+export * from './providers/runtime-executor.js';
+export * from './tools/filesystem.js';
+export * from './tools/shell.js';
+export * from './tools/registry.js';
+export * from './workers/http.js';

package/dist/index.js

@@ -0,0 +1,11 @@
+export * from './providers/types.js';
+export * from './providers/normalize.js';
+export * from './providers/mock.js';
+export * from './providers/openai-compat.js';
+export * from './providers/anthropic.js';
+export * from './providers/factory.js';
+export * from './providers/runtime-executor.js';
+export * from './tools/filesystem.js';
+export * from './tools/shell.js';
+export * from './tools/registry.js';
+export * from './workers/http.js';

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,16 @@
+import type { JsonValue, LLMRequestProjection } from '@hunterzhu/pulse-runtime';
+import type { ProviderAdapter, ProviderPresetConfig } from './types.js';
+export declare class AnthropicAdapter implements ProviderAdapter {
+    readonly id: string;
+    private readonly config;
+    readonly name = "Anthropic Messages";
+    constructor(id: string, config: ProviderPresetConfig);
+    executeAttempt(params: {
+        request: LLMRequestProjection;
+        signal: AbortSignal;
+        onObservation?: (chunk: string) => void;
+        outputSchema?: JsonValue;
+        model?: string;
+        maxOutputTokens?: number;
+    }): Promise<import("@hunterzhu/pulse-runtime").LLMResult>;
+}

package/dist/providers/anthropic.js

@@ -0,0 +1,89 @@
+import { consumeProviderSse, normalizeAnthropicResponse, parseProviderJson, providerHttpError, providerNetworkError, providerResponseError } from './normalize.js';
+export class AnthropicAdapter {
+    id;
+    config;
+    name = 'Anthropic Messages';
+    constructor(id, config) {
+        this.id = id;
+        this.config = config;
+    }
+    async executeAttempt(params) {
+        const system = params.request.blocks.filter((block) => block.kind === 'system' || block.kind === 'policy' || block.kind === 'tools').map((block) => typeof block.content === 'string' ? block.content : JSON.stringify(block.content)).join('\n');
+        const messages = [{ role: 'user', content: params.request.blocks.filter((block) => !['system', 'policy', 'tools'].includes(block.kind)).map((block) => ({ type: 'text', text: typeof block.content === 'string' ? block.content : JSON.stringify(block.content) })) }];
+        const streaming = params.onObservation !== undefined;
+        const tools = toolDefinitions(params.request);
+        const body = { ...(params.model ?? this.config.defaultModel ? { model: params.model ?? this.config.defaultModel } : {}), max_tokens: params.maxOutputTokens ?? this.config.maxOutputTokens ?? 4096, ...(system ? { system } : {}), messages, ...(tools.length ? { tools, ...(this.config.toolChoice === undefined ? {} : { tool_choice: anthropicToolChoice(this.config.toolChoice) }) } : {}), ...(params.outputSchema === undefined ? {} : { output_format: { type: 'json_schema', schema: params.outputSchema } }), ...(streaming ? { stream: true } : {}) };
+        try {
+            const response = await fetch(`${(this.config.baseURL ?? 'https://api.anthropic.com').replace(/\/$/, '')}/v1/messages`, { method: 'POST', signal: params.signal, headers: { 'content-type': 'application/json', ...(this.config.apiKey ? { 'x-api-key': this.config.apiKey } : {}), 'anthropic-version': '2023-06-01' }, body: JSON.stringify(body) });
+            if (!response.ok)
+                throw providerHttpError(response.status);
+            if (!streaming || !response.headers.get('content-type')?.includes('text/event-stream'))
+                return normalizeAnthropicResponse(await parseProviderJson(response));
+            const events = await consumeProviderSse(response);
+            const blocks = [];
+            let stopReason;
+            let usage = {};
+            for (const event of events) {
+                if (!event.data || typeof event.data !== 'object')
+                    continue;
+                const data = event.data;
+                if (event.event === 'message_start' && data.message?.usage && typeof data.message.usage === 'object')
+                    usage = { ...usage, ...data.message.usage };
+                if (event.event === 'content_block_start' && data.content_block && typeof data.content_block === 'object')
+                    blocks[Number(data.index ?? blocks.length)] = { ...data.content_block };
+                if (event.event === 'content_block_delta' && data.delta && typeof data.delta === 'object') {
+                    const index = Number(data.index ?? 0);
+                    const block = blocks[index] ?? {};
+                    if (data.delta.type === 'text_delta' && typeof data.delta.text === 'string') {
+                        block.type = 'text';
+                        block.text = `${typeof block.text === 'string' ? block.text : ''}${data.delta.text}`;
+                        params.onObservation?.(data.delta.text);
+                    }
+                    if (data.delta.type === 'input_json_delta' && typeof data.delta.partial_json === 'string')
+                        block.inputJson = `${typeof block.inputJson === 'string' ? block.inputJson : ''}${data.delta.partial_json}`;
+                    blocks[index] = block;
+                }
+                if (event.event === 'message_delta') {
+                    if (typeof data.delta?.stop_reason === 'string')
+                        stopReason = data.delta.stop_reason;
+                    if (data.usage && typeof data.usage === 'object')
+                        usage = { ...usage, ...data.usage };
+                }
+            }
+            const content = blocks.filter(Boolean).map((block) => {
+                if (block.type === 'tool_use' && typeof block.inputJson === 'string') {
+                    try {
+                        return { ...block, input: JSON.parse(block.inputJson) };
+                    }
+                    catch {
+                        throw providerResponseError('INVALID_TOOL_ARGUMENTS');
+                    }
+                }
+                return block;
+            });
+            return normalizeAnthropicResponse({ content, stop_reason: stopReason, ...(Object.keys(usage).length ? { usage } : {}) });
+        }
+        catch (cause) {
+            if (params.signal.aborted)
+                throw Object.assign(new Error('Provider request was cancelled.'), { code: 'PROVIDER_REQUEST_CANCELLED', retryable: false, cause });
+            if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string' && 'retryable' in cause && typeof cause.retryable === 'boolean')
+                throw cause;
+            throw providerNetworkError(cause);
+        }
+    }
+}
+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 : [];
+    return values.filter((value) => typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value.name === 'string').map((value) => ({ name: value.name, ...(typeof value.description === 'string' ? { description: value.description } : {}), input_schema: (value.inputSchema ?? value.parameters ?? {}) }));
+}
+function anthropicToolChoice(choice) {
+    if (choice === 'auto')
+        return { type: 'auto' };
+    if (choice === 'required')
+        return { type: 'any' };
+    if (choice === 'none')
+        return undefined;
+    return { type: 'tool', name: choice.function.name };
+}

package/dist/providers/factory.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderAdapter, ProviderPresetConfig } from './types.js';
+export declare function createProviderAdapter(config: ProviderPresetConfig): ProviderAdapter;

package/dist/providers/factory.js

@@ -0,0 +1,6 @@
+import { AnthropicAdapter } from './anthropic.js';
+import { OpenAICompatibleAdapter } from './openai-compat.js';
+import { MockAdapter } from './mock.js';
+export function createProviderAdapter(config) { if (config.provider === 'anthropic')
+    return new AnthropicAdapter(config.provider, config); if (config.provider === 'mock')
+    return new MockAdapter(); return new OpenAICompatibleAdapter(config.provider, config); }

package/dist/providers/mock.d.ts

@@ -0,0 +1,10 @@
+import type { LLMResult } from '@hunterzhu/pulse-runtime';
+import type { ProviderAdapter } from './types.js';
+export declare class MockAdapter implements ProviderAdapter {
+    readonly id: string;
+    readonly name = "Mock Provider";
+    private readonly queue;
+    constructor(id?: string);
+    enqueue(result: LLMResult | Error): void;
+    executeAttempt(): Promise<LLMResult>;
+}

package/dist/providers/mock.js

@@ -0,0 +1,12 @@
+export class MockAdapter {
+    id;
+    name = 'Mock Provider';
+    queue = [];
+    constructor(id = 'mock') {
+        this.id = id;
+    }
+    enqueue(result) { this.queue.push(result); }
+    async executeAttempt() { const next = this.queue.shift(); if (!next)
+        return { text: '', toolCalls: [], finishReason: 'stop' }; if (next instanceof Error)
+        throw next; return structuredClone(next); }
+}

package/dist/providers/normalize.d.ts

@@ -0,0 +1,22 @@
+import type { LLMResult } from '@hunterzhu/pulse-runtime';
+export interface ProviderSseEvent {
+    event?: string;
+    data: any;
+}
+export declare function providerHttpError(status: number): Error & {
+    code: string;
+    retryable: boolean;
+};
+export declare function providerNetworkError(cause: unknown): Error & {
+    code: string;
+    retryable: boolean;
+};
+export declare function providerResponseError(detail: string): Error & {
+    code: string;
+    retryable: boolean;
+};
+export declare function parseProviderJson(response: Response): Promise<unknown>;
+/** Read provider SSE frames without treating incomplete tool arguments as executable input. */
+export declare function consumeProviderSse(response: Response): Promise<ProviderSseEvent[]>;
+export declare function normalizeOpenAIResponse(response: any): LLMResult;
+export declare function normalizeAnthropicResponse(response: any): LLMResult;

package/dist/providers/normalize.js

@@ -0,0 +1,236 @@
+export function providerHttpError(status) {
+    const retryable = status === 408 || status === 425 || status === 429 || status >= 500;
+    return Object.assign(new Error(`PROVIDER_HTTP_${status}`), { code: `PROVIDER_HTTP_${status}`, retryable });
+}
+export function providerNetworkError(cause) {
+    return Object.assign(new Error('PROVIDER_NETWORK_ERROR'), { code: 'PROVIDER_NETWORK_ERROR', retryable: true, cause });
+}
+export function providerResponseError(detail) {
+    return Object.assign(new Error(`PROVIDER_RESPONSE_INVALID: ${detail}`), { code: 'PROVIDER_RESPONSE_INVALID', retryable: true });
+}
+export async function parseProviderJson(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        throw providerResponseError('PROVIDER_RESPONSE_INVALID_JSON');
+    }
+}
+/** Read provider SSE frames without treating incomplete tool arguments as executable input. */
+export async function consumeProviderSse(response) {
+    if (!response.body)
+        throw providerResponseError('PROVIDER_STREAM_BODY_MISSING');
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const events = [];
+    let buffer = '';
+    let eventName;
+    let dataLines = [];
+    const flush = () => {
+        if (dataLines.length === 0) {
+            eventName = undefined;
+            return;
+        }
+        const raw = dataLines.join('\n');
+        dataLines = [];
+        const data = raw === '[DONE]' ? raw : (() => { try {
+            return JSON.parse(raw);
+        }
+        catch {
+            throw providerResponseError('PROVIDER_STREAM_INVALID_JSON');
+        } })();
+        events.push({ ...(eventName === undefined ? {} : { event: eventName }), data });
+        eventName = undefined;
+    };
+    const consumeLines = (text) => {
+        buffer += text;
+        let newline = buffer.indexOf('\n');
+        while (newline >= 0) {
+            let line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            if (line.endsWith('\r'))
+                line = line.slice(0, -1);
+            if (line.length === 0)
+                flush();
+            else if (line.startsWith(':')) { /* SSE comment */ }
+            else if (line.startsWith('event:'))
+                eventName = line.slice('event:'.length).trim();
+            else if (line.startsWith('data:'))
+                dataLines.push(line.slice('data:'.length).trimStart());
+            newline = buffer.indexOf('\n');
+        }
+    };
+    while (true) {
+        const chunk = await reader.read();
+        if (chunk.done)
+            break;
+        consumeLines(decoder.decode(chunk.value, { stream: true }));
+    }
+    consumeLines(decoder.decode());
+    if (buffer.length > 0 || dataLines.length > 0)
+        flush();
+    return events;
+}
+export function normalizeOpenAIResponse(response) {
+    const root = providerRecord(response, 'OpenAI response');
+    if (!Array.isArray(root.choices) || root.choices.length === 0)
+        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 = message.tool_calls === undefined ? [] : normalizeOpenAIToolCalls(message.tool_calls);
+    const refusal = message.refusal === undefined ? undefined : requiredProviderString(message.refusal, 'OpenAI refusal');
+    const text = providerText(message.content, 'OpenAI message content');
+    const finishReason = normalizeOpenAIFinishReason(choice.finish_reason, refusal, toolCalls.length > 0);
+    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 }, { input: 'prompt_tokens', output: 'completion_tokens', cached: 'cached_tokens' }, 'OpenAI');
+    return { text, ...(parseStructured(text) === undefined ? {} : { structured: parseStructured(text) }), toolCalls, ...(refusal === undefined ? {} : { refusal }), finishReason, ...(usage === undefined ? {} : { usage }) };
+}
+export function normalizeAnthropicResponse(response) {
+    const root = providerRecord(response, 'Anthropic response');
+    if (!Array.isArray(root.content))
+        throw providerResponseError('Anthropic response content must be an array');
+    const blocks = root.content;
+    const text = blocks.filter((block) => providerRecord(block, 'Anthropic content block').type === 'text').map((block) => requiredProviderString(providerRecord(block, 'Anthropic text block').text, 'Anthropic text block text')).join('');
+    const toolBlocks = blocks.filter((block) => providerRecord(block, 'Anthropic content block').type === 'tool_use');
+    const toolCalls = toolBlocks.map((block, index) => {
+        const value = providerRecord(block, 'Anthropic tool block');
+        return { toolCallId: `pulse-tool-${index + 1}`, name: requiredProviderString(value.name, 'Anthropic tool name'), input: parseJson(value.input) };
+    });
+    const refusalBlock = blocks.find((block) => block.type === 'refusal' && typeof block.text === 'string');
+    const refusal = refusalBlock?.text;
+    const finishReason = normalizeAnthropicFinishReason(root.stop_reason, refusal, toolCalls.length > 0);
+    const usage = normalizeUsage(root.usage, { input: 'input_tokens', output: 'output_tokens', cached: 'cache_read_input_tokens' }, 'Anthropic');
+    return { text, ...(parseStructured(text) === undefined ? {} : { structured: parseStructured(text) }), toolCalls, ...(refusal === undefined ? {} : { refusal }), finishReason, ...(usage === undefined ? {} : { usage }) };
+}
+function providerRecord(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw providerResponseError(`${label} must be an object`);
+    return value;
+}
+function requiredProviderString(value, label) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw providerResponseError(`${label} must be a non-empty string`);
+    return value;
+}
+function providerText(value, label) {
+    if (value === undefined || value === null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value) && value.every((part) => {
+        if (!part || typeof part !== 'object' || Array.isArray(part))
+            return false;
+        const item = part;
+        return item.type === 'text' && typeof item.text === 'string';
+    }))
+        return value.map((part) => part.text).join('');
+    throw providerResponseError(`${label} must be a string, null, or text-part array`);
+}
+function providerMetric(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isInteger(value) || !Number.isFinite(value) || value < 0)
+        throw providerResponseError(`${label} must be a non-negative integer`);
+    return value;
+}
+function normalizeUsage(raw, fields, provider) {
+    if (raw === undefined)
+        return undefined;
+    const value = providerRecord(raw, `${provider} usage`);
+    const inputTokens = providerMetric(value[fields.input], `${provider} input tokens`);
+    const outputTokens = providerMetric(value[fields.output], `${provider} output tokens`);
+    const cachedInputTokens = providerMetric(value[fields.cached], `${provider} cached input tokens`);
+    if (inputTokens !== undefined && cachedInputTokens !== undefined && cachedInputTokens > inputTokens)
+        throw providerResponseError(`${provider} cached input tokens exceed input tokens`);
+    const cost = value.cost === undefined ? undefined : normalizeCost(value.cost, provider);
+    return { ...(inputTokens === undefined ? {} : { inputTokens }), ...(outputTokens === undefined ? {} : { outputTokens }), ...(cachedInputTokens === undefined ? {} : { cachedInputTokens }), ...(inputTokens !== undefined && cachedInputTokens !== undefined ? { uncachedInputTokens: inputTokens - cachedInputTokens } : {}), ...(cost === undefined ? {} : { cost }) };
+}
+function normalizeCost(raw, provider) {
+    const value = providerRecord(raw, `${provider} cost`);
+    if (typeof value.amount !== 'number' || !Number.isFinite(value.amount) || value.amount < 0)
+        throw providerResponseError(`${provider} cost amount must be a non-negative number`);
+    if (typeof value.currency !== 'string' || value.currency.length === 0)
+        throw providerResponseError(`${provider} cost currency must be a non-empty string`);
+    if (value.pricing_version !== undefined && typeof value.pricing_version !== 'string')
+        throw providerResponseError(`${provider} pricing version must be a string`);
+    return { amount: value.amount, currency: value.currency, source: 'reported', ...(value.pricing_version === undefined ? {} : { pricingVersion: value.pricing_version }) };
+}
+function normalizeOpenAIToolCalls(raw) {
+    if (!Array.isArray(raw))
+        throw providerResponseError('OpenAI tool_calls must be an array');
+    return raw.map((call, index) => {
+        const value = providerRecord(call, 'OpenAI tool call');
+        const fn = providerRecord(value.function, 'OpenAI tool function');
+        return { toolCallId: `pulse-tool-${index + 1}`, name: requiredProviderString(fn.name, 'OpenAI tool name'), input: parseJson(fn.arguments) };
+    });
+}
+function normalizeOpenAIFinishReason(raw, refusal, hasTools) {
+    if (refusal !== undefined || raw === 'refusal')
+        return 'refusal';
+    if (raw === undefined)
+        return hasTools ? 'tool_calls' : 'stop';
+    if (raw === 'tool_calls') {
+        if (!hasTools)
+            throw providerResponseError('tool_calls finish reason requires tool calls');
+        return 'tool_calls';
+    }
+    if (raw === 'stop') {
+        if (hasTools)
+            throw providerResponseError('stop finish reason cannot contain tool calls');
+        return 'stop';
+    }
+    if (raw === 'length') {
+        if (hasTools)
+            throw providerResponseError('length finish reason cannot contain tool calls');
+        return 'length';
+    }
+    if (raw === 'error' || raw === 'content_filter') {
+        if (hasTools)
+            throw providerResponseError('error finish reason cannot contain tool calls');
+        return 'error';
+    }
+    throw providerResponseError(`unsupported OpenAI finish reason: ${String(raw)}`);
+}
+function normalizeAnthropicFinishReason(raw, refusal, hasTools) {
+    if (refusal !== undefined || raw === 'refusal')
+        return 'refusal';
+    if (raw === undefined)
+        return hasTools ? 'tool_calls' : 'stop';
+    if (raw === 'tool_use') {
+        if (!hasTools)
+            throw providerResponseError('tool_use stop reason requires tool calls');
+        return 'tool_calls';
+    }
+    if (raw === 'max_tokens') {
+        if (hasTools)
+            throw providerResponseError('max_tokens stop reason cannot contain tool calls');
+        return 'length';
+    }
+    if (raw === 'end_turn' || raw === 'stop_sequence') {
+        if (hasTools)
+            throw providerResponseError('text stop reason cannot contain tool calls');
+        return 'stop';
+    }
+    throw providerResponseError(`unsupported Anthropic stop reason: ${String(raw)}`);
+}
+function parseJson(value) {
+    if (value === undefined || value === null || value === '')
+        return {};
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw providerResponseError('INVALID_TOOL_ARGUMENTS');
+    }
+}
+function parseStructured(value) { if (!value.trim())
+    return undefined; try {
+    const parsed = JSON.parse(value);
+    return parsed !== null && typeof parsed === 'object' ? parsed : undefined;
+}
+catch {
+    return undefined;
+} }

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

@@ -0,0 +1,22 @@
+import type { JsonValue, LLMRequestProjection } from '@hunterzhu/pulse-runtime';
+import type { ProviderAdapter, ProviderPresetConfig } from './types.js';
+export declare class OpenAICompatibleAdapter implements ProviderAdapter {
+    readonly id: string;
+    private readonly config;
+    readonly name = "OpenAI Compatible";
+    private readonly baseURL;
+    constructor(id: string, config: ProviderPresetConfig);
+    executeAttempt(params: {
+        request: LLMRequestProjection;
+        signal: AbortSignal;
+        onObservation?: (chunk: string) => void;
+        model?: string;
+        outputSchema?: JsonValue;
+        maxOutputTokens?: number;
+    }): Promise<import("@hunterzhu/pulse-runtime").LLMResult>;
+}
+export declare function toOpenAIMessages(request: LLMRequestProjection): Array<{
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+    name?: string;
+}>;

package/dist/providers/openai-compat.js

@@ -0,0 +1,87 @@
+import { consumeProviderSse, normalizeOpenAIResponse, parseProviderJson, providerHttpError, providerNetworkError } from './normalize.js';
+export class OpenAICompatibleAdapter {
+    id;
+    config;
+    name = 'OpenAI Compatible';
+    baseURL;
+    constructor(id, config) {
+        this.id = id;
+        this.config = config;
+        this.baseURL = config.baseURL ?? 'https://api.openai.com/v1';
+    }
+    async executeAttempt(params) {
+        const streaming = params.onObservation !== undefined;
+        const tools = toolDefinitions(params.request);
+        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 }), messages: toMessages(params.request), ...(tools.length ? { tools, ...(this.config.toolChoice === undefined ? {} : { tool_choice: this.config.toolChoice }) } : {}), ...(params.outputSchema === undefined ? {} : { response_format: { type: 'json_schema', json_schema: { name: 'pulse_output', strict: true, schema: params.outputSchema } } }), ...(streaming ? { stream: true, stream_options: { include_usage: true } } : {}) };
+        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)
+                throw providerHttpError(response.status);
+            if (!streaming || !response.headers.get('content-type')?.includes('text/event-stream'))
+                return normalizeOpenAIResponse(await parseProviderJson(response));
+            const events = await consumeProviderSse(response);
+            const content = [];
+            const refusals = [];
+            const toolCalls = new Map();
+            let finishReason;
+            let usage;
+            for (const event of events) {
+                if (event.data === '[DONE]' || !event.data || typeof event.data !== 'object')
+                    continue;
+                const choice = event.data.choices?.[0];
+                const delta = choice?.delta;
+                if (typeof delta?.content === 'string') {
+                    content.push(delta.content);
+                    params.onObservation?.(delta.content);
+                }
+                if (typeof delta?.refusal === 'string') {
+                    refusals.push(delta.refusal);
+                    params.onObservation?.(delta.refusal);
+                }
+                if (typeof choice?.finish_reason === 'string')
+                    finishReason = choice.finish_reason;
+                if (Array.isArray(delta?.tool_calls))
+                    for (const call of delta.tool_calls) {
+                        const index = Number(call.index ?? 0);
+                        const current = toolCalls.get(index) ?? { name: '', arguments: '' };
+                        if (typeof call.id === 'string')
+                            current.id = call.id;
+                        if (typeof call.function?.name === 'string')
+                            current.name += call.function.name;
+                        if (typeof call.function?.arguments === 'string')
+                            current.arguments += call.function.arguments;
+                        toolCalls.set(index, current);
+                    }
+                if (event.data.usage !== undefined)
+                    usage = event.data.usage;
+            }
+            return normalizeOpenAIResponse({ choices: [{ message: { content: content.join('') || null, ...(refusals.length ? { refusal: refusals.join('') } : {}), ...(toolCalls.size ? { tool_calls: [...toolCalls.entries()].sort(([left], [right]) => left - right).map(([, call]) => ({ id: call.id, function: { name: call.name, arguments: call.arguments } })) } : {}) }, finish_reason: finishReason ?? 'stop' }], ...(usage === undefined ? {} : { usage }) });
+        }
+        catch (cause) {
+            if (params.signal.aborted)
+                throw Object.assign(new Error('Provider request was cancelled.'), { code: 'PROVIDER_REQUEST_CANCELLED', retryable: false, cause });
+            if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string' && 'retryable' in cause && typeof cause.retryable === 'boolean')
+                throw cause;
+            throw providerNetworkError(cause);
+        }
+    }
+}
+export function toOpenAIMessages(request) {
+    return request.blocks.map((block) => {
+        const content = typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
+        if (block.kind === 'system' || block.kind === 'policy' || block.kind === 'tools')
+            return { role: 'system', content };
+        if (block.kind === 'history')
+            return { role: 'assistant', content };
+        return { role: 'user', name: block.kind, content };
+    });
+}
+function toMessages(request) {
+    return toOpenAIMessages(request);
+}
+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 : [];
+    return values.filter((value) => typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value.name === 'string').map((value) => ({ type: 'function', function: { name: value.name, ...(typeof value.description === 'string' ? { description: value.description } : {}), parameters: (value.inputSchema ?? value.parameters ?? {}) } }));
+}

package/dist/providers/runtime-executor.d.ts

@@ -0,0 +1,9 @@
+import type { EffectExecutor, ModelRouteRequirements, ModelRouter } from '@hunterzhu/pulse-runtime';
+import type { ProviderAdapter } from './types.js';
+export declare function createModelEffectExecutor(config: {
+    router: ModelRouter;
+    providers: ReadonlyMap<string, ProviderAdapter>;
+    requirements?: ModelRouteRequirements;
+    maxConcurrentByProvider?: Readonly<Record<string, number>>;
+    maxConcurrentByModel?: Readonly<Record<string, number>>;
+}): EffectExecutor;