@deepstrike/sdk 0.1.1

package/dist/harness/harness.d.ts

@@ -0,0 +1,40 @@
+import type { Agent } from "../agent.js";
+export interface HarnessRequest {
+    goal: string;
+    criteria?: string[];
+    extensions?: Record<string, unknown>;
+}
+export interface HarnessOutcome {
+    result: string;
+    passed: boolean;
+    iterations: number;
+    totalTokens: number;
+    status: string;
+    /** Feedback from the evaluator LLM — injected into the next attempt's goal. */
+    feedback?: string;
+}
+export declare class SinglePassHarness {
+    private agent;
+    constructor(agent: Agent);
+    run(request: HarnessRequest): Promise<HarnessOutcome>;
+}
+export interface HarnessLoopOptions {
+    maxAttempts?: number;
+    /** Directory to write distilled skills into. Requires the agent to have skillDir set. */
+    skillDir?: string;
+}
+/**
+ * Eval loop with LLM-as-judge and feedback injection.
+ *
+ * Each failed attempt feeds the evaluator's feedback back into the next goal,
+ * so the agent knows *why* it failed. On success, if the evaluator proposes a
+ * skill candidate it is written to `skillDir` for future sessions to reuse.
+ */
+export declare class HarnessLoop {
+    private agent;
+    private evalProvider;
+    private maxAttempts;
+    private skillDir?;
+    constructor(agent: Agent, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
+    run(request: HarnessRequest): Promise<HarnessOutcome>;
+}

package/dist/harness/harness.js

@@ -0,0 +1,100 @@
+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");
+}
+async function runOnce(agent, req) {
+    let text = "";
+    let done;
+    for await (const evt of agent.runStreaming(req.goal, req.criteria, req.extensions)) {
+        if (evt.type === "text_delta")
+            text += evt.delta;
+        else if (evt.type === "done")
+            done = evt;
+    }
+    return {
+        result: text,
+        passed: false,
+        iterations: done?.iterations ?? 0,
+        totalTokens: done?.totalTokens ?? 0,
+        status: done?.status ?? "error",
+    };
+}
+export class SinglePassHarness {
+    agent;
+    constructor(agent) {
+        this.agent = agent;
+    }
+    async run(request) {
+        return { ...await runOnce(this.agent, request), passed: true };
+    }
+}
+/**
+ * Eval loop with LLM-as-judge and feedback injection.
+ *
+ * Each failed attempt feeds the evaluator's feedback back into the next goal,
+ * so the agent knows *why* it failed. On success, if the evaluator proposes a
+ * skill candidate it is written to `skillDir` for future sessions to reuse.
+ */
+export class HarnessLoop {
+    agent;
+    evalProvider;
+    maxAttempts;
+    skillDir;
+    constructor(agent, evalProvider, options = {}) {
+        this.agent = agent;
+        this.evalProvider = evalProvider;
+        this.maxAttempts = options.maxAttempts ?? 3;
+        this.skillDir = options.skillDir;
+    }
+    async run(request) {
+        const kernel = await loadKernel();
+        const pipeline = new kernel.EvalPipeline({ extractSkillOnPass: true });
+        let outcome = { result: "", passed: false, iterations: 0, totalTokens: 0, status: "error" };
+        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,
+            });
+            if (evalAction.kind !== "evaluate")
+                break;
+            // Phase 2: SDK calls evaluator LLM
+            let evalText = "";
+            for await (const evt of this.evalProvider.stream(evalAction.messages ?? [], [], undefined)) {
+                if (evt.type === "text_delta")
+                    evalText += evt.delta;
+            }
+            // Phase 3: kernel parses verdict
+            const doneAction = pipeline.feedEvalResult({ content: 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;
+                    const frontmatter = [
+                        "---",
+                        `name: ${name}`,
+                        `description: ${description}`,
+                        whenToUse ? `when_to_use: ${whenToUse}` : null,
+                        "---",
+                        "",
+                    ].filter(l => l !== null).join("\n");
+                    await writeFile(path.join(this.skillDir, `${name}.md`), frontmatter + content, "utf8");
+                }
+                return outcome;
+            }
+            // Inject feedback into next attempt's goal
+            currentGoal = `${request.goal}\n\n[Previous attempt ${attempt} failed: ${evalResult.feedback}]`;
+            pipeline.reset();
+        }
+        return outcome;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+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 { OllamaProvider } from "./providers/ollama.js";
+export { CircuitBreaker, normalizeToolCall } from "./providers/base.js";
+export { tool, executeTools, readFile } from "./tools/index.js";
+export type { RegisteredTool } from "./tools/index.js";
+export { scanSkillDir, readSkillFile } from "./skills/loader.js";
+export type { SkillMetadata } from "./skills/loader.js";
+export { WorkingMemory } from "./memory/working.js";
+export type { DreamStore, DreamResult, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, } from "./memory/protocols.js";
+export type { KnowledgeSource } from "./knowledge/source.js";
+export { SinglePassHarness, HarnessLoop } from "./harness/harness.js";
+export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions } 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";

