@deepstrike/sdk 0.1.5 → 0.1.8

package/dist/providers/anthropic.js

@@ -1,14 +1,19 @@
 import Anthropic from "@anthropic-ai/sdk";
-import { CircuitBreaker, normalizeToolCall, toAnthropicContent } from "./base.js";
+import { withServerRuntimeGuard } from "../runtime/server.js";
+import { CircuitBreaker, normalizeToolCall, splitAnthropicSystem, toAnthropicMessages } from "./base.js";
 export class AnthropicProvider {
     model;
     client;
     circuit;
     maxRetries;
     baseDelay;
-    constructor(apiKey, model = "claude-sonnet-4-6", retry = { maxRetries: 3, baseDelay: 1000 }) {
+    nativeAssistantBlocks = new Map();
+    constructor(apiKey, model = "claude-sonnet-4-6", retry = { maxRetries: 3, baseDelay: 1000 }, options = {}) {
         this.model = model;
-        this.client = new Anthropic({ apiKey });
+        this.client = withServerRuntimeGuard(() => new Anthropic({
+            ...(options.authMode === "bearer" ? { authToken: apiKey } : { apiKey }),
+            ...(options.baseURL ? { baseURL: options.baseURL } : {}),
+        }));
         this.circuit = new CircuitBreaker();
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
@@ -23,8 +28,8 @@ export class AnthropicProvider {
     async complete(messages, tools) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const system = messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
-        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: toAnthropicContent(m) }));
+        const system = splitAnthropicSystem(messages);
+        const msgs = this.buildMessages(messages);
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
@@ -47,7 +52,9 @@ export class AnthropicProvider {
                             toolCalls.push(tc);
                     }
                 }
-                return { role: "assistant", content, tokenCount: resp.usage.input_tokens + resp.usage.output_tokens, toolCalls };
+                const message = { role: "assistant", content, tokenCount: resp.usage.input_tokens + resp.usage.output_tokens, toolCalls };
+                this.rememberNativeBlocks(message, resp.content);
+                return message;
             }
             catch (err) {
                 lastErr = err;
@@ -59,9 +66,12 @@ export class AnthropicProvider {
         throw lastErr;
     }
     async *stream(messages, tools, extensions) {
-        const system = messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
-        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: toAnthropicContent(m) }));
+        const system = splitAnthropicSystem(messages);
+        const msgs = this.buildMessages(messages);
         const toolBlocks = {};
