simple-agents-wasm 0.3.6 → 0.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-agents-wasm",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Browser-compatible SimpleAgents client for OpenAI-compatible providers",
   "type": "module",
   "main": "index.js",

package/pkg/simple_agents_wasm.d.ts

@@ -24,15 +24,12 @@ export class WasmClient {
 
 export function supportsRustWasm(): boolean;
 
-export function toJsArray(value: any): Array<any>;
-
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_wasmclient_free: (a: number, b: number) => void;
     readonly supportsRustWasm: () => number;
-    readonly toJsArray: (a: any) => any;
     readonly wasmclient_complete: (a: number, b: number, c: number, d: any, e: number) => any;
     readonly wasmclient_new: (a: number, b: number, c: any) => [number, number, number];
     readonly wasmclient_runWorkflowYaml: (a: number, b: number, c: number, d: any) => [number, number, number];
@@ -41,6 +38,7 @@ export interface InitOutput {
     readonly wasmclient_streamEvents: (a: number, b: number, c: number, d: any, e: any, f: number) => any;
     readonly wasm_bindgen__convert__closures_____invoke__h9f53f643b01d7c8e: (a: number, b: number, c: any) => [number, number];
     readonly wasm_bindgen__convert__closures_____invoke__h05acb8c479b21d4b: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h25554e005bd8517d: (a: number, b: number, c: any) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;

package/pkg/simple_agents_wasm.js

@@ -108,15 +108,6 @@ export function supportsRustWasm() {
     return ret !== 0;
 }
 
-/**
- * @param {any} value
- * @returns {Array<any>}
- */
-export function toJsArray(value) {
-    const ret = wasm.toJsArray(value);
-    return ret;
-}
-
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -357,13 +348,13 @@ function __wbg_get_imports() {
             const ret = arg0.next();
             return ret;
         }, arguments); },
+        __wbg_parse_545d11396395fbbd: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return ret;
+        }, arguments); },
         __wbg_prototypesetcall_3e05eb9545565046: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
-        __wbg_push_6bdbc990be5ac37b: function(arg0, arg1) {
-            const ret = arg0.push(arg1);
-            return ret;
-        },
         __wbg_queueMicrotask_abaf92f0bd4e80a4: function(arg0) {
             const ret = arg0.queueMicrotask;
             return ret;
@@ -418,26 +409,31 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 152, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 157, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h9f53f643b01d7c8e);
             return ret;
         },
