simple-agents-wasm 0.2.30 → 0.2.32

package/index.d.ts

@@ -103,6 +103,7 @@ export interface ClientConfig {
 export interface WorkflowRunOptions {
   telemetry?: Record<string, unknown>;
   trace?: Record<string, unknown>;
+  onEvent?: (event: Record<string, unknown>) => void;
   functions?: Record<
     string,
     (

package/index.js

@@ -62,10 +62,175 @@ function toToolCalls(toolCalls) {
     }));
 }
 
+function createStreamEventBridge(model, onChunk) {
+  let aggregate = "";
+  let finalId = "";
+  let finalModel = model;
+  let finalFinishReason;
+
+  return {
+    onEvent(event) {
+      if (event.eventType === "delta") {
+        const delta = event.delta;
+        if (!delta) {
+          return;
+        }
+
+        if (!finalId && delta.id) {
+          finalId = delta.id;
+        }
+        if (delta.model) {
+          finalModel = delta.model;
+        }
+        if (delta.content) {
+          aggregate += delta.content;
+        }
+        if (delta.finishReason) {
+          finalFinishReason = delta.finishReason;
+        }
+
+        onChunk({
+          id: delta.id,
+          model: delta.model,
+          content: delta.content,
+          finishReason: delta.finishReason,
+          raw: delta.raw
+        });
+      }
+
+      if (event.eventType === "error") {
+        onChunk({
+          id: finalId || "error",
+          model: finalModel,
+          error: event.error?.message ?? "stream error"
+        });
+      }
+    },
+    mergeResult(result, started) {
+      return {
+        ...result,
+        id: result.id || finalId,
+        model: result.model || finalModel,
+        content: result.content ?? aggregate,
+        finishReason: result.finishReason ?? finalFinishReason,
+        latencyMs: Math.max(0, Math.round(performance.now() - started))
+      };
+    }
+  };
+}
+
+function assertWorkflowResultShape(result) {
+  if (result === null || typeof result !== "object") {
+    throw runtimeError(
+      "workflow result contract mismatch: expected an object with workflow_id and outputs"
+    );
+  }
+
+  if (!("workflow_id" in result) || !("outputs" in result)) {
+    throw runtimeError(
+      "workflow result contract mismatch: expected keys 'workflow_id' and 'outputs'"
+    );
+  }
+
+  return result;
+}
+
+function normalizeWorkflowResult(result) {
+  if (result === null || typeof result !== "object") {
+    return result;
+  }
+  if ("workflow_id" in result && "outputs" in result) {
+    return result;
+  }
+  if (!("context" in result) || !result.context || typeof result.context !== "object") {
+    return result;
+  }
+
+  const context = result.context;
+  const nodeOutputs =
+    context && typeof context === "object" && context.nodes && typeof context.nodes === "object"
+      ? context.nodes
+      : context;
+  const trace = Array.isArray(result.events)
+    ? result.events
+        .filter((event) => event && event.status === "completed" && typeof event.stepId === "string")
+        .map((event) => event.stepId)
+    : [];
+  const terminalNode = trace.at(-1) ?? "";
+
+  return {
+    workflow_id: typeof result.workflow_id === "string" ? result.workflow_id : "wasm_workflow",
+    entry_node: typeof result.entry_node === "string" ? result.entry_node : trace[0] ?? "",
+    email_text: typeof context?.input?.email_text === "string" ? context.input.email_text : "",
+    trace,
+    outputs: nodeOutputs,
+    terminal_node: typeof result.terminal_node === "string" ? result.terminal_node : terminalNode,
+    terminal_output: result.output,
+    events: Array.isArray(result.events) ? result.events : [],
+    status: typeof result.status === "string" ? result.status : "ok"
+  };
+}
+
 function normalizeBaseUrl(baseUrl) {
   return baseUrl.replace(/\/$/, "");
 }
 
