@deepstrike/sdk 0.1.10 → 0.1.12

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.10",
+  "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.10",
+    "@deepstrike/core": "0.1.12",
     "@google/generative-ai": "^0.24.1",
     "openai": "^4.77.0"
   },