@deepstrike/sdk 0.1.3 → 0.1.5

package/README.md

@@ -8,7 +8,23 @@ Agent framework built on a Rust kernel. The kernel handles loop control, context
 npm install @deepstrike/sdk
 ```
 
-Requires Node.js 18+. The Rust kernel is distributed as a pre-built native addon (`@deepstrike/core`).
+Requires Node.js 18+.
+
+### Platform support
+
+Pre-built native addons are available for the following platforms:
+
+| Platform | Package |
+| -------- | ------- |
+| Linux x64 (glibc) | `@deepstrike/core-linux-x64-gnu` |
+| Linux ARM64 (glibc) | `@deepstrike/core-linux-arm64-gnu` |
+| macOS x64 | `@deepstrike/core-darwin-x64` |
+| macOS ARM64 (Apple Silicon) | `@deepstrike/core-darwin-arm64` |
+| Windows x64 | `@deepstrike/core-win32-x64-msvc` |
+
+The correct platform package is selected and installed automatically via `optionalDependencies`.
+
+> **Note:** `@deepstrike/core` is the low-level native addon package and is not intended for direct use. It is an internal dependency automatically managed by `@deepstrike/sdk`. Direct installation is only relevant when building from Rust source.
 
 ---
 

package/dist/agent.d.ts

@@ -8,6 +8,17 @@ export interface AgentOptions {
     maxTurns?: number;
     timeoutMs?: number;
     extensions?: Record<string, unknown>;
+    /**
+     * System-level instructions prepended to every context render.
+     * 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.

package/dist/agent.js

@@ -63,6 +63,9 @@ export class Agent {
         this.pendingInterrupt = false;
         this._turn = 0;
         this._pressure = 0;
+        if (this.knowledgeSource) {
+            await this.knowledgeSource.init();
+        }
         const kernel = await loadKernel();
         const ext = { ...this.extensions, ...(extensions ?? {}) };
         const sm = new kernel.LoopStateMachine({
@@ -74,6 +77,13 @@ export class Agent {
         const router = new kernel.SignalRouter(256);
         const toolSchemas = Array.from(this.tools.values()).map(t => t.schema);
         sm.setTools(toolSchemas);
+        if (this.options.systemPrompt) {
+            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)));
+        }
         if (this.skillDir) {
             const skillMetas = await scanSkillDir(this.skillDir);
             sm.setAvailableSkills(skillMetas.map((m) => ({
@@ -91,6 +101,8 @@ export class Agent {
             sm.setKnowledgeEnabled(true);
         }
         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;
@@ -172,6 +184,7 @@ 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 ?? [];
@@ -258,9 +271,20 @@ export class Agent {
         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;
+        if (this.options.dreamStore && this.options.agentId && sessionMsgs.length > 1) {
+            try {
+                await this.options.dreamStore.saveSession({
+                    sessionId: crypto.randomUUID(),
+                    agentId: this.options.agentId,
+                    messages: sessionMsgs,
+                    metadata: null,
+                    createdAtMs: sessionStart,
+                    updatedAtMs: Date.now(),
+                });
+            }
+            catch { /* session save failure must not surface to caller */ }
+        }
         yield {
             type: "done",
             iterations,

package/dist/harness/harness.d.ts

@@ -1,7 +1,18 @@
 import type { Agent } from "../agent.js";
+export interface Criterion {
+    text: string;
+    required: boolean;
+    weight?: number;
+}
+export interface CriterionResult {
+    criterion: string;
+    passed: boolean;
+    score: number;
+    feedback: string;
+}
 export interface HarnessRequest {
     goal: string;
-    criteria?: string[];
+    criteria?: Criterion[];
     extensions?: Record<string, unknown>;
 }
 export interface HarnessOutcome {
@@ -10,9 +21,42 @@ export interface HarnessOutcome {
     iterations: number;
     totalTokens: number;
     status: string;
-    /** Feedback from the evaluator LLM — injected into the next attempt's goal. */
+    overallScore?: number;
     feedback?: string;
+    details?: CriterionResult[];
+}
+export interface Verdict {
+    passed: boolean;
+    overallScore: number;
+    feedback: string;
+    details: CriterionResult[];
 }
+export type HarnessEvent = {
+    type: "token";
+    text: string;
+} | {
+    type: "tool_call";
+    id: string;
+    name: string;
+} | {
+    type: "tool_result";
+    callId: string;
+    content: string;
+    isError: boolean;
+} | {
+    type: "supervising";
+} | {
+    type: "revising";
+    verdict: Verdict;
+} | {
+    type: "done";
+    verdict: Verdict;
+    iterations: number;
+    totalTokens: number;
+    status: string;
+} | {
+    type: "max_attempts_reached";
+};
 export interface QualityGate {
     evaluate(request: HarnessRequest, outcome: HarnessOutcome): Promise<boolean>;
 }
@@ -21,7 +65,6 @@ export declare class SinglePassHarness {
     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;
@@ -31,21 +74,13 @@ export declare class EvalLoopHarness {
 }
 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>;
+    runStreaming(request: HarnessRequest): AsyncIterable<HarnessEvent>;
 }

package/dist/harness/harness.js

@@ -9,19 +9,13 @@ async function loadKernel() {
 async function runOnce(agent, req) {
     let text = "";
     let done;
-    for await (const evt of agent.runStreaming(req.goal, req.criteria, req.extensions)) {
+    for await (const evt of agent.runStreaming(req.goal, req.criteria?.map(c => c.text), 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",
-    };
+    return { result: text, passed: false, iterations: done?.iterations ?? 0, totalTokens: done?.totalTokens ?? 0, status: done?.status ?? "error" };
 }
 export class SinglePassHarness {
     agent;
@@ -32,7 +26,6 @@ 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;
@@ -46,20 +39,12 @@ export class EvalLoopHarness {
         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)) {
+            if (await this.gate.evaluate(request, outcome))
                 return { ...outcome, passed: true };
-            }
         }
         return outcome;
     }
 }
-/**
- * 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;
@@ -71,47 +56,77 @@ export class HarnessLoop {
         this.maxAttempts = options.maxAttempts ?? 3;
         this.skillDir = options.skillDir;
     }
-    async run(request) {
+    async *runStreaming(request) {
         const kernel = await loadKernel();
         const pipeline = new kernel.EvalPipeline({ extractSkillOnPass: true });
-        let outcome = { result: "", passed: false, iterations: 0, totalTokens: 0, status: "error" };
+        const criteria = request.criteria ?? [];
+        // history tracks the full conversation; agent sees only the current goal message
+        // but we inject feedback as user messages to guide revision without discarding prior output
         let currentGoal = request.goal;
+        let lastIterations = 0;
+        let lastTotalTokens = 0;
+        let lastStatus = "error";
+        let lastResult = "";
         for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
-            outcome = await runOnce(this.agent, { ...request, goal: currentGoal });
-            // Phase 1: kernel builds eval prompt (positional args per kernel API)
-            const evalAction = pipeline.feedOutcome(request.goal, request.criteria ?? [], outcome.result, attempt);
+            // Stream agent output directly to caller
+            for await (const evt of this.agent.runStreaming(currentGoal, criteria.map(c => c.text), request.extensions)) {
+                if (evt.type === "text_delta") {
+                    lastResult += evt.delta;
+                    yield { type: "token", text: evt.delta };
+                }
+                else if (evt.type === "tool_call") {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const tc = evt;
+                    yield { type: "tool_call", id: tc.id, name: tc.name };
+                }
+                else if (evt.type === "tool_result") {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const tr = evt;
+                    yield { type: "tool_result", callId: tr.callId, content: tr.content, isError: tr.isError };
+                }
+                else if (evt.type === "done") {
+                    const d = evt;
+                    lastIterations = d.iterations;
+                    lastTotalTokens = d.totalTokens;
+                    lastStatus = d.status;
+                }
+            }
+            // Checkpoint: evaluator judges the completed output
+            yield { type: "supervising" };
+            const evalAction = pipeline.feedOutcome(request.goal, criteria, lastResult, 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(evalText);
             if (doneAction.kind !== "done")
                 break;
-            outcome = { ...outcome, passed: doneAction.passed, feedback: doneAction.feedback };
-            if (doneAction.passed) {
+            const verdict = {
+                passed: doneAction.passed ?? false,
+                overallScore: doneAction.overallScore ?? 0,
+                feedback: doneAction.feedback ?? "",
+                details: doneAction.details ?? [],
+            };
+            if (verdict.passed) {
                 if (doneAction.skill_candidate && this.skillDir) {
                     const { name, description, whenToUse, content } = doneAction.skill_candidate;
-                    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");
+                    const fm = ["---", `name: ${name}`, `description: ${description}`,
+                        whenToUse ? `when_to_use: ${whenToUse}` : null, "---", ""]
+                        .filter(Boolean).join("\n");
+                    await writeFile(path.join(this.skillDir, `${name}.md`), fm + content, "utf8");
                 }
-                return outcome;
+                yield { type: "done", verdict, iterations: lastIterations, totalTokens: lastTotalTokens, status: lastStatus };
+                return;
             }
-            // Inject feedback into next attempt's goal
-            currentGoal = `${request.goal}\n\n[Previous attempt ${attempt} failed: ${doneAction.feedback}]`;
+            yield { type: "revising", verdict };
+            // Inject feedback as next turn's goal — agent sees its prior output + evaluator notes
+            currentGoal = `${request.goal}\n\n[Attempt ${attempt} feedback: ${verdict.feedback}]`;
+            lastResult = "";
             pipeline.reset();
         }
-        return outcome;
+        yield { type: "max_attempts_reached" };
     }
 }

package/dist/knowledge/source.d.ts

@@ -1,3 +1,5 @@
 export interface KnowledgeSource {
     retrieve(goal: string, topK?: number): Promise<string[]>;
+    /** One-time warmup called before the first run (load index, open connection, etc.). */
+    init(): Promise<void>;
 }

package/dist/memory/protocols.d.ts

@@ -39,6 +39,8 @@ export interface DreamStore {
     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[]>;
+    /** Persist a completed session for future consolidation via `Agent.dream()`. */
+    saveSession(data: SessionData): Promise<void>;
 }
 export interface DreamResult {
     sessionsProcessed: number;

package/dist/skills/loader.d.ts

@@ -5,7 +5,7 @@ export interface SkillMetadata {
     effort?: number;
     estimatedTokens?: number;
 }
-/** Read one skill file and return its full markdown content. */
+/** Read one skill file and return its body (frontmatter stripped). */
 export declare function readSkillFile(skillDir: string, name: string): Promise<string | null>;
 /** Scan a skill directory and return frontmatter-only metadata for all `.md` files. */
 export declare function scanSkillDir(skillDir: string): Promise<SkillMetadata[]>;

package/dist/skills/loader.js

@@ -12,10 +12,11 @@ function parseFrontmatter(content) {
     }
     return { meta, body: match[2] };
 }
-/** Read one skill file and return its full markdown content. */
+/** Read one skill file and return its body (frontmatter stripped). */
 export async function readSkillFile(skillDir, name) {
     try {
-        return await readFile(path.join(skillDir, `${name}.md`), "utf8");
+        const raw = await readFile(path.join(skillDir, `${name}.md`), "utf8");
+        return parseFrontmatter(raw).body;
     }
     catch {
         return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
-    "@deepstrike/core": "0.1.3",
+    "@deepstrike/core": "0.1.5",
     "openai": "^4.77.0"
   },
   "devDependencies": {