@deepstrike/sdk 0.1.14 → 0.1.16

package/dist/index.d.ts

@@ -25,6 +25,7 @@ export { OpenAIChatAdapter } from "./providers/openai-chat.js";
 export { OpenAIResponsesAdapter, OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export type { OpenAIResponsesRunState } from "./providers/openai-responses.js";
 export { endpointProfiles, modelProfiles, getModelProfile } from "./providers/profiles.js";
+export type { ModelProfileId, ProviderId } from "./providers/profiles.js";
 export { createProvider } from "./providers/catalog.js";
 export type { CreateProviderOptions, EndpointProfileId } from "./providers/catalog.js";
 export { tool, streamingTool, executeTools, readFile, validateToolArguments } from "./tools/index.js";
@@ -43,7 +44,7 @@ export { Governance } from "./governance.js";
 export type { GovernanceVerdict } from "./governance.js";
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
 export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions, QualityGate } from "./harness/harness.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, RenderedContext, } from "./types.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, ProviderReplay, RenderedContext, } from "./types.js";
 export type { AcceptanceCriterion, VerificationContract, ContractCheckResult, } from "./collaboration/contract.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
 export { AgentPool } from "./collaboration/pool.js";

package/dist/providers/anthropic.d.ts

@@ -1,4 +1,4 @@
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+import type { Message, ProviderReplay, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 interface AnthropicProviderOptions {
     baseURL?: string;
     authMode?: "api-key" | "bearer";
@@ -15,6 +15,8 @@ export declare class AnthropicProvider implements LLMProvider {
         baseDelay: number;
     }, options?: AnthropicProviderOptions);
     runtimePolicy(): RuntimePolicy;
+    peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
+    seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
     private buildTools;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
@@ -24,6 +26,5 @@ export declare class AnthropicProvider implements LLMProvider {
     private streamMessage;
     private buildMessages;
     private rememberNativeBlocks;
-    private assistantReplayKey;
 }
 export {};

package/dist/providers/anthropic.js

@@ -1,12 +1,16 @@
 import Anthropic from "@anthropic-ai/sdk";
+import { assistantReplayKey } from "../runtime/provider-replay.js";
 import { withServerRuntimeGuard } from "../runtime/server.js";
 import { CircuitBreaker, normalizeToolCall, omitExtensionKeys, toAnthropicMessages } from "./base.js";
 const CLAUDE_POLICIES = {
+    "claude-opus-4-1": { maxTurns: 50 },
     "claude-opus-4-7": { maxTurns: 50 },
     "claude-opus-4-6": { maxTurns: 50 },
+    "claude-opus-4-0": { maxTurns: 50 },
     "claude-sonnet-4-6": { maxTurns: 25 },
+    "claude-sonnet-4-0": { maxTurns: 25 },
     "claude-haiku-4-5": { maxTurns: 15 },
-    "claude-haiku-4-5-20251001": { maxTurns: 15 },
+    "claude-3-5-haiku-latest": { maxTurns: 15 },
 };
 export class AnthropicProvider {
     model;
@@ -28,6 +32,15 @@ export class AnthropicProvider {
     runtimePolicy() {
         return CLAUDE_POLICIES[this.model] ?? {};
     }
+    peekProviderReplay(message) {
+        const blocks = this.nativeAssistantBlocks.get(assistantReplayKey(message));
+        return blocks?.length ? { native_blocks: blocks } : undefined;
+    }
+    seedProviderReplay(message, replay) {
+        if (replay.native_blocks?.length) {
+            this.nativeAssistantBlocks.set(assistantReplayKey(message), replay.native_blocks);
+        }
+    }
     buildTools(tools) {
         return tools.map(t => ({
             name: t.name,
@@ -161,17 +174,13 @@ export class AnthropicProvider {
             : this.client.messages.stream(params));
     }
     buildMessages(context) {
-        return toAnthropicMessages(context.turns, message => this.nativeAssistantBlocks.get(this.assistantReplayKey(message)));
+        return toAnthropicMessages(context.turns, message => this.nativeAssistantBlocks.get(assistantReplayKey(message)));
     }
     rememberNativeBlocks(message, blocks) {
-        if (!message.toolCalls?.length)
+        if (!blocks.length)
             return;
-        this.nativeAssistantBlocks.set(this.assistantReplayKey(message), blocks);
-    }
-    assistantReplayKey(message) {
-        return JSON.stringify({
-            content: message.content,
-            toolCalls: message.toolCalls ?? [],
-        });
+        if (!message.toolCalls?.length && !blocks.some(b => b.type === "thinking"))
+            return;
+        this.nativeAssistantBlocks.set(assistantReplayKey(message), blocks);
     }
 }

package/dist/providers/base.d.ts

@@ -23,3 +23,15 @@ export declare function toOpenAIContent(msg: Message): string | Array<Record<str
 /** Build the full OpenAI messages array from a RenderedContext.
  *  Prepends systemText as the first system message, then converts turns. */
 export declare function toOpenAIMessageParams(context: RenderedContext): Array<Record<string, unknown>>;
+export declare class ThinkingTagStreamExtractor {
+    private buffer;
+    private inThinking;
+    feed(chunk: string): Array<{
+        type: "text" | "thinking";
+        content: string;
+    }>;
+    flush(): Array<{
+        type: "text" | "thinking";
+        content: string;
+    }>;
+}

package/dist/providers/base.js

@@ -166,3 +166,78 @@ export function toOpenAIMessageParams(context) {
     }
     return result;
 }
+export class ThinkingTagStreamExtractor {
+    buffer = "";
+    inThinking = false;
+    feed(chunk) {
+        this.buffer += chunk;
+        const events = [];
+        while (true) {
+            if (!this.inThinking) {
+                const thinkIndex = this.buffer.indexOf("<think>");
+                if (thinkIndex !== -1) {
+                    const textBefore = this.buffer.substring(0, thinkIndex);
+                    if (textBefore) {
+                        events.push({ type: "text", content: textBefore });
+                    }
+                    this.inThinking = true;
+                    this.buffer = this.buffer.substring(thinkIndex + 7);
+                    continue;
+                }
+                const possibleTagStart = this.buffer.lastIndexOf("<");
+                if (possibleTagStart !== -1 && "<think>".startsWith(this.buffer.substring(possibleTagStart))) {
+                    const toEmit = this.buffer.substring(0, possibleTagStart);
+                    if (toEmit) {
+                        events.push({ type: "text", content: toEmit });
+                    }
+                    this.buffer = this.buffer.substring(possibleTagStart);
+                    break;
+                }
+                else {
+                    if (this.buffer) {
+                        events.push({ type: "text", content: this.buffer });
+                        this.buffer = "";
+                    }
+                    break;
+                }
+            }
+            else {
+                const endThinkIndex = this.buffer.indexOf("</think>");
+                if (endThinkIndex !== -1) {
+                    const thinkingContent = this.buffer.substring(0, endThinkIndex);
+                    if (thinkingContent) {
+                        events.push({ type: "thinking", content: thinkingContent });
+                    }
+                    this.inThinking = false;
+                    this.buffer = this.buffer.substring(endThinkIndex + 8);
+                    continue;
+                }
+                const possibleEndStart = this.buffer.lastIndexOf("<");
+                if (possibleEndStart !== -1 && "</think>".startsWith(this.buffer.substring(possibleEndStart))) {
+                    const toEmit = this.buffer.substring(0, possibleEndStart);
+                    if (toEmit) {
+                        events.push({ type: "thinking", content: toEmit });
+                    }
+                    this.buffer = this.buffer.substring(possibleEndStart);
+                    break;
+                }
+                else {
+                    if (this.buffer) {
+                        events.push({ type: "thinking", content: this.buffer });
+                        this.buffer = "";
+                    }
+                    break;
+                }
+            }
+        }
+        return events;
+    }
+    flush() {
+        const events = [];
+        if (this.buffer) {
+            events.push({ type: this.inThinking ? "thinking" : "text", content: this.buffer });
+            this.buffer = "";
+        }
+        return events;
+    }
+}

package/dist/providers/catalog.d.ts

@@ -1,9 +1,10 @@
 import type { LLMProvider } from "../types.js";
-import { endpointProfiles, type ModelProfileId } from "./profiles.js";
+import { endpointProfiles, type ModelProfileId, type ProviderId } from "./profiles.js";
 export type EndpointProfileId = keyof typeof endpointProfiles;
 export interface CreateProviderOptions {
-    model: ModelProfileId;
+    model: ModelProfileId | string;
     apiKey: string;
+    provider?: ProviderId;
     endpoint?: EndpointProfileId;
     retry?: {
         maxRetries: number;

package/dist/providers/catalog.js

@@ -1,3 +1,4 @@
+import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIChatProvider } from "./openai.js";
 import { DeepSeekProvider } from "./deepseek.js";
 import { KimiProvider } from "./kimi.js";
@@ -5,20 +6,35 @@ 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";
+import { GLMProvider } from "./glm.js";
+import { endpointProfiles, getModelProfile, modelProfiles } from "./profiles.js";
 export function createProvider(options) {
-    const profile = getModelProfile(options.model);
-    const endpointId = (options.endpoint ?? profile.defaultEndpointId);
+    const profile = isModelProfileId(options.model) ? getModelProfile(options.model) : undefined;
+    const parsedProviderId = providerPrefix(options.model);
+    const endpointId = (options.endpoint ?? profile?.defaultEndpointId ?? defaultEndpointForProvider(options.provider ?? parsedProviderId));
+    if (!endpointId) {
+        throw new Error(`Unknown model profile: ${options.model}. Pass provider or endpoint for custom model names.`);
+    }
     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 providerId = profile?.providerId ?? options.provider ?? parsedProviderId ?? endpoint.providerId;
+    if (profile && options.provider && options.provider !== profile.providerId) {
+        throw new Error(`Model ${profile.id} belongs to provider ${profile.providerId}, not ${options.provider}`);
+    }
+    if (parsedProviderId && options.provider && parsedProviderId !== options.provider) {
+        throw new Error(`Model ${options.model} uses provider prefix ${parsedProviderId}, not ${options.provider}`);
+    }
+    if (endpoint.providerId !== providerId) {
+        throw new Error(`Endpoint ${endpoint.id} does not belong to provider ${providerId}`);
     }
-    const model = options.model.slice(`${profile.providerId}/`.length);
+    const model = modelNameForProvider(options.model, providerId);
     const baseURL = options.baseURL ?? endpoint.baseURL;
-    if (profile.providerId === "openai") {
+    if (providerId === "anthropic" && endpoint.protocol === "anthropic-messages") {
+        return new AnthropicProvider(options.apiKey, model, options.retry, { baseURL });
+    }
+    if (providerId === "openai") {
         if (endpoint.protocol === "openai-chat") {
             return new OpenAIChatProvider(options.apiKey, model, options.retry, baseURL);
         }
@@ -26,20 +42,52 @@ export function createProvider(options) {
             return new OpenAIResponsesProvider(options.apiKey, model, options.retry, baseURL);
         }
     }
-    if (profile.providerId === "minimax" && endpoint.protocol === "anthropic-messages") {
+    if (providerId === "minimax" && endpoint.protocol === "anthropic-messages") {
         return new MiniMaxProvider(options.apiKey, model, options.retry, baseURL);
     }
-    if (profile.providerId === "deepseek" && endpoint.protocol === "openai-chat") {
+    if (providerId === "deepseek" && endpoint.protocol === "openai-chat") {
         return new DeepSeekProvider(options.apiKey, model, options.retry, baseURL);
     }
-    if (profile.providerId === "kimi" && endpoint.protocol === "openai-chat") {
+    if (providerId === "kimi" && endpoint.protocol === "openai-chat") {
         return new KimiProvider(options.apiKey, model, options.retry, baseURL);
     }
-    if (profile.providerId === "qwen" && endpoint.protocol === "openai-chat") {
+    if (providerId === "qwen" && endpoint.protocol === "openai-chat") {
         return new QwenProvider(options.apiKey, model, options.retry, baseURL);
     }
-    if (profile.providerId === "gemini" && endpoint.protocol === "gemini") {
+    if (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}`);
+    if (providerId === "glm" && endpoint.protocol === "openai-chat") {
+        return new GLMProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    throw new Error(`No Node provider factory for ${options.model} on ${endpoint.id}`);
+}
+function isModelProfileId(model) {
+    return Object.prototype.hasOwnProperty.call(modelProfiles, model);
+}
+function providerPrefix(model) {
+    const [prefix] = model.split("/", 1);
+    return providerIds().includes(prefix) ? prefix : undefined;
+}
+function providerIds() {
+    return Array.from(new Set(Object.values(endpointProfiles).map(endpoint => endpoint.providerId)));
+}
+function defaultEndpointForProvider(providerId) {
+    if (!providerId)
+        return undefined;
+    const defaults = {
+        anthropic: "anthropic.messages",
+        openai: "openai.chat",
+        minimax: "minimax.anthropic",
+        deepseek: "deepseek.openai",
+        kimi: "kimi.openai",
+        qwen: "qwen.dashscope",
+        gemini: "gemini.google",
+        glm: "glm.openai",
+    };
+    return defaults[providerId];
+}
+function modelNameForProvider(model, providerId) {
+    const prefix = `${providerId}/`;
+    return model.startsWith(prefix) ? model.slice(prefix.length) : model;
 }

package/dist/providers/deepseek.js

@@ -91,7 +91,7 @@ export class DeepSeekProvider extends OpenAIChatProvider {
         const toolCalls = Object.values(toolCallBufs).map(tb => ({
             id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
         }));
-        if (toolCalls.length) {
+        if (toolCalls.length || reasoningContent) {
             this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
         }
         for (const [index, tb] of Object.entries(toolCallBufs)) {

package/dist/providers/gemini.d.ts

@@ -1,10 +1,13 @@
+import { type Content } from "@google/generative-ai";
 import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+export declare function buildContents(turns: Message[]): Content[];
 export declare class GeminiProvider implements LLMProvider {
     private readonly model;
     private genAI;
     private circuit;
     private maxRetries;
     private baseDelay;
+    private requestOptions;
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;

package/dist/providers/gemini.js

@@ -4,6 +4,9 @@ import { CircuitBreaker, normalizeToolCall } from "./base.js";
 import { endpointProfiles } from "./profiles.js";
 const GEMINI_BASE = endpointProfiles["gemini.google"].baseURL;
 const GEMINI_POLICIES = {
+    "gemini-3-pro-preview": { maxTurns: 50 },
+    "gemini-3-flash-preview": { maxTurns: 25 },
+    "gemini-3.5-flash": { maxTurns: 30 },
     "gemini-2.5-pro": { maxTurns: 35 },
     "gemini-2.5-flash": { maxTurns: 20 },
     "gemini-2.0-flash": { maxTurns: 15 },
@@ -11,15 +14,30 @@ const GEMINI_POLICIES = {
     "gemini-1.5-pro": { maxTurns: 30 },
     "gemini-1.5-flash": { maxTurns: 15 },
 };
-function buildContents(turns) {
+export function buildContents(turns) {
     const contents = [];
     for (const msg of turns) {
         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: "" }));
+                .map(p => {
+                if (p.type !== "tool_result")
+                    return { text: "" };
+                let toolName = p.callId;
+                for (let i = turns.length - 1; i >= 0; i--) {
+                    const turn = turns[i];
+                    if (turn.role === "assistant" && turn.toolCalls) {
+                        const matched = turn.toolCalls.find(tc => tc.id === p.callId);
+                        if (matched) {
+                            toolName = matched.name;
+                            break;
+                        }
+                    }
+                }
+                return {
+                    functionResponse: { name: toolName, response: { output: p.output } },
+                };
+            });
             if (parts.length)
                 contents.push({ role: "user", parts });
             continue;
@@ -62,12 +80,14 @@ export class GeminiProvider {
     circuit;
     maxRetries;
     baseDelay;
+    requestOptions;
     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;
+        this.requestOptions = { baseUrl: baseURL };
     }
     runtimePolicy() {
         return GEMINI_POLICIES[this.model] ?? {};
@@ -86,7 +106,7 @@ export class GeminiProvider {
                     model: this.model,
                     ...(system ? { systemInstruction: system } : {}),
                     ...(geminiTools.length ? { tools: geminiTools } : {}),
-                });
+                }, this.requestOptions);
                 const resp = await m.generateContent({ contents });
                 this.circuit.recordSuccess();
                 const candidate = resp.response.candidates?.[0];
@@ -127,7 +147,7 @@ export class GeminiProvider {
             model: this.model,
             ...(system ? { systemInstruction: system } : {}),
             ...(geminiTools.length ? { tools: geminiTools } : {}),
-        });
+        }, this.requestOptions);
         const result = await m.generateContentStream({ contents });
         const toolCalls = [];
         for await (const chunk of result.stream) {

package/dist/providers/glm.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimePolicy } from "../types.js";
+import { OpenAIChatProvider } from "./openai.js";
+export declare class GLMProvider extends OpenAIChatProvider {
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    runtimePolicy(): RuntimePolicy;
+}

package/dist/providers/glm.js

@@ -0,0 +1,21 @@
+import { OpenAIChatProvider } from "./openai.js";
+import { endpointProfiles } from "./profiles.js";
+const GLM_BASE = endpointProfiles["glm.openai"].baseURL;
+const GLM_POLICIES = {
+    "glm-5.1": { maxTurns: 50 },
+    "glm/glm-5.1": { maxTurns: 50 },
+    "glm-4-plus": { maxTurns: 35 },
+    "glm/glm-4-plus": { maxTurns: 35 },
+    "glm-4-flash": { maxTurns: 15 },
+    "glm/glm-4-flash": { maxTurns: 15 },
+    "glm-4-air": { maxTurns: 20 },
+    "glm/glm-4-air": { maxTurns: 20 },
+};
+export class GLMProvider extends OpenAIChatProvider {
+    constructor(apiKey, model = "glm-5.1", retry, baseURL = GLM_BASE) {
+        super(apiKey, model, retry, baseURL);
+    }
+    runtimePolicy() {
+        return GLM_POLICIES[this.model] ?? {};
+    }
+}

package/dist/providers/kimi.js

@@ -7,6 +7,8 @@ const KIMI_POLICIES = {
     "moonshot-v1-128k": { maxTurns: 30 },
     "kimi-k2.5": { maxTurns: 30 },
     "kimi-k2.6": { maxTurns: 35 },
+    "kimi-k2-thinking": { maxTurns: 50 },
+    "kimi-k2-thinking-turbo": { maxTurns: 40 },
 };
 export class KimiProvider extends OpenAIChatProvider {
     constructor(apiKey, model = "kimi-k2.6", retry, baseURL = MOONSHOT_BASE) {

package/dist/providers/minimax.js

@@ -2,7 +2,12 @@ import { AnthropicProvider } from "./anthropic.js";
 import { endpointProfiles } from "./profiles.js";
 const MINIMAX_POLICIES = {
     "MiniMax-M2.7": { maxTurns: 35 },
+    "MiniMax-M2.7-highspeed": { maxTurns: 35 },
     "MiniMax-M2.5": { maxTurns: 25 },
+    "MiniMax-M2.5-highspeed": { maxTurns: 25 },
+    "MiniMax-M2.1": { maxTurns: 25 },
+    "MiniMax-M2.1-highspeed": { maxTurns: 25 },
+    "MiniMax-M2": { maxTurns: 20 },
     "MiniMax-Text-01": { maxTurns: 20 },
 };
 export class MiniMaxProvider extends AnthropicProvider {

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

@@ -23,5 +23,5 @@ export declare class OpenAIChatAdapter {
         arguments: string;
     }>;
     rememberReplayFields(message: Pick<Message, "content" | "toolCalls">, fields: Record<string, unknown>): void;
-    private assistantReplayKey;
+    peekReplayFields(message: Pick<Message, "content" | "toolCalls">): Record<string, unknown> | undefined;
 }

package/dist/providers/openai-chat.js

@@ -1,3 +1,4 @@
+import { assistantReplayKey } from "../runtime/provider-replay.js";
 import { normalizeToolCall, toOpenAIMessageParams } from "./base.js";
 export class OpenAIChatAdapter {
     replayFields = new Map();
@@ -18,7 +19,7 @@ export class OpenAIChatAdapter {
                 continue;
             }
             if (source.role === "assistant") {
-                const replay = this.replayFields.get(this.assistantReplayKey(source));
+                const replay = this.replayFields.get(assistantReplayKey(source));
                 if (replay)
                     serialized[cursor] = { ...serialized[cursor], ...replay };
             }
@@ -32,12 +33,9 @@ export class OpenAIChatAdapter {
             .filter(Boolean);
     }
     rememberReplayFields(message, fields) {
-        this.replayFields.set(this.assistantReplayKey(message), fields);
+        this.replayFields.set(assistantReplayKey(message), fields);
     }
-    assistantReplayKey(message) {
-        return JSON.stringify({
-            content: message.content,
-            toolCalls: message.toolCalls ?? [],
-        });
+    peekReplayFields(message) {
+        return this.replayFields.get(assistantReplayKey(message));
     }
 }

package/dist/providers/openai-responses.js

@@ -115,11 +115,20 @@ export class OpenAIResponsesProvider {
     }
     runtimePolicy() {
         const table = {
+            "gpt-5.5": { maxTurns: 60 },
+            "gpt-5.4": { maxTurns: 50 },
+            "gpt-5.4-mini": { maxTurns: 25 },
+            "gpt-5.4-nano": { maxTurns: 15 },
+            "gpt-5.2": { maxTurns: 50 },
+            "gpt-5.2-pro": { maxTurns: 60 },
+            "gpt-5.1": { maxTurns: 50 },
             "gpt-4.1": { maxTurns: 35 },
             "gpt-4.1-mini": { maxTurns: 20 },
             "gpt-4.1-nano": { maxTurns: 15 },
             "gpt-5": { maxTurns: 50 },
+            "gpt-5-pro": { maxTurns: 60 },
             "gpt-5-mini": { maxTurns: 25 },
+            "gpt-5-nano": { maxTurns: 15 },
             "o3": { maxTurns: 50 },
             "o3-mini": { maxTurns: 25 },
             "o4-mini": { maxTurns: 25 },

package/dist/providers/openai.d.ts

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+import type { Message, ProviderReplay, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
 export declare class OpenAIChatProvider implements LLMProvider {
@@ -14,6 +14,8 @@ export declare class OpenAIChatProvider implements LLMProvider {
         baseDelay: number;
     }, baseURL?: string);
     runtimePolicy(): RuntimePolicy;
+    peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
+    seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
     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>;