-        __wbindgen_cast_0000000000000002: function(arg0) {
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 78, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h25554e005bd8517d);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000003: function(arg0) {
+        __wbindgen_cast_0000000000000004: function(arg0) {
             // Cast intrinsic for `I64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000005: function(arg0) {
+        __wbindgen_cast_0000000000000006: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return ret;
@@ -458,6 +454,10 @@ function __wbg_get_imports() {
     };
 }
 
+function wasm_bindgen__convert__closures_____invoke__h25554e005bd8517d(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h25554e005bd8517d(arg0, arg1, arg2);
+}
+
 function wasm_bindgen__convert__closures_____invoke__h9f53f643b01d7c8e(arg0, arg1, arg2) {
     const ret = wasm.wasm_bindgen__convert__closures_____invoke__h9f53f643b01d7c8e(arg0, arg1, arg2);
     if (ret[1]) {

package/pkg/simple_agents_wasm_bg.wasm.d.ts

@@ -3,7 +3,6 @@
 export const memory: WebAssembly.Memory;
 export const __wbg_wasmclient_free: (a: number, b: number) => void;
 export const supportsRustWasm: () => number;
-export const toJsArray: (a: any) => any;
 export const wasmclient_complete: (a: number, b: number, c: number, d: any, e: number) => any;
 export const wasmclient_new: (a: number, b: number, c: any) => [number, number, number];
 export const wasmclient_runWorkflowYaml: (a: number, b: number, c: number, d: any) => [number, number, number];
@@ -12,6 +11,7 @@ export const wasmclient_runYamlString: (a: number, b: number, c: number, d: any,
 export const wasmclient_streamEvents: (a: number, b: number, c: number, d: any, e: any, f: number) => any;
 export const wasm_bindgen__convert__closures_____invoke__h9f53f643b01d7c8e: (a: number, b: number, c: any) => [number, number];
 export const wasm_bindgen__convert__closures_____invoke__h05acb8c479b21d4b: (a: number, b: number, c: any, d: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h25554e005bd8517d: (a: number, b: number, c: any) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

package/runtime/rust-runtime.js

@@ -1,16 +1,34 @@
 let rustModulePromise;
 
+function isNodeRuntime() {
+  return typeof process !== "undefined" && Boolean(process.versions?.node);
+}
+
 export async function loadRustModule() {
   if (!rustModulePromise) {
     rustModulePromise = (async () => {
       try {
         const moduleValue = await import("../pkg/simple_agents_wasm.js");
         const wasmUrl = new URL("../pkg/simple_agents_wasm_bg.wasm", import.meta.url);
-        await moduleValue.default({ module_or_path: wasmUrl });
+        let initArg;
+        if (isNodeRuntime()) {
+          const [{ readFile }, { fileURLToPath }] = await Promise.all([
+            import("node:fs/promises"),
+            import("node:url")
+          ]);
+          initArg = { module_or_path: await readFile(fileURLToPath(wasmUrl)) };
+        } else {
+          initArg = { module_or_path: wasmUrl };
+        }
+        await moduleValue.default(initArg);
         return moduleValue;
       } catch (error) {
-        console.debug("[simple-agents-wasm] Rust module unavailable, falling back to JS runtime", error);
-        return null;
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(
+          `[simple-agents-wasm] Failed to load Rust WASM backend. ` +
+          `Build artifacts are required (run "npm run build" in bindings/wasm/simple-agents-wasm). ` +
+          `Original error: ${reason}`
+        );
       }
     })();
   }

package/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "simple-agents-wasm-rust"
-version = "0.3.6"
+version = "0.3.8"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 

package/rust/src/lib.rs

@@ -1,7 +1,9 @@
 use js_sys::{Array, Function, Object, Promise, Reflect};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Map as JsonMap, Value as JsonValue};
+use std::cell::RefCell;
 use std::collections::HashMap;
+use wasm_bindgen::closure::Closure;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsCast;
 use wasm_bindgen_futures::JsFuture;
@@ -86,6 +88,7 @@ struct WorkflowDoc {
 
 #[derive(Deserialize, Clone)]
 struct GraphWorkflowDoc {
+    id: Option<String>,
     model: Option<String>,
     entry_node: String,
     nodes: Vec<GraphWorkflowNode>,
@@ -125,6 +128,7 @@ struct GraphLlmCall {
     temperature: Option<f64>,
     messages_path: Option<String>,
     append_prompt_as_user: Option<bool>,
+    stream: Option<bool>,
 }
 
 #[derive(Deserialize, Clone)]
@@ -271,6 +275,29 @@ struct WorkflowRunOptions {
     trace: Option<JsonValue>,
     #[serde(skip)]
     functions_js: Option<JsValue>,
+    #[serde(skip)]
+    on_event_js: Option<Function>,
+    /// Injected by JS as `__fetchImpl` so HTTP calls use the same fetch as tests (no global race).
+    #[serde(skip)]
+    fetch_js: Option<JsValue>,
+}
+
+struct FetchOverrideGuard<'a> {
+    cell: &'a RefCell<Option<JsValue>>,
+    previous: Option<JsValue>,
+}
+
+impl<'a> FetchOverrideGuard<'a> {
+    fn new(cell: &'a RefCell<Option<JsValue>>, value: Option<JsValue>) -> Self {
+        let previous = cell.replace(value);
+        Self { cell, previous }
+    }
+}
+
+impl Drop for FetchOverrideGuard<'_> {
+    fn drop(&mut self) {
+        self.cell.replace(self.previous.take());
+    }
 }
 
 fn js_error(message: impl Into<String>) -> JsValue {
@@ -289,6 +316,24 @@ fn config_error(message: impl Into<String>) -> JsValue {
     .into()
 }
 
+/// Plain objects for JS `Function.call` / stream callbacks. `serde_wasm_bindgen::to_value`
+/// can yield empty externref objects in Node for callback arguments; `JSON.parse` matches browser behavior.
+fn json_value_to_js_plain(value: &JsonValue) -> Result<JsValue, JsValue> {
+    let s =
+        serde_json::to_string(value).map_err(|_| js_error("failed to serialize value for JS"))?;
+    js_sys::JSON::parse(&s).map_err(|_| js_error("failed to parse JSON for JS"))
+}
+
+fn emit_workflow_event(on_event: &Option<Function>, event: JsonValue) -> Result<(), JsValue> {
+    if let Some(callback) = on_event {
+        let event_js = json_value_to_js_plain(&event)?;
+        callback
+            .call1(&JsValue::NULL, &event_js)
+            .map_err(|_| js_error("failed to call workflow stream callback"))?;
+    }
+    Ok(())
+}
+
 fn now_millis() -> f64 {
     let global = js_sys::global();
     let performance = Reflect::get(&global, &JsValue::from_str("performance")).ok();
@@ -463,13 +508,23 @@ fn call_method2_sync(
 }
 
 async fn js_fetch(
+    fetch_override: Option<JsValue>,
     url: &str,
     body: &JsonValue,
     headers: &HashMap<String, String>,
 ) -> Result<JsValue, JsValue> {
     let global = js_sys::global();
-    let fetch_value = Reflect::get(&global, &JsValue::from_str("fetch"))
-        .map_err(|_| js_error("global fetch is unavailable"))?;
+    let fetch_value = if let Some(f) = fetch_override {
+        if f.is_function() {
+            f
+        } else {
+            Reflect::get(&global, &JsValue::from_str("fetch"))
+                .map_err(|_| js_error("global fetch is unavailable"))?
+        }
+    } else {
+        Reflect::get(&global, &JsValue::from_str("fetch"))
+            .map_err(|_| js_error("global fetch is unavailable"))?
+    };
     let fetch_fn = fetch_value
         .dyn_into::<Function>()
         .map_err(|_| js_error("global fetch is not callable"))?;
@@ -985,6 +1040,7 @@ pub struct WasmClient {
     base_url: String,
     api_key: String,
     headers: HashMap<String, String>,
+    fetch_override: RefCell<Option<JsValue>>,
 }
 
 #[wasm_bindgen]
@@ -1013,6 +1069,7 @@ impl WasmClient {
             base_url: normalize_base_url(&base),
             api_key: parsed.api_key,
             headers: parsed.headers.unwrap_or_default(),
+            fetch_override: RefCell::new(None),
         })
     }
 
@@ -1066,7 +1123,9 @@ impl WasmClient {
                 .or_insert_with(|| "https://simpleagents.dev".to_string());
         }
 
+        let fetch_override = self.fetch_override.borrow().clone();
         let response = js_fetch(
+            fetch_override,
             &format!("{}/chat/completions", self.base_url),
             &body,
             &headers,
@@ -1235,7 +1294,9 @@ impl WasmClient {
                 .or_insert_with(|| "https://simpleagents.dev".to_string());
         }
 
+        let fetch_override = self.fetch_override.borrow().clone();
         let response = js_fetch(
+            fetch_override,
             &format!("{}/chat/completions", self.base_url),
             &body,
             &headers,
@@ -1260,8 +1321,7 @@ impl WasmClient {
                 "eventType": "error",
                 "error": { "message": message }
             });
-            let event_js = serde_wasm_bindgen::to_value(&err_event)
-                .map_err(|_| js_error("failed to serialize stream error event"))?;
+            let event_js = json_value_to_js_plain(&err_event)?;
             on_event
                 .call1(&JsValue::NULL, &event_js)
                 .map_err(|_| js_error("failed to call stream callback"))?;
@@ -1337,8 +1397,7 @@ impl WasmClient {
                     "raw": data,
                 }
             });
-            let event_js = serde_wasm_bindgen::to_value(&delta_event)
-                .map_err(|_| js_error("failed to serialize stream delta event"))?;
+            let event_js = json_value_to_js_plain(&delta_event)?;
             on_event
                 .call1(&JsValue::NULL, &event_js)
                 .map_err(|_| js_error("failed to call stream callback"))?;
@@ -1348,8 +1407,7 @@ impl WasmClient {
         .await?;
 
         let done_event = json!({ "eventType": "done" });
-        let done_js = serde_wasm_bindgen::to_value(&done_event)
-            .map_err(|_| js_error("failed to serialize stream done event"))?;
+        let done_js = json_value_to_js_plain(&done_event)?;
         on_event
             .call1(&JsValue::NULL, &done_js)
             .map_err(|_| js_error("failed to call stream callback"))?;
@@ -1396,14 +1454,34 @@ impl WasmClient {
             telemetry: None,
             trace: None,
             functions_js: None,
+            on_event_js: None,
+            fetch_js: None,
         };
         if let Some(options_js) = workflow_options {
             options = serde_wasm_bindgen::from_value(options_js.clone())
                 .map_err(|_| config_error("invalid workflowOptions object"))?;
             let functions_value = Reflect::get(&options_js, &JsValue::from_str("functions")).ok();
-            options.functions_js = functions_value;
+            options.functions_js = functions_value.and_then(|v| {
+                if v.is_undefined() || v.is_null() {
+                    None
+                } else {
+                    Some(v)
+                }
+            });
+            let on_event_value = Reflect::get(&options_js, &JsValue::from_str("onEvent")).ok();
+            options.on_event_js = on_event_value.and_then(|v| {
+                if v.is_undefined() || v.is_null() {
+                    None
+                } else {
+                    v.dyn_into::<Function>().ok()
+                }
+            });
+            let fetch_js = Reflect::get(&options_js, &JsValue::from_str("__fetchImpl")).ok();
+            options.fetch_js = fetch_js;
         }
 
+        let _fetch_guard = FetchOverrideGuard::new(&self.fetch_override, options.fetch_js.clone());
+
         if raw_doc.get("entry_node").is_some() && raw_doc.get("nodes").is_some() {
             let graph_doc: GraphWorkflowDoc = serde_json::from_value(raw_doc.clone())
                 .map_err(|error| config_error(format!("invalid graph workflow YAML: {error}")))?;
@@ -1445,6 +1523,14 @@ impl WasmClient {
             let total_reasoning_tokens: u64 = 0;
             let mut llm_nodes_without_usage: Vec<String> = Vec::new();
 
+            emit_workflow_event(
+                &options.on_event_js,
+                json!({
+                    "event_type": "workflow_started",
+                    "workflow_id": graph_doc.id.clone().unwrap_or_else(|| "wasm_workflow".to_string())
+                }),
+            )?;
+
             while !pointer.is_empty() {
                 iterations += 1;
                 if iterations > 1000 {
@@ -1519,24 +1605,74 @@ impl WasmClient {
                                 tool_calls: None,
                             });
                         }
-                        serde_wasm_bindgen::to_value(&history)
-                            .map_err(|_| js_error("failed to serialize graph llm messages"))?
+                        json_value_to_js_plain(
+                            &serde_json::to_value(&history)
+                                .map_err(|_| js_error("failed to serialize graph llm messages"))?,
+                        )?
                     } else {
                         JsValue::from_str(&prompt)
                     };
 
                     let opts = json!({ "temperature": llm.temperature });
-                    let completion_js = self
-                        .complete(
-                            model,
-                            prompt_js,
-                            Some(
-                                serde_wasm_bindgen::to_value(&opts).map_err(|_| {
-                                    js_error("failed to serialize completion options")
-                                })?,
-                            ),
-                        )
-                        .await?;
+                    let completion_js = if llm.stream.unwrap_or(false) && options.on_event_js.is_some() {
+                        let node_id = node.id.clone();
+                        let step_id = node.id.clone();
+                        let workflow_on_event = options
+                            .on_event_js
+                            .clone()
+                            .ok_or_else(|| js_error("missing workflow stream callback"))?;
+                        let mapped_stream_cb = Closure::wrap(Box::new(move |stream_event_js: JsValue| {
+                            let stream_event: JsonValue =
+                                serde_wasm_bindgen::from_value(stream_event_js).unwrap_or(JsonValue::Null);
+                            let stream_event_type = stream_event
+                                .get("eventType")
+                                .and_then(JsonValue::as_str)
+                                .unwrap_or_default();
+
+                            if stream_event_type == "delta" {
+                                if let Some(delta) = stream_event
+                                    .get("delta")
+                                    .and_then(|v| v.get("content"))
+                                    .and_then(JsonValue::as_str)
+                                {
+                                    let workflow_event = json!({
+                                        "event_type": "node_stream_delta",
+                                        "node_id": node_id.clone(),
+                                        "step_id": step_id.clone(),
+                                        "delta": delta
+                                    });
+                                    if let Ok(event_js) = json_value_to_js_plain(&workflow_event) {
+                                        let _ = workflow_on_event.call1(&JsValue::NULL, &event_js);
+                                    }
+                                }
+                            } else if stream_event_type == "done" {
+                                let workflow_event = json!({
+                                    "event_type": "node_stream_snapshot",
+                                    "node_id": node_id.clone(),
+                                    "step_id": step_id.clone(),
+                                    "metadata": { "is_complete": true }
+                                });
+                                if let Ok(event_js) = json_value_to_js_plain(&workflow_event) {
+                                    let _ = workflow_on_event.call1(&JsValue::NULL, &event_js);
+                                }
+                            }
+                        }) as Box<dyn FnMut(JsValue)>);
+                        let stream_callback_fn: Function =
+                            mapped_stream_cb.as_ref().unchecked_ref::<Function>().clone();
+                        let result = self
+                            .stream_events(
+                                model,
+                                prompt_js,
+                                stream_callback_fn,
+                                Some(json_value_to_js_plain(&opts)?),
+                            )
+                            .await;
+                        drop(mapped_stream_cb);
+                        result?
+                    } else {
+                        self.complete(model, prompt_js, Some(json_value_to_js_plain(&opts)?))
+                            .await?
+                    };
                     let completion: JsonValue = serde_wasm_bindgen::from_value(completion_js)
                         .map_err(|_| js_error("failed to parse completion result"))?;
 
@@ -1630,17 +1766,23 @@ impl WasmClient {
                         .unwrap_or_else(|| handler.clone());
                     let functions_js = options.functions_js.clone().ok_or_else(|| {
                         config_error(format!(
-                            "custom_worker node '{}' requires workflowOptions.functions",
-                            node.id
+                            "custom_worker node '{}' requires workflowOptions.functions['{}']",
+                            node.id, lookup_key
                         ))
                     })?;
                     let function_value = Reflect::get(&functions_js, &JsValue::from_str(&lookup_key))
                         .map_err(|_| {
                             config_error(format!(
-                                "failed to resolve custom worker handler key '{}' from workflowOptions.functions",
-                                lookup_key
+                                "custom_worker node '{}' requires workflowOptions.functions['{}']",
+                                node.id, lookup_key
                             ))
                         })?;
+                    if function_value.is_undefined() || function_value.is_null() {
+                        return Err(config_error(format!(
+                            "custom_worker node '{}' requires workflowOptions.functions['{}']",
+                            node.id, lookup_key
+                        )));
+                    }
                     let function = function_value.dyn_into::<Function>().map_err(|_| {
                         config_error(format!(
                             "custom_worker node '{}' requires workflowOptions.functions['{}']",
@@ -1660,10 +1802,8 @@ impl WasmClient {
                             .unwrap_or(JsonValue::Null),
                         "nodeId": node.id.clone()
                     });
-                    let args_js = serde_wasm_bindgen::to_value(&worker_args)
-                        .map_err(|_| js_error("failed to serialize custom_worker args"))?;
-                    let context_js = serde_wasm_bindgen::to_value(&graph_context)
-                        .map_err(|_| js_error("failed to serialize graph context"))?;
+                    let args_js = json_value_to_js_plain(&worker_args)?;
+                    let context_js = json_value_to_js_plain(&graph_context)?;
                     let worker_call_output = function
                         .call2(&JsValue::NULL, &args_js, &context_js)
                         .map_err(|_| {
@@ -1741,6 +1881,17 @@ impl WasmClient {
                 trace.push(node.id.clone());
             }
 
+            emit_workflow_event(
+                &options.on_event_js,
+                json!({
+                    "event_type": "workflow_completed",
+                    "workflow_id": raw_doc
+                        .get("id")
+                        .and_then(JsonValue::as_str)
+                        .unwrap_or("wasm_workflow")
+                }),
+            )?;
+
             let total_elapsed_ms = (now_millis() - workflow_started).max(0.0) as u64;
             let terminal_node = trace.last().cloned().unwrap_or_default();
             let workflow_id = raw_doc
@@ -1814,8 +1965,9 @@ impl WasmClient {
                 trace_id: None,
                 metadata: Some(json!({"nerdstats": nerdstats})),
             };
-            return serde_wasm_bindgen::to_value(&result)
-                .map_err(|_| js_error("failed to serialize workflow result"));
+            let jv = serde_json::to_value(&result)
+                .map_err(|_| js_error("failed to serialize workflow result"))?;
+            return json_value_to_js_plain(&jv);
         }
 
         let doc: WorkflowDoc = serde_json::from_value(raw_doc)
@@ -1885,11 +2037,7 @@ impl WasmClient {
                         .complete(
                             model,
                             JsValue::from_str(&prompt),
-                            Some(
-                                serde_wasm_bindgen::to_value(&opts).map_err(|_| {
-                                    js_error("failed to serialize completion options")
-                                })?,
-                            ),
+                            Some(json_value_to_js_plain(&opts)?),
                         )
                         .await?;
                     let completion: JsonValue = serde_wasm_bindgen::from_value(completion_js)
@@ -1956,11 +2104,8 @@ impl WasmClient {
                             .unwrap_or_else(|| JsonValue::Object(JsonMap::new())),
                         &context,
                     );
-                    let args_js = serde_wasm_bindgen::to_value(&args_value)
-                        .map_err(|_| js_error("failed to serialize call_function args"))?;
-                    let context_js =
-                        serde_wasm_bindgen::to_value(&JsonValue::Object(context.clone()))
-                            .map_err(|_| js_error("failed to serialize workflow context"))?;
+                    let args_js = json_value_to_js_plain(&args_value)?;
+                    let context_js = json_value_to_js_plain(&JsonValue::Object(context.clone()))?;
                     let call_output = function
                         .call2(&JsValue::NULL, &args_js, &context_js)
                         .map_err(|_| {
@@ -2017,18 +2162,32 @@ impl WasmClient {
             pointer += 1;
         }
 
+        let trace: Vec<String> = events
+            .iter()
+            .filter(|e| e.status == "completed")
+            .map(|e| e.step_id.clone())
+            .collect();
+        let terminal_node = trace.last().cloned();
+
+        let context_value = JsonValue::Object(context);
+        let outputs_value = context_value
+            .as_object()
+            .cloned()
+            .map(JsonValue::Object)
+            .unwrap_or_else(|| JsonValue::Object(JsonMap::new()));
+
         let result = WorkflowRunResult {
             status: "ok".to_string(),
-            context: JsonValue::Object(context),
-            output,
+            context: context_value.clone(),
+            output: output.clone(),
             events,
-            workflow_id: None,
+            workflow_id: Some("wasm_workflow".to_string()),
             entry_node: None,
             email_text: None,
-            trace: None,
-            outputs: None,
-            terminal_node: None,
-            terminal_output: None,
+            trace: Some(trace),
+            outputs: Some(outputs_value),
+            terminal_node,
+            terminal_output: output,
             step_timings: None,
             total_elapsed_ms: None,
             ttft_ms: None,
@@ -2040,8 +2199,9 @@ impl WasmClient {
             trace_id: None,
             metadata: None,
         };
-        serde_wasm_bindgen::to_value(&result)
-            .map_err(|_| js_error("failed to serialize workflow result"))
+        let jv = serde_json::to_value(&result)
+            .map_err(|_| js_error("failed to serialize workflow result"))?;
+        json_value_to_js_plain(&jv)
     }
 
     #[wasm_bindgen(js_name = runWorkflowYaml)]
@@ -2080,8 +2240,7 @@ impl WasmClient {
             serde_json::json!([])
         };
 
-        let input_js = serde_wasm_bindgen::to_value(&serde_json::json!({ "messages": messages_value }))
-            .map_err(|_| js_error("failed to serialize messages input"))?;
+        let input_js = json_value_to_js_plain(&serde_json::json!({ "messages": messages_value }))?;
 
         self.run_workflow_yaml_string(yaml_text, input_js, options).await
     }
@@ -2091,10 +2250,3 @@ impl WasmClient {
 pub fn supports_rust_wasm() -> bool {
     true
 }
-
-#[wasm_bindgen(js_name = toJsArray)]
-pub fn to_js_array(value: JsValue) -> Array {
-    let arr = Array::new();
-    arr.push(&value);
-    arr
-}