@pi-oxide/pi-host-web 0.3.1 → 0.4.0

package/pi_host_web.js

@@ -1,39 +1,30 @@
 /* @ts-self-types="./pi_host_web.d.ts" */
 
 /**
- * @param {number} handle
- * @returns {StepResult}
+ * @param {AgentOptions} options
+ * @param {ContextProjectionBudget} budget
+ * @returns {CreateHostAgentResult}
  */
-export function abort(handle) {
-    const ret = wasm.abort(handle);
+export function createHostAgent(options, budget) {
+    const ret = wasm.createHostAgent(options, budget);
     return ret;
 }
 
 /**
- * @param {number} handle
- * @param {SessionEntry} entry
- * @returns {EmptyResult}
+ * @param {ContextProjectionBudget} _budget
+ * @returns {CreateHostStateResult}
  */
-export function appendSessionEntry(handle, entry) {
-    const ret = wasm.appendSessionEntry(handle, entry);
+export function createHostState(_budget) {
+    const ret = wasm.createHostState(_budget);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @returns {StepResult}
- */
-export function continueTurn(handle) {
-    const ret = wasm.continueTurn(handle);
-    return ret;
-}
-
-/**
- * @param {AgentOptions} options
- * @returns {CreateAgentResult}
+ * @returns {EmptyResult}
  */
-export function createAgent(options) {
-    const ret = wasm.createAgent(options);
+export function destroyHostAgent(handle) {
+    const ret = wasm.destroyHostAgent(handle);
     return ret;
 }
 
@@ -41,8 +32,8 @@ export function createAgent(options) {
  * @param {number} handle
  * @returns {EmptyResult}
  */
-export function destroyAgent(handle) {
-    const ret = wasm.destroyAgent(handle);
+export function destroyHostState(handle) {
+    const ret = wasm.destroyHostState(handle);
     return ret;
 }
 
@@ -67,193 +58,218 @@ export function estimateTokensForText(text) {
 }
 
 /**
- * @param {string} tool_name
- * @returns {ContextStrategy}
+ * @param {number} handle
+ * @returns {HostStatePersistDataResult}
  */
-export function fallbackStrategy(tool_name) {
-    const ptr0 = passStringToWasm0(tool_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.fallbackStrategy(ptr0, len0);
+export function getHostAgentPersistData(handle) {
+    const ret = wasm.getHostAgentPersistData(handle);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {LlmChunk} chunk
- * @returns {EventsResult}
+ * @returns {HostStatePersistDataResult}
  */
-export function feedLlmChunk(handle, chunk) {
-    const ret = wasm.feedLlmChunk(handle, chunk);
+export function getHostStatePersistData(handle) {
+    const ret = wasm.getHostStatePersistData(handle);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {AgentMessage} message
- * @returns {EmptyResult}
+ * @returns {TurnResultResult}
  */
-export function followUp(handle, message) {
-    const ret = wasm.followUp(handle, message);
+export function hostAbort(handle) {
+    const ret = wasm.hostAbort(handle);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @returns {SessionBranchResult}
+ * @param {string} summary
+ * @param {string[]} _compacted_entry_ids
+ * @returns {TurnResultResult}
  */
-export function getSessionBranch(handle) {
-    const ret = wasm.getSessionBranch(handle);
+export function hostAcceptCompaction(handle, summary, _compacted_entry_ids) {
+    const ptr0 = passStringToWasm0(summary, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayJsValueToWasm0(_compacted_entry_ids, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.hostAcceptCompaction(handle, ptr0, len0, ptr1, len1);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @returns {SessionStateResult}
+ * @returns {TurnResultResult}
  */
-export function getSessionState(handle) {
-    const ret = wasm.getSessionState(handle);
+export function hostContinueTurn(handle) {
+    const ret = wasm.hostContinueTurn(handle);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {string} target_id
- * @param {BranchSummary | null} [summary]
- * @returns {MoveToResult}
+ * @param {LlmChunk} chunk
+ * @returns {TurnResultResult}
  */
-export function moveTo(handle, target_id, summary) {
-    const ptr0 = passStringToWasm0(target_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.moveTo(handle, ptr0, len0, isLikeNone(summary) ? 0 : addToExternrefTable0(summary));
+export function hostFeedLlmChunk(handle, chunk) {
+    const ret = wasm.hostFeedLlmChunk(handle, chunk);
     return ret;
 }
 
 /**
  * @param {number} handle
  * @param {LlmResult} result
- * @returns {StepResult}
+ * @returns {TurnResultResult}
  */
-export function onLlmDone(handle, result) {
-    const ret = wasm.onLlmDone(handle, result);
+export function hostLlmDone(handle, result) {
+    const ret = wasm.hostLlmDone(handle, result);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {string} tool_call_id
- * @param {CancelReason} reason
- * @returns {StepResult}
+ * @param {string} artifact_id
+ * @returns {string}
  */
-export function onToolCancelled(handle, tool_call_id, reason) {
-    const ptr0 = passStringToWasm0(tool_call_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.onToolCancelled(handle, ptr0, len0, reason);
-    return ret;
+export function hostReadArtifact(handle, artifact_id) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(artifact_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hostReadArtifact(handle, ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
 }
 
 /**
  * @param {number} handle
- * @param {string} tool_call_id
- * @param {ToolDonePayload} payload
- * @returns {StepResult}
+ * @returns {EmptyResult}
  */
-export function onToolDone(handle, tool_call_id, payload) {
-    const ptr0 = passStringToWasm0(tool_call_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.onToolDone(handle, ptr0, len0, payload);
+export function hostReset(handle) {
+    const ret = wasm.hostReset(handle);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {string} tool_call_id
- * @returns {EventsResult}
+ * @param {string} query
+ * @returns {ArtifactSearchResults}
  */
-export function onToolStarted(handle, tool_call_id) {
-    const ptr0 = passStringToWasm0(tool_call_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+export function hostSearchArtifacts(handle, query) {
+    const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.onToolStarted(handle, ptr0, len0);
-    return ret;
+    const ret = wasm.hostSearchArtifacts(handle, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
  * @param {number} handle
- * @param {ToolExecutionUpdate} update
- * @returns {EventsResult}
+ * @param {AgentMessage} message
+ * @returns {TurnResultResult}
  */
-export function onToolUpdate(handle, update) {
-    const ret = wasm.onToolUpdate(handle, update);
+export function hostSteer(handle, message) {
+    const ret = wasm.hostSteer(handle, message);
     return ret;
 }
 
 /**
- * @param {ProjectionInput} input
- * @returns {ProjectionResult}
+ * @param {number} handle
+ * @param {string} tool_call_id
+ * @param {CancelReason} reason
+ * @returns {TurnResultResult}
  */
-export function projectContext(input) {
-    const ret = wasm.projectContext(input);
+export function hostToolCancelled(handle, tool_call_id, reason) {
+    const ptr0 = passStringToWasm0(tool_call_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.hostToolCancelled(handle, ptr0, len0, reason);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {PromptRequest} prompt
- * @returns {StepResult}
+ * @param {ToolCallId} id
+ * @param {ToolResult} result
+ * @returns {TurnResultResult}
  */
-export function prompt(handle, prompt) {
-    const ret = wasm.prompt(handle, prompt);
+export function hostToolDone(handle, id, result) {
+    const ret = wasm.hostToolDone(handle, id, result);
     return ret;
 }
 
 /**
- * @param {number} handle
- * @returns {EmptyResult}
+ * @param {AgentOptions} options
+ * @param {PersistData} data
+ * @returns {CreateHostAgentResult}
  */
-export function reset(handle) {
-    const ret = wasm.reset(handle);
+export function restoreHostAgent(options, data) {
+    const ret = wasm.restoreHostAgent(options, data);
     return ret;
 }
 
 /**
- * @param {string} level
+ * @param {PersistData} data
+ * @returns {CreateHostStateResult}
  */
-export function setLogLevel(level) {
-    const ptr0 = passStringToWasm0(level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.setLogLevel(ptr0, len0);
+export function restoreHostState(data) {
+    const ret = wasm.restoreHostState(data);
+    return ret;
 }
 
 /**
- * @param {number} handle
- * @param {SessionState} state
- * @returns {EmptyResult}
+ * @param {string} json
+ * @returns {CreateHostStateResult}
  */
-export function setSessionState(handle, state) {
-    const ret = wasm.setSessionState(handle, state);
+export function restoreHostStateFromJson(json) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.restoreHostStateFromJson(ptr0, len0);
     return ret;
 }
 
 /**
- * @param {number} handle
- * @returns {StateResult}
+ * @param {string} level
  */
-export function state(handle) {
-    const ret = wasm.state(handle);
-    return ret;
+export function setLogLevel(level) {
+    const ptr0 = passStringToWasm0(level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.setLogLevel(ptr0, len0);
 }
 
 /**
  * @param {number} handle
- * @param {AgentMessage} message
- * @returns {EventsResult}
+ * @param {StartTurnInput} input
+ * @returns {TurnResultResult}
  */
-export function steer(handle, message) {
-    const ret = wasm.steer(handle, message);
+export function startTurn(handle, input) {
+    const ret = wasm.startTurn(handle, input);
     return ret;
 }
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg___wbindgen_debug_string_0accd80f45e5faa2: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_is_undefined_67b456be8673d3d7: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
@@ -325,10 +341,17 @@ function __wbg_get_imports() {
             const ret = new Error();
             return ret;
         },
+        __wbg_new_ce1ab61c1c2b300d: function() {
+            const ret = new Object();
+            return ret;
+        },
         __wbg_parse_03863847d06c4e89: function() { return handleError(function (arg0, arg1) {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
         }, arguments); },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
         __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
             const ret = arg1.stack;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -340,6 +363,11 @@ function __wbg_get_imports() {
             const ret = JSON.stringify(arg0);
             return ret;
         }, arguments); },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
@@ -362,6 +390,71 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -395,6 +488,16 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -432,6 +535,12 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
 const MAX_SAFARI_DECODE_BYTES = 2146435072;