simple-agents-wasm 0.3.0 → 0.3.3

package/index.d.ts

@@ -100,10 +100,43 @@ export interface ClientConfig {
   headers?: Record<string, string>;
 }
 
+/** Matches Rust `YamlWorkflowTelemetryConfig` JSON (snake_case). */
+export interface WorkflowTelemetryConfig {
+  enabled?: boolean;
+  nerdstats?: boolean;
+  sample_rate?: number;
+  payload_mode?: "full_payload" | "redacted_payload";
+  retention_days?: number;
+  multi_tenant?: boolean;
+  tool_trace_mode?: "full" | "redacted" | "off";
+}
+
+export interface WorkflowTraceContext {
+  trace_id?: string;
+  span_id?: string;
+  parent_span_id?: string;
+  traceparent?: string;
+  tracestate?: string;
+  baggage?: Record<string, string>;
+}
+
+export interface WorkflowTraceTenant {
+  workspace_id?: string;
+  user_id?: string;
+  conversation_id?: string;
+  request_id?: string;
+  run_id?: string;
+}
+
+export interface WorkflowTraceConfig {
+  context?: WorkflowTraceContext;
+  tenant?: WorkflowTraceTenant;
+}
+
 export interface WorkflowRunOptions {
-  telemetry?: Record<string, unknown>;
-  trace?: Record<string, unknown>;
   model?: string;
+  telemetry?: WorkflowTelemetryConfig;
+  trace?: WorkflowTraceConfig;
   onEvent?: (event: Record<string, unknown>) => void;
   functions?: Record<
     string,
@@ -114,6 +147,12 @@ export interface WorkflowRunOptions {
   >;
 }
 
+/** Common workflow `input` fields; extra keys are allowed for workflow-specific payloads. */
+export interface WorkflowInputFields {
+  email_text?: string;
+  [key: string]: unknown;
+}
+
 export interface WorkflowRunEvent {
   stepId: string;
   stepType: string;
@@ -132,6 +171,7 @@ export interface WorkflowExecutionFlags {
   healing?: boolean;
   workflow_streaming?: boolean;
   node_llm_streaming?: boolean;
+  split_stream_deltas?: boolean;
 }
 
 export interface WorkflowExecutionRequest {
@@ -139,7 +179,7 @@ export interface WorkflowExecutionRequest {
   messages: MessageInput[];
   context?: Record<string, unknown>;
   media?: Record<string, unknown>;
-  input?: Record<string, unknown>;
+  input?: WorkflowInputFields;
   execution?: WorkflowExecutionFlags;
   workflow_options?: WorkflowRunOptions;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-agents-wasm",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "Browser-compatible SimpleAgents client for OpenAI-compatible providers",
   "type": "module",
   "main": "index.js",
@@ -16,12 +16,26 @@
   "files": [
     "index.js",
     "index.d.ts",
+    "workflow_stream_printer.mjs",
+    "workflow_stream_printer.d.ts",
     "runtime",
     "README.md",
     "pkg",
     "rust/Cargo.toml",
     "rust/src"
   ],
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./workflow_stream_printer": {
+      "types": "./workflow_stream_printer.d.ts",
+      "import": "./workflow_stream_printer.mjs",
+      "default": "./workflow_stream_printer.mjs"
+    }
+  },
   "engines": {
     "node": ">=18"
   },

package/pkg/simple_agents_wasm.d.ts

@@ -8,6 +8,17 @@ export class WasmClient {
     constructor(provider: string, config: any);
     runWorkflowYaml(workflow_path: string, _workflow_input: any): any;
     runWorkflowYamlString(yaml_text: string, workflow_input: any, workflow_options?: any | null): Promise<any>;
+    /**
+     * Run a YAML workflow from a YAML text string (new unified API alias).
+     *
+     * This is an alias for `runWorkflowYamlString` using the new naming convention.
+     * WASM cannot use file paths; pass the YAML document text directly.
+     *
+     * ```js
+     * const result = await client.runYamlString(yamlText, messages);
+     * ```
+     */
+    runYamlString(yaml_text: string, messages: any, options?: any | null): Promise<any>;
     streamEvents(model: string, prompt_or_messages: any, on_event: Function, options?: any | null): Promise<any>;
 }
 
@@ -26,9 +37,10 @@ export interface InitOutput {
     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];
     readonly wasmclient_runWorkflowYamlString: (a: number, b: number, c: number, d: any, e: number) => any;
+    readonly wasmclient_runYamlString: (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__convert__closures_____invoke__h327a4c82efcf6931: (a: number, b: number, c: any) => [number, number];
-    readonly wasm_bindgen__convert__closures_____invoke__h67e61867e7d8792e: (a: number, b: number, c: any, d: any) => void;
+    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 __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

@@ -64,6 +64,26 @@ export class WasmClient {
         const ret = wasm.wasmclient_runWorkflowYamlString(this.__wbg_ptr, ptr0, len0, workflow_input, isLikeNone(workflow_options) ? 0 : addToExternrefTable0(workflow_options));
         return ret;
     }
+    /**
+     * Run a YAML workflow from a YAML text string (new unified API alias).
+     *
+     * This is an alias for `runWorkflowYamlString` using the new naming convention.
+     * WASM cannot use file paths; pass the YAML document text directly.
+     *
+     * ```js
+     * const result = await client.runYamlString(yamlText, messages);
+     * ```
+     * @param {string} yaml_text
+     * @param {any} messages
+     * @param {any | null} [options]
+     * @returns {Promise<any>}
+     */
+    runYamlString(yaml_text, messages, options) {
+        const ptr0 = passStringToWasm0(yaml_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmclient_runYamlString(this.__wbg_ptr, ptr0, len0, messages, isLikeNone(options) ? 0 : addToExternrefTable0(options));
+        return ret;
+    }
     /**
      * @param {string} model
      * @param {any} prompt_or_messages
@@ -267,6 +287,10 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_isArray_4daec0bfe3d60230: function(arg0) {
+            const ret = Array.isArray(arg0);
+            return ret;
+        },
         __wbg_isArray_db61795ad004c139: function(arg0) {
             const ret = Array.isArray(arg0);
             return ret;
@@ -314,7 +338,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h67e61867e7d8792e(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h05acb8c479b21d4b(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -394,8 +418,8 @@ 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: 147, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h327a4c82efcf6931);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 151, 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) {
@@ -434,15 +458,15 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h327a4c82efcf6931(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h327a4c82efcf6931(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]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h67e61867e7d8792e(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h67e61867e7d8792e(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h05acb8c479b21d4b(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h05acb8c479b21d4b(arg0, arg1, arg2, arg3);
 }
 
 const WasmClientFinalization = (typeof FinalizationRegistry === 'undefined')

package/pkg/simple_agents_wasm_bg.wasm.d.ts

@@ -8,9 +8,10 @@ export const wasmclient_complete: (a: number, b: number, c: number, d: any, e: n
 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];
 export const wasmclient_runWorkflowYamlString: (a: number, b: number, c: number, d: any, e: number) => any;
+export const wasmclient_runYamlString: (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__convert__closures_____invoke__h327a4c82efcf6931: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h67e61867e7d8792e: (a: number, b: number, c: any, d: any) => void;
+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 __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.3.0"
+version = "0.3.3"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 

package/rust/src/lib.rs

@@ -2000,6 +2000,37 @@ impl WasmClient {
             "workflow file paths are not supported in browser runtime: {workflow_path}"
         )))
     }
+
+    /// Run a YAML workflow from a YAML text string (new unified API alias).
+    ///
+    /// This is an alias for `runWorkflowYamlString` using the new naming convention.
+    /// WASM cannot use file paths; pass the YAML document text directly.
+    ///
+    /// ```js
+    /// const result = await client.runYamlString(yamlText, messages);
+    /// ```
+    #[wasm_bindgen(js_name = runYamlString)]
+    pub async fn run_yaml_string(
+        &self,
+        yaml_text: String,
+        messages: JsValue,
+        options: Option<JsValue>,
+    ) -> Result<JsValue, JsValue> {
+        // Build workflow input envelope from the messages arg
+        let messages_value: serde_json::Value = if messages.is_array() || messages.is_object() {
+            serde_wasm_bindgen::from_value(messages)
+                .unwrap_or(serde_json::json!([]))
+        } else if let Some(prompt) = messages.as_string() {
+            serde_json::json!([{"role": "user", "content": prompt}])
+        } else {
+            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"))?;
+
+        self.run_workflow_yaml_string(yaml_text, input_js, options).await
+    }
 }
 
 #[wasm_bindgen(js_name = supportsRustWasm)]

package/workflow_stream_printer.d.ts

@@ -0,0 +1,12 @@
+export interface WorkflowStreamPrinterOptions {
+  /** When true, print thinking vs output deltas instead of merged `node_stream_delta`. */
+  splitThinking?: boolean;
+}
+
+/**
+ * Build a default `onEvent` callback for {@link Client.streamWorkflow} (Node-friendly streaming;
+ * in browsers without `process.stdout`, falls back to `console.log` per chunk).
+ */
+export function createWorkflowStreamPrinter(
+  options?: WorkflowStreamPrinterOptions,
+): (event: Record<string, unknown>) => void;

package/workflow_stream_printer.mjs

@@ -0,0 +1,87 @@
+/**
+ * @typedef {Object} WorkflowStreamPrinterOptions
+ * @property {boolean} [splitThinking] When true, print `node_stream_thinking_delta` and
+ *   `node_stream_output_delta`; otherwise print `node_stream_delta`.
+ */
+
+/**
+ * Default `onEvent` handler for {@link Client.streamWorkflow} that prints stream tokens to stdout.
+ * @param {WorkflowStreamPrinterOptions} [options]
+ * @returns {(event: Record<string, unknown>) => void}
+ */
+function writeChunk(chunk) {
+  if (typeof process !== "undefined" && process.stdout?.write) {
+    process.stdout.write(chunk);
+  } else if (typeof chunk === "string" && chunk.length > 0) {
+    console.log(chunk);
+  }
+}
+
+function writeLine() {
+  if (typeof process !== "undefined" && process.stdout?.write) {
+    process.stdout.write("\n");
+  } else {
+    console.log();
+  }
+}
+
+export function createWorkflowStreamPrinter(options = {}) {
+  const splitThinking = options.splitThinking === true;
+  /** @type {{ currentNode: string | null, lineOpen: boolean, lastTokenLabel: string | null }} */
+  const state = { currentNode: null, lineOpen: false, lastTokenLabel: null };
+
+  return (event) => {
+    const eventType = event?.event_type;
+    if (typeof eventType !== "string") return;
+
+    let isStream = eventType === "node_stream_delta";
+    if (splitThinking) {
+      isStream =
+        eventType === "node_stream_thinking_delta" ||
+        eventType === "node_stream_output_delta";
+    }
+
+    const delta = typeof event.delta === "string" ? event.delta : "";
+    if (isStream && delta !== "") {
+      let displayId =
+        typeof event.node_id === "string"
+          ? event.node_id
+          : typeof event.step_id === "string"
+            ? event.step_id
+            : "?";
+
+      if (state.currentNode !== displayId) {
+        if (state.lineOpen) writeLine();
+        writeChunk(`\nStep: ${displayId}\nStreaming: `);
+        state.currentNode = displayId;
+        state.lineOpen = true;
+        state.lastTokenLabel = null;
+      }
+
+      if (splitThinking) {
+        const parts = [];
+        if (typeof event.token_kind === "string" && event.token_kind.trim()) {
+          parts.push(event.token_kind.trim());
+        }
+        if (event.is_terminal_node_token === true) {
+          parts.push("terminal");
+        }
+        const tokenLabel = parts.length ? `[${parts.join(" ")}] ` : "";
+        if (tokenLabel && tokenLabel !== state.lastTokenLabel) {
+          if (state.lineOpen) writeLine();
+          writeChunk(`${tokenLabel}${displayId}: `);
+          state.lastTokenLabel = tokenLabel;
+          state.lineOpen = true;
+        }
+        writeChunk(delta);
+      } else {
+        writeChunk(delta);
+      }
+      return;
+    }
+
+    if (eventType === "workflow_started" || eventType === "workflow_completed") {
+      return;
+    }
+  };
+}