@deepstrike/sdk 0.1.11 → 0.1.13

package/dist/providers/base.js

@@ -26,6 +26,12 @@ export class CircuitBreaker {
             this.openedAt = Date.now();
     }
 }
+export function omitExtensionKeys(extensions, keys) {
+    if (!extensions)
+        return {};
+    const blocked = new Set(keys);
+    return Object.fromEntries(Object.entries(extensions).filter(([key]) => !blocked.has(key)));
+}
 export function normalizeToolCall(id, name, args) {
     const n = String(name ?? "").trim();
     if (!n)
@@ -44,6 +50,15 @@ export function normalizeToolCall(id, name, args) {
     }
     return { id: String(id ?? ""), name: n, arguments: JSON.stringify(parsed) };
 }
+function parseToolArguments(args) {
+    try {
+        return JSON.parse(args || "{}");
+    }
+    catch {
+        return {};
+    }
+}
+// ─── Anthropic message conversion ────────────────────────────────────────────
 export function toAnthropicContent(msg) {
     if (!msg.contentParts?.length)
         return msg.content;
@@ -65,39 +80,11 @@ export function toAnthropicContent(msg) {
         return { type: "text", text: "" };
     });
 }
-export function toOpenAIContent(msg) {
-    if (!msg.contentParts?.length)
-        return msg.content;
-    return msg.contentParts.map(p => {
-        if (p.type === "text")
-            return { type: "text", text: p.text };
-        if (p.type === "image") {
-            const url = p.data ? `data:${p.mediaType ?? "image/png"};base64,${p.data}` : p.url;
-            return { type: "image_url", image_url: { url, ...(p.detail ? { detail: p.detail } : {}) } };
-        }
-        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) {
+/** Convert RenderedContext.turns to Anthropic messages array.
+ *  `turns` contains only user / assistant / tool roles — no system filtering needed. */
+export function toAnthropicMessages(turns, nativeReplay) {
     const result = [];
-    for (const msg of messages.filter(m => m.role !== "system")) {
+    for (const msg of turns) {
         if (msg.role === "tool") {
             const parts = (msg.contentParts ?? [])
                 .filter((p) => p.type === "tool_result")
@@ -124,16 +111,38 @@ export function toAnthropicMessages(messages, nativeReplay) {
             result.push({ role: "assistant", content: blocks });
             continue;
         }
-        result.push({
-            role: msg.role,
-            content: toAnthropicContent(msg),
-        });
+        result.push({ role: msg.role, content: toAnthropicContent(msg) });
     }
     return result;
 }
-export function toOpenAIMessageParams(messages) {
+// ─── OpenAI-compatible message conversion ────────────────────────────────────
+export function toOpenAIContent(msg) {
+    if (!msg.contentParts?.length)
+        return msg.content;
+    return msg.contentParts.map(p => {
+        if (p.type === "text")
+            return { type: "text", text: p.text };
+        if (p.type === "image") {
+            const url = p.data ? `data:${p.mediaType ?? "image/png"};base64,${p.data}` : p.url;
+            return { type: "image_url", image_url: { url, ...(p.detail ? { detail: p.detail } : {}) } };
+        }
+        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: "" };
+    });
+}
+/** Build the full OpenAI messages array from a RenderedContext.
+ *  Prepends systemText as the first system message, then converts turns. */
+export function toOpenAIMessageParams(context) {
     const result = [];
-    for (const msg of messages) {
+    if (context.systemText) {
+        result.push({ role: "system", content: context.systemText });
+    }
+    for (const msg of context.turns) {
         if (msg.role === "tool") {
             const parts = (msg.contentParts ?? [])
                 .filter((p) => p.type === "tool_result");

package/dist/providers/deepseek.d.ts

@@ -1,9 +1,10 @@
-import type { Message, ToolSchema, StreamEvent } from "../types.js";
+import type { Message, RenderedContext, 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>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }

package/dist/providers/deepseek.js

@@ -1,19 +1,34 @@
 import { OpenAIChatProvider } from "./openai.js";
 import { endpointProfiles } from "./profiles.js";
+import { omitExtensionKeys } from "./base.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) {
+    async complete(context, tools, extensions) {
+        const thinking = extensions?.thinking === false ? "disabled" : "enabled";
+        const reasoningEffort = extensions?.reasoningEffort === "max" ? "max" : "high";
+        return super.complete(context, tools, {
+            ...omitExtensionKeys(extensions, ["thinking", "reasoningEffort", "exposeReasoning", "extra_body", "reasoning_effort"]),
+            reasoning_effort: reasoningEffort,
+            extra_body: { thinking: { type: thinking } },
+        });
+    }
+    async *stream(context, 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 msgs = this.chat.buildMessages(context);
         const toolCallBufs = {};
+        const emittedToolCallIndexes = new Set();
         let reasoningContent = "";
         let finalText = "";
         const stream = await this.client.chat.completions.create({
+            ...omitExtensionKeys(extensions, [
+                "model", "messages", "tools", "stream", "extra_body", "reasoning_effort",
+                "exposeReasoning", "thinking", "reasoningEffort",
+            ]),
             model: this.model,
             messages: msgs,
             ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
@@ -48,7 +63,10 @@ export class DeepSeekProvider extends OpenAIChatProvider {
                     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)) {
+                for (const [index, tb] of Object.entries(toolCallBufs)) {
+                    const idx = Number(index);
+                    if (emittedToolCallIndexes.has(idx))
+                        continue;
                     let args = {};
                     try {
                         args = JSON.parse(tb.argsBuf || "{}");
@@ -56,9 +74,30 @@ export class DeepSeekProvider extends OpenAIChatProvider {
                     catch {
                         args = {};
                     }
+                    emittedToolCallIndexes.add(idx);
                     yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
                 }
             }
         }
+        const toolCalls = Object.values(toolCallBufs).map(tb => ({
+            id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
+        }));
+        if (toolCalls.length) {
+            this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
+        }
+        for (const [index, tb] of Object.entries(toolCallBufs)) {
+            const idx = Number(index);
+            if (emittedToolCallIndexes.has(idx))
+                continue;
+            let args = {};
+            try {
+                args = JSON.parse(tb.argsBuf || "{}");
+            }
+            catch {
+                args = {};
+            }
+            emittedToolCallIndexes.add(idx);
+            yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
+        }
     }
 }

package/dist/providers/gemini.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
 export declare class GeminiProvider implements LLMProvider {
     private readonly model;
     private genAI;
@@ -9,6 +9,7 @@ export declare class GeminiProvider implements LLMProvider {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    private modelExtensions;
 }

package/dist/providers/gemini.js

@@ -3,11 +3,9 @@ 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) {
+function buildContents(turns) {
     const contents = [];
-    for (const msg of messages) {
-        if (msg.role === "system")
-            continue;
+    for (const msg of turns) {
         if (msg.role === "tool") {
             const parts = (msg.contentParts ?? [])
                 .filter(p => p.type === "tool_result")
@@ -50,9 +48,6 @@ function buildTools(tools) {
             })),
         }];
 }
-function systemInstruction(messages) {
-    return messages.find(m => m.role === "system")?.content;
-}
 export class GeminiProvider {
     model;
     genAI;
@@ -66,16 +61,17 @@ export class GeminiProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
-    async complete(messages, tools) {
+    async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const system = systemInstruction(messages);
-        const contents = buildContents(messages);
+        const system = context.systemText || undefined;
+        const contents = buildContents(context.turns);
         const geminiTools = buildTools(tools);
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
                 const m = this.genAI.getGenerativeModel({
+                    ...this.modelExtensions(extensions),
                     model: this.model,
                     ...(system ? { systemInstruction: system } : {}),
                     ...(geminiTools.length ? { tools: geminiTools } : {}),
@@ -111,32 +107,39 @@ export class GeminiProvider {
         }
         throw lastErr;
     }
-    async *stream(messages, tools, extensions) {
-        const system = systemInstruction(messages);
-        const contents = buildContents(messages);
+    async *stream(context, tools, extensions) {
+        const system = context.systemText || undefined;
+        const contents = buildContents(context.turns);
         const geminiTools = buildTools(tools);
         const m = this.genAI.getGenerativeModel({
+            ...this.modelExtensions(extensions),
             model: this.model,
             ...(system ? { systemInstruction: system } : {}),
             ...(geminiTools.length ? { tools: geminiTools } : {}),
         });
         const result = await m.generateContentStream({ contents });
-        const toolCallBufs = {};
+        const toolCalls = [];
         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 };
+                    toolCalls.push({ id: `call_${toolCalls.length + 1}`, name, args: args });
                 }
             }
         }
-        for (const [id, tc] of Object.entries(toolCallBufs)) {
-            yield { type: "tool_call", id, name: tc.name, arguments: tc.args };
+        for (const tc of toolCalls) {
+            yield { type: "tool_call", id: tc.id, name: tc.name, arguments: tc.args };
         }
         const usage = (await result.response).usageMetadata;
         if (usage?.totalTokenCount)
             yield { type: "usage", totalTokens: usage.totalTokenCount };
     }
+    modelExtensions(extensions) {
+        if (!extensions)
+            return {};
+        const { model: _model, systemInstruction: _systemInstruction, tools: _tools, ...rest } = extensions;
+        return rest;
+    }
 }

package/dist/providers/ollama.d.ts

@@ -1,9 +1,11 @@
-import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
 export declare class OllamaProvider implements LLMProvider {
     private readonly model;
     private readonly baseUrl;
     constructor(model?: string, baseUrl?: string);
     private toOllamaMessages;
-    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    private buildTools;
+    private requestExtensions;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }

package/dist/providers/ollama.js

@@ -1,4 +1,4 @@
-import { normalizeToolCall } from "./base.js";
+import { normalizeToolCall, omitExtensionKeys } from "./base.js";
 export class OllamaProvider {
     model;
     baseUrl;
@@ -6,8 +6,11 @@ export class OllamaProvider {
         this.model = model;
         this.baseUrl = baseUrl;
     }
-    toOllamaMessages(messages) {
-        return messages.map(m => {
+    toOllamaMessages(context) {
+        const result = [];
+        if (context.systemText)
+            result.push({ role: "system", content: context.systemText });
+        for (const m of context.turns) {
             const images = [];
             if (m.contentParts?.length) {
                 for (const p of m.contentParts) {
@@ -15,31 +18,54 @@ export class OllamaProvider {
                         images.push(p.data);
                 }
             }
-            return { role: m.role, content: m.content, ...(images.length ? { images } : {}) };
-        });
+            result.push({ role: m.role, content: m.content, ...(images.length ? { images } : {}) });
+        }
+        return result;
+    }
+    buildTools(tools) {
+        return tools.map(t => ({
+            type: "function",
+            function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) },
+        }));
     }
-    async complete(messages, tools) {
+    requestExtensions(extensions) {
+        return omitExtensionKeys(extensions, ["model", "messages", "tools", "stream"]);
+    }
+    async complete(context, tools, extensions) {
         const resp = await fetch(`${this.baseUrl}/api/chat`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ model: this.model, messages: this.toOllamaMessages(messages), stream: false }),
+            body: JSON.stringify({
+                ...this.requestExtensions(extensions),
+                model: this.model,
+                messages: this.toOllamaMessages(context),
+                ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+                stream: false,
+            }),
         });
         if (!resp.ok)
             throw new Error(`Ollama error: ${resp.status}`);
         const data = await resp.json();
         return { role: "assistant", content: data.message.content };
     }
-    async *stream(messages, tools, extensions) {
+    async *stream(context, tools, extensions) {
         const resp = await fetch(`${this.baseUrl}/api/chat`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ model: this.model, messages: this.toOllamaMessages(messages), stream: true }),
+            body: JSON.stringify({
+                ...this.requestExtensions(extensions),
+                model: this.model,
+                messages: this.toOllamaMessages(context),
+                ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+                stream: true,
+            }),
         });
         if (!resp.ok)
             throw new Error(`Ollama error: ${resp.status}`);
         const reader = resp.body.getReader();
         const decoder = new TextDecoder();
         let buf = "";
+        const pendingToolCalls = new Map();
         while (true) {
             const { done, value } = await reader.read();
             if (done)
@@ -55,13 +81,25 @@ export class OllamaProvider {
                     if (chunk.message?.content)
                         yield { type: "text_delta", delta: chunk.message.content };
                     for (const tc of chunk.message?.tool_calls ?? []) {
-                        const norm = normalizeToolCall(crypto.randomUUID(), tc.function.name, tc.function.arguments);
-                        if (norm)
-                            yield { type: "tool_call", id: norm.id, name: norm.name, arguments: JSON.parse(norm.arguments) };
+                        const norm = normalizeToolCall("", tc.function.name, tc.function.arguments);
+                        if (!norm)
+                            continue;
+                        const args = JSON.parse(norm.arguments);
+                        const key = `${norm.name}:${norm.arguments}`;
+                        if (!pendingToolCalls.has(key)) {
+                            pendingToolCalls.set(key, {
+                                id: `call_${pendingToolCalls.size + 1}`,
+                                name: norm.name,
+                                arguments: args,
+                            });
+                        }
                     }
                 }
                 catch { /* skip malformed lines */ }
             }
         }
+        for (const tc of pendingToolCalls.values()) {
+            yield { type: "tool_call", id: tc.id, name: tc.name, arguments: tc.arguments };
+        }
     }
 }

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

@@ -1,5 +1,5 @@
 import type OpenAI from "openai";
-import type { Message, ToolSchema } from "../types.js";
+import type { Message, RenderedContext, ToolSchema } from "../types.js";
 export declare class OpenAIChatAdapter {
     private replayFields;
     buildTools(tools: ToolSchema[]): {
@@ -10,7 +10,7 @@ export declare class OpenAIChatAdapter {
             parameters: any;
         };
     }[];
-    buildMessages(messages: Message[]): OpenAI.ChatCompletionMessageParam[];
+    buildMessages(context: RenderedContext): OpenAI.ChatCompletionMessageParam[];
     normalizeToolCalls(toolCalls?: Array<{
         id: string;
         function: {

package/dist/providers/openai-chat.js

@@ -7,10 +7,12 @@ export class OpenAIChatAdapter {
             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) {
+    buildMessages(context) {
+        // toOpenAIMessageParams prepends systemText as messages[0], then turns.
+        const serialized = toOpenAIMessageParams(context);
+        // Cursor starts at 1 to skip the system message injected by toOpenAIMessageParams.
+        let cursor = context.systemText ? 1 : 0;
+        for (const source of context.turns) {
             if (source.role === "tool") {
                 cursor += (source.contentParts ?? []).filter(p => p.type === "tool_result").length;
                 continue;

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

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { Message, ProviderRunState, StreamEvent, ToolSchema, LLMProvider } from "../types.js";
+import type { Message, ProviderRunState, RenderedContext, StreamEvent, ToolSchema, LLMProvider } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 export interface OpenAIResponsesRunState extends ProviderRunState {
     previousResponseId?: string;
@@ -12,8 +12,8 @@ export declare class OpenAIResponsesAdapter {
         description: string;
         parameters: any;
     }[];
-    buildInstructions(messages: Message[]): string | undefined;
-    buildInput(messages: Message[], state?: OpenAIResponsesRunState): Array<Record<string, unknown>>;
+    buildInstructions(context: RenderedContext): string | undefined;
+    buildInput(context: RenderedContext, state?: OpenAIResponsesRunState): Array<Record<string, unknown>>;
     decodeOutput(output: Array<Record<string, unknown>>): {
         content: string;
         toolCalls: Array<{
@@ -36,7 +36,8 @@ export declare class OpenAIResponsesProvider implements LLMProvider {
         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>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
+    private requestExtensions;
     private asRunState;
 }

package/dist/providers/openai-responses.js

@@ -1,6 +1,6 @@
 import OpenAI from "openai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
-import { CircuitBreaker } from "./base.js";
+import { CircuitBreaker, omitExtensionKeys } from "./base.js";
 import { normalizeToolCall } from "./base.js";
 export class OpenAIResponsesAdapter {
     buildTools(tools) {
@@ -11,22 +11,16 @@ export class OpenAIResponsesAdapter {
             parameters: JSON.parse(t.parameters),
         }));
     }
-    buildInstructions(messages) {
-        const instructions = messages
-            .filter(message => message.role === "system")
-            .map(message => message.content)
-            .filter(Boolean);
-        return instructions.length ? instructions.join("\n\n") : undefined;
+    buildInstructions(context) {
+        return context.systemText || undefined;
     }
-    buildInput(messages, state) {
+    buildInput(context, state) {
         const input = [];
+        const turns = context.turns;
         const uncoveredMessages = state?.previousResponseId
-            ? messages.slice(state.coveredMessageCount)
-            : messages;
+            ? turns.slice(state.coveredMessageCount)
+            : turns;
         for (const message of uncoveredMessages) {
-            if (message.role === "system") {
-                continue;
-            }
             if (message.role === "assistant" && message.toolCalls?.length) {
                 if (message.content || message.contentParts?.length) {
                     input.push({
@@ -122,16 +116,17 @@ export class OpenAIResponsesProvider {
     createRunState() {
         return { coveredMessageCount: 0 };
     }
-    async complete(messages, tools) {
+    async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
-                const instructions = this.responses.buildInstructions(messages);
+                const instructions = this.responses.buildInstructions(context);
                 const resp = await this.client.responses.create({
+                    ...this.requestExtensions(extensions),
                     model: this.model,
-                    input: this.responses.buildInput(messages),
+                    input: this.responses.buildInput(context),
                     ...(instructions ? { instructions } : {}),
                     ...(tools.length ? { tools: this.responses.buildTools(tools) } : {}),
                 });
@@ -153,13 +148,14 @@ export class OpenAIResponsesProvider {
         }
         throw lastErr;
     }
-    async *stream(messages, tools, _extensions, state) {
+    async *stream(context, tools, extensions, state) {
         const runState = this.asRunState(state);
         const functionCalls = new Map();
-        const instructions = this.responses.buildInstructions(messages);
+        const instructions = this.responses.buildInstructions(context);
         const stream = await this.client.responses.create({
+            ...this.requestExtensions(extensions),
             model: this.model,
-            input: this.responses.buildInput(messages, runState),
+            input: this.responses.buildInput(context, runState),
             ...(instructions ? { instructions } : {}),
             ...(runState.previousResponseId ? { previous_response_id: runState.previousResponseId } : {}),
             ...(tools.length ? { tools: this.responses.buildTools(tools) } : {}),
@@ -203,13 +199,18 @@ export class OpenAIResponsesProvider {
             }
             else if (evt.type === "response.completed") {
                 runState.previousResponseId = evt.response.id;
-                runState.coveredMessageCount = messages.length + 1;
+                runState.coveredMessageCount = context.turns.length + 1;
                 if (evt.response.usage?.total_tokens) {
                     yield { type: "usage", totalTokens: evt.response.usage.total_tokens };
                 }
             }
         }
     }
+    requestExtensions(extensions) {
+        return omitExtensionKeys(extensions, [
+            "model", "input", "instructions", "tools", "stream", "previous_response_id",
+        ]);
+    }
     asRunState(state) {
         if (!state)
             return this.createRunState();

package/dist/providers/openai.d.ts

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
 export declare class OpenAIChatProvider implements LLMProvider {
@@ -13,7 +13,8 @@ export declare class OpenAIChatProvider implements LLMProvider {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    protected requestExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
 }
 export { OpenAIChatProvider as OpenAIProvider };