simple-agents-wasm 0.2.28 → 0.2.31

package/README.md

@@ -47,5 +47,8 @@ console.log(result.content);
 - Browser mode still depends on provider CORS support.
 - `healed_json` and `schema` completion modes are not supported yet.
 - `runWorkflowYaml(workflowPath, ...)` is not supported in browser runtime.
-- `runWorkflowYamlString(...)` supports string-based workflow execution only.
+- `runWorkflowYamlString(...)` supports string-based workflow execution for:
+  - step workflows (`steps` DSL)
+  - graph workflows (`entry_node` + `nodes` + `edges`) with `llm_call`, `switch`, and `custom_worker`.
+- Graph `custom_worker` nodes call `workflowOptions.functions[handler]` and throw a runtime error when the handler is missing.
 - Use `hasRustBackend()` to check whether Rust wasm backend was loaded.

package/index.d.ts

@@ -105,7 +105,10 @@ export interface WorkflowRunOptions {
   trace?: Record<string, unknown>;
   functions?: Record<
     string,
-    (args: Record<string, unknown>, context: Record<string, unknown>) => unknown
+    (
+      args: Record<string, unknown>,
+      context: Record<string, unknown>
+    ) => unknown | Promise<unknown>
   >;
 }
 

package/index.js

@@ -127,13 +127,343 @@ function parseWorkflow(yamlText) {
     throw configError("workflow YAML must parse to an object");
   }
 
-  if (!Array.isArray(parsed.steps)) {
-    throw configError("workflow YAML must contain a steps array");
+  if (!Array.isArray(parsed.steps) && !isGraphWorkflow(parsed)) {
+    throw configError(
+      "workflow YAML must contain either a steps array or graph fields (entry_node + nodes)"
+    );
   }
 
   return parsed;
 }
 