package/dist/index.js

@@ -0,0 +1,12 @@
+export { Agent } from "./agent.js";
+export { AnthropicProvider } from "./providers/anthropic.js";
+export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider } 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 { ScheduledPrompt } from "./signals/scheduled.js";
+export { SignalGateway } from "./signals/gateway.js";
+export { PermissionManager, PermissionMode } from "./safety/permissions.js";

package/dist/knowledge/source.d.ts

@@ -0,0 +1,3 @@
+export interface KnowledgeSource {
+    retrieve(goal: string, topK?: number): Promise<string[]>;
+}

package/dist/knowledge/source.js

@@ -0,0 +1 @@
+export {};

package/dist/memory/protocols.d.ts

@@ -0,0 +1,48 @@
+export interface SessionMessage {
+    role: string;
+    content: string;
+    tokenCount?: number;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>;
+}
+export interface SessionData {
+    sessionId: string;
+    agentId: string;
+    messages: SessionMessage[];
+    metadata: unknown;
+    createdAtMs: number;
+    updatedAtMs: number;
+}
+export interface MemoryEntry {
+    text: string;
+    score: number;
+    metadata: unknown;
+}
+export interface CurationStats {
+    insightsProcessed: number;
+    duplicatesRemoved: number;
+    conflictsResolved: number;
+    entriesAdded: number;
+}
+export interface CurationResult {
+    toAdd: MemoryEntry[];
+    /** Indices into the `existingMemories` array passed to `DreamStore.loadMemories`. */
+    toRemoveIndices: number[];
+    stats: CurationStats;
+}
+export interface DreamStore {
+    loadSessions(agentId: string): Promise<SessionData[]>;
+    loadMemories(agentId: string): Promise<MemoryEntry[]>;
+    commit(agentId: string, result: CurationResult, existing: MemoryEntry[]): Promise<void>;
+    /** Semantic search over the agent's long-term memories. Called on demand during a run. */
+    search(agentId: string, query: string, topK?: number): Promise<MemoryEntry[]>;
+}
+export interface DreamResult {
+    sessionsProcessed: number;
+    insightsExtracted: number;
+    entriesAdded: number;
+    entriesRemoved: number;
+}

package/dist/memory/protocols.js

@@ -0,0 +1,2 @@
+// ─── Dream / idle-pipeline types ─────────────────────────────────────────────
+export {};

package/dist/memory/working.d.ts

@@ -0,0 +1,8 @@
+export declare class WorkingMemory {
+    private store;
+    set(key: string, value: unknown): void;
+    get<T = unknown>(key: string, defaultValue?: T): T | undefined;
+    delete(key: string): void;
+    clear(): void;
+    has(key: string): boolean;
+}

package/dist/memory/working.js

