@workglow/util 0.0.101 → 0.0.103

package/dist/browser.js

@@ -143,6 +143,117 @@ class EventEmitter {
     return () => this.off(event, listener);
   }
 }
+// src/logging/ConsoleLogger.ts
+class ConsoleLogger {
+  bindings;
+  constructor(bindings = {}) {
+    this.bindings = bindings;
+  }
+  info(message, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.info(message, merged);
+    } else {
+      console.info(message);
+    }
+  }
+  warn(message, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.warn(message, merged);
+    } else {
+      console.warn(message);
+    }
+  }
+  error(message, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.error(message, merged);
+    } else {
+      console.error(message);
+    }
+  }
+  debug(message, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.debug(message, merged);
+    } else {
+      console.debug(message);
+    }
+  }
+  fatal(err, message, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.error(message, { ...merged, error: err });
+    } else {
+      console.error(message, { error: err });
+    }
+  }
+  time(label, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.info(`[time] ${label}`, merged);
+    }
+    console.time(label);
+  }
+  timeEnd(label, meta) {
+    console.timeEnd(label);
+    const merged = this.merge(meta);
+    if (merged) {
+      console.info(`[timeEnd] ${label}`, merged);
+    }
+  }
+  group(label, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.group(label, merged);
+    } else {
+      console.group(label);
+    }
+  }
+  groupEnd() {
+    console.groupEnd();
+  }
+  child(bindings) {
+    return new ConsoleLogger({ ...this.bindings, ...bindings });
+  }
+  merge(meta) {
+    const hasBindings = Object.keys(this.bindings).length > 0;
+    if (!hasBindings && !meta)
+      return;
+    if (!hasBindings)
+      return meta;
+    if (!meta)
+      return this.bindings;
+    return { ...this.bindings, ...meta };
+  }
+}
+// src/logging/NullLogger.ts
+class NullLogger {
+  info(_message, _meta) {}
+  error(_message, _meta) {}
+  warn(_message, _meta) {}
+  debug(_message, _meta) {}
+  fatal(_err, _message, _meta) {}
+  time(_label, _meta) {}
+  timeEnd(_label, _meta) {}
+  group(_label, _meta) {}
+  groupEnd() {}
+  child(_bindings) {
+    return this;
+  }
+}
+// src/logging/LoggerRegistry.ts
+var LOGGER = createServiceToken("logger");
+if (!globalServiceRegistry.has(LOGGER)) {
+  globalServiceRegistry.register(LOGGER, () => new ConsoleLogger, true);
+}
+function getLogger() {
+  return globalServiceRegistry.get(LOGGER);
+}
+function setLogger(logger) {
+  globalServiceRegistry.registerInstance(LOGGER, logger);
+}
 // src/utilities/BaseError.ts
 class BaseError {
   static type = "BaseError";
@@ -977,6 +1088,169 @@ function areObjectSchemasSemanticallyCompatible(sourceSchema, targetSchema) {
 }
 // src/json-schema/SchemaValidation.ts
 import { compileSchema } from "@sroussey/json-schema-library";
+// src/json-schema/parsePartialJson.ts
+function parsePartialJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed)
+    return;
+  try {
+    const result = JSON.parse(trimmed);
+    if (typeof result === "object" && result !== null && !Array.isArray(result)) {
+      return result;
+    }
+    return;
+  } catch {}
+  if (trimmed[0] !== "{")
+    return;
+  const repaired = repairJson(trimmed);
+  if (repaired === undefined)
+    return;
+  try {
+    const result = JSON.parse(repaired);
+    if (typeof result === "object" && result !== null && !Array.isArray(result)) {
+      return result;
+    }
+    return;
+  } catch {
+    return;
+  }
+}
+function repairJson(text) {
+  let result = "";
+  let i = 0;
+  const len = text.length;
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  let lastSafeEnd = 0;
+  while (i < len) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      result += ch;
+      i++;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      result += ch;
+      i++;
+      continue;
+    }
+    if (inString) {
+      if (ch === '"') {
+        inString = false;
+        result += ch;
+        i++;
+        lastSafeEnd = result.length;
+        continue;
+      }
+      result += ch;
+      i++;
+      continue;
+    }
+    switch (ch) {
+      case '"':
+        inString = true;
+        result += ch;
+        i++;
+        break;
+      case "{":
+        stack.push("}");
+        result += ch;
+        i++;
+        break;
+      case "[":
+        stack.push("]");
+        result += ch;
+        i++;
+        break;
+      case "}":
+        if (stack.length > 0 && stack[stack.length - 1] === "}") {
+          stack.pop();
+          result += ch;
+          i++;
+          lastSafeEnd = result.length;
+        } else {
+          return closeStack(result, stack);
+        }
+        break;
+      case "]":
+        if (stack.length > 0 && stack[stack.length - 1] === "]") {
+          stack.pop();
+          result += ch;
+          i++;
+          lastSafeEnd = result.length;
+        } else {
+          return closeStack(result, stack);
+        }
+        break;
+      default:
+        result += ch;
+        i++;
+        break;
+    }
+  }
+  if (inString) {
+    result += '"';
+  }
+  if (stack.length === 0) {
+    return result;
+  }
+  return closeStack(cleanTrailing(result), stack);
+}
+function cleanTrailing(text) {
+  let s = text.trimEnd();
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const trimmed = s.trimEnd();
+    if (trimmed.endsWith(",")) {
+      s = trimmed.slice(0, -1);
+      changed = true;
+      continue;
+    }
+    if (trimmed.endsWith(":")) {
+      const withoutColon = trimmed.slice(0, -1).trimEnd();
+      if (withoutColon.endsWith('"')) {
+        const keyStart = withoutColon.lastIndexOf('"', withoutColon.length - 2);
+        if (keyStart >= 0) {
+          let before = withoutColon.slice(0, keyStart).trimEnd();
+          if (before.endsWith(",")) {
+            before = before.slice(0, -1);
+          }
+          s = before;
+          changed = true;
+          continue;
+        }
+      }
+      s = withoutColon;
+      changed = true;
+      continue;
+    }
+    const bareTokenMatch = trimmed.match(/,\s*"[^"]*"\s*:\s*(?:tru|fal|nul|true|false|null|[\d.eE+-]+)$/);
+    if (bareTokenMatch) {
+      const valueStr = trimmed.slice(trimmed.lastIndexOf(":") + 1).trim();
+      try {
+        JSON.parse(valueStr);
+      } catch {
+        s = trimmed.slice(0, bareTokenMatch.index).trimEnd();
+        if (s.endsWith(","))
+          s = s.slice(0, -1);
+        changed = true;
+        continue;
+      }
+    }
+  }
+  return s;
+}
+function closeStack(text, stack) {
+  let result = text;
+  for (let i = stack.length - 1;i >= 0; i--) {
+    result += stack[i];
+  }
+  return result;
+}
 // src/utilities/Misc.ts
 function forceArray(input) {
   if (Array.isArray(input))
@@ -1581,43 +1855,12 @@ function normalizeNumberArray(values, throwOnZero = false) {
   return values.map((v) => v / norm);
 }
 // src/worker/WorkerManager.ts
-function extractTransferables(obj) {
-  const transferables = [];
-  const seen = new WeakSet;
-  function findTransferables(value) {
-    if (value && typeof value === "object" && seen.has(value)) {
-      return;
-    }
-    if (value && typeof value === "object") {
-      seen.add(value);
-    }
-    if (value instanceof Float32Array || value instanceof Int16Array) {
-      transferables.push(value.buffer);
-    } else if (value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array || value instanceof Uint16Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Float64Array || value instanceof BigInt64Array || value instanceof BigUint64Array) {
-      transferables.push(value.buffer);
-    } else if (typeof OffscreenCanvas !== "undefined" && value instanceof OffscreenCanvas) {
-      transferables.push(value);
-    } else if (typeof ImageBitmap !== "undefined" && value instanceof ImageBitmap) {
-      transferables.push(value);
-    } else if (typeof VideoFrame !== "undefined" && value instanceof VideoFrame) {
-      transferables.push(value);
-    } else if (typeof MessagePort !== "undefined" && value instanceof MessagePort) {
-      transferables.push(value);
-    } else if (value instanceof ArrayBuffer) {
-      transferables.push(value);
-    } else if (Array.isArray(value)) {
-      value.forEach(findTransferables);
-    } else if (value && typeof value === "object") {
-      Object.values(value).forEach(findTransferables);
-    }
-  }
-  findTransferables(obj);
-  return transferables;
-}
-
 class WorkerManager {
   workers = new Map;
   readyWorkers = new Map;
+  workerFunctions = new Map;
+  workerStreamFunctions = new Map;
+  workerReactiveFunctions = new Map;
   registerWorker(name, worker) {
     if (this.workers.has(name))
       throw new Error(`Worker ${name} is already registered.`);
@@ -1633,6 +1876,9 @@ class WorkerManager {
       const handleReady = (event) => {
         if (event.data?.type === "ready") {
           worker.removeEventListener("message", handleReady);
+          this.workerFunctions.set(name, new Set(event.data.functions ?? []));
+          this.workerStreamFunctions.set(name, new Set(event.data.streamFunctions ?? []));
+          this.workerReactiveFunctions.set(name, new Set(event.data.reactiveFunctions ?? []));
           resolve();
         }
       };
@@ -1651,6 +1897,10 @@ class WorkerManager {
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
     await this.readyWorkers.get(workerName);
+    const knownFunctions = this.workerFunctions.get(workerName);
+    if (knownFunctions && !knownFunctions.has(functionName)) {
+      throw new Error(`Function "${functionName}" is not registered on worker "${workerName}".`);
+    }
     return new Promise((resolve, reject) => {
       const requestId = crypto.randomUUID();
       const handleMessage = (event) => {
@@ -1679,8 +1929,7 @@ class WorkerManager {
         options.signal.addEventListener("abort", handleAbort, { once: true });
       }
       const message = { id: requestId, type: "call", functionName, args };
-      const transferables = extractTransferables(message);
-      worker.postMessage(message, transferables);
+      worker.postMessage(message);
     });
   }
   async callWorkerReactiveFunction(workerName, functionName, args) {
@@ -1688,6 +1937,9 @@ class WorkerManager {
     if (!worker)
       return;
     await this.readyWorkers.get(workerName);
+    const knownReactive = this.workerReactiveFunctions.get(workerName);
+    if (knownReactive && !knownReactive.has(functionName))
+      return;
     return new Promise((resolve) => {
       const requestId = crypto.randomUUID();
       const handleMessage = (event) => {
@@ -1707,8 +1959,7 @@ class WorkerManager {
       };
       worker.addEventListener("message", handleMessage);
       const message = { id: requestId, type: "call", functionName, args, reactive: true };
-      const transferables = extractTransferables(message);
-      worker.postMessage(message, transferables);
+      worker.postMessage(message);
     });
   }
   async* callWorkerStreamFunction(workerName, functionName, args, options) {
@@ -1716,6 +1967,11 @@ class WorkerManager {
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
     await this.readyWorkers.get(workerName);
+    const knownStream = this.workerStreamFunctions.get(workerName);
+    const knownFns = this.workerFunctions.get(workerName);
+    if (knownStream && knownFns && !knownStream.has(functionName) && !knownFns.has(functionName)) {
+      throw new Error(`Function "${functionName}" is not registered on worker "${workerName}".`);
+    }
     const requestId = crypto.randomUUID();
     const queue = [];
     let waiting = null;
@@ -1757,8 +2013,7 @@ class WorkerManager {
       options.signal.addEventListener("abort", handleAbort, { once: true });
     }
     const message = { id: requestId, type: "call", functionName, args, stream: true };
-    const transferables = extractTransferables(message);
-    worker.postMessage(message, transferables);
+    worker.postMessage(message);
     let completedNormally = false;
     try {
       while (true) {
@@ -1790,7 +2045,7 @@ var WORKER_MANAGER = createServiceToken("worker.manager");
 globalServiceRegistry.register(WORKER_MANAGER, () => new WorkerManager, true);
 // src/worker/WorkerServer.ts
 import { parentPort } from "@workglow/util";
-function extractTransferables2(obj) {
+function extractTransferables(obj) {
   const transferables = [];
   const seen = new WeakSet;
   function findTransferables(value) {
@@ -1844,8 +2099,9 @@ class WorkerServer {
       return;
     }
     this.completedRequests.add(id);
-    const transferables = extractTransferables2(result);
-    postMessage({ id, type: "complete", data: result }, transferables);
+    const transferables = extractTransferables(result);
+    const uniqueTransferables = [...new Set(transferables)];
+    postMessage({ id, type: "complete", data: result }, uniqueTransferables);
   };
   postError = (id, errorMessage) => {
     if (this.completedRequests.has(id)) {
@@ -1860,6 +2116,14 @@ class WorkerServer {
     }
     postMessage({ id, type: "stream_chunk", data: event });
   };
+  sendReady() {
+    postMessage({
+      type: "ready",
+      functions: Object.keys(this.functions),
+      streamFunctions: Object.keys(this.streamFunctions),
+      reactiveFunctions: Object.keys(this.reactiveFunctions)
+    });
+  }
   registerFunction(name, fn) {
     this.functions[name] = fn;
   }
@@ -2007,6 +2271,7 @@ function uuid4() {
 import { Client } from "@modelcontextprotocol/sdk/client";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var MCP_PROTOCOL_VERSION_HEADER = "2025-11-25";
 var mcpTransportTypes = ["streamable-http", "sse"];
 var mcpServerConfigSchema = {
   transport: {
@@ -2025,12 +2290,24 @@ var mcpServerConfigSchema = {
 async function createMcpClient(config, signal) {
   let transport;
   switch (config.transport) {
-    case "sse":
-      transport = new SSEClientTransport(new URL(config.server_url));
+    case "sse": {
+      const requestInit = {
+        headers: { "MCP-Protocol-Version": MCP_PROTOCOL_VERSION_HEADER }
+      };
+      transport = new SSEClientTransport(new URL(config.server_url), {
+        requestInit
+      });
       break;
-    case "streamable-http":
-      transport = new StreamableHTTPClientTransport(new URL(config.server_url));
+    }
+    case "streamable-http": {
+      const requestInit = {
+        headers: { "MCP-Protocol-Version": MCP_PROTOCOL_VERSION_HEADER }
+      };
+      transport = new StreamableHTTPClientTransport(new URL(config.server_url), {
+        requestInit
+      });
       break;
+    }
     default:
       throw new Error(`Unsupported transport type: ${config.transport}`);
   }
@@ -2049,6 +2326,10 @@ async function createMcpClient(config, signal) {
     if (is405) {
       throw new Error(`MCP connection failed with 405 Method Not Allowed for ${url}. ` + `This usually means the server does not accept GET requests. `, { cause: err });
     }
+    const is406 = message.includes("406") || message.includes("Not Acceptable") || typeof err === "object" && err !== null && "code" in err && err.code === 406;
+    if (is406) {
+      throw new Error(`MCP connection failed with 406 Not Acceptable for ${url}. ` + `Try using transport "sse" instead of "streamable-http", or ensure the server accepts the request format (Accept: application/json, text/event-stream and MCP-Protocol-Version).`, { cause: err });
+    }
     throw err;
   }
   return { client, transport };
@@ -2133,8 +2414,10 @@ export {
   sortObject,
   sleep,
   sha256,
+  setLogger,
   serialize,
   registerInputResolver,
+  parsePartialJson,
   parseDataUri,
   parentPort2 as parentPort,
   objectOfArraysAsArrayOfObjects,
@@ -2152,6 +2435,7 @@ export {
   hammingDistance,
   globalServiceRegistry,
   globalContainer,
+  getLogger,
   getInputResolvers,
   forceArray,
   deepEqual,
@@ -2175,8 +2459,10 @@ export {
   TensorType,
   TensorSchema,
   ServiceRegistry,
+  NullLogger,
   NodeDoesntExistError,
   NodeAlreadyExistsError,
+  LOGGER,
   INPUT_RESOLVERS,
   Graph,
   FromSchemaDefaultOptions,
@@ -2185,7 +2471,8 @@ export {
   DirectedAcyclicGraph,
   CycleError,
   Container,
+  ConsoleLogger,
   BaseError
 };
 
-//# debugId=D448FCC901209B0664756E2164756E21
+//# debugId=90D32FFAFD9AE31364756E2164756E21