@deepstrike/wasm-kernel 0.2.36 → 0.2.37

package/deepstrike_wasm.d.ts

@@ -1,5 +1,19 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Discriminated union returned by `IdlePipeline` methods. Inspect `kind`:
+ * - `\"synthesize_insights\"` → `messages` (SDK must call the LLM, then `feedSynthesisResult`)
+ * - `\"commit_memories\"`     → `agentId`, `curationResult`, `runResult`
+ * - `\"noop\"` | `\"aborted\"`
+ */
+export interface IdlePipelineAction {
+    kind: string;
+    messages?: Message[];
+    agentId?: string;
+    curationResult?: CurationResult;
+    runResult?: IdleRunResult;
+}
+
 /**
  * Structured context for a provider call — emitted with `kind === \"call_llm\"`.
  */
@@ -51,12 +65,33 @@ export interface CriterionResult {
     feedback: string;
 }
 
+export interface CurationResult {
+    toAdd: MemoryEntry[];
+    /**
+     * Indices into the `existingMemories` slice passed to `feedTrigger`.
+     */
+    toRemoveIndices: number[];
+    stats: CurationStats;
+}
+
+export interface CurationStats {
+    insightsProcessed: number;
+    duplicatesRemoved: number;
+    conflictsResolved: number;
+    entriesAdded: number;
+}
+
 export interface GovernanceVerdict {
     kind: string;
     reason?: string;
     retryAfterMs?: number;
 }
 