+function finiteNumberOrNull(value) {
+  return Number.isFinite(value) ? value : null;
+}
+
+function buildStepDetail(step) {
+  const detail = {
+    elapsed_ms: step.elapsedMs,
+    node_id: step.nodeId,
+    node_kind: step.nodeKind
+  };
+
+  if (step.nodeKind === "llm_call") {
+    if (typeof step.modelName === "string") {
+      detail.model_name = step.modelName;
+    }
+    const promptTokens = finiteNumberOrNull(step.promptTokens);
+    if (promptTokens !== null) {
+      detail.prompt_tokens = promptTokens;
+    }
+    const completionTokens = finiteNumberOrNull(step.completionTokens);
+    if (completionTokens !== null) {
+      detail.completion_tokens = completionTokens;
+    }
+    const totalTokens = finiteNumberOrNull(step.totalTokens);
+    if (totalTokens !== null) {
+      detail.total_tokens = totalTokens;
+    }
+    detail.reasoning_tokens = 0;
+    const tokensPerSecond = finiteNumberOrNull(step.tokensPerSecond);
+    if (tokensPerSecond !== null) {
+      detail.tokens_per_second = tokensPerSecond;
+    }
+  }
+
+  return detail;
+}
+
+function buildWorkflowNerdstats(summary) {
+  return {
+    workflow_id: summary.workflowId,
+    terminal_node: summary.terminalNode,
+    total_elapsed_ms: summary.totalElapsedMs,
+    ttft_ms: summary.ttftMs,
+    step_details: summary.stepDetails,
+    total_input_tokens: summary.totalInputTokens,
+    total_output_tokens: summary.totalOutputTokens,
+    total_tokens: summary.totalTokens,
+    total_reasoning_tokens: summary.totalReasoningTokens,
+    tokens_per_second: summary.tokensPerSecond,
+    trace_id: summary.traceId,
+    token_metrics_available: summary.tokenMetricsAvailable,
+    token_metrics_source: summary.tokenMetricsSource,
+    llm_nodes_without_usage: summary.llmNodesWithoutUsage
+  };
+}
+
 function interpolate(value, context) {
   if (typeof value === "string") {
     return value.replace(/{{\s*([^}]+)\s*}}/g, (_, key) => {
@@ -179,6 +344,35 @@ function interpolatePathTemplate(template, context) {
   });
 }
 
+function interpolatePathValue(value, context) {
+  if (typeof value === "string") {
+    return value.replace(/{{\s*([^}]+)\s*}}/g, (_, token) => {
+      const resolved = getPathValue(context, token);
+      if (resolved === null || resolved === undefined) {
+        return "";
+      }
+      if (typeof resolved === "string") {
+        return resolved;
+      }
+      return JSON.stringify(resolved);
+    });
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((entry) => interpolatePathValue(entry, context));
+  }
+
+  if (value !== null && value !== undefined && typeof value === "object") {
+    const output = {};
+    for (const [key, nested] of Object.entries(value)) {
+      output[key] = interpolatePathValue(nested, context);
+    }
+    return output;
+  }
+
+  return value;
+}
+
 function maybeParseJson(text) {
   if (typeof text !== "string") {
     return text;
@@ -584,63 +778,17 @@ class BrowserJsClient {
       throw configError("onChunk callback is required");
     }
 
-    let aggregate = "";
-    let finalId = "";
-    let finalModel = model;
-    let finalFinishReason;
     const started = performance.now();
+    const streamBridge = createStreamEventBridge(model, onChunk);
 
     const result = await this.streamEvents(
       model,
       promptOrMessages,
-      (event) => {
-        if (event.eventType === "delta") {
-          const delta = event.delta;
-          if (!delta) {
-            return;
-          }
-
-          if (delta.id && finalId.length === 0) {
-            finalId = delta.id;
-          }
-          if (delta.model) {
-            finalModel = delta.model;
-          }
-          if (delta.content) {
-            aggregate += delta.content;
-          }
-          if (delta.finishReason) {
-            finalFinishReason = delta.finishReason;
-          }
-
-          onChunk({
-            id: delta.id,
-            model: delta.model,
-            content: delta.content,
-            finishReason: delta.finishReason,
-            raw: delta.raw
-          });
-        }
-
-        if (event.eventType === "error") {
-          onChunk({
-            id: finalId || "error",
-            model: finalModel,
-            error: event.error?.message ?? "stream error"
-          });
-        }
-      },
+      (event) => streamBridge.onEvent(event),
       options
     );
 
-    return {
-      ...result,
-      id: result.id || finalId,
-      model: result.model || finalModel,
-      content: result.content ?? aggregate,
-      finishReason: result.finishReason ?? finalFinishReason,
-      latencyMs: Math.max(0, Math.round(performance.now() - started))
-    };
+    return streamBridge.mergeResult(result, started);
   }
 
   async streamEvents(model, promptOrMessages, onEvent, options = {}) {
@@ -665,7 +813,10 @@ class BrowserJsClient {
         max_tokens: options.maxTokens,
         temperature: options.temperature,
         top_p: options.topP,
-        stream: true
+        stream: true,
+        stream_options: {
+          include_usage: true
+        }
       })
     });
 
