simple-agents-wasm 0.3.11 → 0.4.0

package/README.md

@@ -36,7 +36,10 @@ import { Client } from "simple-agents-wasm";
 
 const client = new Client("openai", {
   apiKey: "<BYOK>",
-  baseUrl: "https://api.openai.com/v1"
+  baseUrl: "https://api.openai.com/v1",
+  timeoutSeconds: 60,
+  retryAttempts: 3,
+  retryStrategy: "exponential"
 });
 
 const result = await client.complete("gpt-4o-mini", "Say hi in one line.");

package/index.d.ts

@@ -112,6 +112,9 @@ export interface ClientConfig {
   apiKey: string;
   fetchImpl?: typeof fetch;
   headers?: Record<string, string>;
+  timeoutSeconds?: number;
+  retryAttempts?: number;
+  retryStrategy?: "none" | "fixed" | "exponential";
 }
 
 /** Matches Rust `YamlWorkflowTelemetryConfig` JSON (snake_case). */
@@ -210,6 +213,7 @@ export interface WorkflowExecutionFlags {
   workflow_streaming?: boolean;
   node_llm_streaming?: boolean;
   split_stream_deltas?: boolean;
+  debug_stream_parse?: boolean;
 }
 
 export interface WorkflowExecutionRequest {

package/index.js

@@ -58,6 +58,105 @@ function assertWorkflowResultShape(result) {
   return result;
 }
 
+function parseClientOptions(config) {
+  const timeoutSeconds = config.timeoutSeconds;
+  if (timeoutSeconds !== undefined) {
+    if (typeof timeoutSeconds !== "number" || !Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
+      throw configError("config.timeoutSeconds must be a positive finite number");
+    }
+  }
+
+  const retryAttempts = config.retryAttempts ?? 3;
+  if (!Number.isInteger(retryAttempts) || retryAttempts < 1) {
+    throw configError("config.retryAttempts must be greater than or equal to 1");
+  }
+
+  const retryStrategy = config.retryStrategy ?? "exponential";
+  if (!["none", "fixed", "exponential"].includes(retryStrategy)) {
+    throw configError("config.retryStrategy must be 'none', 'fixed', or 'exponential'");
+  }
+
+  return { timeoutSeconds, retryAttempts, retryStrategy };
+}
+
+function retryDelayMs(strategy, failedAttempt) {
+  if (strategy === "none") {
+    return 0;
+  }
+  const baseMs = 1000;
+  if (strategy === "fixed") {
+    return baseMs;
+  }
+  return Math.min(baseMs * (2 ** Math.max(0, failedAttempt - 1)), 10000);
+}
+
+function retryAfterMs(response) {
+  const header = response?.headers?.get?.("retry-after");
+  if (!header) {
+    return undefined;
+  }
+  const seconds = Number(header);
+  return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1000 : undefined;
+}
+
+function isRetryableResponse(response) {
+  const status = Number(response?.status ?? 0);
+  return status === 429 || (status >= 500 && status <= 599);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function createManagedFetch(fetchImpl, options) {
+  const sourceFetch = typeof fetchImpl === "function" ? fetchImpl : globalThis.fetch;
+  if (typeof sourceFetch !== "function") {
+    throw configError("fetch is unavailable; pass config.fetchImpl");
+  }
+
+  return async function managedFetch(input, init = {}) {
+    let attempt = 1;
+    while (true) {
+      const controller = options.timeoutSeconds && typeof AbortController === "function"
+        ? new AbortController()
+        : undefined;
+      const timeoutId = controller
+        ? setTimeout(() => controller.abort(), options.timeoutSeconds * 1000)
+        : undefined;
+      const requestInit = controller ? { ...init, signal: controller.signal } : init;
+
+      try {
+        const response = await sourceFetch(input, requestInit);
+        if (
+          attempt >= options.retryAttempts
+          || options.retryStrategy === "none"
+          || !isRetryableResponse(response)
+        ) {
+          return response;
+        }
+        const delay = retryAfterMs(response) ?? retryDelayMs(options.retryStrategy, attempt);
+        if (delay > 0) {
+          await sleep(delay);
+        }
+        attempt += 1;
+      } catch (error) {
+        if (attempt >= options.retryAttempts || options.retryStrategy === "none") {
+          throw error;
+        }
+        const delay = retryDelayMs(options.retryStrategy, attempt);
+        if (delay > 0) {
+          await sleep(delay);
+        }
+        attempt += 1;
+      } finally {
+        if (timeoutId !== undefined) {
+          clearTimeout(timeoutId);
+        }
+      }
+    }
+  };
+}
+
 function normalizeWorkflowResult(result) {
   if (result === null || typeof result !== "object") {
     return result;
@@ -108,7 +207,12 @@ export class Client {
     }
 
     this.provider = provider;
-    this.config = config;
+    const clientOptions = parseClientOptions(config);
+    this.config = {
+      ...config,
+      fetchImpl: createManagedFetch(config.fetchImpl, clientOptions),
+    };
+    this.clientOptions = clientOptions;
     this.rustClient = null;
     this.readyPromise = null;
     this.fetchOverrideQueue = Promise.resolve();

package/package.json

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

package/pkg/simple_agents_wasm.d.ts

@@ -36,9 +36,9 @@ export interface InitOutput {
     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__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__h8bdb42cdb6bde112: (a: number, b: number, c: any) => void;
+    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__h5cfabd7a8f920681: (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

@@ -329,7 +329,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h05acb8c479b21d4b(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h67e61867e7d8792e(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -410,12 +410,12 @@ function __wbg_get_imports() {
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // 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);
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h327a4c82efcf6931);
             return ret;
         },
         __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__h8bdb42cdb6bde112);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 68, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h5cfabd7a8f920681);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0) {
@@ -454,19 +454,19 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h8bdb42cdb6bde112(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h8bdb42cdb6bde112(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h5cfabd7a8f920681(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h5cfabd7a8f920681(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);
+function wasm_bindgen__convert__closures_____invoke__h327a4c82efcf6931(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h327a4c82efcf6931(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h05acb8c479b21d4b(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h05acb8c479b21d4b(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h67e61867e7d8792e(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h67e61867e7d8792e(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_runWorkflowYaml: (a: number, b: number, c: number, d: an
 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__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__h8bdb42cdb6bde112: (a: number, b: number, c: any) => void;
+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__h5cfabd7a8f920681: (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/rust/Cargo.toml

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