@@ -0,0 +1,8 @@
+export class WorkingMemory {
+    store = new Map();
+    set(key, value) { this.store.set(key, value); }
+    get(key, defaultValue) { return (this.store.get(key) ?? defaultValue); }
+    delete(key) { this.store.delete(key); }
+    clear() { this.store.clear(); }
+    has(key) { return this.store.has(key); }
+}

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,15 @@
+import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+export declare class AnthropicProvider implements LLMProvider {
+    private readonly model;
+    private client;
+    private circuit;
+    private maxRetries;
+    private baseDelay;
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    });
+    private buildTools;
+    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}

package/dist/providers/anthropic.js

@@ -0,0 +1,102 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { CircuitBreaker, normalizeToolCall } from "./base.js";
+export class AnthropicProvider {
+    model;
+    client;
+    circuit;
+    maxRetries;
+    baseDelay;
+    constructor(apiKey, model = "claude-sonnet-4-6", retry = { maxRetries: 3, baseDelay: 1000 }) {
+        this.model = model;
+        this.client = new Anthropic({ apiKey });
+        this.circuit = new CircuitBreaker();
+        this.maxRetries = retry.maxRetries;
+        this.baseDelay = retry.baseDelay;
+    }
+    buildTools(tools) {
+        return tools.map(t => ({
+            name: t.name,
+            description: t.description,
+            input_schema: JSON.parse(t.parameters),
+        }));
+    }
+    async complete(messages, tools) {
+        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 }));
+        let lastErr;
+        for (let i = 0; i < this.maxRetries; i++) {
+            try {
+                const resp = await this.client.messages.create({
+                    model: this.model,
+                    max_tokens: 8096,
+                    ...(system ? { system } : {}),
+                    messages: msgs,
+                    ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+                });
+                this.circuit.recordSuccess();
+                let content = "";
+                const toolCalls = [];
+                for (const block of resp.content) {
+                    if (block.type === "text")
+                        content += block.text;
+                    else if (block.type === "tool_use") {
+                        const tc = normalizeToolCall(block.id, block.name, block.input);
+                        if (tc)
+                            toolCalls.push(tc);
+                    }
+                }
+                return { role: "assistant", content, tokenCount: resp.usage.input_tokens + resp.usage.output_tokens, toolCalls };
+            }
+            catch (err) {
+                lastErr = err;
+                this.circuit.recordFailure();
+                if (i < this.maxRetries - 1)
+                    await new Promise(r => setTimeout(r, this.baseDelay * 2 ** i));
+            }
+        }
+        throw lastErr;
+    }
+    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 toolBlocks = {};
+        const stream = this.client.messages.stream({
+            model: this.model,
+            max_tokens: 8096,
+            ...(system ? { system } : {}),
+            messages: msgs,
+            ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+        });
+        for await (const evt of stream) {
+            if (evt.type === "content_block_start" && evt.content_block.type === "tool_use") {
+                toolBlocks[evt.index] = { id: evt.content_block.id, name: evt.content_block.name, argsBuf: "" };
+            }
+            else if (evt.type === "content_block_delta") {
+                const d = evt.delta;
+                if (d.type === "text_delta") {
+                    yield { type: "text_delta", delta: d.text };
+                }
+                else if (d.type === "thinking_delta") {
+                    yield { type: "thinking_delta", delta: d.thinking };
+                }
+                else if (d.type === "input_json_delta" && toolBlocks[evt.index]) {
+                    toolBlocks[evt.index].argsBuf += d.partial_json;
+                }
+            }
+            else if (evt.type === "content_block_stop" && toolBlocks[evt.index] !== undefined) {
+                const tb = toolBlocks[evt.index];
+                delete toolBlocks[evt.index];
+                let args = {};
+                try {
+                    args = JSON.parse(tb.argsBuf || "{}");
+                }
+                catch {
+                    args = {};
+                }
+                yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
+            }
+        }
+    }
+}

package/dist/providers/base.d.ts