+function isGraphWorkflow(doc) {
+  return (
+    doc &&
+    typeof doc === "object" &&
+    typeof doc.entry_node === "string" &&
+    Array.isArray(doc.nodes)
+  );
+}
+
+function getPathValue(source, path) {
+  if (!source || typeof source !== "object") {
+    return undefined;
+  }
+
+  const normalized = String(path).trim().replace(/^\$\./, "");
+  const tokens = normalized.split(".").filter((token) => token.length > 0);
+  let current = source;
+  for (const token of tokens) {
+    if (!current || typeof current !== "object") {
+      return undefined;
+    }
+    current = current[token];
+  }
+  return current;
+}
+
+function interpolatePathTemplate(template, context) {
+  if (typeof template !== "string") {
+    return "";
+  }
+
+  return template.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);
+  });
+}
+
+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;
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch {
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start !== -1 && end !== -1 && end > start) {
+      const candidate = text.slice(start, end + 1);
+      try {
+        return JSON.parse(candidate);
+      } catch {
+        return text;
+      }
+    }
+    return text;
+  }
+}
+
+function matchesJsonSchemaType(expectedType, value) {
+  if (expectedType === "null") {
+    return value === null;
+  }
+  if (expectedType === "array") {
+    return Array.isArray(value);
+  }
+  if (expectedType === "object") {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  }
+  if (expectedType === "integer") {
+    return typeof value === "number" && Number.isInteger(value);
+  }
+  return typeof value === expectedType;
+}
+
+function jsonValueType(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  return typeof value;
+}
+
+function equalJsonValue(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (
+    left === null ||
+    right === null ||
+    left === undefined ||
+    right === undefined ||
+    typeof left !== "object" ||
+    typeof right !== "object"
+  ) {
+    return false;
+  }
+
+  try {
+    return JSON.stringify(left) === JSON.stringify(right);
+  } catch {
+    return false;
+  }
+}
+
+function schemaValidationError(schema, value, path = "$") {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return null;
+  }
+
+  if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
+    const anyOfErrors = schema.anyOf
+      .map((nested) => schemaValidationError(nested, value, path))
+      .filter((entry) => typeof entry === "string");
+    if (anyOfErrors.length === schema.anyOf.length) {
+      return `${path} did not satisfy anyOf`;
+    }
+  }
+
+  if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+    let matched = 0;
+    for (const nested of schema.oneOf) {
+      if (schemaValidationError(nested, value, path) === null) {
+        matched += 1;
+      }
+    }
+    if (matched !== 1) {
+      return `${path} must satisfy exactly one oneOf schema`;
+    }
+  }
+
+  if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+    for (const nested of schema.allOf) {
+      const error = schemaValidationError(nested, value, path);
+      if (error !== null) {
+        return error;
+      }
+    }
+  }
+
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    const matched = schema.enum.some((candidate) => equalJsonValue(candidate, value));
+    if (!matched) {
+      return `${path} must be one of enum values`;
+    }
+  }
+
+  if (schema.type !== undefined) {
+    const expectedTypes = Array.isArray(schema.type) ? schema.type : [schema.type];
+    const matchedType = expectedTypes.some((expectedType) => {
+      return typeof expectedType === "string" && matchesJsonSchemaType(expectedType, value);
+    });
+    if (!matchedType) {
+      return `${path} expected type ${expectedTypes.join(" | ")}, got ${jsonValueType(value)}`;
+    }
+  }
+
+  if (typeof value === "string") {
+    if (typeof schema.minLength === "number" && value.length < schema.minLength) {
+      return `${path} must have minLength ${schema.minLength}`;
+    }
+    if (typeof schema.maxLength === "number" && value.length > schema.maxLength) {
+      return `${path} must have maxLength ${schema.maxLength}`;
+    }
+    if (typeof schema.pattern === "string") {
+      const pattern = new RegExp(schema.pattern);
+      if (!pattern.test(value)) {
+        return `${path} must match pattern ${schema.pattern}`;
+      }
+    }
+  }
+
+  if (typeof value === "number") {
+    if (typeof schema.minimum === "number" && value < schema.minimum) {
+      return `${path} must be >= ${schema.minimum}`;
+    }
+    if (typeof schema.maximum === "number" && value > schema.maximum) {
+      return `${path} must be <= ${schema.maximum}`;
+    }
+  }
+
+  if (Array.isArray(value)) {
+    if (typeof schema.minItems === "number" && value.length < schema.minItems) {
+      return `${path} must have at least ${schema.minItems} items`;
+    }
+    if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
+      return `${path} must have at most ${schema.maxItems} items`;
+    }
+    if (schema.items !== undefined) {
+      for (let index = 0; index < value.length; index += 1) {
+        const error = schemaValidationError(schema.items, value[index], `${path}[${index}]`);
+        if (error !== null) {
+          return error;
+        }
+      }
+    }
+  }
+
+  const isObjectValue = value !== null && typeof value === "object" && !Array.isArray(value);
+  if (isObjectValue) {
+    const properties =
+      schema.properties && typeof schema.properties === "object" && !Array.isArray(schema.properties)
+        ? schema.properties
+        : {};
+
+    if (Array.isArray(schema.required)) {
+      for (const key of schema.required) {
+        if (typeof key !== "string") {
+          continue;
+        }
+        if (!(key in value)) {
+          return `${path}.${key} is required`;
+        }
+      }
+    }
+
+    for (const [key, propertySchema] of Object.entries(properties)) {
+      if (!(key in value)) {
+        continue;
+      }
+      const error = schemaValidationError(propertySchema, value[key], `${path}.${key}`);
+      if (error !== null) {
+        return error;
+      }
+    }
+
+    const knownKeys = new Set(Object.keys(properties));
+    if (schema.additionalProperties === false) {
+      for (const key of Object.keys(value)) {
+        if (!knownKeys.has(key)) {
+          return `${path}.${key} is not allowed`;
+        }
+      }
+    } else if (
+      schema.additionalProperties !== undefined &&
+      schema.additionalProperties !== true
+    ) {
+      for (const key of Object.keys(value)) {
+        if (knownKeys.has(key)) {
+          continue;
+        }
+        const error = schemaValidationError(
+          schema.additionalProperties,
+          value[key],
+          `${path}.${key}`
+        );
+        if (error !== null) {
+          return error;
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+function llmOutputSchema(node) {
+  const schema = node?.config?.output_schema;
+  if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+    return schema;
+  }
+  return {
+    type: "object",
+    additionalProperties: true
+  };
+}
+
+function normalizeSseChunk(chunk) {
+  return chunk.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+function evaluateSwitchCondition(condition, context) {
+  if (typeof condition !== "string") {
+    return false;
+  }
+
+  const eq = condition.match(/^\$\.([A-Za-z0-9_.]+)\s*==\s*"([\s\S]*)"$/);
+  if (eq) {
+    const left = getPathValue(context, eq[1]);
+    return String(left ?? "") === eq[2];
+  }
+
+  const ne = condition.match(/^\$\.([A-Za-z0-9_.]+)\s*!=\s*"([\s\S]*)"$/);
+  if (ne) {
+    const left = getPathValue(context, ne[1]);
+    return String(left ?? "") !== ne[2];
+  }
+
+  return false;
+}
+
 function parseSseEventBlock(block) {
   const lines = block.split("\n");
   const dataLines = [];
@@ -174,7 +504,7 @@ async function* iterateSse(response) {
       break;
     }
 
-    buffer += decoder.decode(value, { stream: true });
+    buffer += normalizeSseChunk(decoder.decode(value, { stream: true }));
     let delimiterIndex = buffer.indexOf("\n\n");
     while (delimiterIndex !== -1) {
       const block = buffer.slice(0, delimiterIndex).trim();
@@ -186,6 +516,8 @@ async function* iterateSse(response) {
     }
   }
 
+  buffer += normalizeSseChunk(decoder.decode());
+
   const trailing = buffer.trim();
   if (trailing.length > 0) {
     yield trailing;
@@ -468,6 +800,142 @@ class BrowserJsClient {
         ? workflowOptions.functions
         : {};
 
+    if (isGraphWorkflow(doc)) {
+      const nodeById = new Map();
+      for (const node of doc.nodes) {
+        if (!node || typeof node !== "object" || typeof node.id !== "string") {
+          throw configError("workflow node is invalid or missing id");
+        }
+        nodeById.set(node.id, node);
+      }
+
+      const edgeMap = new Map();
+      if (Array.isArray(doc.edges)) {
+        for (const edge of doc.edges) {
+          if (!edge || typeof edge.from !== "string" || typeof edge.to !== "string") {
+            continue;
+          }
+          const existing = edgeMap.get(edge.from) ?? [];
+          existing.push(edge.to);
+          edgeMap.set(edge.from, existing);
+        }
+      }
+
+      const graphContext = {
+        input: workflowInput,
+        nodes: {}
+      };
+
+      let pointer = doc.entry_node;
+      let output;
+      let iterations = 0;
+
+      while (typeof pointer === "string" && pointer.length > 0) {
+        iterations += 1;
+        if (iterations > 1000) {
+          throw runtimeError("workflow exceeded maximum step iterations");
+        }
+
+        const node = nodeById.get(pointer);
+        if (!node) {
+          throw configError(`workflow references unknown node '${pointer}'`);
+        }
+
+        const nodeType = node.node_type ?? {};
+        const nodeTypeName = Object.keys(nodeType)[0] ?? "unknown";
+        events.push({ stepId: node.id, stepType: nodeTypeName, status: "started" });
+
+        if (nodeType.llm_call) {
+          const llm = nodeType.llm_call;
+          const model = llm.model ?? doc.model ?? workflowInput.model;
+          if (typeof model !== "string" || model.trim().length === 0) {
+            throw configError(`llm_call node '${node.id}' requires node_type.llm_call.model`);
+          }
+
+          const prompt = interpolatePathTemplate(node.config?.prompt ?? "", graphContext);
+          let promptOrMessages = prompt;
+          if (llm.messages_path === "input.messages") {
+            const source = getPathValue(graphContext, llm.messages_path);
+            const history = Array.isArray(source)
+              ? source
+                  .filter((message) => {
+                    return (
+                      message &&
+                      typeof message === "object" &&
+                      typeof message.role === "string" &&
+                      typeof message.content === "string"
+                    );
+                  })
+                  .map((message) => ({ role: message.role, content: message.content }))
+              : [];
+            if (llm.append_prompt_as_user !== false) {
+              history.push({ role: "user", content: prompt });
+            }
+            promptOrMessages = history;
+          }
+
+          const completion = await this.complete(model, promptOrMessages, {
+            temperature: llm.temperature
+          });
+          const parsedOutput = maybeParseJson(completion.content ?? "");
+          const validationError = schemaValidationError(llmOutputSchema(node), parsedOutput);
+          if (validationError !== null) {
+            throw runtimeError(
+              `llm_call node '${node.id}' output failed schema validation: ${validationError}`
+            );
+          }
+          graphContext.nodes[node.id] = {
+            output: parsedOutput,
+            raw: completion.content ?? ""
+          };
+          output = parsedOutput;
+
+          const nextTargets = edgeMap.get(node.id) ?? [];
+          pointer = nextTargets[0] ?? "";
+        } else if (nodeType.switch) {
+          const switchSpec = nodeType.switch;
+          const branches = Array.isArray(switchSpec.branches) ? switchSpec.branches : [];
+          const matched = branches.find((branch) =>
+            evaluateSwitchCondition(branch?.condition, graphContext)
+          );
+          pointer = matched?.target ?? switchSpec.default ?? "";
+        } else if (nodeType.custom_worker) {
+          const handler = nodeType.custom_worker.handler ?? "custom_worker";
+          const fn = functions[handler];
+          if (typeof fn !== "function") {
+            throw runtimeError(
+              `custom_worker node '${node.id}' requires workflowOptions.functions['${handler}']`
+            );
+          }
+          const workerOutput = await fn(
+            {
+              handler,
+              payload: interpolatePathValue(node.config?.payload ?? null, graphContext),
+              nodeId: node.id
+            },
+            graphContext
+          );
+          graphContext.nodes[node.id] = {
+            output: workerOutput
+          };
+          output = workerOutput;
+          const nextTargets = edgeMap.get(node.id) ?? [];
+          pointer = nextTargets[0] ?? "";
+        } else {
+          throw configError(`unsupported node_type in simple-agents-wasm graph workflow`);
+        }
+
+        events.push({ stepId: node.id, stepType: nodeTypeName, status: "completed" });
+      }
+
+      return {
+        status: "ok",
+        context: graphContext,
+        output,
+        events
+      };
+    }
+
     const indexById = new Map();
     doc.steps.forEach((step, index) => {
       if (!step || typeof step !== "object") {
@@ -530,7 +998,7 @@ class BrowserJsClient {
         }
 
         const args = interpolate(step.args ?? {}, context);
-        context[step.id] = fn(args, context);
+        context[step.id] = await fn(args, context);
       } else if (step.type === "output") {
         output = interpolate(step.text ?? step.value ?? "", context);
         context[step.id] = output;

package/package.json

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

package/pkg/simple_agents_wasm.js

@@ -138,6 +138,10 @@ function __wbg_get_imports() {
             const ret = typeof(arg0) === 'function';
             return ret;
         },
+        __wbg___wbindgen_is_null_0b605fc6b167c56f: function(arg0) {
+            const ret = arg0 === null;
+            return ret;
+        },
         __wbg___wbindgen_is_object_781bc9f159099513: function(arg0) {
             const val = arg0;
             const ret = typeof(val) === 'object' && val !== null;
@@ -191,6 +195,10 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1);
             return ret;
         }, arguments); },
+        __wbg_construct_526a6dedb187eba9: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.construct(arg0, arg1);
+            return ret;
+        }, arguments); },
         __wbg_done_08ce71ee07e3bd17: function(arg0) {
             const ret = arg0.done;
             return ret;
@@ -386,7 +394,7 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 85, function: Function { arguments: [Externref], shim_idx: 86, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // 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);
             return ret;
         },

package/rust/Cargo.toml

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