@dot-agent/kernel-dsl 0.1.1 → 0.1.2

package/index.js

@@ -65,8 +65,8 @@ export class AgentDSLKernel {
   send_complete() { return this._kernel.send_complete(); }
   send_event(event) { return this._kernel.send_event(event); }
   send_failed() { return this._kernel.send_failed(); }
-  send_fallback() { return this._kernel.send_fallback(); }
   send_intent(intent) { return this._kernel.send_intent(intent); }
+  set_memory(domain, key, value_json) { return this._kernel.set_memory(domain, key, value_json); }
   send_offtopic() { return this._kernel.send_offtopic(); }
   tick_prompt() { return this._kernel.tick_prompt(); }
   free() { return this._kernel.free(); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dot-agent/kernel-dsl",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "WASM kernel for parsing and executing the agent behavior DSL",
   "type": "module",
   "main": "./index.js",
@@ -41,6 +41,7 @@
     "scripts/patch-wasm-bindgen.js",
     "pkg/dot_agent_kernel_dsl.js",
     "pkg/dot_agent_kernel_dsl.d.ts",
+    "pkg/dot_agent_kernel_dsl_bg.js",
     "pkg/dot_agent_kernel_dsl_bg.wasm",
     "pkg/dot_agent_kernel_dsl_bg.wasm.d.ts",
     "pkg/package.json"
@@ -63,6 +64,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-  }
+  "dependencies": {}
 }

package/pkg/dot_agent_kernel_dsl_bg.js

@@ -0,0 +1,327 @@
+export class AgentDSLKernel {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AgentDSLKernelFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_agentdslkernel_free(ptr, 0);
+    }
+    /**
+     * Return the name of the current state.
+     * @returns {string}
+     */
+    get_current_state() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.agentdslkernel_get_current_state(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Return the state graph as { states, transitions, current }.
+     *
+     * Use this to render the Flow Graph panel in VS Code or any diagram tool.
+     * @returns {any}
+     */
+    get_graph() {
+        const ret = wasm.agentdslkernel_get_graph(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Return the full memory store as a JSON array of { domain, key, value } entries.
+     * @returns {any}
+     */
+    get_memory() {
+        const ret = wasm.agentdslkernel_get_memory(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Return an array of intent strings declared in the current state.
+     *
+     * Use this to build the list of valid intent names to pass to the LLM classifier.
+     * @returns {Array<any>}
+     */
+    get_valid_intents() {
+        const ret = wasm.agentdslkernel_get_valid_intents(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Parse and load a .behavior DSL text.
+     *
+     * Fires the observer for each entry effect of the first state (typically goal +
+     * request_interact). Also returns the effects array for imperative call sites.
+     * On parse error, fires and returns a single ParseError effect.
+     * @param {string} text
+     * @returns {any}
+     */
+    load_behavior(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.agentdslkernel_load_behavior(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    constructor() {
+        const ret = wasm.agentdslkernel_new();
+        this.__wbg_ptr = ret;
+        AgentDSLKernelFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Register a callback that WASM will call once per Effect as they are produced.
+     *
+     * This is the primary integration point — the equivalent of the importObject in a
+     * raw WebAssembly.instantiate call. The callback receives a single Effect object
+     * per invocation and must implement all WASM→JS directives (goal, guide, teach,
+     * run_script, run_subagent, run_tool, apply_css, …).
+     *
+     * Only one observer can be active at a time; calling observe() again replaces it.
+     * @param {Function} callback
+     */
+    observe(callback) {
+        wasm.agentdslkernel_observe(this.__wbg_ptr, callback);
+    }
+    /**
+     * Signal that the last async operation (run_script, run_subagent, run_tool) completed successfully.
+     *
+     * Fires the observer with the effects of the current state's `on complete` block.
+     * @returns {any}
+     */
+    send_complete() {
+        const ret = wasm.agentdslkernel_send_complete(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Signal that the runtime could not resolve the current action.
+     * Dispatch a named global event (e.g. "session.ended", "script.done").
+     *
+     * Matches top-level `on event "…"` declarations. Use this to notify the FSM
+     * when an async operation triggered by run_script / run_subagent / run_tool completes.
+     * @param {string} event
+     * @returns {any}
+     */
+    send_event(event) {
+        const ptr0 = passStringToWasm0(event, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.agentdslkernel_send_event(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Signal that the last async operation (run_script, run_subagent, run_tool) failed.
+     *
+     * Fires the observer with the effects of the current state's `on failed` block.
+     * @returns {any}
+     */
+    send_failed() {
+        const ret = wasm.agentdslkernel_send_failed(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Dispatch a named intent to the FSM.
+     *
+     * Call this after the LLM classifies the user's message into an intent name that
+     * matches one of the `on intent "…"` declarations in the current state.
+     * Fires the observer with transition + any entry effects of the new state.
+     * @param {string} intent
+     * @returns {any}
+     */
+    send_intent(intent) {
+        const ptr0 = passStringToWasm0(intent, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.agentdslkernel_send_intent(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Signal that the current message is off-topic.
+     *
+     * Fires the observer with the effects of the current state's `on offtopic` block.
+     * @returns {any}
+     */
+    send_offtopic() {
+        const ret = wasm.agentdslkernel_send_offtopic(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Set a value in the memory store from JS.
+     *
+     * domain: "context" | "session" | "worksession" | "user"
+     * value_json: value serialized as a JSON primitive ("text", 42, true, null)
+     * @param {string} domain
+     * @param {string} key
+     * @param {string} value_json
+     */
+    set_memory(domain, key, value_json) {
+        const ptr0 = passStringToWasm0(domain, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(value_json, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.agentdslkernel_set_memory(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    }
+    /**
+     * Notify the engine that a prompt turn was processed.
+     *
+     * Call once per LLM completion. Triggers any matching `after N prompts` handlers
+     * in the current state, firing their effects through the observer.
+     * @returns {any}
+     */
+    tick_prompt() {
+        const ret = wasm.agentdslkernel_tick_prompt(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) AgentDSLKernel.prototype[Symbol.dispose] = AgentDSLKernel.prototype.free;
+export function __wbg___wbindgen_throw_1506f2235d1bdba0(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_call_9c758de292015997() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+}, arguments); }
+export function __wbg_new_ce1ab61c1c2b300d() {
+    const ret = new Object();
+    return ret;
+}
+export function __wbg_new_d90091b82fdf5b91() {
+    const ret = new Array();
+    return ret;
+}
+export function __wbg_push_a6822215aa43e71c(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+}
+export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+}
+export function __wbg_set_dca99999bba88a9a(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+}
+export function __wbindgen_cast_0000000000000001(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+}
+const AgentDSLKernelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_agentdslkernel_free(ptr, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc_command_export();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store_command_export(idx);
+    }
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}