@@ -0,0 +1,15 @@
+export declare class CircuitBreaker {
+    private readonly openAfter;
+    private readonly resetAfter;
+    private failures;
+    private openedAt;
+    constructor(openAfter?: number, resetAfter?: number);
+    isOpen(): boolean;
+    recordSuccess(): void;
+    recordFailure(): void;
+}
+export declare function normalizeToolCall(id: string, name: string, args: unknown): {
+    id: string;
+    name: string;
+    arguments: string;
+} | null;

package/dist/providers/base.js

@@ -0,0 +1,46 @@
+export class CircuitBreaker {
+    openAfter;
+    resetAfter;
+    failures = 0;
+    openedAt = null;
+    constructor(openAfter = 5, resetAfter = 60_000) {
+        this.openAfter = openAfter;
+        this.resetAfter = resetAfter;
+    }
+    isOpen() {
+        if (this.openedAt === null)
+            return false;
+        if (Date.now() - this.openedAt >= this.resetAfter) {
+            this.openedAt = null;
+            return false;
+        }
+        return true;
+    }
+    recordSuccess() {
+        this.failures = 0;
+        this.openedAt = null;
+    }
+    recordFailure() {
+        this.failures++;
+        if (this.failures >= this.openAfter)
+            this.openedAt = Date.now();
+    }
+}
+export function normalizeToolCall(id, name, args) {
+    const n = String(name ?? "").trim();
+    if (!n)
+        return null;
+    let parsed = {};
+    if (typeof args === "string") {
+        try {
+            parsed = JSON.parse(args || "{}");
+        }
+        catch {
+            parsed = {};
+        }
+    }
+    else if (args && typeof args === "object") {
+        parsed = args;
+    }
+    return { id: String(id ?? ""), name: n, arguments: JSON.stringify(parsed) };
+}

package/dist/providers/ollama.d.ts

@@ -0,0 +1,9 @@
+import type { Message, 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>;
+}

package/dist/providers/ollama.js

@@ -0,0 +1,58 @@
+import { normalizeToolCall } from "./base.js";
+export class OllamaProvider {
+    model;
+    baseUrl;
+    constructor(model = "llama3", baseUrl = "http://localhost:11434") {
+        this.model = model;
+        this.baseUrl = baseUrl;
+    }
+    toOllamaMessages(messages) {
+        return messages.map(m => ({ role: m.role, content: m.content }));
+    }
+    async complete(messages, 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 }),
+        });
+        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) {
+        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 }),
+        });
+        if (!resp.ok)
+            throw new Error(`Ollama error: ${resp.status}`);
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            const lines = buf.split("\n");
+            buf = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const chunk = JSON.parse(line);
+                    if (chunk.message?.content)
+                        yield { type: "text_delta", delta: chunk.message.content };
+                    for (const tc of chunk.message?.tool_calls ?? []) {
+                        const norm = normalizeToolCall(crypto.randomUUID(), tc.function.name, tc.function.arguments);
+                        if (norm)
+                            yield { type: "tool_call", id: norm.id, name: norm.name, arguments: JSON.parse(norm.arguments) };
+                    }
+                }
+                catch { /* skip malformed lines */ }
+            }
+        }
+    }
+}

package/dist/providers/openai.d.ts

@@ -0,0 +1,44 @@
+import OpenAI from "openai";
+import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+import { CircuitBreaker } from "./base.js";
+export declare class OpenAIProvider implements LLMProvider {
+    protected readonly model: string;
+    protected client: OpenAI;
+    protected circuit: CircuitBreaker;
+    protected maxRetries: number;
+    protected baseDelay: number;
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    protected buildTools(tools: ToolSchema[]): {
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: any;
+        };
+    }[];
+    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}
+export declare class QwenProvider extends OpenAIProvider {
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    });
+}
+export declare class DeepSeekProvider extends OpenAIProvider {
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    });
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}
+export declare class MiniMaxProvider extends OpenAIProvider {
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    });
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}