+        const nativeBlocks = {};
+        let finalText = "";
+        const finalToolCalls = [];
         const stream = this.client.messages.stream({
             model: this.model,
             max_tokens: 8096,
@@ -70,17 +80,26 @@ export class AnthropicProvider {
             ...(tools.length ? { tools: this.buildTools(tools) } : {}),
         });
         for await (const evt of stream) {
-            if (evt.type === "content_block_start" && evt.content_block.type === "tool_use") {
-                toolBlocks[evt.index] = { id: evt.content_block.id, name: evt.content_block.name, argsBuf: "" };
+            if (evt.type === "content_block_start") {
+                nativeBlocks[evt.index] = { ...evt.content_block };
+                if (evt.content_block.type === "tool_use") {
+                    toolBlocks[evt.index] = { id: evt.content_block.id, name: evt.content_block.name, argsBuf: "" };
+                }
             }
             else if (evt.type === "content_block_delta") {
                 const d = evt.delta;
                 if (d.type === "text_delta") {
+                    finalText += d.text;
+                    nativeBlocks[evt.index] = { ...nativeBlocks[evt.index], text: String(nativeBlocks[evt.index]?.text ?? "") + d.text };
                     yield { type: "text_delta", delta: d.text };
                 }
                 else if (d.type === "thinking_delta") {
+                    nativeBlocks[evt.index] = { ...nativeBlocks[evt.index], thinking: String(nativeBlocks[evt.index]?.thinking ?? "") + d.thinking };
                     yield { type: "thinking_delta", delta: d.thinking };
                 }
+                else if (d.type === "signature_delta") {
+                    nativeBlocks[evt.index] = { ...nativeBlocks[evt.index], signature: String(nativeBlocks[evt.index]?.signature ?? "") + d.signature };
+                }
                 else if (d.type === "input_json_delta" && toolBlocks[evt.index]) {
                     toolBlocks[evt.index].argsBuf += d.partial_json;
                 }
@@ -95,8 +114,25 @@ export class AnthropicProvider {
                 catch {
                     args = {};
                 }
+                nativeBlocks[evt.index] = { ...nativeBlocks[evt.index], input: args };
+                finalToolCalls.push({ id: tb.id, name: tb.name, arguments: JSON.stringify(args) });
                 yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
             }
         }
+        this.rememberNativeBlocks({ content: finalText, toolCalls: finalToolCalls }, Object.keys(nativeBlocks).map(Number).sort((a, b) => a - b).map(index => nativeBlocks[index]));
+    }
+    buildMessages(messages) {
+        return toAnthropicMessages(messages, message => this.nativeAssistantBlocks.get(this.assistantReplayKey(message)));
+    }
+    rememberNativeBlocks(message, blocks) {
+        if (!message.toolCalls?.length)
+            return;
+        this.nativeAssistantBlocks.set(this.assistantReplayKey(message), blocks);
+    }
+    assistantReplayKey(message) {
+        return JSON.stringify({
+            content: message.content,
+            toolCalls: message.toolCalls ?? [],
+        });
     }
 }

package/dist/providers/base.d.ts

@@ -16,3 +16,6 @@ export declare function normalizeToolCall(id: string, name: string, args: unknow
 import type { Message } from "../types.js";
 export declare function toAnthropicContent(msg: Message): string | Array<Record<string, unknown>>;
 export declare function toOpenAIContent(msg: Message): string | Array<Record<string, unknown>>;
+export declare function splitAnthropicSystem(messages: Message[]): string;
+export declare function toAnthropicMessages(messages: Message[], nativeReplay?: (message: Message) => Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
+export declare function toOpenAIMessageParams(messages: Message[]): Array<Record<string, unknown>>;

package/dist/providers/base.js

@@ -59,6 +59,9 @@ export function toAnthropicContent(msg) {
         if (p.type === "audio") {
             return { type: "text", text: `[audio: ${p.mediaType}]` };
         }
+        if (p.type === "tool_result") {
+            return { type: "tool_result", tool_use_id: p.callId, content: p.output, is_error: p.isError };
+        }
         return { type: "text", text: "" };
     });
 }
@@ -75,6 +78,82 @@ export function toOpenAIContent(msg) {
         if (p.type === "audio") {
             return { type: "input_audio", input_audio: { data: p.data, format: p.mediaType?.split("/")[1] ?? "wav" } };
         }
+        if (p.type === "tool_result") {
+            return { type: "text", text: p.output };
+        }
         return { type: "text", text: "" };
     });
 }
+function parseToolArguments(args) {
+    try {
+        return JSON.parse(args || "{}");
+    }
+    catch {
+        return {};
+    }
+}
+export function splitAnthropicSystem(messages) {
+    return messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
+}
+export function toAnthropicMessages(messages, nativeReplay) {
+    const result = [];
+    for (const msg of messages.filter(m => m.role !== "system")) {
+        if (msg.role === "tool") {
+            const parts = (msg.contentParts ?? [])
+                .filter((p) => p.type === "tool_result")
+                .map(p => ({ type: "tool_result", tool_use_id: p.callId, content: p.output, is_error: p.isError }));
+            if (parts.length)
+                result.push({ role: "user", content: parts });
+            continue;
+        }
+        if (msg.role === "assistant" && msg.toolCalls?.length) {
+            const replay = nativeReplay?.(msg);
+            if (replay) {
+                result.push({ role: "assistant", content: replay });
+                continue;
+            }
+            const blocks = [];
+            if (msg.content)
+                blocks.push({ type: "text", text: msg.content });
+            blocks.push(...msg.toolCalls.map(tc => ({
+                type: "tool_use",
+                id: tc.id,
+                name: tc.name,
+                input: parseToolArguments(tc.arguments),
+            })));
+            result.push({ role: "assistant", content: blocks });
+            continue;
+        }
+        result.push({
+            role: msg.role,
+            content: toAnthropicContent(msg),
+        });
+    }
+    return result;
+}
+export function toOpenAIMessageParams(messages) {
+    const result = [];
+    for (const msg of messages) {
+        if (msg.role === "tool") {
+            const parts = (msg.contentParts ?? [])
+                .filter((p) => p.type === "tool_result");
+            for (const p of parts) {
+                result.push({ role: "tool", tool_call_id: p.callId, content: p.output });
+            }
+            continue;
+        }
+        const next = {
+            role: msg.role,
+            content: toOpenAIContent(msg),
+        };
+        if (msg.role === "assistant" && msg.toolCalls?.length) {
+            next.tool_calls = msg.toolCalls.map(tc => ({
+                id: tc.id,
+                type: "function",
+                function: { name: tc.name, arguments: tc.arguments },
+            }));
+        }
+        result.push(next);
+    }
+    return result;
+}

