@deepstrike/sdk 0.1.11 → 0.1.12

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
@@ -196,6 +205,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

package/dist/agent.d.ts

@@ -1,6 +1,6 @@
 import type { LLMProvider, StreamEvent } 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.
@@ -56,6 +52,7 @@ export declare class Agent {
     private knowledgeSource?;
     private signalSource?;
     private dreamStore?;
+    private readonly inMemorySessions;
     private interrupted;
     private pendingInterrupt;
     private _turn;
@@ -72,8 +69,12 @@ 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 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

@@ -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 ?? [];
@@ -266,12 +267,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 +281,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 +299,36 @@ export class Agent {
             status,
         };
     }
+    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 +375,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.js

@@ -92,7 +92,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

@@ -20,7 +20,7 @@ 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, 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/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,8 @@ 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[]): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
     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, toAnthropicMessages } from "./base.js";
 export class AnthropicProvider {
     model;
     client;
@@ -25,11 +25,11 @@ export class AnthropicProvider {
             input_schema: JSON.parse(t.parameters),
         }));
     }
-    async complete(messages, tools) {
+    async complete(context, tools) {
         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);
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
@@ -65,9 +65,9 @@ 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 toolBlocks = {};
         const nativeBlocks = {};
         let finalText = "";
@@ -121,8 +121,8 @@ 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)));
+    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;
@@ -13,9 +14,11 @@ export declare function normalizeToolCall(id: string, name: string, args: unknow
     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>>;

package/dist/providers/base.js

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

package/dist/providers/deepseek.js

@@ -5,11 +5,11 @@ 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 *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 = {};
         let reasoningContent = "";
         let finalText = "";

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,6 @@ 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[]): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }

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,11 +61,11 @@ export class GeminiProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
-    async complete(messages, tools) {
+    async complete(context, tools) {
         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++) {
@@ -111,9 +106,9 @@ 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({
             model: this.model,

package/dist/providers/ollama.d.ts

@@ -1,9 +1,9 @@
-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>;
+    complete(context: RenderedContext, tools: ToolSchema[]): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }

package/dist/providers/ollama.js

@@ -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,25 +18,26 @@ 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;
     }
-    async complete(messages, tools) {
+    async complete(context, tools) {
         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({ model: this.model, messages: this.toOllamaMessages(context), 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({ model: this.model, messages: this.toOllamaMessages(context), stream: true }),
         });
         if (!resp.ok)
             throw new Error(`Ollama error: ${resp.status}`);

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,7 @@ 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[]): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], _extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
     private asRunState;
 }

package/dist/providers/openai-responses.js

@@ -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,16 @@ export class OpenAIResponsesProvider {
     createRunState() {
         return { coveredMessageCount: 0 };
     }
-    async complete(messages, tools) {
+    async complete(context, tools) {
         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({
                     model: this.model,
-                    input: this.responses.buildInput(messages),
+                    input: this.responses.buildInput(context),
                     ...(instructions ? { instructions } : {}),
                     ...(tools.length ? { tools: this.responses.buildTools(tools) } : {}),
                 });
@@ -153,13 +147,13 @@ 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({
             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,7 +197,7 @@ 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 };
                 }

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,7 @@ 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[]): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }
 export { OpenAIChatProvider as OpenAIProvider };

package/dist/providers/openai.js

@@ -16,10 +16,10 @@ export class OpenAIChatProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
-    async complete(messages, tools) {
+    async complete(context, tools) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const msgs = this.chat.buildMessages(messages);
+        const msgs = this.chat.buildMessages(context);
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
@@ -42,8 +42,8 @@ export class OpenAIChatProvider {
         }
         throw lastErr;
     }
-    async *stream(messages, tools, extensions) {
-        const msgs = this.chat.buildMessages(messages);
+    async *stream(context, tools, extensions) {
+        const msgs = this.chat.buildMessages(context);
         const toolCallBufs = {};
         const stream = await this.client.chat.completions.create({
             model: this.model,

package/dist/providers/qwen.d.ts

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { LLMProvider, Message, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, Message, RenderedContext, StreamEvent, ToolSchema } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
 export declare class QwenProvider implements LLMProvider {
@@ -13,6 +13,6 @@ export declare class QwenProvider 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[]): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }

package/dist/providers/qwen.js

@@ -18,10 +18,10 @@ export class QwenProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
-    async complete(messages, tools) {
+    async complete(context, tools) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const msgs = this.chat.buildMessages(messages);
+        const msgs = this.chat.buildMessages(context);
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
@@ -44,10 +44,10 @@ export class QwenProvider {
         }
         throw lastErr;
     }
-    async *stream(messages, tools, extensions) {
+    async *stream(context, tools, extensions) {
         const enableThinking = Boolean(extensions?.enableThinking ?? extensions?.enable_thinking);
         const thinkingBudget = extensions?.thinkingBudget ?? extensions?.thinking_budget;
-        const msgs = this.chat.buildMessages(messages);
+        const msgs = this.chat.buildMessages(context);
         const toolCallBufs = {};
         const stream = await this.client.chat.completions.create({
             model: this.model,

package/dist/types.d.ts

@@ -117,8 +117,18 @@ export interface RetryConfig {
  * Responses `previous_response_id` without leaking those semantics into the kernel.
  */
 export type ProviderRunState = Record<string, unknown>;
+/** Structured render output produced by the kernel for each LLM call. */
+export interface RenderedContext {
+    /** Combined system text: system partition + dashboard (when non-empty).
+     *  Anthropic → `system` param · OpenAI → messages[0] system role ·
+     *  Gemini → `systemInstruction`. */
+    systemText: string;
+    /** Strictly alternating user / assistant / tool turns.
+     *  Working-partition signals are already folded into the first user turn. */
+    turns: Message[];
+}
 export interface LLMProvider {
     createRunState?(): ProviderRunState;
-    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[]): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
-    "@deepstrike/core": "0.1.11",
+    "@deepstrike/core": "0.1.12",
     "@google/generative-ai": "^0.24.1",
     "openai": "^4.77.0"
   },