@deepstrike/sdk 0.1.1 → 0.1.3

package/dist/agent.js

@@ -2,13 +2,15 @@ import { executeTools } from "./tools/index.js";
 import { readSkillFile, scanSkillDir } from "./skills/loader.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function loadKernel() {
-    return import("@deepstrike/core");
+    const mod = await import("@deepstrike/core");
+    // CJS modules imported via ESM dynamic import expose exports under `.default`
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return mod.default ?? mod;
 }
 export class Agent {
     provider;
     options;
     tools = new Map();
-    blockedTools = new Set();
     extensions;
     skillDir;
     knowledgeSource;
@@ -16,6 +18,9 @@ export class Agent {
     dreamStore;
     interrupted = false;
     pendingInterrupt = false;
+    // Live telemetry — updated each runStreaming call
+    _turn = 0;
+    _pressure = 0;
     constructor(provider, options) {
         this.provider = provider;
         this.options = options;
@@ -25,6 +30,10 @@ export class Agent {
         this.signalSource = options.signalSource;
         this.dreamStore = options.dreamStore;
     }
+    /** Current turn index within the active run (0 before a run starts). */
+    get turn() { return this._turn; }
+    /** Context pressure ratio [0–1] from the kernel. Values > 0.8 trigger compression. */
+    get pressure() { return this._pressure; }
     interrupt() {
         this.interrupted = true;
     }
@@ -37,21 +46,23 @@ export class Agent {
         this.tools.delete(name);
         return this;
     }
-    blockTool(name) {
-        this.blockedTools.add(name);
-        return this;
-    }
+    /**
+     * Collect the full text response and return it.
+     * For richer control (streaming, tool events, token counts) use `runStreaming`.
+     */
     async run(goal, criteria, extensions) {
-        let result;
+        let content = "";
         for await (const evt of this.runStreaming(goal, criteria, extensions)) {
-            if (evt.type === "done")
-                result = evt;
+            if (evt.type === "text_delta")
+                content += evt.delta;
         }
-        return result ? `done in ${result.iterations} turns (${result.status})` : "done";
+        return content;
     }
     async *runStreaming(goal, criteria, extensions) {
         this.interrupted = false;
         this.pendingInterrupt = false;
+        this._turn = 0;
+        this._pressure = 0;
         const kernel = await loadKernel();
         const ext = { ...this.extensions, ...(extensions ?? {}) };
         const sm = new kernel.LoopStateMachine({
@@ -59,15 +70,13 @@ export class Agent {
             maxTurns: this.options.maxTurns ?? 25,
             timeoutMs: this.options.timeoutMs,
         });
-        // Create a per-run SignalRouter so dedup state doesn't leak across runs.
+        // Per-run SignalRouter — dedup state never leaks between runs.
         const router = new kernel.SignalRouter(256);
         const toolSchemas = Array.from(this.tools.values()).map(t => t.schema);
         sm.setTools(toolSchemas);
-        // Scan skill directory and register metadata with the kernel.
-        // The kernel will auto-inject the `skill` meta-tool into every CallLLM action.
         if (this.skillDir) {
             const skillMetas = await scanSkillDir(this.skillDir);
-            sm.setAvailableSkills(skillMetas.map(m => ({
+            sm.setAvailableSkills(skillMetas.map((m) => ({
                 name: m.name,
                 description: m.description,
                 whenToUse: m.whenToUse,
@@ -75,17 +84,18 @@ export class Agent {
                 estimatedTokens: m.estimatedTokens ?? 0,
             })));
         }
-        // Enable the memory meta-tool when both dreamStore and agentId are provided.
         if (this.dreamStore && this.options.agentId) {
             sm.setMemoryEnabled(true);
         }
-        // Enable the knowledge meta-tool when a KnowledgeSource is configured.
         if (this.knowledgeSource) {
             sm.setKnowledgeEnabled(true);
         }
         let action = sm.start({ goal, criteria: criteria ?? [] });
-        let finalText = "";
         while (!sm.isTerminal()) {
+            // Update telemetry
+            this._turn = sm.turn;
+            this._pressure = sm.pressure();
+            // Hard interrupt
             if (this.interrupted) {
                 action = sm.feedTimeout();
                 break;
@@ -95,18 +105,22 @@ export class Agent {
                 action = sm.feedTimeout();
                 break;
             }
+            // Drain context-compression observations
+            sm.takeObservations();
             // Poll signal source and route through kernel SignalRouter
             if (this.signalSource) {
                 const sig = await this.signalSource.nextSignal();
                 if (sig) {
+                    const sigAny = sig;
                     const kernelSig = {
                         id: crypto.randomUUID(),
-                        source: sig.source ?? "custom",
-                        signalType: sig.signalType ?? "event",
-                        urgency: sig.urgency ?? (sig.kind === "interrupt" ? "critical" : "normal"),
+                        source: sigAny.source ?? "custom",
+                        signalType: sigAny.signalType ?? "event",
+                        urgency: sigAny.urgency
+                            ?? (sig.kind === "interrupt" ? "critical" : "normal"),
                         summary: String(sig.payload?.goal ?? sig.kind),
                         payload: JSON.stringify(sig.payload ?? {}),
-                        dedupeKey: sig.dedupeKey ?? null,
+                        dedupeKey: sigAny.dedupeKey ?? null,
                         timestampMs: Date.now(),
                     };
                     const disposition = router.ingest(kernelSig, action.kind === "execute_tools");
@@ -114,20 +128,35 @@ export class Agent {
                         action = sm.feedTimeout();
                         break;
                     }
-                    if (disposition === "interrupt") {
+                    if (disposition === "interrupt")
                         this.pendingInterrupt = true;
-                    }
-                    // "queue" → buffered; "observe" / "ignore" / "dropped" → no action
                 }
             }
-            sm.takeObservations();
+            // Drain previously queued signals — apply any high-urgency ones
+            let queued = router.next();
+            while (queued) {
+                if (queued.urgency === "critical") {
+                    action = sm.feedTimeout();
+                    break;
+                }
+                if (queued.urgency === "high")
+                    this.pendingInterrupt = true;
+                queued = router.next();
+            }
+            if (this.interrupted || (sm.isTerminal()))
+                break;
             if (action.kind === "call_llm") {
-                finalText = "";
                 const finalToolCalls = [];
+                let finalText = "";
                 const messages = (action.messages ?? []);
                 const tools = (action.tools ?? []);
+                let turnTokens = 0;
                 try {
                     for await (const evt of this.provider.stream(messages, tools, Object.keys(ext).length ? ext : undefined)) {
+                        if (evt.type === "usage") {
+                            turnTokens = evt.totalTokens;
+                            continue;
+                        }
                         yield evt;
                         if (evt.type === "text_delta")
                             finalText += evt.delta;
@@ -142,45 +171,46 @@ export class Agent {
                     action = sm.feedTimeout();
                     break;
                 }
-                action = sm.feedLlmResponse({ role: "assistant", content: finalText, toolCalls: finalToolCalls });
+                action = sm.feedLlmResponse({ role: "assistant", content: finalText, toolCalls: finalToolCalls, tokenCount: turnTokens || undefined });
             }
             else if (action.kind === "execute_tools") {
                 const allCalls = action.calls ?? [];
-                // Governance check: blocked tools + GovernancePipeline
+                // Governance evaluation
                 const permittedCalls = [];
+                const deniedResults = [];
                 for (const c of allCalls) {
-                    if (this.blockedTools.has(c.name)) {
-                        yield { type: "error", message: `tool blocked: ${c.name}` };
-                        continue;
-                    }
                     if (this.options.governance) {
                         const verdict = this.options.governance.evaluate(c.name, c.arguments);
                         if (verdict.kind === "deny") {
-                            yield { type: "error", message: `permission denied: ${c.name} — ${verdict.reason}` };
+                            const msg = `permission denied: ${c.name} — ${verdict.reason ?? ""}`;
+                            yield { type: "error", message: msg };
+                            deniedResults.push({ callId: c.id, name: c.name, output: msg, isError: true });
+                            continue;
+                        }
+                        if (verdict.kind === "rate_limited") {
+                            const msg = `rate limited: ${c.name} — retry after ${verdict.retryAfterMs ?? 0}ms`;
+                            yield { type: "error", message: msg };
+                            deniedResults.push({ callId: c.id, name: c.name, output: msg, isError: true });
                             continue;
                         }
                         if (verdict.kind === "ask_user") {
-                            yield { type: "permission_request", callId: c.id, toolName: c.name, arguments: c.arguments, reason: verdict.reason };
+                            yield { type: "permission_request", callId: c.id, toolName: c.name, arguments: c.arguments, reason: verdict.reason ?? "" };
+                            deniedResults.push({ callId: c.id, name: c.name, output: `awaiting user approval: ${c.name}`, isError: true });
                             continue;
                         }
                     }
                     permittedCalls.push(c);
                 }
-                const calls = permittedCalls;
-                // Intercept `skill` meta-tool calls: read file, return content as tool result.
-                const skillCalls = calls.filter((c) => c.name === "skill");
-                // Intercept `memory` meta-tool calls: search DreamStore, return entries as tool result.
-                const memoryCalls = calls.filter((c) => c.name === "memory");
-                // Intercept `knowledge` meta-tool calls: retrieve from KnowledgeSource.
-                const knowledgeCalls = calls.filter((c) => c.name === "knowledge");
-                const regularCalls = calls.filter((c) => c.name !== "skill" && c.name !== "memory" && c.name !== "knowledge");
+                const skillCalls = permittedCalls.filter((c) => c.name === "skill");
+                const memoryCalls = permittedCalls.filter((c) => c.name === "memory");
+                const knowledgeCalls = permittedCalls.filter((c) => c.name === "knowledge");
+                const regularCalls = permittedCalls.filter((c) => c.name !== "skill" && c.name !== "memory" && c.name !== "knowledge");
                 const skillResults = this.skillDir
                     ? await Promise.all(skillCalls.map(async (c) => {
                         const args = tryParseJson(c.arguments);
                         const name = String(args?.name ?? "");
                         const content = await readSkillFile(this.skillDir, name);
-                        const output = content ?? `Skill "${name}" not found.`;
-                        return { callId: c.id, name: c.name, output, isError: !content };
+                        return { callId: c.id, name: c.name, output: content ?? `Skill "${name}" not found.`, isError: !content };
                     }))
                     : skillCalls.map((c) => ({ callId: c.id, name: c.name, output: "No skill directory configured.", isError: true }));
                 const memoryResults = (this.dreamStore && this.options.agentId)
@@ -190,7 +220,7 @@ export class Agent {
                         const topK = typeof args?.top_k === "number" ? args.top_k : 5;
                         const entries = await this.dreamStore.search(this.options.agentId, query, topK);
                         const output = entries.length
-                            ? entries.map(e => `[score=${e.score.toFixed(3)}] ${e.text}`).join("\n---\n")
+                            ? entries.map((e) => `[score=${e.score.toFixed(3)}] ${e.text}`).join("\n---\n")
                             : "No relevant memories found.";
                         return { callId: c.id, name: c.name, output, isError: false };
                     }))
@@ -205,18 +235,18 @@ export class Agent {
                         return { callId: c.id, name: c.name, output, isError: false };
                     }))
                     : knowledgeCalls.map((c) => ({ callId: c.id, name: c.name, output: "Knowledge source not configured.", isError: true }));
-                // Yield all meta-tool results
                 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);
                 for (const r of results) {
-                    const name = regularCalls.find(c => c.id === r.callId)?.name ?? "";
+                    const name = regularCalls.find((c) => c.id === r.callId)?.name ?? "";
                     yield { type: "tool_result", callId: r.callId, name, content: r.output, isError: r.isError };
                 }
                 action = sm.feedToolResults([
-                    ...skillResults,
-                    ...memoryResults,
-                    ...knowledgeResults,
+                    ...deniedResults.map(r => ({ callId: r.callId, output: r.output, isError: r.isError })),
+                    ...skillResults.map(r => ({ callId: r.callId, output: r.output, isError: r.isError })),
+                    ...memoryResults.map(r => ({ callId: r.callId, output: r.output, isError: r.isError })),
+                    ...knowledgeResults.map(r => ({ callId: r.callId, output: r.output, isError: r.isError })),
                     ...results.map(r => ({ callId: r.callId, output: r.output, isError: r.isError })),
                 ]);
             }
@@ -225,20 +255,27 @@ export class Agent {
             }
         }
         const result = action.result;
+        this._turn = sm.turn;
+        this._pressure = sm.pressure();
+        const status = result?.termination === "completed" ? "success" : (result?.termination ?? "error");
+        // turnsUsed counts tool execution rounds; for single-turn text-only runs it's 0.
+        // Map to iterations: at least 1 if we got a result.
+        const iterations = result ? Math.max(1, result.turnsUsed) : 0;
         yield {
             type: "done",
-            iterations: result?.turnsUsed ?? 0,
-            totalTokens: Number(result?.totalTokensUsed ?? 0),
-            status: result?.termination ?? "error",
+            iterations,
+            totalTokens: result?.totalTokensUsed ? Number(result.totalTokensUsed) : 0,
+            status,
         };
     }
     /**
-     * Trigger an idle dreaming cycle for the given agent.
+     * Trigger the idle dreaming cycle for this agent.
+     * Requires `dreamStore` and `agentId` to be configured.
      *
-     * Phase 1 — kernel rule-based analysis + LLM prompt assembly (kernel, pure computation)
-     * Phase 2 — LLM synthesis call (SDK, I/O here)
-     * Phase 3 — kernel parses + curates results (kernel, pure computation)
-     * Phase 4 — commit delta to DreamStore (SDK, I/O here)
+     * Phase 1 — kernel rule-based analysis + LLM prompt assembly
+     * Phase 2 — LLM synthesis call (I/O)
+     * Phase 3 — kernel parses + curates results
+     * Phase 4 — commit delta to DreamStore (I/O)
      */
     async dream(agentId, nowMs = Date.now()) {
         if (!this.dreamStore)
@@ -256,9 +293,7 @@ export class Agent {
                 role: m.role,
                 content: m.content,
                 tokenCount: m.tokenCount,
-                toolCalls: (m.toolCalls ?? []).map(tc => ({
-                    id: tc.id, name: tc.name, arguments: tc.arguments,
-                })),
+                toolCalls: (m.toolCalls ?? []).map(tc => ({ id: tc.id, name: tc.name, arguments: tc.arguments })),
             })),
             metadata: JSON.stringify(s.metadata ?? null),
             createdAtMs: s.createdAtMs,
@@ -271,7 +306,7 @@ export class Agent {
         }));
         const pipeline = new kernel.IdlePipeline(agentId);
         const action1 = pipeline.feedTrigger(kernelSessions, kernelMemories, nowMs);
-        if (action1.kind === "noop") {
+        if (action1.kind === "noop" || action1.kind === "aborted") {
             return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
         }
         if (action1.kind !== "synthesize_insights") {

package/dist/harness/harness.d.ts

@@ -13,11 +13,22 @@ export interface HarnessOutcome {
     /** Feedback from the evaluator LLM — injected into the next attempt's goal. */
     feedback?: string;
 }
+export interface QualityGate {
+    evaluate(request: HarnessRequest, outcome: HarnessOutcome): Promise<boolean>;
+}
 export declare class SinglePassHarness {
     private agent;
     constructor(agent: Agent);
     run(request: HarnessRequest): Promise<HarnessOutcome>;
 }
+/** Retry loop driven by a pluggable QualityGate (not LLM-as-judge). */
+export declare class EvalLoopHarness {
+    private agent;
+    private gate;
+    private maxAttempts;
+    constructor(agent: Agent, gate: QualityGate, maxAttempts?: number);
+    run(request: HarnessRequest): Promise<HarnessOutcome>;
+}
 export interface HarnessLoopOptions {
     maxAttempts?: number;
     /** Directory to write distilled skills into. Requires the agent to have skillDir set. */

package/dist/harness/harness.js

@@ -2,7 +2,9 @@ import { writeFile } from "fs/promises";
 import path from "path";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function loadKernel() {
-    return import("@deepstrike/core");
+    const mod = await import("@deepstrike/core");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return mod.default ?? mod;
 }
 async function runOnce(agent, req) {
     let text = "";
@@ -30,6 +32,27 @@ export class SinglePassHarness {
         return { ...await runOnce(this.agent, request), passed: true };
     }
 }
+/** Retry loop driven by a pluggable QualityGate (not LLM-as-judge). */
+export class EvalLoopHarness {
+    agent;
+    gate;
+    maxAttempts;
+    constructor(agent, gate, maxAttempts = 3) {
+        this.agent = agent;
+        this.gate = gate;
+        this.maxAttempts = maxAttempts;
+    }
+    async run(request) {
+        let outcome = { result: "", passed: false, iterations: 0, totalTokens: 0, status: "error" };
+        for (let i = 0; i < this.maxAttempts; i++) {
+            outcome = await runOnce(this.agent, request);
+            if (await this.gate.evaluate(request, outcome)) {
+                return { ...outcome, passed: true };
+            }
+        }
+        return outcome;
+    }
+}
 /**
  * Eval loop with LLM-as-judge and feedback injection.
  *
@@ -55,13 +78,8 @@ export class HarnessLoop {
         let currentGoal = request.goal;
         for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
             outcome = await runOnce(this.agent, { ...request, goal: currentGoal });
-            // Phase 1: kernel builds eval prompt
-            const evalAction = pipeline.feedOutcome({
-                goal: request.goal,
-                criteria: request.criteria ?? [],
-                result: outcome.result,
-                attempt,
-            });
+            // Phase 1: kernel builds eval prompt (positional args per kernel API)
+            const evalAction = pipeline.feedOutcome(request.goal, request.criteria ?? [], outcome.result, attempt);
             if (evalAction.kind !== "evaluate")
                 break;
             // Phase 2: SDK calls evaluator LLM
@@ -71,14 +89,13 @@ export class HarnessLoop {
                     evalText += evt.delta;
             }
             // Phase 3: kernel parses verdict
-            const doneAction = pipeline.feedEvalResult({ content: evalText });
+            const doneAction = pipeline.feedEvalResult(evalText);
             if (doneAction.kind !== "done")
                 break;
-            const evalResult = doneAction.result;
-            outcome = { ...outcome, passed: evalResult.passed, feedback: evalResult.feedback };
-            if (evalResult.passed) {
-                if (evalResult.skillCandidate && this.skillDir) {
-                    const { name, description, whenToUse, content } = evalResult.skillCandidate;
+            outcome = { ...outcome, passed: doneAction.passed, feedback: doneAction.feedback };
+            if (doneAction.passed) {
+                if (doneAction.skill_candidate && this.skillDir) {
+                    const { name, description, whenToUse, content } = doneAction.skill_candidate;
                     const frontmatter = [
                         "---",
                         `name: ${name}`,
@@ -92,7 +109,7 @@ export class HarnessLoop {
                 return outcome;
             }
             // Inject feedback into next attempt's goal
-            currentGoal = `${request.goal}\n\n[Previous attempt ${attempt} failed: ${evalResult.feedback}]`;
+            currentGoal = `${request.goal}\n\n[Previous attempt ${attempt} failed: ${doneAction.feedback}]`;
             pipeline.reset();
         }
         return outcome;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { Agent } from "./agent.js";
 export type { AgentOptions } from "./agent.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
-export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider } from "./providers/openai.js";
+export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
 export { OllamaProvider } from "./providers/ollama.js";
 export { CircuitBreaker, normalizeToolCall } from "./providers/base.js";
 export { tool, executeTools, readFile } from "./tools/index.js";
@@ -11,11 +11,13 @@ 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 { KnowledgeSource } from "./knowledge/source.js";
-export { SinglePassHarness, HarnessLoop } from "./harness/harness.js";
-export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions } from "./harness/harness.js";
+export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
+export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions, QualityGate } from "./harness/harness.js";
 export { ScheduledPrompt } from "./signals/scheduled.js";
 export { SignalGateway } from "./signals/gateway.js";
 export type { RuntimeSignal, SignalSource } from "./signals/types.js";
 export { PermissionManager, PermissionMode } from "./safety/permissions.js";
-export type { PermissionDecision } from "./safety/permissions.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, } from "./types.js";
+export type { PermissionDecision, Permission } from "./safety/permissions.js";
+export declare const Governance: typeof import("@deepstrike/core").Governance;
+export type { GovernanceVerdictObj as GovernanceVerdict } from "@deepstrike/core";
+export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, } from "./types.js";

package/dist/index.js

@@ -1,12 +1,19 @@
 export { Agent } from "./agent.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
-export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider } from "./providers/openai.js";
+export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
 export { OllamaProvider } from "./providers/ollama.js";
 export { CircuitBreaker, normalizeToolCall } from "./providers/base.js";
 export { tool, executeTools, readFile } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
 export { WorkingMemory } from "./memory/working.js";
-export { SinglePassHarness, HarnessLoop } from "./harness/harness.js";
+export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
 export { ScheduledPrompt } from "./signals/scheduled.js";
 export { SignalGateway } from "./signals/gateway.js";
 export { PermissionManager, PermissionMode } from "./safety/permissions.js";
+// Kernel Governance — full pipeline (Permission → Veto → RateLimit → Constraint → Audit)
+// @deepstrike/core is a CJS native addon; static ESM named re-export doesn't work,
+// so we load it via createRequire and re-export with proper types preserved.
+import { createRequire } from "module";
+const _cjsRequire = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const Governance = _cjsRequire("@deepstrike/core").Governance;

package/dist/providers/anthropic.js

@@ -1,5 +1,5 @@
 import Anthropic from "@anthropic-ai/sdk";
-import { CircuitBreaker, normalizeToolCall } from "./base.js";
+import { CircuitBreaker, normalizeToolCall, toAnthropicContent } from "./base.js";
 export class AnthropicProvider {
     model;
     client;
@@ -24,7 +24,7 @@ export class AnthropicProvider {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
         const system = messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
-        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: m.content }));
+        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: toAnthropicContent(m) }));
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
@@ -60,7 +60,7 @@ export class AnthropicProvider {
     }
     async *stream(messages, tools, extensions) {
         const system = messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
-        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: m.content }));
+        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: toAnthropicContent(m) }));
         const toolBlocks = {};
         const stream = this.client.messages.stream({
             model: this.model,

package/dist/providers/base.d.ts

@@ -13,3 +13,6 @@ 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>>;
+export declare function toOpenAIContent(msg: Message): string | Array<Record<string, unknown>>;

package/dist/providers/base.js

@@ -44,3 +44,37 @@ export function normalizeToolCall(id, name, args) {
     }
     return { id: String(id ?? ""), name: n, arguments: JSON.stringify(parsed) };
 }
+export function toAnthropicContent(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") {
+            if (p.data) {
+                return { type: "image", source: { type: "base64", media_type: p.mediaType ?? "image/png", data: p.data } };
+            }
+            return { type: "image", source: { type: "url", url: p.url } };
+        }
+        if (p.type === "audio") {
+            return { type: "text", text: `[audio: ${p.mediaType}]` };
+        }
+        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" } };
+        }
+        return { type: "text", text: "" };
+    });
+}

package/dist/providers/ollama.js

@@ -7,7 +7,16 @@ export class OllamaProvider {
         this.baseUrl = baseUrl;
     }
     toOllamaMessages(messages) {
-        return messages.map(m => ({ role: m.role, content: m.content }));
+        return messages.map(m => {
+            const images = [];
+            if (m.contentParts?.length) {
+                for (const p of m.contentParts) {
+                    if (p.type === "image" && p.data)
+                        images.push(p.data);
+                }
+            }
+            return { role: m.role, content: m.content, ...(images.length ? { images } : {}) };
+        });
     }
     async complete(messages, tools) {
         const resp = await fetch(`${this.baseUrl}/api/chat`, {

package/dist/providers/openai.d.ts

@@ -27,6 +27,7 @@ export declare class QwenProvider extends OpenAIProvider {
         maxRetries: number;
         baseDelay: number;
     });
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }
 export declare class DeepSeekProvider extends OpenAIProvider {
     constructor(apiKey: string, model?: string, retry?: {
@@ -42,3 +43,9 @@ export declare class MiniMaxProvider extends OpenAIProvider {
     });
     stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }
+export declare class KimiProvider extends OpenAIProvider {
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    });
+}