+export interface IdleRunResult {
+    sessionsProcessed: number;
+    insightsExtracted: number;
+}
+
 export interface LoopPolicy {
     maxTokens: number;
     maxTurns?: number;
@@ -71,6 +106,15 @@ export interface LoopResult {
     totalTokensUsed: number;
 }
 
+export interface MemoryEntry {
+    text: string;
+    score: number;
+    /**
+     * JSON-encoded metadata blob.
+     */
+    metadata: string;
+}
+
 export interface Message {
     role: string;
     content: string;
@@ -116,6 +160,18 @@ export interface RuntimeTask {
     lane?: string;
 }
 
+export interface SessionData {
+    sessionId: string;
+    agentId: string;
+    messages: Message[];
+    /**
+     * JSON-encoded metadata blob.
+     */
+    metadata: string;
+    createdAtMs: number;
+    updatedAtMs: number;
+}
+
 export interface SkillCandidate {
     name: string;
     description: string;
@@ -169,6 +225,20 @@ export class Governance {
     setTime(now_ms: number): void;
 }
 
+/**
+ * Two-phase offline dream pipeline (parity with the napi/pyo3 exports):
+ * 1. `feedTrigger(sessions, existingMemories, nowMs)` → `"synthesize_insights"` + prompt messages
+ * 2. Call the LLM with those messages, collect the text response
+ * 3. `feedSynthesisResult(text)` → `"commit_memories"` with the curation delta
+ */
+export class IdlePipeline {
+    free(): void;
+    [Symbol.dispose](): void;
+    feedSynthesisResult(content: string): IdlePipelineAction;
+    feedTrigger(sessions: SessionData[], existing_memories: MemoryEntry[], now_ms: number): IdlePipelineAction;
+    constructor(agent_id: string);
+}
+
 export class KernelRuntime {
     free(): void;
     [Symbol.dispose](): void;
@@ -199,11 +269,6 @@ export class SignalRouter {
      * Pull the next queued signal (highest priority first).
      */
     next(): RuntimeSignal | undefined;
-    /**
-     * Pull the next queued signal visible to `recipient` (broadcasts plus signals
-     * addressed to it); other recipients' signals stay queued. Omit ⇒ no filter.
-     */
-    nextFor(recipient?: string | null): RuntimeSignal | undefined;
 }
 
 /**

package/deepstrike_wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./deepstrike_wasm_bg.js";
 __wbg_set_wasm(wasm);
 
 export {
-    Governance, KernelRuntime, SignalRouter, buildEvalMessages, parseVerdict, verdictOutputSchema
+    Governance, IdlePipeline, KernelRuntime, SignalRouter, buildEvalMessages, parseVerdict, verdictOutputSchema
 } from "./deepstrike_wasm_bg.js";

package/deepstrike_wasm_bg.js

@@ -120,6 +120,72 @@ export class Governance {
 }
 if (Symbol.dispose) Governance.prototype[Symbol.dispose] = Governance.prototype.free;
 
+/**
+ * Two-phase offline dream pipeline (parity with the napi/pyo3 exports):
+ * 1. `feedTrigger(sessions, existingMemories, nowMs)` → `"synthesize_insights"` + prompt messages
+ * 2. Call the LLM with those messages, collect the text response
+ * 3. `feedSynthesisResult(text)` → `"commit_memories"` with the curation delta
+ */
+export class IdlePipeline {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdlePipelineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_idlepipeline_free(ptr, 0);
+    }
+    /**
+     * @param {string} content
+     * @returns {IdlePipelineAction}
+     */
+    feedSynthesisResult(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.idlepipeline_feedSynthesisResult(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @param {SessionData[]} sessions
+     * @param {MemoryEntry[]} existing_memories
+     * @param {number} now_ms
+     * @returns {IdlePipelineAction}
+     */
+    feedTrigger(sessions, existing_memories, now_ms) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(sessions, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(existing_memories, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.idlepipeline_feedTrigger(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, now_ms);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {string} agent_id
+     */
+    constructor(agent_id) {
+        const ptr0 = passStringToWasm0(agent_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.idlepipeline_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        IdlePipelineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) IdlePipeline.prototype[Symbol.dispose] = IdlePipeline.prototype.free;
+
 export class KernelRuntime {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -294,18 +360,6 @@ export class SignalRouter {
         const ret = wasm.signalrouter_next(this.__wbg_ptr);
         return takeObject(ret);
     }
-    /**
-     * Pull the next queued signal visible to `recipient` (broadcasts plus signals
-     * addressed to it); other recipients' signals stay queued. Omit ⇒ no filter.
-     * @param {string | null} [recipient]
-     * @returns {RuntimeSignal | undefined}
-     */
-    nextFor(recipient) {
-        var ptr0 = isLikeNone(recipient) ? 0 : passStringToWasm0(recipient, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.signalrouter_nextFor(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
 }
 if (Symbol.dispose) SignalRouter.prototype[Symbol.dispose] = SignalRouter.prototype.free;
 
@@ -404,6 +458,10 @@ export function __wbg___wbindgen_in_07056af4f902c445(arg0, arg1) {
     const ret = getObject(arg0) in getObject(arg1);
     return ret;
 }
+export function __wbg___wbindgen_is_function_5cd60d5cf78b4eef(arg0) {
+    const ret = typeof(getObject(arg0)) === 'function';
+    return ret;
+}
 export function __wbg___wbindgen_is_object_b4593df85baada48(arg0) {
     const val = getObject(arg0);
     const ret = typeof(val) === 'object' && val !== null;
@@ -434,9 +492,25 @@ export function __wbg___wbindgen_string_get_d109740c0d18f4d7(arg0, arg1) {
 export function __wbg___wbindgen_throw_9c31b086c2b26051(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
+export function __wbg_call_13665d9f14390edc() { return handleError(function (arg0, arg1) {
+    const ret = getObject(arg0).call(getObject(arg1));
+    return addHeapObject(ret);
+}, arguments); }
+export function __wbg_done_54b8da57023b7ed2(arg0) {
+    const ret = getObject(arg0).done;
+    return ret;
+}
 export function __wbg_getRandomValues_ef12552bf5acd2fe() { return handleError(function (arg0, arg1) {
     globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
 }, arguments); }
+export function __wbg_get_3e9a707ab7d352eb() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(getObject(arg0), getObject(arg1));
+    return addHeapObject(ret);
+}, arguments); }
+export function __wbg_get_unchecked_1dfe6d05ad91d9b7(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+}
 export function __wbg_get_with_ref_key_6412cf3094599694(arg0, arg1) {
     const ret = getObject(arg0)[getObject(arg1)];
     return addHeapObject(ret);
@@ -461,10 +535,22 @@ export function __wbg_instanceof_Uint8Array_abd07d4bd221d50b(arg0) {
     const ret = result;
     return ret;
 }
+export function __wbg_isArray_94898ed3aad6947b(arg0) {
+    const ret = Array.isArray(getObject(arg0));
+    return ret;
+}
 export function __wbg_isSafeInteger_01e964d144ad3a55(arg0) {
     const ret = Number.isSafeInteger(getObject(arg0));
     return ret;
 }
+export function __wbg_iterator_1441b47f341dc34f() {
+    const ret = Symbol.iterator;
+    return addHeapObject(ret);
+}
+export function __wbg_length_2591a0f4f659a55c(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+}
 export function __wbg_length_56fcd3e2b7e0299d(arg0) {
     const ret = getObject(arg0).length;
     return ret;
@@ -481,6 +567,14 @@ export function __wbg_new_7ddec6de44ff8f5d(arg0) {
     const ret = new Uint8Array(getObject(arg0));
     return addHeapObject(ret);
 }
+export function __wbg_next_2a4e19f4f5083b0f(arg0) {
+    const ret = getObject(arg0).next;
+    return addHeapObject(ret);
+}
+export function __wbg_next_6429a146bf756f93() { return handleError(function (arg0) {
+    const ret = getObject(arg0).next();
+    return addHeapObject(ret);
+}, arguments); }
 export function __wbg_prototypesetcall_5f9bdc8d75e07276(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 }
@@ -490,6 +584,10 @@ export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
 export function __wbg_set_78ea6a19f4818587(arg0, arg1, arg2) {
     getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
 }
+export function __wbg_value_9cc0518af87a489c(arg0) {
+    const ret = getObject(arg0).value;
+    return addHeapObject(ret);
+}
 export function __wbindgen_cast_0000000000000001(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;
@@ -510,6 +608,9 @@ export function __wbindgen_object_drop_ref(arg0) {
 const GovernanceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_governance_free(ptr, 1));
+const IdlePipelineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_idlepipeline_free(ptr, 1));
 const KernelRuntimeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_kernelruntime_free(ptr, 1));

package/package.json

@@ -2,7 +2,7 @@
   "name": "@deepstrike/wasm-kernel",
   "type": "module",
   "description": "WebAssembly bindings for DeepStrike runtime kernel",
-  "version": "0.2.36",
+  "version": "0.2.37",
   "license": "MIT",
   "files": [
     "deepstrike_wasm_bg.wasm",