simple-agents-wasm 0.2.36 → 0.3.2

package/index.d.ts

@@ -100,9 +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,
@@ -113,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;
@@ -126,6 +166,24 @@ export interface WorkflowRunResult {
   events: WorkflowRunEvent[];
 }
 
+export interface WorkflowExecutionFlags {
+  model?: string;
+  healing?: boolean;
+  workflow_streaming?: boolean;
+  node_llm_streaming?: boolean;
+  split_stream_deltas?: boolean;
+}
+
+export interface WorkflowExecutionRequest {
+  workflow_yaml: string;
+  messages: MessageInput[];
+  context?: Record<string, unknown>;
+  media?: Record<string, unknown>;
+  input?: WorkflowInputFields;
+  execution?: WorkflowExecutionFlags;
+  workflow_options?: WorkflowRunOptions;
+}
+
 export declare class Client {
   constructor(provider: string, config: ClientConfig);
   complete(
@@ -154,6 +212,12 @@ export declare class Client {
     workflowPath: string,
     workflowInput: Record<string, unknown>
   ): Promise<never>;
+  run(request: WorkflowExecutionRequest): Promise<WorkflowRunResult>;
+  runAsync(request: WorkflowExecutionRequest): Promise<WorkflowRunResult>;
+  streamWorkflow(
+    request: WorkflowExecutionRequest,
+    onEvent?: (event: Record<string, unknown>) => void
+  ): Promise<WorkflowRunResult>;
 }
 
 export declare function hasRustBackend(): Promise<boolean>;

package/index.js

@@ -30,6 +30,43 @@ function toMessages(promptOrMessages) {
   return promptOrMessages;
 }
 
+function buildWorkflowInputFromExecutionRequest(request) {
+  if (!request || typeof request !== "object") {
+    throw configError("workflow request must be an object");
+  }
+  if (typeof request.workflow_yaml !== "string" || request.workflow_yaml.trim().length === 0) {
+    throw configError("workflow_yaml must be a non-empty string");
+  }
+  if (!Array.isArray(request.messages) || request.messages.length === 0) {
+    throw configError("messages must be a non-empty array");
+  }
+  const input = request.input && typeof request.input === "object" ? { ...request.input } : {};
+  input.messages = request.messages;
+  if (request.context && typeof request.context === "object") {
+    input.context = request.context;
+  }
+  if (request.media && typeof request.media === "object") {
+    input.media = request.media;
+  }
+  return input;
+}
+
+function buildWorkflowOptionsFromExecutionRequest(request, onEvent) {
+  const execution = request.execution && typeof request.execution === "object"
+    ? request.execution
+    : {};
+  const options = request.workflow_options && typeof request.workflow_options === "object"
+    ? { ...request.workflow_options }
+    : {};
+  if (typeof execution.model === "string" && execution.model.trim().length > 0) {
+    options.model = execution.model;
+  }
+  if (typeof onEvent === "function") {
+    options.onEvent = onEvent;
+  }
+  return options;
+}
+
 function toUsage(usage) {
   if (!usage || typeof usage !== "object") {
     return {
@@ -1272,6 +1309,23 @@ export class Client {
     const result = await this.fallbackClient.runWorkflowYaml(workflowPath, workflowInput);
     return assertWorkflowResultShape(normalizeWorkflowResult(result));
   }
+
+  async run(request) {
+    const workflowInput = buildWorkflowInputFromExecutionRequest(request);
+    const workflowOptions = buildWorkflowOptionsFromExecutionRequest(request, undefined);
+    return this.runWorkflowYamlString(request.workflow_yaml, workflowInput, workflowOptions);
+  }
+
+  async runAsync(request) {
+    return this.run(request);
+  }
+
+  // Workflow-streaming surface (completion streaming already uses `stream`).
+  async streamWorkflow(request, onEvent) {
+    const workflowInput = buildWorkflowInputFromExecutionRequest(request);
+    const workflowOptions = buildWorkflowOptionsFromExecutionRequest(request, onEvent);
+    return this.runWorkflowYamlString(request.workflow_yaml, workflowInput, workflowOptions);
+  }
 }
 
 export async function hasRustBackend() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-agents-wasm",
-  "version": "0.2.36",
+  "version": "0.3.2",
   "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/rust/Cargo.toml

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

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;
+    }
+  };
+}