package/dist/providers/catalog.d.ts

@@ -0,0 +1,14 @@
+import type { LLMProvider } from "../types.js";
+import { endpointProfiles, type ModelProfileId } from "./profiles.js";
+export type EndpointProfileId = keyof typeof endpointProfiles;
+export interface CreateProviderOptions {
+    model: ModelProfileId;
+    apiKey: string;
+    endpoint?: EndpointProfileId;
+    retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    };
+    baseURL?: string;
+}
+export declare function createProvider(options: CreateProviderOptions): LLMProvider;

package/dist/providers/catalog.js

@@ -0,0 +1,45 @@
+import { OpenAIChatProvider } from "./openai.js";
+import { DeepSeekProvider } from "./deepseek.js";
+import { KimiProvider } from "./kimi.js";
+import { OpenAIResponsesProvider } from "./openai-responses.js";
+import { MiniMaxProvider } from "./minimax.js";
+import { QwenProvider } from "./qwen.js";
+import { GeminiProvider } from "./gemini.js";
+import { endpointProfiles, getModelProfile } from "./profiles.js";
+export function createProvider(options) {
+    const profile = getModelProfile(options.model);
+    const endpointId = (options.endpoint ?? profile.defaultEndpointId);
+    const endpoint = endpointProfiles[endpointId];
+    if (!endpoint) {
+        throw new Error(`Unknown endpoint profile: ${endpointId}`);
+    }
+    if (endpoint.providerId !== profile.providerId) {
+        throw new Error(`Endpoint ${endpoint.id} does not belong to provider ${profile.providerId}`);
+    }
+    const model = options.model.slice(`${profile.providerId}/`.length);
+    const baseURL = options.baseURL ?? endpoint.baseURL;
+    if (profile.providerId === "openai") {
+        if (endpoint.protocol === "openai-chat") {
+            return new OpenAIChatProvider(options.apiKey, model, options.retry, baseURL);
+        }
+        if (endpoint.protocol === "openai-responses") {
+            return new OpenAIResponsesProvider(options.apiKey, model, options.retry, baseURL);
+        }
+    }
+    if (profile.providerId === "minimax" && endpoint.protocol === "anthropic-messages") {
+        return new MiniMaxProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    if (profile.providerId === "deepseek" && endpoint.protocol === "openai-chat") {
+        return new DeepSeekProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    if (profile.providerId === "kimi" && endpoint.protocol === "openai-chat") {
+        return new KimiProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    if (profile.providerId === "qwen" && endpoint.protocol === "openai-chat") {
+        return new QwenProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    if (profile.providerId === "gemini" && endpoint.protocol === "gemini") {
+        return new GeminiProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    throw new Error(`No Node provider factory for ${profile.id} on ${endpoint.id}`);
+}

package/dist/providers/deepseek.d.ts

@@ -0,0 +1,9 @@
+import type { Message, ToolSchema, StreamEvent } from "../types.js";
+import { OpenAIChatProvider } from "./openai.js";
+export declare class DeepSeekProvider extends OpenAIChatProvider {
+    constructor(apiKey: string, model?: "deepseek-v4-flash" | "deepseek-v4-pro", retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}

package/dist/providers/deepseek.js

@@ -0,0 +1,64 @@
+import { OpenAIChatProvider } from "./openai.js";
+import { endpointProfiles } from "./profiles.js";
+const DEEPSEEK_BASE = endpointProfiles["deepseek.openai"].baseURL;
+export class DeepSeekProvider extends OpenAIChatProvider {
+    constructor(apiKey, model = "deepseek-v4-flash", retry, baseURL = DEEPSEEK_BASE) {
+        super(apiKey, model, retry, baseURL);
+    }
+    async *stream(messages, tools, extensions) {
+        const exposeReasoning = extensions?.exposeReasoning ?? false;
+        const thinking = extensions?.thinking === false ? "disabled" : "enabled";
+        const reasoningEffort = extensions?.reasoningEffort === "max" ? "max" : "high";
+        const msgs = this.chat.buildMessages(messages);
+        const toolCallBufs = {};
+        let reasoningContent = "";
+        let finalText = "";
+        const stream = await this.client.chat.completions.create({
+            model: this.model,
+            messages: msgs,
+            ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
+            stream: true,
+            reasoning_effort: reasoningEffort,
+            extra_body: { thinking: { type: thinking } },
+        });
+        for await (const chunk of stream) {
+            const choice = chunk.choices[0];
+            if (!choice)
+                continue;
+            const delta = choice.delta;
+            if (exposeReasoning && delta.reasoning_content) {
+                yield { type: "thinking_delta", delta: delta.reasoning_content };
+            }
+            if (delta.reasoning_content)
+                reasoningContent += String(delta.reasoning_content);
+            if (delta.content) {
+                finalText += String(delta.content);
+                yield { type: "text_delta", delta: delta.content };
+            }
+            for (const tc of delta.tool_calls ?? []) {
+                const idx = tc.index;
+                if (!toolCallBufs[idx])
+                    toolCallBufs[idx] = { id: tc.id ?? "", name: "", argsBuf: "" };
+                if (tc.function?.name)
+                    toolCallBufs[idx].name += tc.function.name;
+                toolCallBufs[idx].argsBuf += tc.function?.arguments ?? "";
+            }
+            if (choice.finish_reason === "tool_calls") {
+                const toolCalls = Object.values(toolCallBufs).map(tb => ({
+                    id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
+                }));
+                this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
+                for (const tb of Object.values(toolCallBufs)) {
+                    let args = {};
+                    try {
+                        args = JSON.parse(tb.argsBuf || "{}");
+                    }
+                    catch {
+                        args = {};
+                    }
+                    yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
+                }
+            }
+        }
+    }
+}

package/dist/providers/gemini.d.ts

@@ -0,0 +1,14 @@
+import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+export declare class GeminiProvider implements LLMProvider {
+    private readonly model;
+    private genAI;
+    private circuit;
+    private maxRetries;
+    private baseDelay;
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}

package/dist/providers/gemini.js

@@ -0,0 +1,142 @@
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { withServerRuntimeGuard } from "../runtime/server.js";
+import { CircuitBreaker, normalizeToolCall } from "./base.js";
+import { endpointProfiles } from "./profiles.js";
+const GEMINI_BASE = endpointProfiles["gemini.google"].baseURL;
+function buildContents(messages) {
+    const contents = [];
+    for (const msg of messages) {
+        if (msg.role === "system")
+            continue;
+        if (msg.role === "tool") {
+            const parts = (msg.contentParts ?? [])
+                .filter(p => p.type === "tool_result")
+                .map(p => p.type === "tool_result" ? ({
+                functionResponse: { name: p.callId, response: { output: p.output } },
+            }) : ({ text: "" }));
+            if (parts.length)
+                contents.push({ role: "user", parts });
+            continue;
+        }
+        const role = msg.role === "assistant" ? "model" : "user";
+        const parts = [];
+        if (msg.toolCalls?.length) {
+            for (const tc of msg.toolCalls) {
+                let args = {};
+                try {
+                    args = JSON.parse(tc.arguments);
+                }
+                catch {
+                    args = {};
+                }
+                parts.push({ functionCall: { name: tc.name, args } });
+            }
+        }
+        if (msg.content)
+            parts.push({ text: msg.content });
+        if (parts.length)
+            contents.push({ role, parts });
+    }
+    return contents;
+}
+function buildTools(tools) {
+    if (!tools.length)
+        return [];
+    return [{
+            functionDeclarations: tools.map(t => ({
+                name: t.name,
+                description: t.description,
+                parameters: JSON.parse(t.parameters),
+            })),
+        }];
+}
+function systemInstruction(messages) {
+    return messages.find(m => m.role === "system")?.content;
+}
+export class GeminiProvider {
+    model;
+    genAI;
+    circuit;
+    maxRetries;
+    baseDelay;
+    constructor(apiKey, model = "gemini-2.0-flash", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = GEMINI_BASE) {
+        this.model = model;
+        this.genAI = withServerRuntimeGuard(() => new GoogleGenerativeAI(apiKey));
+        this.circuit = new CircuitBreaker();
+        this.maxRetries = retry.maxRetries;
+        this.baseDelay = retry.baseDelay;
+    }
+    async complete(messages, tools) {
+        if (this.circuit.isOpen())
+            throw new Error("Circuit breaker open");
+        const system = systemInstruction(messages);
+        const contents = buildContents(messages);
+        const geminiTools = buildTools(tools);
+        let lastErr;
+        for (let i = 0; i < this.maxRetries; i++) {
+            try {
+                const m = this.genAI.getGenerativeModel({
+                    model: this.model,
+                    ...(system ? { systemInstruction: system } : {}),
+                    ...(geminiTools.length ? { tools: geminiTools } : {}),
+                });
+                const resp = await m.generateContent({ contents });
+                this.circuit.recordSuccess();
+                const candidate = resp.response.candidates?.[0];
+                let content = "";
+                const toolCalls = [];
+                for (const part of candidate?.content.parts ?? []) {
+                    if (part.text)
+                        content += part.text;
+                    else if (part.functionCall) {
+                        const tc = normalizeToolCall(part.functionCall.name, part.functionCall.name, part.functionCall.args);
+                        if (tc)
+                            toolCalls.push(tc);
+                    }
+                }
+                const usage = resp.response.usageMetadata;
+                return {
+                    role: "assistant",
+                    content,
+                    tokenCount: usage?.totalTokenCount,
+                    toolCalls,
+                };
+            }
+            catch (err) {
+                lastErr = err;
+                this.circuit.recordFailure();
+                if (i < this.maxRetries - 1)
+                    await new Promise(r => setTimeout(r, this.baseDelay * 2 ** i));
+            }
+        }
+        throw lastErr;
+    }
+    async *stream(messages, tools, extensions) {
+        const system = systemInstruction(messages);
+        const contents = buildContents(messages);
+        const geminiTools = buildTools(tools);
+        const m = this.genAI.getGenerativeModel({
+            model: this.model,
+            ...(system ? { systemInstruction: system } : {}),
+            ...(geminiTools.length ? { tools: geminiTools } : {}),
+        });
+        const result = await m.generateContentStream({ contents });
+        const toolCallBufs = {};
+        for await (const chunk of result.stream) {
+            for (const part of chunk.candidates?.[0]?.content.parts ?? []) {
+                if (part.text)
+                    yield { type: "text_delta", delta: part.text };
+                else if (part.functionCall) {
+                    const { name, args } = part.functionCall;
+                    toolCallBufs[name] = { name, args: args };
+                }
+            }
+        }
+        for (const [id, tc] of Object.entries(toolCallBufs)) {
+            yield { type: "tool_call", id, name: tc.name, arguments: tc.args };
+        }
+        const usage = (await result.response).usageMetadata;
+        if (usage?.totalTokenCount)
+            yield { type: "usage", totalTokens: usage.totalTokenCount };
+    }
+}

package/dist/providers/kimi.d.ts

@@ -0,0 +1,7 @@
+import { OpenAIChatProvider } from "./openai.js";
+export declare class KimiProvider extends OpenAIChatProvider {
+    constructor(apiKey: string, model?: "kimi-k2.5" | "kimi-k2.6", retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+}

package/dist/providers/kimi.js

@@ -0,0 +1,8 @@
+import { OpenAIChatProvider } from "./openai.js";
+import { endpointProfiles } from "./profiles.js";
+const MOONSHOT_BASE = endpointProfiles["kimi.openai"].baseURL;
+export class KimiProvider extends OpenAIChatProvider {
+    constructor(apiKey, model = "kimi-k2.6", retry, baseURL = MOONSHOT_BASE) {
+        super(apiKey, model, retry, baseURL);
+    }
+}

package/dist/providers/minimax.d.ts

@@ -0,0 +1,7 @@
+import { AnthropicProvider } from "./anthropic.js";
+export declare class MiniMaxProvider extends AnthropicProvider {
+    constructor(apiKey: string, model?: "MiniMax-M2.7" | "MiniMax-M2.5", retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+}

package/dist/providers/minimax.js

@@ -0,0 +1,10 @@
+import { AnthropicProvider } from "./anthropic.js";
+import { endpointProfiles } from "./profiles.js";
+export class MiniMaxProvider extends AnthropicProvider {
+    constructor(apiKey, model = "MiniMax-M2.7", retry, baseURL = endpointProfiles["minimax.anthropic"].baseURL) {
+        super(apiKey, model, retry, {
+            baseURL,
+            authMode: "bearer",
+        });
+    }
+}

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

@@ -0,0 +1,27 @@
+import type OpenAI from "openai";
+import type { Message, ToolSchema } from "../types.js";
+export declare class OpenAIChatAdapter {
+    private replayFields;
+    buildTools(tools: ToolSchema[]): {
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: any;
+        };
+    }[];
+    buildMessages(messages: Message[]): OpenAI.ChatCompletionMessageParam[];
+    normalizeToolCalls(toolCalls?: Array<{
+        id: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>): Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>;
+    rememberReplayFields(message: Pick<Message, "content" | "toolCalls">, fields: Record<string, unknown>): void;
+    private assistantReplayKey;
+}

package/dist/providers/openai-chat.js

@@ -0,0 +1,41 @@
+import { normalizeToolCall, toOpenAIMessageParams } from "./base.js";
+export class OpenAIChatAdapter {
+    replayFields = new Map();
+    buildTools(tools) {
+        return tools.map(t => ({
+            type: "function",
+            function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) },
+        }));
+    }
+    buildMessages(messages) {
+        const serialized = toOpenAIMessageParams(messages);
+        let cursor = 0;
+        for (const source of messages) {
+            if (source.role === "tool") {
+                cursor += (source.contentParts ?? []).filter(p => p.type === "tool_result").length;
+                continue;
+            }
+            if (source.role === "assistant") {
+                const replay = this.replayFields.get(this.assistantReplayKey(source));
+                if (replay)
+                    serialized[cursor] = { ...serialized[cursor], ...replay };
+            }
+            cursor += 1;
+        }
+        return serialized;
+    }
+    normalizeToolCalls(toolCalls = []) {
+        return toolCalls
+            .map(tc => normalizeToolCall(tc.id, tc.function.name, tc.function.arguments))
+            .filter(Boolean);
+    }
+    rememberReplayFields(message, fields) {
+        this.replayFields.set(this.assistantReplayKey(message), fields);
+    }
+    assistantReplayKey(message) {
+        return JSON.stringify({
+            content: message.content,
+            toolCalls: message.toolCalls ?? [],
+        });
+    }
+}

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

@@ -0,0 +1,42 @@
+import OpenAI from "openai";
+import type { Message, ProviderRunState, StreamEvent, ToolSchema, LLMProvider } from "../types.js";
+import { CircuitBreaker } from "./base.js";
+export interface OpenAIResponsesRunState extends ProviderRunState {
+    previousResponseId?: string;
+    coveredMessageCount: number;
+}
+export declare class OpenAIResponsesAdapter {
+    buildTools(tools: ToolSchema[]): {
+        type: "function";
+        name: string;
+        description: string;
+        parameters: any;
+    }[];
+    buildInstructions(messages: Message[]): string | undefined;
+    buildInput(messages: Message[], state?: OpenAIResponsesRunState): Array<Record<string, unknown>>;
+    decodeOutput(output: Array<Record<string, unknown>>): {
+        content: string;
+        toolCalls: Array<{
+            id: string;
+            name: string;
+            arguments: string;
+        }>;
+    };
+    private buildMessageContent;
+}
+export declare class OpenAIResponsesProvider implements LLMProvider {
+    protected readonly model: string;
+    protected client: OpenAI;
+    protected circuit: CircuitBreaker;
+    protected maxRetries: number;
+    protected baseDelay: number;
+    protected readonly responses: OpenAIResponsesAdapter;
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    createRunState(): OpenAIResponsesRunState;
+    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
+    stream(messages: Message[], tools: ToolSchema[], _extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
+    private asRunState;
+}