@@ -682,6 +833,12 @@ class BrowserJsClient {
     let responseModel = model;
     let aggregate = "";
     let finishReason;
+    let usage = {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0
+    };
+    let usageAvailable = false;
 
     try {
       for await (const block of iterateSse(response)) {
@@ -722,6 +879,10 @@ class BrowserJsClient {
         if (delta.finishReason) {
           finishReason = delta.finishReason;
         }
+        if (chunk?.usage && typeof chunk.usage === "object") {
+          usage = toUsage(chunk.usage);
+          usageAvailable = true;
+        }
 
         onEvent({ eventType: "delta", delta });
       }
@@ -742,11 +903,9 @@ class BrowserJsClient {
       content: aggregate,
       finishReason,
       usage: {
-        promptTokens: 0,
-        completionTokens: 0,
-        totalTokens: 0
+        ...usage
       },
-      usageAvailable: false,
+      usageAvailable,
       latencyMs,
       raw: undefined,
       healed: undefined,
@@ -797,9 +956,17 @@ class BrowserJsClient {
         nodes: {}
       };
 
+      const workflowStarted = performance.now();
+      let workflowTtftMs = 0;
       let pointer = doc.entry_node;
       let output;
       let iterations = 0;
+      const stepDetails = [];
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      let totalTokens = 0;
+      const totalReasoningTokens = 0;
+      const llmNodesWithoutUsage = [];
 
       while (typeof pointer === "string" && pointer.length > 0) {
         iterations += 1;
@@ -814,6 +981,11 @@ class BrowserJsClient {
 
         const nodeType = node.node_type ?? {};
         const nodeTypeName = Object.keys(nodeType)[0] ?? "unknown";
+        const nodeStarted = performance.now();
+        let stepModelName;
+        let stepPromptTokens;
+        let stepCompletionTokens;
+        let stepTotalTokens;
         events.push({ stepId: node.id, stepType: nodeTypeName, status: "started" });
 
         if (nodeType.llm_call) {
@@ -845,10 +1017,57 @@ class BrowserJsClient {
             promptOrMessages = history;
           }
 
-          const completion = await this.complete(model, promptOrMessages, {
-            temperature: llm.temperature
-          });
-          const parsedOutput = maybeParseJson(completion.content ?? "");
+          let rawContent = "";
+          let completion;
+          if (llm.stream === true) {
+            completion = await this.streamEvents(
+              model,
+              promptOrMessages,
+              (event) => {
+                if (event && event.eventType === "delta" && typeof event.delta?.content === "string") {
+                  if (workflowTtftMs === 0) {
+                    const measured = Math.max(0, Math.round(performance.now() - workflowStarted));
+                    workflowTtftMs = measured === 0 ? 1 : measured;
+                  }
+                  rawContent += event.delta.content;
+                  if (typeof workflowOptions?.onEvent === "function") {
+                    workflowOptions.onEvent({
+                      eventType: "node_stream_delta",
+                      nodeId: node.id,
+                      delta: event.delta.content,
+                      model: event.delta.model ?? model
+                    });
+                  }
+                }
+              },
+              {
+                temperature: llm.temperature
+              }
+            );
+            rawContent = completion.content ?? rawContent;
+          } else {
+            completion = await this.complete(model, promptOrMessages, {
+              temperature: llm.temperature
+            });
+            rawContent = completion.content ?? "";
+          }
+
+          stepModelName = completion?.model ?? model;
+          if (completion?.usageAvailable === true && completion?.usage && typeof completion.usage === "object") {
+            const usage = completion.usage;
+            stepPromptTokens = Number.isFinite(usage.promptTokens) ? usage.promptTokens : 0;
+            stepCompletionTokens = Number.isFinite(usage.completionTokens)
+              ? usage.completionTokens
+              : 0;
+            stepTotalTokens = Number.isFinite(usage.totalTokens) ? usage.totalTokens : 0;
+            totalInputTokens += stepPromptTokens;
+            totalOutputTokens += stepCompletionTokens;
+            totalTokens += stepTotalTokens;
+          } else {
+            llmNodesWithoutUsage.push(node.id);
+          }
+
+          const parsedOutput = maybeParseJson(rawContent);
           const validationError = schemaValidationError(llmOutputSchema(node), parsedOutput);
           if (validationError !== null) {
             throw runtimeError(
@@ -857,7 +1076,7 @@ class BrowserJsClient {
           }
           graphContext.nodes[node.id] = {
             output: parsedOutput,
-            raw: completion.content ?? ""
+            raw: rawContent
           };
           output = parsedOutput;
 
@@ -872,16 +1091,23 @@ class BrowserJsClient {
           pointer = matched?.target ?? switchSpec.default ?? "";
         } else if (nodeType.custom_worker) {
           const handler = nodeType.custom_worker.handler ?? "custom_worker";
-          const fn = functions[handler];
+          const handlerFile = nodeType.custom_worker.handler_file;
+          const lookupKey =
+            typeof handlerFile === "string" && handlerFile.length > 0
+              ? `${handlerFile}#${handler}`
+              : handler;
+          const fn = functions[lookupKey];
           if (typeof fn !== "function") {
             throw runtimeError(
-              `custom_worker node '${node.id}' requires workflowOptions.functions['${handler}']`
+              `custom_worker node '${node.id}' requires workflowOptions.functions['${lookupKey}']`
             );
           }
           const workerOutput = await fn(
             {
               handler,
-              payload: node.config?.payload ?? null,
+              handler_file: handlerFile,
+              handler_lookup_key: lookupKey,
+              payload: interpolatePathValue(node.config?.payload ?? null, graphContext),
               nodeId: node.id
             },
             graphContext
@@ -897,13 +1123,92 @@ class BrowserJsClient {
         }
 
         events.push({ stepId: node.id, stepType: nodeTypeName, status: "completed" });
+        const elapsedMs = Math.max(0, Math.round(performance.now() - nodeStarted));
+        const stepTokensPerSecond =
+          Number.isFinite(stepCompletionTokens) && elapsedMs > 0
+            ? Math.round((stepCompletionTokens / (elapsedMs / 1000)) * 100) / 100
+            : null;
+        stepDetails.push(
+          buildStepDetail({
+            nodeId: node.id,
+            nodeKind: nodeTypeName,
+            modelName: stepModelName,
+            elapsedMs,
+            promptTokens: stepPromptTokens,
+            completionTokens: stepCompletionTokens,
+            totalTokens: stepTotalTokens,
+            tokensPerSecond: stepTokensPerSecond
+          })
+        );
+      }
+
+      const trace = events
+        .filter((event) => event && event.status === "completed")
+        .map((event) => event.stepId);
+      const terminalNode = trace.at(-1) ?? "";
+      const totalElapsedMs = Math.max(0, Math.round(performance.now() - workflowStarted));
+      const tokenMetricsAvailable = llmNodesWithoutUsage.length === 0;
+      const overallTokensPerSecond =
+        totalElapsedMs > 0 ? Math.round((totalOutputTokens / (totalElapsedMs / 1000)) * 100) / 100 : 0;
+      const workflowId =
+        typeof doc.id === "string" && doc.id.length > 0 ? doc.id : "browser_js_workflow";
+      const nerdstats = buildWorkflowNerdstats({
+        workflowId,
+        terminalNode,
+        totalElapsedMs,
+        ttftMs: workflowTtftMs,
+        stepDetails,
+        totalInputTokens,
+        totalOutputTokens,
+        totalTokens,
+        totalReasoningTokens,
+        tokensPerSecond: overallTokensPerSecond,
+        traceId: "",
+        tokenMetricsAvailable,
+        tokenMetricsSource: tokenMetricsAvailable ? "provider_usage" : "unavailable",
+        llmNodesWithoutUsage
+      });
+      if (typeof workflowOptions?.onEvent === "function") {
+        workflowOptions.onEvent({
+          event_type: "workflow_completed",
+          metadata: {
+            nerdstats
+          }
+        });
+      }
+
+      const outputs = {};
+      for (const [nodeId, nodeValue] of Object.entries(graphContext.nodes ?? {})) {
+        if (nodeValue && typeof nodeValue === "object" && "output" in nodeValue) {
+          outputs[nodeId] = nodeValue.output;
+        } else {
+          outputs[nodeId] = nodeValue;
+        }
       }
 
       return {
-        status: "ok",
+        workflow_id: workflowId,
+        entry_node: doc.entry_node,
+        email_text: typeof graphContext.input?.email_text === "string" ? graphContext.input.email_text : "",
+        trace,
+        outputs,
+        terminal_node: terminalNode,
+        terminal_output: output,
+        step_timings: stepDetails,
+        total_elapsed_ms: totalElapsedMs,
+        ttft_ms: workflowTtftMs,
+        total_input_tokens: totalInputTokens,
+        total_output_tokens: totalOutputTokens,
+        total_tokens: totalTokens,
+        total_reasoning_tokens: totalReasoningTokens,
+        tokens_per_second: overallTokensPerSecond,
+        trace_id: "",
+        metadata: {
+          nerdstats
+        },
+        events,
         context: graphContext,
-        output,
-        events
+        status: "ok"
       };
     }
 
@@ -992,10 +1297,22 @@ class BrowserJsClient {
     }
 
     return {
-      status: "ok",
+      workflow_id:
+        typeof doc.id === "string" && doc.id.length > 0 ? doc.id : "browser_js_workflow",
+      entry_node: typeof doc.steps?.[0]?.id === "string" ? doc.steps[0].id : "",
+      email_text: typeof workflowInput?.email_text === "string" ? workflowInput.email_text : "",
+      trace: events
+        .filter((event) => event && event.status === "completed")
+        .map((event) => event.stepId),
+      outputs: { ...context },
+      terminal_node: events
+        .filter((event) => event && event.status === "completed")
+        .map((event) => event.stepId)
+        .at(-1) ?? "",
+      terminal_output: output,
+      events,
       context,
-      output,
-      events
+      status: "ok"
     };
   }
 
@@ -1014,7 +1331,7 @@ async function loadRustModule() {
       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(wasmUrl);
+        await moduleValue.default({ module_or_path: wasmUrl });
         return moduleValue;
       } catch {
         return null;
@@ -1079,56 +1396,17 @@ export class Client {
   async stream(model, promptOrMessages, onChunk, options = {}) {
     const rust = await this.ensureBackend();
     if (rust) {
-      let aggregate = "";
-      let finalId = "";
-      let finalModel = model;
-      let finalFinishReason;
       const started = performance.now();
+      const streamBridge = createStreamEventBridge(model, onChunk);
 
-      const result = await rust.streamEvents(model, promptOrMessages, (event) => {
-        if (event.eventType === "delta") {
-          const delta = event.delta;
-          if (!delta) {
-            return;
-          }
-          if (!finalId && delta.id) {
-            finalId = delta.id;
-          }
-          if (delta.model) {
-            finalModel = delta.model;
-          }
-          if (delta.content) {
-            aggregate += delta.content;
-          }
-          if (delta.finishReason) {
-            finalFinishReason = delta.finishReason;
-          }
-          onChunk({
-            id: delta.id,
-            model: delta.model,
-            content: delta.content,
-            finishReason: delta.finishReason,
-            raw: delta.raw
-          });
-        }
-
-        if (event.eventType === "error") {
-          onChunk({
-            id: finalId || "error",
-            model: finalModel,
-            error: event.error?.message ?? "stream error"
-          });
-        }
-      }, options);
+      const result = await rust.streamEvents(
+        model,
+        promptOrMessages,
+        (event) => streamBridge.onEvent(event),
+        options
+      );
 
-      return {
-        ...result,
-        id: result.id || finalId,
-        model: result.model || finalModel,
-        content: result.content ?? aggregate,
-        finishReason: result.finishReason ?? finalFinishReason,
-        latencyMs: Math.max(0, Math.round(performance.now() - started))
-      };
+      return streamBridge.mergeResult(result, started);
     }
 
     return this.fallbackClient.stream(model, promptOrMessages, onChunk, options);
@@ -1145,17 +1423,25 @@ export class Client {
   async runWorkflowYamlString(yamlText, workflowInput, workflowOptions) {
     const rust = await this.ensureBackend();
     if (rust) {
-      return rust.runWorkflowYamlString(yamlText, workflowInput, workflowOptions);
+      const result = await rust.runWorkflowYamlString(yamlText, workflowInput, workflowOptions);
+      return assertWorkflowResultShape(normalizeWorkflowResult(result));
     }
-    return this.fallbackClient.runWorkflowYamlString(yamlText, workflowInput, workflowOptions);
+    const result = await this.fallbackClient.runWorkflowYamlString(
+      yamlText,
+      workflowInput,
+      workflowOptions
+    );
+    return assertWorkflowResultShape(normalizeWorkflowResult(result));
   }
 
   async runWorkflowYaml(workflowPath, workflowInput) {
     const rust = await this.ensureBackend();
     if (rust) {
-      return rust.runWorkflowYaml(workflowPath, workflowInput);
+      const result = await rust.runWorkflowYaml(workflowPath, workflowInput);
+      return assertWorkflowResultShape(normalizeWorkflowResult(result));
     }
-    return this.fallbackClient.runWorkflowYaml(workflowPath, workflowInput);
+    const result = await this.fallbackClient.runWorkflowYaml(workflowPath, workflowInput);
+    return assertWorkflowResultShape(normalizeWorkflowResult(result));
   }
 }
 

package/package.json

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

package/pkg/simple_agents_wasm.d.ts

@@ -27,9 +27,9 @@ export interface InitOutput {
     readonly wasmclient_runWorkflowYaml: (a: number, b: number, c: number, d: any) => [number, number, number];
     readonly wasmclient_runWorkflowYamlString: (a: number, b: number, c: number, d: any, e: number) => any;
     readonly wasmclient_streamEvents: (a: number, b: number, c: number, d: any, e: any, f: number) => any;
-    readonly wasm_bindgen__closure__destroy__h5b569a9b0c99a6ce: (a: number, b: number) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__h26e23bd7929d5711: (a: number, b: number, c: any) => [number, number];
-    readonly wasm_bindgen__convert__closures_____invoke__h6589060427acb019: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__closure__destroy__haab24713ba6d07cd: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h0653cfab9850c2f3: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h133df7605c346924: (a: number, b: number, c: any, d: 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

@@ -314,7 +314,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h6589060427acb019(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h133df7605c346924(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -395,7 +395,7 @@ function __wbg_get_imports() {
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { dtor_idx: 106, function: Function { arguments: [Externref], shim_idx: 107, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h5b569a9b0c99a6ce, wasm_bindgen__convert__closures_____invoke__h26e23bd7929d5711);
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__haab24713ba6d07cd, wasm_bindgen__convert__closures_____invoke__h0653cfab9850c2f3);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -434,15 +434,15 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h26e23bd7929d5711(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h26e23bd7929d5711(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h0653cfab9850c2f3(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h0653cfab9850c2f3(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h6589060427acb019(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h6589060427acb019(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h133df7605c346924(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h133df7605c346924(arg0, arg1, arg2, arg3);
 }
 
 const WasmClientFinalization = (typeof FinalizationRegistry === 'undefined')

package/pkg/simple_agents_wasm_bg.wasm.d.ts

@@ -9,9 +9,9 @@ export const wasmclient_new: (a: number, b: number, c: any) => [number, number,
 export const wasmclient_runWorkflowYaml: (a: number, b: number, c: number, d: any) => [number, number, number];
 export const wasmclient_runWorkflowYamlString: (a: number, b: number, c: number, d: any, e: number) => any;
 export const wasmclient_streamEvents: (a: number, b: number, c: number, d: any, e: any, f: number) => any;
-export const wasm_bindgen__closure__destroy__h5b569a9b0c99a6ce: (a: number, b: number) => void;
-export const wasm_bindgen__convert__closures_____invoke__h26e23bd7929d5711: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h6589060427acb019: (a: number, b: number, c: any, d: any) => void;
+export const wasm_bindgen__closure__destroy__haab24713ba6d07cd: (a: number, b: number) => void;
+export const wasm_bindgen__convert__closures_____invoke__h0653cfab9850c2f3: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h133df7605c346924: (a: number, b: number, c: any, d: 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/rust/Cargo.toml

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

package/rust/src/lib.rs

@@ -140,6 +140,7 @@ struct GraphSwitchBranch {
 #[derive(Deserialize, Clone)]
 struct GraphCustomWorker {
     handler: Option<String>,
+    handler_file: Option<String>,
 }
 
 #[derive(Deserialize, Clone)]
@@ -223,6 +224,40 @@ struct WorkflowRunResult {
     context: JsonValue,
     output: Option<JsonValue>,
     events: Vec<WorkflowRunEvent>,
+    #[serde(rename = "workflow_id", skip_serializing_if = "Option::is_none")]
+    workflow_id: Option<String>,
+    #[serde(rename = "entry_node", skip_serializing_if = "Option::is_none")]
+    entry_node: Option<String>,
+    #[serde(rename = "email_text", skip_serializing_if = "Option::is_none")]
+    email_text: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    trace: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    outputs: Option<JsonValue>,
+    #[serde(rename = "terminal_node", skip_serializing_if = "Option::is_none")]
+    terminal_node: Option<String>,
+    #[serde(rename = "terminal_output", skip_serializing_if = "Option::is_none")]
+    terminal_output: Option<JsonValue>,
+    #[serde(rename = "step_timings", skip_serializing_if = "Option::is_none")]
+    step_timings: Option<JsonValue>,
+    #[serde(rename = "total_elapsed_ms", skip_serializing_if = "Option::is_none")]
+    total_elapsed_ms: Option<u64>,
+    #[serde(rename = "ttft_ms", skip_serializing_if = "Option::is_none")]
+    ttft_ms: Option<u64>,
+    #[serde(rename = "total_input_tokens", skip_serializing_if = "Option::is_none")]
+    total_input_tokens: Option<u64>,
+    #[serde(rename = "total_output_tokens", skip_serializing_if = "Option::is_none")]
+    total_output_tokens: Option<u64>,
+    #[serde(rename = "total_tokens", skip_serializing_if = "Option::is_none")]
+    total_tokens: Option<u64>,
+    #[serde(rename = "total_reasoning_tokens", skip_serializing_if = "Option::is_none")]
+    total_reasoning_tokens: Option<u64>,
+    #[serde(rename = "tokens_per_second", skip_serializing_if = "Option::is_none")]
+    tokens_per_second: Option<f64>,
+    #[serde(rename = "trace_id", skip_serializing_if = "Option::is_none")]
+    trace_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    metadata: Option<JsonValue>,
 }
 
 #[derive(Deserialize)]
@@ -538,6 +573,24 @@ fn interpolate_graph_prompt(input: &str, context: &JsonValue) -> String {
     output
 }
 
+fn interpolate_graph_json(value: &JsonValue, context: &JsonValue) -> JsonValue {
+    match value {
+        JsonValue::String(s) => JsonValue::String(interpolate_graph_prompt(s, context)),
+        JsonValue::Array(items) => JsonValue::Array(
+            items
+                .iter()
+                .map(|item| interpolate_graph_json(item, context))
+                .collect(),
+        ),
+        JsonValue::Object(map) => JsonValue::Object(
+            map.iter()
+                .map(|(key, value)| (key.clone(), interpolate_graph_json(value, context)))
+                .collect(),
+        ),
+        _ => value.clone(),
+    }
+}
+
 fn parse_json_from_text(value: &str) -> JsonValue {
     if let Ok(parsed) = serde_json::from_str::<JsonValue>(value) {
         return parsed;
@@ -1298,7 +1351,7 @@ impl WasmClient {
         }
 
         if raw_doc.get("entry_node").is_some() && raw_doc.get("nodes").is_some() {
-            let graph_doc: GraphWorkflowDoc = serde_json::from_value(raw_doc)
+            let graph_doc: GraphWorkflowDoc = serde_json::from_value(raw_doc.clone())
                 .map_err(|error| config_error(format!("invalid graph workflow YAML: {error}")))?;
 
             let mut node_by_id: HashMap<String, GraphWorkflowNode> = HashMap::new();
@@ -1324,10 +1377,19 @@ impl WasmClient {
                 "nodes": JsonValue::Object(JsonMap::new())
             });
 
+            let workflow_started = now_millis();
             let mut events = Vec::new();
             let mut output: Option<JsonValue> = None;
             let mut pointer = graph_doc.entry_node.clone();
             let mut iterations = 0usize;
+            let mut workflow_ttft_ms: Option<u64> = None;
+            let mut trace: Vec<String> = Vec::new();
+            let mut step_timings: Vec<JsonValue> = Vec::new();
+            let mut total_input_tokens: u64 = 0;
+            let mut total_output_tokens: u64 = 0;
+            let mut total_tokens: u64 = 0;
+            let total_reasoning_tokens: u64 = 0;
+            let mut llm_nodes_without_usage: Vec<String> = Vec::new();
 
             while !pointer.is_empty() {
                 iterations += 1;
@@ -1355,6 +1417,12 @@ impl WasmClient {
                     status: "started".to_string(),
                 });
 
+                let node_started = now_millis();
+                let mut model_name: Option<String> = None;
+                let mut prompt_tokens: Option<u64> = None;
+                let mut completion_tokens: Option<u64> = None;
+                let mut total_node_tokens: Option<u64> = None;
+
                 if let Some(llm) = node.node_type.llm_call.as_ref() {
                     let model = llm
                         .model
@@ -1418,6 +1486,32 @@ impl WasmClient {
                     let completion: JsonValue = serde_wasm_bindgen::from_value(completion_js)
                         .map_err(|_| js_error("failed to parse completion result"))?;
 
+                    if workflow_ttft_ms.is_none() {
+                        let measured = (now_millis() - workflow_started).max(0.0) as u64;
+                        workflow_ttft_ms = Some(if measured == 0 { 1 } else { measured });
+                    }
+
+                    model_name = completion
+                        .get("model")
+                        .and_then(JsonValue::as_str)
+                        .map(ToString::to_string);
+                    let usage = completion.get("usage");
+                    let usage_available = completion
+                        .get("usage_available")
+                        .and_then(JsonValue::as_bool)
+                        .unwrap_or(false);
+                    if usage_available {
+                        prompt_tokens = usage
+                            .and_then(|value| value.get("prompt_tokens"))
+                            .and_then(JsonValue::as_u64);
+                        completion_tokens = usage
+                            .and_then(|value| value.get("completion_tokens"))
+                            .and_then(JsonValue::as_u64);
+                        total_node_tokens = usage
+                            .and_then(|value| value.get("total_tokens"))
+                            .and_then(JsonValue::as_u64);
+                    }
+
                     let raw_content = completion
                         .get("content")
                         .and_then(JsonValue::as_str)
@@ -1475,32 +1569,40 @@ impl WasmClient {
                         .handler
                         .clone()
                         .unwrap_or_else(|| "custom_worker".to_string());
+                    let lookup_key = custom_worker
+                        .handler_file
+                        .as_deref()
+                        .map(|file| format!("{}#{}", file, handler.as_str()))
+                        .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
                         ))
                     })?;
-                    let function_value = Reflect::get(&functions_js, &JsValue::from_str(&handler))
+                    let function_value = Reflect::get(&functions_js, &JsValue::from_str(&lookup_key))
                         .map_err(|_| {
                             config_error(format!(
-                                "failed to resolve custom worker handler '{}' from workflowOptions.functions",
-                                handler
+                                "failed to resolve custom worker handler key '{}' from workflowOptions.functions",
+                                lookup_key
                             ))
                         })?;
                     let function = function_value.dyn_into::<Function>().map_err(|_| {
                         config_error(format!(
                             "custom_worker node '{}' requires workflowOptions.functions['{}']",
-                            node.id, handler
+                            node.id, lookup_key
                         ))
                     })?;
 
                     let worker_args = json!({
                         "handler": handler,
+                        "handler_file": custom_worker.handler_file,
+                        "handler_lookup_key": lookup_key,
                         "payload": node
                             .config
                             .as_ref()
-                            .and_then(|config| config.payload.clone())
+                            .and_then(|config| config.payload.as_ref())
+                            .map(|payload| interpolate_graph_json(payload, &graph_context))
                             .unwrap_or(JsonValue::Null),
                         "nodeId": node.id.clone()
                     });
@@ -1551,17 +1653,112 @@ impl WasmClient {
                 }
 
                 events.push(WorkflowRunEvent {
-                    step_id: node.id,
+                    step_id: node.id.clone(),
                     step_type: step_type.to_string(),
                     status: "completed".to_string(),
                 });
+                let elapsed_ms = (now_millis() - node_started).max(0.0) as u64;
+                if step_type == "llm_call" {
+                    if prompt_tokens.is_none() || completion_tokens.is_none() || total_node_tokens.is_none() {
+                        llm_nodes_without_usage.push(node.id.clone());
+                    }
+                    total_input_tokens += prompt_tokens.unwrap_or(0);
+                    total_output_tokens += completion_tokens.unwrap_or(0);
+                    total_tokens += total_node_tokens.unwrap_or(0);
+                }
+                let step_tokens_per_second = completion_tokens.map(|tokens| {
+                    if elapsed_ms == 0 {
+                        tokens as f64
+                    } else {
+                        ((tokens as f64 / (elapsed_ms as f64 / 1000.0)) * 100.0).round() / 100.0
+                    }
+                });
+                step_timings.push(json!({
+                    "node_id": node.id.clone(),
+                    "node_kind": step_type,
+                    "model_name": model_name,
+                    "elapsed_ms": elapsed_ms,
+                    "prompt_tokens": prompt_tokens,
+                    "completion_tokens": completion_tokens,
+                    "total_tokens": total_node_tokens,
+                    "reasoning_tokens": 0,
+                    "tokens_per_second": step_tokens_per_second,
+                }));
+                trace.push(node.id.clone());
             }
 
+            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
+                .get("id")
+                .and_then(JsonValue::as_str)
+                .unwrap_or("wasm_workflow")
+                .to_string();
+            let email_text = graph_context
+                .get("input")
+                .and_then(|input| input.get("email_text"))
+                .and_then(JsonValue::as_str)
+                .unwrap_or_default()
+                .to_string();
+            let outputs = graph_context
+                .get("nodes")
+                .cloned()
+                .unwrap_or(JsonValue::Object(JsonMap::new()));
+            let token_metrics_available = llm_nodes_without_usage.is_empty();
+            let overall_tokens_per_second = if total_elapsed_ms == 0 {
+                Some(total_output_tokens as f64)
+            } else {
+                Some(
+                    ((total_output_tokens as f64 / (total_elapsed_ms as f64 / 1000.0)) * 100.0)
+                        .round()
+                        / 100.0,
+                )
+            };
+            let nerdstats = json!({
+                "workflow_id": workflow_id,
+                "terminal_node": terminal_node,
+                "total_elapsed_ms": total_elapsed_ms,
+                "ttft_ms": workflow_ttft_ms.unwrap_or(0),
+                "step_details": step_timings,
+                "total_input_tokens": total_input_tokens,
+                "total_output_tokens": total_output_tokens,
+                "total_tokens": total_tokens,
+                "total_reasoning_tokens": total_reasoning_tokens,
+                "tokens_per_second": overall_tokens_per_second,
+                "trace_id": JsonValue::Null,
+                "token_metrics_available": token_metrics_available,
+                "token_metrics_source": if token_metrics_available { "provider_usage" } else { "unavailable" },
+                "llm_nodes_without_usage": llm_nodes_without_usage,
+            });
+
             let result = WorkflowRunResult {
                 status: "ok".to_string(),
                 context: graph_context,
-                output,
+                output: output.clone(),
                 events,
+                workflow_id: Some(
+                    raw_doc
+                        .get("id")
+                        .and_then(JsonValue::as_str)
+                        .unwrap_or("wasm_workflow")
+                        .to_string(),
+                ),
+                entry_node: Some(graph_doc.entry_node),
+                email_text: Some(email_text),
+                trace: Some(trace),
+                outputs: Some(outputs),
+                terminal_node: Some(terminal_node),
+                terminal_output: output,
+                step_timings: Some(nerdstats.get("step_details").cloned().unwrap_or(JsonValue::Array(vec![]))),
+                total_elapsed_ms: Some(total_elapsed_ms),
+                ttft_ms: Some(workflow_ttft_ms.unwrap_or(0)),
+                total_input_tokens: Some(total_input_tokens),
+                total_output_tokens: Some(total_output_tokens),
+                total_tokens: Some(total_tokens),
+                total_reasoning_tokens: Some(total_reasoning_tokens),
+                tokens_per_second: overall_tokens_per_second,
+                trace_id: None,
+                metadata: Some(json!({"nerdstats": nerdstats})),
             };
             return serde_wasm_bindgen::to_value(&result)
                 .map_err(|_| js_error("failed to serialize workflow result"));
@@ -1771,6 +1968,23 @@ impl WasmClient {
             context: JsonValue::Object(context),
             output,
             events,
+            workflow_id: None,
+            entry_node: None,
+            email_text: None,
+            trace: None,
+            outputs: None,
+            terminal_node: None,
+            terminal_output: None,
+            step_timings: None,
+            total_elapsed_ms: None,
+            ttft_ms: None,
+            total_input_tokens: None,
+            total_output_tokens: None,
+            total_tokens: None,
+            total_reasoning_tokens: None,
+            tokens_per_second: None,
+            trace_id: None,
+            metadata: None,
         };
         serde_wasm_bindgen::to_value(&result)
             .map_err(|_| js_error("failed to serialize workflow result"))