@deepstrike/sdk 0.1.11 → 0.1.13

package/README.md

@@ -50,6 +50,15 @@ const result = await agent.run("What is 17 + 28?")
 console.log(result)
 ```
 
+Same-session conversation continuity is explicit via `sessionId`:
+
+```typescript
+await agent.run("My name is Ada.", undefined, undefined, "chat-1")
+const reply = await agent.run("What is my name?", undefined, undefined, "chat-1")
+```
+
+By default, the agent keeps session transcripts in memory for the lifetime of that `Agent` instance. Provide a `sessionStore` when the transcript must survive process restarts or be shared across workers.
+
 Streaming:
 
 ```typescript
@@ -79,6 +88,8 @@ for await (const event of agent.runStreaming("Summarize README.md")) {
 
 All providers accept `RetryConfig` for exponential backoff and share a `CircuitBreaker`.
 
+`extensions` are forwarded by every provider in both `complete()` and `stream()` while SDK-owned structural fields such as `model`, `messages`, `tools`, and streaming flags remain protected. Provider-specific controls still keep their native spellings: for example Anthropic `thinking` / `betas`, OpenAI Responses `reasoning`, Gemini `generationConfig`, Ollama `think` / `options`, DeepSeek `thinking` + `reasoningEffort`, and Qwen `enableThinking` + `thinkingBudget`.
+
 OpenAI can also be selected through the provider catalog:
 
 ```typescript
@@ -99,7 +110,7 @@ const agent = new Agent(provider, {
   maxTokens: 4096,            // context window size
   maxTurns: 25,               // max turns (default 25)
   timeoutMs: 60_000,          // timeout in ms
-  extensions: { temperature: 0.1 },  // pass-through to LLM
+  extensions: { temperature: 0.1 },  // provider-native controls, passed through to the LLM
   skillDir: "./skills",       // skill .md files directory
   knowledgeSource: myKS,      // KnowledgeSource implementation
   signalSource: rx,           // SignalSource for external signals
@@ -196,6 +207,22 @@ const agent = new Agent(provider, {
 const result = await agent.dream("my-agent", Date.now())
 ```
 
+### SessionStore (same-session transcript continuity)
+
+```typescript
+import type { SessionStore } from "@deepstrike/sdk"
+
+class MySessionStore implements SessionStore {
+  async loadSession(sessionId) { return db.sessions.get(sessionId) }
+  async saveSession(session) { await db.sessions.put(session.sessionId, session) }
+}
+
+const agent = new Agent(provider, {
+  maxTokens: 4096,
+  sessionStore: new MySessionStore(),
+})
+```
+
 ---
 
 ## Governance
@@ -282,6 +309,8 @@ console.log(out.passed, out.feedback)
 | `text_delta` | `delta` |
 | `thinking_delta` | `delta` |
 | `tool_call` | `id`, `name`, `arguments` |
+| `tool_delta` | `callId`, `delta?`, `chunk?` |
+| `tool_suspend` | `callId`, `suspensionId`, `payload?` |
 | `tool_result` | `callId`, `content`, `isError` |
 | `permission_request` | `toolName`, `reason` |
 | `done` | `iterations`, `totalTokens`, `status` |

package/dist/agent.d.ts

@@ -1,6 +1,6 @@
-import type { LLMProvider, StreamEvent } from "./types.js";
+import type { LLMProvider, StreamEvent, ToolSuspendEvent } from "./types.js";
 import type { RegisteredTool } from "./tools/index.js";
-import type { DreamStore, DreamResult } from "./memory/protocols.js";
+import type { DreamStore, DreamResult, SessionStore } from "./memory/protocols.js";
 import type { KnowledgeSource } from "./knowledge/source.js";
 import type { SignalSource } from "./signals/types.js";
 export interface AgentOptions {
@@ -13,12 +13,6 @@ export interface AgentOptions {
      * Passed to the kernel's `system` partition before the first LLM call.
      */
     systemPrompt?: string;
-    /**
-     * Long-term memory snippets pre-seeded into the context before the first LLM call.
-     * Each string is pushed to the kernel's `memory` partition (highest-priority context
-     * after system). Use to inject memories retrieved from a DreamStore before a run.
-     */
-    initialMemory?: string[];
     /**
      * Directory containing skill `.md` files. The kernel auto-injects a `skill`
      * meta-tool so the model can load any skill by name on demand.
@@ -28,6 +22,8 @@ export interface AgentOptions {
     signalSource?: SignalSource;
     /** Backing store for the idle dreaming pipeline. Required to call `Agent.dream()`. */
     dreamStore?: DreamStore;
+    /** Optional durable transcript store for same-session conversational continuity. */
+    sessionStore?: SessionStore;
     /**
      * Stable identifier for this agent. Required to enable in-session memory retrieval
      * when `dreamStore` is configured.
@@ -38,6 +34,7 @@ export interface AgentOptions {
      * `evaluate(toolName: string, argsJson: string): { kind: string; reason?: string; retryAfterMs?: number }`.
      * When provided, every tool call is evaluated through the full pipeline.
      */
+    onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
     governance?: {
         setTime?(nowMs: bigint): void;
         evaluate(toolName: string, argsJson: string): {
@@ -56,6 +53,7 @@ export declare class Agent {
     private knowledgeSource?;
     private signalSource?;
     private dreamStore?;
+    private readonly inMemorySessions;
     private interrupted;
     private pendingInterrupt;
     private _turn;
@@ -72,8 +70,13 @@ export declare class Agent {
      * Collect the full text response and return it.
      * For richer control (streaming, tool events, token counts) use `runStreaming`.
      */
-    run(goal: string, criteria?: string[], extensions?: Record<string, unknown>): Promise<string>;
-    runStreaming(goal: string, criteria?: string[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    run(goal: string, criteria?: string[], extensions?: Record<string, unknown>, sessionId?: string): Promise<string>;
+    runStreaming(goal: string, criteria?: string[], extensions?: Record<string, unknown>, sessionId?: string): AsyncIterable<StreamEvent>;
+    private runRegularTool;
+    private loadSession;
+    private saveSession;
+    private toMessage;
+    private kernelMsgToSessionMsg;
     /**
      * Trigger the idle dreaming cycle for this agent.
      * Requires `dreamStore` and `agentId` to be configured.

package/dist/agent.js

@@ -1,4 +1,4 @@
-import { executeTools } from "./tools/index.js";
+import { isAsyncIterable, normalizeToolChunk, toolChunkText, validateToolArguments } from "./tools/index.js";
 import { readSkillFile, scanSkillDir } from "./skills/loader.js";
 import { getKernel } from "./kernel.js";
 export class Agent {
@@ -10,6 +10,7 @@ export class Agent {
     knowledgeSource;
     signalSource;
     dreamStore;
+    inMemorySessions = new Map();
     interrupted = false;
     pendingInterrupt = false;
     // Live telemetry — updated each runStreaming call
@@ -44,15 +45,15 @@ export class Agent {
      * Collect the full text response and return it.
      * For richer control (streaming, tool events, token counts) use `runStreaming`.
      */
-    async run(goal, criteria, extensions) {
+    async run(goal, criteria, extensions, sessionId) {
         let content = "";
-        for await (const evt of this.runStreaming(goal, criteria, extensions)) {
+        for await (const evt of this.runStreaming(goal, criteria, extensions, sessionId)) {
             if (evt.type === "text_delta")
                 content += evt.delta;
         }
         return content;
     }
-    async *runStreaming(goal, criteria, extensions) {
+    async *runStreaming(goal, criteria, extensions, sessionId) {
         this.interrupted = false;
         this.pendingInterrupt = false;
         this._turn = 0;
@@ -76,8 +77,10 @@ export class Agent {
             const tokens = Math.max(1, Math.ceil(this.options.systemPrompt.length / 4));
             sm.addSystemMessage(this.options.systemPrompt, tokens);
         }
-        for (const mem of this.options.initialMemory ?? []) {
-            sm.addMemoryMessage(mem, Math.max(1, Math.ceil(mem.length / 4)));
+        const previousSession = sessionId ? await this.loadSession(sessionId) : undefined;
+        const previousMsgs = previousSession?.messages ?? [];
+        if (previousMsgs.length > 0) {
+            sm.preloadHistory(previousMsgs.map(m => this.toMessage(m)));
         }
         if (this.skillDir) {
             const skillMetas = await scanSkillDir(this.skillDir);
@@ -97,7 +100,6 @@ export class Agent {
         }
         let action = sm.start({ goal, criteria: criteria ?? [] });
         const sessionStart = Date.now();
-        const sessionMsgs = [{ role: "user", content: goal }];
         while (!sm.isTerminal()) {
             // Update telemetry
             this._turn = sm.turn;
@@ -153,11 +155,11 @@ export class Agent {
             if (action.kind === "call_llm") {
                 const finalToolCalls = [];
                 let finalText = "";
-                const messages = (action.messages ?? []);
+                const context = action.context;
                 const tools = (action.tools ?? []);
                 let turnTokens = 0;
                 try {
-                    for await (const evt of this.provider.stream(messages, tools, Object.keys(ext).length ? ext : undefined, providerState)) {
+                    for await (const evt of this.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState)) {
                         if (evt.type === "usage") {
                             turnTokens = evt.totalTokens;
                             continue;
@@ -177,7 +179,6 @@ export class Agent {
                     break;
                 }
                 action = sm.feedLlmResponse({ role: "assistant", content: finalText, toolCalls: finalToolCalls, tokenCount: turnTokens || undefined });
-                sessionMsgs.push({ role: "assistant", content: finalText, toolCalls: finalToolCalls });
             }
             else if (action.kind === "execute_tools") {
                 const allCalls = action.calls ?? [];
@@ -244,7 +245,22 @@ export class Agent {
                     : knowledgeCalls.map((c) => ({ callId: c.id, name: c.name, output: "Knowledge source not configured.", isError: true }));
                 for (const r of [...skillResults, ...memoryResults, ...knowledgeResults])
                     yield { type: "tool_result", callId: r.callId, name: r.name, content: r.output, isError: r.isError };
-                const results = await executeTools(regularCalls, this.tools);
+                const results = [];
+                const active = regularCalls.map(call => {
+                    const iterator = this.runRegularTool(call);
+                    return { iterator, pending: iterator.next() };
+                });
+                while (active.length) {
+                    const next = await Promise.race(active.map((task, index) => task.pending.then(result => ({ index, result }))));
+                    const task = active[next.index];
+                    if (next.result.done) {
+                        results.push(next.result.value);
+                        active.splice(next.index, 1);
+                        continue;
+                    }
+                    yield next.result.value;
+                    task.pending = task.iterator.next();
+                }
                 for (const r of results) {
                     const name = regularCalls.find((c) => c.id === r.callId)?.name ?? "";
                     yield { type: "tool_result", callId: r.callId, name, content: r.output, isError: r.isError };
@@ -266,12 +282,13 @@ export class Agent {
         this._pressure = sm.pressure();
         const status = result?.termination ?? "error";
         const iterations = result ? Math.max(1, result.turnsUsed) : 0;
-        if (this.options.dreamStore && this.options.agentId && sessionMsgs.length > 1) {
+        const newMsgs = sm.drainNewMessages().map(m => this.kernelMsgToSessionMsg(m));
+        if (this.options.dreamStore && this.options.agentId && newMsgs.length > 0) {
             try {
                 await this.options.dreamStore.saveSession({
                     sessionId: crypto.randomUUID(),
                     agentId: this.options.agentId,
-                    messages: sessionMsgs,
+                    messages: newMsgs,
                     metadata: null,
                     createdAtMs: sessionStart,
                     updatedAtMs: Date.now(),
@@ -279,6 +296,17 @@ export class Agent {
             }
             catch { /* session save failure must not surface to caller */ }
         }
+        if (sessionId) {
+            const now = Date.now();
+            await this.saveSession({
+                sessionId,
+                agentId: this.options.agentId ?? "default",
+                messages: [...previousMsgs, ...newMsgs],
+                metadata: previousSession?.metadata ?? null,
+                createdAtMs: previousSession?.createdAtMs ?? sessionStart,
+                updatedAtMs: now,
+            });
+        }
         yield {
             type: "done",
             iterations,
@@ -286,6 +314,90 @@ export class Agent {
             status,
         };
     }
+    async *runRegularTool(call) {
+        const registeredTool = this.tools.get(call.name);
+        if (!registeredTool)
+            return { callId: call.id, output: `unknown tool: ${call.name}`, isError: true };
+        try {
+            const args = JSON.parse(call.arguments || "{}");
+            const validationError = validateToolArguments(registeredTool.schema.parameters, args);
+            if (validationError)
+                return { callId: call.id, output: `invalid arguments: ${validationError}`, isError: true };
+            const output = await registeredTool.execute(args);
+            if (isAsyncIterable(output)) {
+                let combined = "";
+                const iterator = output[Symbol.asyncIterator]();
+                let resumeValue;
+                while (true) {
+                    const next = await iterator.next(resumeValue);
+                    resumeValue = undefined;
+                    if (next.done)
+                        break;
+                    const rawChunk = next.value;
+                    const chunk = normalizeToolChunk(rawChunk);
+                    if (chunk.type === "suspend") {
+                        const event = {
+                            type: "tool_suspend",
+                            callId: call.id,
+                            name: call.name,
+                            suspensionId: chunk.suspensionId,
+                            ...(chunk.payload ? { payload: chunk.payload } : {}),
+                        };
+                        yield event;
+                        if (!this.options.onToolSuspend) {
+                            return { callId: call.id, output: `tool suspended without resume handler: ${chunk.suspensionId}`, isError: true };
+                        }
+                        resumeValue = await this.options.onToolSuspend(event);
+                        continue;
+                    }
+                    const delta = toolChunkText(rawChunk);
+                    combined += delta;
+                    yield {
+                        type: "tool_delta",
+                        callId: call.id,
+                        name: call.name,
+                        ...(delta ? { delta } : {}),
+                        ...(typeof rawChunk === "string" ? {} : { chunk }),
+                    };
+                }
+                return { callId: call.id, output: combined, isError: false };
+            }
+            return { callId: call.id, output, isError: false };
+        }
+        catch (err) {
+            return { callId: call.id, output: String(err), isError: true };
+        }
+    }
+    async loadSession(sessionId) {
+        return this.options.sessionStore
+            ? this.options.sessionStore.loadSession(sessionId)
+            : this.inMemorySessions.get(sessionId);
+    }
+    async saveSession(data) {
+        if (this.options.sessionStore) {
+            await this.options.sessionStore.saveSession(data);
+            return;
+        }
+        this.inMemorySessions.set(data.sessionId, data);
+    }
+    toMessage(message) {
+        return {
+            role: message.role,
+            content: message.content,
+            contentParts: message.contentParts,
+            tokenCount: message.tokenCount,
+            toolCalls: message.toolCalls ?? [],
+        };
+    }
+    kernelMsgToSessionMsg(msg) {
+        return {
+            role: msg.role,
+            content: msg.content,
+            contentParts: msg.contentParts,
+            tokenCount: msg.tokenCount,
+            toolCalls: msg.toolCalls?.length ? msg.toolCalls : undefined,
+        };
+    }
     /**
      * Trigger the idle dreaming cycle for this agent.
      * Requires `dreamStore` and `agentId` to be configured.
@@ -332,7 +444,16 @@ export class Agent {
         }
         let synthesisText = "";
         const providerState = this.provider.createRunState?.();
-        for await (const evt of this.provider.stream((action1.messages ?? []), [], undefined, providerState)) {
+        // IdlePipeline produces raw messages for synthesis; wrap them in a RenderedContext.
+        // The first system message (if any) becomes systemText; the rest are turns.
+        const synthMsgs = (action1.messages ?? []);
+        const synthSystemMsgs = synthMsgs.filter(m => m.role === "system");
+        const synthTurns = synthMsgs.filter(m => m.role !== "system");
+        const synthContext = {
+            systemText: synthSystemMsgs.map(m => m.content).join("\n\n"),
+            turns: synthTurns,
+        };
+        for await (const evt of this.provider.stream(synthContext, [], undefined, providerState)) {
             if (evt.type === "text_delta")
                 synthesisText += evt.delta;
         }

package/dist/harness/harness.d.ts

@@ -38,6 +38,16 @@ export type HarnessEvent = {
     type: "tool_call";
     id: string;
     name: string;
+} | {
+    type: "tool_delta";
+    callId: string;
+    delta?: string;
+    chunk?: Record<string, unknown>;
+} | {
+    type: "tool_suspend";
+    callId: string;
+    suspensionId: string;
+    payload?: Record<string, unknown>;
 } | {
     type: "tool_result";
     callId: string;

package/dist/harness/harness.js

@@ -74,6 +74,14 @@ export class HarnessLoop {
                     const tc = evt;
                     yield { type: "tool_call", id: tc.id, name: tc.name };
                 }
+                else if (evt.type === "tool_delta") {
+                    const td = evt;
+                    yield { type: "tool_delta", callId: td.callId, ...(td.delta ? { delta: td.delta } : {}), ...(td.chunk ? { chunk: td.chunk } : {}) };
+                }
+                else if (evt.type === "tool_suspend") {
+                    const ts = evt;
+                    yield { type: "tool_suspend", callId: ts.callId, suspensionId: ts.suspensionId, ...(ts.payload ? { payload: ts.payload } : {}) };
+                }
                 else if (evt.type === "tool_result") {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const tr = evt;
@@ -92,7 +100,13 @@ export class HarnessLoop {
             if (evalAction.kind !== "evaluate")
                 break;
             let evalText = "";
-            for await (const evt of this.evalProvider.stream(evalAction.messages ?? [], [], undefined)) {
+            // Wrap harness eval messages in a RenderedContext (system messages → systemText, rest → turns).
+            const evalMsgs = evalAction.messages ?? [];
+            const evalContext = {
+                systemText: evalMsgs.filter((m) => m.role === "system").map((m) => m.content).join("\n\n"),
+                turns: evalMsgs.filter((m) => m.role !== "system"),
+            };
+            for await (const evt of this.evalProvider.stream(evalContext, [], undefined)) {
                 if (evt.type === "text_delta")
                     evalText += evt.delta;
             }

package/dist/index.d.ts

@@ -15,12 +15,12 @@ export type { OpenAIResponsesRunState } from "./providers/openai-responses.js";
 export { endpointProfiles, modelProfiles, getModelProfile } from "./providers/profiles.js";
 export { createProvider } from "./providers/catalog.js";
 export type { CreateProviderOptions, EndpointProfileId } from "./providers/catalog.js";
-export { tool, executeTools, readFile } from "./tools/index.js";
+export { tool, streamingTool, executeTools, readFile, validateToolArguments } from "./tools/index.js";
 export type { RegisteredTool } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
 export type { SkillMetadata } from "./skills/loader.js";
 export { WorkingMemory } from "./memory/working.js";
-export type { DreamStore, DreamResult, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, } from "./memory/protocols.js";
+export type { DreamStore, DreamResult, SessionStore, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, } from "./memory/protocols.js";
 export type { KnowledgeSource } from "./knowledge/source.js";
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
 export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions, QualityGate } from "./harness/harness.js";
@@ -31,7 +31,7 @@ export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export type { PermissionDecision, Permission } from "./safety/permissions.js";
 export { Governance } from "./governance.js";
 export type { GovernanceVerdict } from "./governance.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, } 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, 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/index.js

@@ -12,7 +12,7 @@ export { OpenAIChatAdapter } from "./providers/openai-chat.js";
 export { OpenAIResponsesAdapter, OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export { endpointProfiles, modelProfiles, getModelProfile } from "./providers/profiles.js";
 export { createProvider } from "./providers/catalog.js";
-export { tool, executeTools, readFile } from "./tools/index.js";
+export { tool, streamingTool, executeTools, readFile, validateToolArguments } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
 export { WorkingMemory } from "./memory/working.js";
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";

package/dist/kernel.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ToolCall, ToolResult, ToolSchema } from "./types.js";
+import type { Message, RenderedContext, ToolCall, ToolResult, ToolSchema } from "./types.js";
 import type { SkillMetadata } from "./skills/loader.js";
 export interface GovernanceVerdict {
     kind: "allow" | "deny" | "rate_limited" | "ask_user";
@@ -28,7 +28,7 @@ export interface RuntimeSignal {
 }
 export interface LoopAction {
     kind: "call_llm" | "execute_tools" | "done";
-    messages?: Message[];
+    context?: RenderedContext;
     tools?: ToolSchema[];
     calls?: ToolCall[];
     result?: {
@@ -48,6 +48,7 @@ interface LoopStateMachineInstance {
     setKnowledgeEnabled(enabled: boolean): void;
     addSystemMessage(content: string, tokens: number): void;
     addMemoryMessage(content: string, tokens: number): void;
+    addHistoryMessage(message: Message, tokens: number): void;
     setTools(tools: ToolSchema[]): void;
     start(task: {
         goal: string;
@@ -57,6 +58,8 @@ interface LoopStateMachineInstance {
     feedToolResults(results: ToolResult[]): LoopAction;
     feedTimeout(): LoopAction;
     isTerminal(): boolean;
+    preloadHistory(messages: Message[]): void;
+    drainNewMessages(): Message[];
     readonly turn: number;
     pressure(): number;
     takeObservations(): LoopObservation[];

package/dist/memory/protocols.d.ts

@@ -1,7 +1,9 @@
-import type { Message } from "../types.js";
+import type { Message, ContentPart } from "../types.js";
 export interface SessionMessage {
     role: Message["role"];
     content: string;
+    /** Structured multimodal parts. Preserved for round-trip fidelity (e.g. tool result messages). */
+    contentParts?: ContentPart[];
     tokenCount?: number;
     toolCalls?: Array<{
         id: string;
@@ -43,6 +45,11 @@ export interface DreamStore {
     /** Persist a completed session for future consolidation via `Agent.dream()`. */
     saveSession(data: SessionData): Promise<void>;
 }
+/** Durable transcript storage for same-session conversational continuity. */
+export interface SessionStore {
+    loadSession(sessionId: string): Promise<SessionData | undefined>;
+    saveSession(data: SessionData): Promise<void>;
+}
 export interface DreamResult {
     sessionsProcessed: number;
     insightsExtracted: number;

package/dist/providers/anthropic.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";
 interface AnthropicProviderOptions {
     baseURL?: string;
     authMode?: "api-key" | "bearer";
@@ -15,8 +15,12 @@ export declare class AnthropicProvider implements LLMProvider {
         baseDelay: number;
     }, options?: AnthropicProviderOptions);
     private buildTools;
-    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 requestExtensions;
+    private hasBetas;
+    private createMessage;
+    private streamMessage;
     private buildMessages;
     private rememberNativeBlocks;
     private assistantReplayKey;

package/dist/providers/anthropic.js

@@ -1,6 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { withServerRuntimeGuard } from "../runtime/server.js";
-import { CircuitBreaker, normalizeToolCall, splitAnthropicSystem, toAnthropicMessages } from "./base.js";
+import { CircuitBreaker, normalizeToolCall, omitExtensionKeys, toAnthropicMessages } from "./base.js";
 export class AnthropicProvider {
     model;
     client;
@@ -25,21 +25,23 @@ export class AnthropicProvider {
             input_schema: JSON.parse(t.parameters),
         }));
     }
-    async complete(messages, tools) {
+    async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const system = splitAnthropicSystem(messages);
-        const msgs = this.buildMessages(messages);
+        const system = context.systemText || undefined;
+        const msgs = this.buildMessages(context);
+        const requestExtensions = this.requestExtensions(extensions);
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
-                const resp = await this.client.messages.create({
+                const resp = await this.createMessage({
+                    ...requestExtensions,
                     model: this.model,
-                    max_tokens: 8096,
+                    max_tokens: typeof extensions?.max_tokens === "number" ? extensions.max_tokens : 8096,
                     ...(system ? { system } : {}),
                     messages: msgs,
                     ...(tools.length ? { tools: this.buildTools(tools) } : {}),
-                });
+                }, extensions);
                 this.circuit.recordSuccess();
                 let content = "";
                 const toolCalls = [];
@@ -65,20 +67,22 @@ export class AnthropicProvider {
         }
         throw lastErr;
     }
-    async *stream(messages, tools, extensions) {
-        const system = splitAnthropicSystem(messages);
-        const msgs = this.buildMessages(messages);
+    async *stream(context, tools, extensions) {
+        const system = context.systemText || undefined;
+        const msgs = this.buildMessages(context);
+        const requestExtensions = this.requestExtensions(extensions);
         const toolBlocks = {};
         const nativeBlocks = {};
         let finalText = "";
         const finalToolCalls = [];
-        const stream = this.client.messages.stream({
+        const stream = this.streamMessage({
+            ...requestExtensions,
             model: this.model,
-            max_tokens: 8096,
+            max_tokens: typeof extensions?.max_tokens === "number" ? extensions.max_tokens : 8096,
             ...(system ? { system } : {}),
             messages: msgs,
             ...(tools.length ? { tools: this.buildTools(tools) } : {}),
-        });
+        }, extensions);
         for await (const evt of stream) {
             if (evt.type === "content_block_start") {
                 nativeBlocks[evt.index] = { ...evt.content_block };
@@ -121,8 +125,25 @@ export class AnthropicProvider {
         }
         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)));
+    requestExtensions(extensions) {
+        return omitExtensionKeys(extensions, ["model", "messages", "system", "tools", "max_tokens", "stream"]);
+    }
+    hasBetas(extensions) {
+        const betas = extensions?.betas;
+        return Array.isArray(betas) && betas.length > 0;
+    }
+    createMessage(params, extensions) {
+        return this.hasBetas(extensions)
+            ? this.client.beta.messages.create(params)
+            : this.client.messages.create(params);
+    }
+    streamMessage(params, extensions) {
+        return (this.hasBetas(extensions)
+            ? this.client.beta.messages.stream(params)
+            : this.client.messages.stream(params));
+    }
+    buildMessages(context) {
+        return toAnthropicMessages(context.turns, message => this.nativeAssistantBlocks.get(this.assistantReplayKey(message)));
     }
     rememberNativeBlocks(message, blocks) {
         if (!message.toolCalls?.length)

package/dist/providers/base.d.ts

@@ -1,3 +1,4 @@
+import type { Message, RenderedContext } from "../types.js";
 export declare class CircuitBreaker {
     private readonly openAfter;
     private readonly resetAfter;
@@ -8,14 +9,17 @@ export declare class CircuitBreaker {
     recordSuccess(): void;
     recordFailure(): void;
 }
+export declare function omitExtensionKeys(extensions: Record<string, unknown> | undefined, keys: readonly string[]): Record<string, unknown>;
 export declare function normalizeToolCall(id: string, name: string, args: unknown): {
     id: string;
     name: string;
     arguments: string;
 } | null;
-import type { Message } from "../types.js";
 export declare function toAnthropicContent(msg: Message): string | Array<Record<string, unknown>>;
+/** Convert RenderedContext.turns to Anthropic messages array.
+ *  `turns` contains only user / assistant / tool roles — no system filtering needed. */
+export declare function toAnthropicMessages(turns: Message[], nativeReplay?: (message: Message) => Array<Record<string, unknown>> | undefined): 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>>;
+/** 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>>;