@workglow/util 0.0.120 → 0.0.122

package/dist/node.js

@@ -885,357 +885,6 @@ var FromSchemaDefaultOptions = {
   references: false,
   deserialize: false
 };
-// src/json-schema/SchemaUtils.ts
-function areFormatStringsCompatible(sourceFormat, targetFormat) {
-  const formatPattern = /^[a-zA-Z][a-zA-Z0-9_-]*(?::[a-zA-Z][a-zA-Z0-9_-]*)?$/;
-  if (!formatPattern.test(sourceFormat) || !formatPattern.test(targetFormat)) {
-    return "incompatible";
-  }
-  const [sourceName, sourceNarrow] = sourceFormat.split(":");
-  const [targetName, targetNarrow] = targetFormat.split(":");
-  if (sourceName !== targetName) {
-    return "incompatible";
-  }
-  if (!sourceNarrow && !targetNarrow) {
-    return "static";
-  }
-  if (sourceNarrow && !targetNarrow) {
-    return "static";
-  }
-  if (!sourceNarrow && targetNarrow) {
-    return "runtime";
-  }
-  if (sourceNarrow === targetNarrow) {
-    return "static";
-  }
-  return "incompatible";
-}
-function isTypeStaticallyCompatible(sourceType, targetType) {
-  if (!targetType) {
-    return true;
-  }
-  if (!sourceType) {
-    return false;
-  }
-  const sourceTypes = Array.isArray(sourceType) ? sourceType : [sourceType];
-  const targetTypes = Array.isArray(targetType) ? targetType : [targetType];
-  return sourceTypes.some((st) => targetTypes.includes(st));
-}
-function mergeAllOfSchemas(schemas) {
-  if (schemas.length === 0)
-    return null;
-  if (schemas.length === 1)
-    return schemas[0];
-  let merged = {};
-  for (const schema of schemas) {
-    if (typeof schema === "boolean") {
-      if (schema === false)
-        return false;
-      continue;
-    }
-    const schemaObj = schema;
-    if (schemaObj.type !== undefined) {
-      if (merged.type === undefined) {
-        merged.type = schemaObj.type;
-      } else if (merged.type !== schemaObj.type) {
-        const mergedTypes = Array.isArray(merged.type) ? merged.type : [merged.type];
-        const schemaTypes = Array.isArray(schemaObj.type) ? schemaObj.type : [schemaObj.type];
-        const commonTypes = mergedTypes.filter((t) => schemaTypes.includes(t));
-        if (commonTypes.length === 0) {
-          return false;
-        }
-        merged.type = commonTypes.length === 1 ? commonTypes[0] : commonTypes;
-      }
-    }
-    const schemaFormat = schemaObj.format;
-    const mergedFormat = merged.format;
-    if (schemaFormat) {
-      if (!mergedFormat) {
-        merged.format = schemaFormat;
-      } else {
-        const formatCompat = areFormatStringsCompatible(mergedFormat, schemaFormat);
-        if (formatCompat === "incompatible") {
-          return false;
-        }
-        const mergedHasNarrow = mergedFormat.includes(":");
-        const schemaHasNarrow = schemaFormat.includes(":");
-        if (schemaHasNarrow && !mergedHasNarrow) {
-          merged.format = schemaFormat;
-        } else if (!schemaHasNarrow && mergedHasNarrow) {} else if (mergedFormat !== schemaFormat) {
-          return false;
-        }
-      }
-    }
-    if (schemaObj.properties && typeof schemaObj.properties === "object") {
-      if (!merged.properties) {
-        merged.properties = {};
-      }
-      const mergedProps = merged.properties;
-      const schemaProps = schemaObj.properties;
-      for (const [key, value] of Object.entries(schemaProps)) {
-        if (mergedProps[key]) {
-          const nestedMerged = mergeAllOfSchemas([mergedProps[key], value]);
-          if (nestedMerged === null || nestedMerged === false) {
-            return false;
-          }
-          mergedProps[key] = nestedMerged;
-        } else {
-          mergedProps[key] = value;
-        }
-      }
-    }
-    if (schemaObj.required && Array.isArray(schemaObj.required)) {
-      if (!merged.required) {
-        merged.required = [];
-      }
-      const mergedRequired = merged.required;
-      const schemaRequired = schemaObj.required;
-      merged.required = mergedRequired.filter((r) => schemaRequired.includes(r));
-    }
-    if (schemaObj.additionalProperties !== undefined) {
-      if (merged.additionalProperties === undefined) {
-        merged.additionalProperties = schemaObj.additionalProperties;
-      } else if (merged.additionalProperties === true && schemaObj.additionalProperties === false) {
-        merged.additionalProperties = false;
-      }
-    }
-    if (schemaObj.items !== undefined) {
-      if (merged.items === undefined) {
-        merged.items = schemaObj.items;
-      } else {
-        const mergedItems = mergeAllOfSchemas([
-          merged.items,
-          schemaObj.items
-        ]);
-        if (mergedItems === null || mergedItems === false) {
-          return false;
-        }
-        merged.items = mergedItems;
-      }
-    }
-  }
-  return merged;
-}
-function isCompatibleWithUnion(sourceSchema, unionSchemas) {
-  let hasStatic = false;
-  let hasRuntime = false;
-  for (const unionSchema of unionSchemas) {
-    const compatibility = areSemanticallyCompatible(sourceSchema, unionSchema);
-    if (compatibility === "static") {
-      hasStatic = true;
-    } else if (compatibility === "runtime") {
-      hasRuntime = true;
-    }
-  }
-  if (hasStatic)
-    return "static";
-  if (hasRuntime)
-    return "runtime";
-  return "incompatible";
-}
-function areSemanticallyCompatible(sourceSchema, targetSchema) {
-  if (sourceSchema === undefined || targetSchema === undefined) {
-    return "incompatible";
-  }
-  if (typeof targetSchema === "boolean") {
-    if (targetSchema === false)
-      return "incompatible";
-    if (targetSchema === true)
-      return "static";
-    return "incompatible";
-  }
-  if (typeof sourceSchema === "boolean") {
-    if (sourceSchema === false)
-      return "incompatible";
-    if (sourceSchema === true)
-      return "runtime";
-  }
-  if (sourceSchema.allOf && Array.isArray(sourceSchema.allOf)) {
-    const mergedSchema = mergeAllOfSchemas(sourceSchema.allOf);
-    if (mergedSchema === null || mergedSchema === false) {
-      return "incompatible";
-    }
-    return areSemanticallyCompatible(mergedSchema, targetSchema);
-  }
-  const sourceType = sourceSchema.type;
-  const targetType = targetSchema.type;
-  if (sourceSchema.oneOf && Array.isArray(sourceSchema.oneOf)) {
-    let hasStatic = false;
-    let hasRuntime = false;
-    for (const sourceOption of sourceSchema.oneOf) {
-      const compatibility = areSemanticallyCompatible(sourceOption, targetSchema);
-      if (compatibility === "static") {
-        hasStatic = true;
-      } else if (compatibility === "runtime") {
-        hasRuntime = true;
-      }
-    }
-    if (hasRuntime)
-      return "runtime";
-    if (hasStatic)
-      return "static";
-    return "incompatible";
-  }
-  if (sourceSchema.anyOf && Array.isArray(sourceSchema.anyOf)) {
-    let hasStatic = false;
-    let hasRuntime = false;
-    for (const sourceOption of sourceSchema.anyOf) {
-      const compatibility = areSemanticallyCompatible(sourceOption, targetSchema);
-      if (compatibility === "static") {
-        hasStatic = true;
-      } else if (compatibility === "runtime") {
-        hasRuntime = true;
-      }
-    }
-    if (hasRuntime)
-      return "runtime";
-    if (hasStatic)
-      return "static";
-    return "incompatible";
-  }
-  if (targetSchema.oneOf && Array.isArray(targetSchema.oneOf)) {
-    return isCompatibleWithUnion(sourceSchema, targetSchema.oneOf);
-  }
-  if (targetSchema.anyOf && Array.isArray(targetSchema.anyOf)) {
-    return isCompatibleWithUnion(sourceSchema, targetSchema.anyOf);
-  }
-  if (targetSchema.allOf && Array.isArray(targetSchema.allOf)) {
-    let hasStatic = false;
-    let hasRuntime = false;
-    for (const allOfSchema of targetSchema.allOf) {
-      const compatibility = areSemanticallyCompatible(sourceSchema, allOfSchema);
-      if (compatibility === "incompatible") {
-        return "incompatible";
-      } else if (compatibility === "static") {
-        hasStatic = true;
-      } else if (compatibility === "runtime") {
-        hasRuntime = true;
-      }
-    }
-    if (hasRuntime)
-      return "runtime";
-    if (hasStatic)
-      return "static";
-    return "incompatible";
-  }
-  if (sourceType === "object" && targetType === "object") {
-    const sourceProperties = sourceSchema.properties;
-    const targetProperties = targetSchema.properties;
-    if (!targetProperties) {
-      return "static";
-    }
-    if (!sourceProperties) {
-      if (targetSchema.additionalProperties === false) {
-        return "incompatible";
-      }
-      return "static";
-    }
-    const targetRequired = targetSchema.required || [];
-    let hasStatic = true;
-    let hasRuntime = false;
-    for (const propName of targetRequired) {
-      const targetProp = targetProperties?.[propName];
-      const sourceProp = sourceProperties?.[propName];
-      if (!sourceProp) {
-        return "incompatible";
-      }
-      if (targetProp) {
-        const propCompatibility = areSemanticallyCompatible(sourceProp, targetProp);
-        if (propCompatibility === "incompatible") {
-          return "incompatible";
-        } else if (propCompatibility === "runtime") {
-          hasRuntime = true;
-          hasStatic = false;
-        }
-      }
-    }
-    if (targetSchema.additionalProperties === false) {
-      const sourcePropNames = Object.keys(sourceProperties);
-      const targetPropNames = Object.keys(targetProperties);
-      const extraProps = sourcePropNames.filter((name) => !targetPropNames.includes(name));
-      if (extraProps.length > 0) {
-        return "incompatible";
-      }
-    }
-    if (hasRuntime)
-      return "runtime";
-    return "static";
-  }
-  if (sourceType === "array" && targetType === "array") {
-    const sourceFormat2 = sourceSchema?.format;
-    const targetFormat2 = targetSchema?.format;
-    let formatCompatibility = null;
-    if (sourceFormat2 && targetFormat2) {
-      formatCompatibility = areFormatStringsCompatible(sourceFormat2, targetFormat2);
-      if (formatCompatibility === "incompatible") {
-        return "incompatible";
-      }
-    }
-    if (sourceFormat2 && !targetFormat2) {
-      return "static";
-    }
-    if (!sourceFormat2 && targetFormat2) {
-      return "incompatible";
-    }
-    const sourceItems = sourceSchema.items;
-    const targetItems = targetSchema.items;
-    if (sourceItems && typeof sourceItems === "object" && !Array.isArray(sourceItems) && targetItems && typeof targetItems === "object" && !Array.isArray(targetItems)) {
-      const itemsCompatibility = areSemanticallyCompatible(sourceItems, targetItems);
-      if (formatCompatibility === "runtime") {
-        return "runtime";
-      }
-      return itemsCompatibility;
-    }
-    if (!targetItems) {
-      return "static";
-    }
-    if (!sourceItems) {
-      return "incompatible";
-    }
-    if (Array.isArray(targetItems)) {
-      return isCompatibleWithUnion(sourceItems, targetItems);
-    }
-    return "static";
-  }
-  if (!sourceType) {
-    const targetFormat2 = targetSchema?.format;
-    if (targetFormat2) {
-      return "runtime";
-    }
-    return "static";
-  }
-  if (!targetType) {
-    const targetFormat2 = targetSchema?.format;
-    if (targetFormat2) {
-      const sourceFormat2 = sourceSchema?.format;
-      if (!sourceFormat2) {
-        return "incompatible";
-      }
-      return areFormatStringsCompatible(sourceFormat2, targetFormat2);
-    }
-    return "static";
-  }
-  if (!isTypeStaticallyCompatible(sourceType, targetType)) {
-    return "incompatible";
-  }
-  const sourceFormat = sourceSchema?.format;
-  const targetFormat = targetSchema?.format;
-  if (sourceFormat && targetFormat) {
-    return areFormatStringsCompatible(sourceFormat, targetFormat);
-  }
-  if (sourceFormat && !targetFormat) {
-    return "static";
-  }
-  if (!sourceFormat && targetFormat) {
-    return "incompatible";
-  }
-  return "static";
-}
-function areObjectSchemasSemanticallyCompatible(sourceSchema, targetSchema) {
-  return areSemanticallyCompatible(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();
@@ -1942,10 +1591,22 @@ class WorkerManager {
   workerFunctions = new Map;
   workerStreamFunctions = new Map;
   workerReactiveFunctions = new Map;
-  registerWorker(name, worker) {
-    if (this.workers.has(name))
+  lazyFactories = new Map;
+  lazyInitPromises = new Map;
+  registerWorker(name, workerOrFactory) {
+    if (this.workers.has(name)) {
       throw new Error(`Worker ${name} is already registered.`);
-    this.workers.set(name, worker);
+    }
+    if (this.lazyFactories.has(name)) {
+      throw new Error(`Worker ${name} is already registered.`);
+    }
+    if (typeof workerOrFactory === "function") {
+      this.lazyFactories.set(name, workerOrFactory);
+    } else {
+      this.attachWorkerInstance(name, workerOrFactory);
+    }
+  }
+  attachWorkerInstance(name, worker) {
     this.workers.set(name, worker);
     worker.addEventListener("error", (event) => {
       console.error("Worker Error:", event.message, "at", event.filename, "line:", event.lineno);
@@ -1967,6 +1628,29 @@ class WorkerManager {
     });
     this.readyWorkers.set(name, readyPromise);
   }
+  async ensureWorkerReady(name) {
+    if (this.workers.has(name)) {
+      await this.readyWorkers.get(name);
+      return;
+    }
+    const factory = this.lazyFactories.get(name);
+    if (!factory) {
+      throw new Error(`Worker ${name} not found.`);
+    }
+    let init = this.lazyInitPromises.get(name);
+    if (!init) {
+      init = (async () => {
+        const f = this.lazyFactories.get(name);
+        this.lazyFactories.delete(name);
+        const worker = f();
+        this.attachWorkerInstance(name, worker);
+      })();
+      this.lazyInitPromises.set(name, init);
+    }
+    await init;
+    await this.readyWorkers.get(name);
+    this.lazyInitPromises.delete(name);
+  }
   getWorker(name) {
     const worker = this.workers.get(name);
     if (!worker)
@@ -1974,6 +1658,7 @@ class WorkerManager {
     return worker;
   }
   async callWorkerFunction(workerName, functionName, args, options) {
+    await this.ensureWorkerReady(workerName);
     const worker = this.workers.get(workerName);
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
@@ -2019,6 +1704,7 @@ class WorkerManager {
     });
   }
   async callWorkerReactiveFunction(workerName, functionName, args) {
+    await this.ensureWorkerReady(workerName);
     const worker = this.workers.get(workerName);
     if (!worker)
       return;
@@ -2050,6 +1736,7 @@ class WorkerManager {
     });
   }
   async* callWorkerStreamFunction(workerName, functionName, args, options) {
+    await this.ensureWorkerReady(workerName);
     const worker = this.workers.get(workerName);
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
@@ -2133,292 +1820,96 @@ class WorkerManager {
 }
 var WORKER_MANAGER = createServiceToken("worker.manager");
 globalServiceRegistry.register(WORKER_MANAGER, () => new WorkerManager, true);
-// src/worker/WorkerServer.ts
-import { parentPort } from "@workglow/util";
-function extractTransferables(obj) {
-  const transferables = [];
-  const seen = new WeakSet;
-  function findTransferables(value) {
-    if (value && typeof value === "object" && seen.has(value)) {
+// src/credentials/ICredentialStore.ts
+var CREDENTIAL_STORE = createServiceToken("credential.store");
+// src/credentials/InMemoryCredentialStore.ts
+class InMemoryCredentialStore {
+  store = new Map;
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry)
+      return;
+    if (entry.metadata.expiresAt && entry.metadata.expiresAt <= new Date) {
+      this.store.delete(key);
       return;
     }
-    if (value && typeof value === "object") {
-      seen.add(value);
+    return entry.value;
+  }
+  async put(key, value, options) {
+    const now = new Date;
+    const existing = this.store.get(key);
+    const metadata = {
+      label: options?.label ?? existing?.metadata.label,
+      provider: options?.provider ?? existing?.metadata.provider,
+      createdAt: existing?.metadata.createdAt ?? now,
+      updatedAt: now,
+      expiresAt: options?.expiresAt ?? existing?.metadata.expiresAt
+    };
+    this.store.set(key, { key, value, metadata });
+  }
+  async delete(key) {
+    return this.store.delete(key);
+  }
+  async has(key) {
+    const entry = this.store.get(key);
+    if (!entry)
+      return false;
+    if (entry.metadata.expiresAt && entry.metadata.expiresAt <= new Date) {
+      this.store.delete(key);
+      return false;
     }
-    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);
+    return true;
+  }
+  async keys() {
+    const now = new Date;
+    const result = [];
+    for (const [key, entry] of this.store) {
+      if (entry.metadata.expiresAt && entry.metadata.expiresAt <= now) {
+        this.store.delete(key);
+        continue;
+      }
+      result.push(key);
     }
+    return result;
+  }
+  async deleteAll() {
+    this.store.clear();
   }
-  findTransferables(obj);
-  return transferables;
 }
-
-class WorkerServer {
-  constructor() {
-    parentPort?.addEventListener("message", async (event) => {
-      const msg = {
-        type: event.type,
-        data: event.data
-      };
-      await this.handleMessage(msg);
-    });
+// src/credentials/EnvCredentialStore.ts
+class EnvCredentialStore {
+  keyToEnvVar;
+  prefix;
+  constructor(mapping = {}, prefix) {
+    this.keyToEnvVar = new Map(Object.entries(mapping));
+    this.prefix = prefix;
   }
-  functions = {};
-  streamFunctions = {};
-  reactiveFunctions = {};
-  requestControllers = new Map;
-  completedRequests = new Set;
-  postResult = (id, result) => {
-    if (this.completedRequests.has(id)) {
-      return;
-    }
-    this.completedRequests.add(id);
-    const transferables = extractTransferables(result);
-    const uniqueTransferables = [...new Set(transferables)];
-    postMessage({ id, type: "complete", data: result }, uniqueTransferables);
-  };
-  postError = (id, errorMessage) => {
-    if (this.completedRequests.has(id)) {
-      return;
-    }
-    this.completedRequests.add(id);
-    postMessage({ id, type: "error", data: errorMessage });
-  };
-  postStreamChunk = (id, event) => {
-    if (this.completedRequests.has(id)) {
-      return;
+  resolveEnvVar(key) {
+    const explicit = this.keyToEnvVar.get(key);
+    if (explicit)
+      return explicit;
+    if (this.prefix) {
+      return `${this.prefix}_${key.toUpperCase().replace(/-/g, "_")}`;
     }
-    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;
+    return key.toUpperCase().replace(/-/g, "_");
   }
-  registerReactiveFunction(name, fn) {
-    this.reactiveFunctions[name] = fn;
+  getEnv(envVar) {
+    if (typeof process !== "undefined" && process.env) {
+      return process.env[envVar];
+    }
+    return;
   }
-  registerStreamFunction(name, fn) {
-    this.streamFunctions[name] = fn;
+  async get(key) {
+    const envVar = this.resolveEnvVar(key);
+    return this.getEnv(envVar);
   }
-  async handleMessage(event) {
-    const { id, type, functionName, args, stream, reactive } = event.data;
-    if (type === "abort") {
-      return await this.handleAbort(id);
+  async put(key, value, _options) {
+    const envVar = this.resolveEnvVar(key);
+    if (typeof process !== "undefined" && process.env) {
+      process.env[envVar] = value;
     }
-    if (type === "call") {
-      if (stream) {
-        return await this.handleStreamCall(id, functionName, args);
-      }
-      if (reactive) {
-        return await this.handleReactiveCall(id, functionName, args);
-      }
-      return await this.handleCall(id, functionName, args);
-    }
-  }
-  async handleAbort(id) {
-    if (this.requestControllers.has(id)) {
-      const controller = this.requestControllers.get(id);
-      controller?.abort();
-      this.requestControllers.delete(id);
-      this.postError(id, "Operation aborted");
-    }
-  }
-  async handleReactiveCall(id, functionName, [input, output, model]) {
-    if (!(functionName in this.reactiveFunctions)) {
-      this.postResult(id, undefined);
-      return;
-    }
-    try {
-      const fn = this.reactiveFunctions[functionName];
-      const result = await fn(input, output, model);
-      this.postResult(id, result);
-    } catch (error) {
-      this.postError(id, error.message);
-    }
-  }
-  async handleCall(id, functionName, [input, model]) {
-    if (!(functionName in this.functions)) {
-      this.postError(id, `Function ${functionName} not found`);
-      return;
-    }
-    try {
-      const abortController = new AbortController;
-      this.requestControllers.set(id, abortController);
-      const fn = this.functions[functionName];
-      const postProgress = (progress, message, details) => {
-        if (!this.completedRequests.has(id)) {
-          postMessage({ id, type: "progress", data: { progress, message, details } });
-        }
-      };
-      const result = await fn(input, model, postProgress, abortController.signal);
-      this.postResult(id, result);
-    } catch (error) {
-      this.postError(id, error.message);
-    } finally {
-      this.requestControllers.delete(id);
-      setTimeout(() => {
-        this.completedRequests.delete(id);
-      }, 1000);
-    }
-  }
-  async handleStreamCall(id, functionName, [input, model]) {
-    if (functionName in this.streamFunctions) {
-      try {
-        const abortController = new AbortController;
-        this.requestControllers.set(id, abortController);
-        const fn = this.streamFunctions[functionName];
-        const iterable = fn(input, model, abortController.signal);
-        for await (const event of iterable) {
-          if (this.completedRequests.has(id))
-            break;
-          this.postStreamChunk(id, event);
-        }
-        this.postResult(id, undefined);
-      } catch (error) {
-        this.postError(id, error.message);
-      } finally {
-        this.requestControllers.delete(id);
-        setTimeout(() => {
-          this.completedRequests.delete(id);
-        }, 1000);
-      }
-    } else if (functionName in this.functions) {
-      try {
-        const abortController = new AbortController;
-        this.requestControllers.set(id, abortController);
-        const fn = this.functions[functionName];
-        const noopProgress = () => {};
-        const result = await fn(input, model, noopProgress, abortController.signal);
-        this.postStreamChunk(id, { type: "finish", data: result });
-        this.postResult(id, undefined);
-      } catch (error) {
-        this.postError(id, error.message);
-      } finally {
-        this.requestControllers.delete(id);
-        setTimeout(() => {
-          this.completedRequests.delete(id);
-        }, 1000);
-      }
-    } else {
-      this.postError(id, `Function ${functionName} not found`);
-    }
-  }
-}
-var WORKER_SERVER = createServiceToken("worker.server");
-globalServiceRegistry.register(WORKER_SERVER, () => new WorkerServer, true);
-// src/credentials/ICredentialStore.ts
-var CREDENTIAL_STORE = createServiceToken("credential.store");
-// src/credentials/InMemoryCredentialStore.ts
-class InMemoryCredentialStore {
-  store = new Map;
-  async get(key) {
-    const entry = this.store.get(key);
-    if (!entry)
-      return;
-    if (entry.metadata.expiresAt && entry.metadata.expiresAt <= new Date) {
-      this.store.delete(key);
-      return;
-    }
-    return entry.value;
-  }
-  async put(key, value, options) {
-    const now = new Date;
-    const existing = this.store.get(key);
-    const metadata = {
-      label: options?.label ?? existing?.metadata.label,
-      provider: options?.provider ?? existing?.metadata.provider,
-      createdAt: existing?.metadata.createdAt ?? now,
-      updatedAt: now,
-      expiresAt: options?.expiresAt ?? existing?.metadata.expiresAt
-    };
-    this.store.set(key, { key, value, metadata });
-  }
-  async delete(key) {
-    return this.store.delete(key);
-  }
-  async has(key) {
-    const entry = this.store.get(key);
-    if (!entry)
-      return false;
-    if (entry.metadata.expiresAt && entry.metadata.expiresAt <= new Date) {
-      this.store.delete(key);
-      return false;
-    }
-    return true;
-  }
-  async keys() {
-    const now = new Date;
-    const result = [];
-    for (const [key, entry] of this.store) {
-      if (entry.metadata.expiresAt && entry.metadata.expiresAt <= now) {
-        this.store.delete(key);
-        continue;
-      }
-      result.push(key);
-    }
-    return result;
-  }
-  async deleteAll() {
-    this.store.clear();
-  }
-}
-// src/credentials/EnvCredentialStore.ts
-class EnvCredentialStore {
-  keyToEnvVar;
-  prefix;
-  constructor(mapping = {}, prefix) {
-    this.keyToEnvVar = new Map(Object.entries(mapping));
-    this.prefix = prefix;
-  }
-  resolveEnvVar(key) {
-    const explicit = this.keyToEnvVar.get(key);
-    if (explicit)
-      return explicit;
-    if (this.prefix) {
-      return `${this.prefix}_${key.toUpperCase().replace(/-/g, "_")}`;
-    }
-    return key.toUpperCase().replace(/-/g, "_");
-  }
-  getEnv(envVar) {
-    if (typeof process !== "undefined" && process.env) {
-      return process.env[envVar];
-    }
-    return;
-  }
-  async get(key) {
-    const envVar = this.resolveEnvVar(key);
-    return this.getEnv(envVar);
-  }
-  async put(key, value, _options) {
-    const envVar = this.resolveEnvVar(key);
-    if (typeof process !== "undefined" && process.env) {
-      process.env[envVar] = value;
-    }
-    if (!this.keyToEnvVar.has(key)) {
-      this.keyToEnvVar.set(key, envVar);
+    if (!this.keyToEnvVar.has(key)) {
+      this.keyToEnvVar.set(key, envVar);
     }
   }
   async delete(key) {
@@ -2554,532 +2045,20 @@ async function decrypt(encrypted, iv, passphrase, keyCache) {
   const plainBuf = await crypto.subtle.decrypt({ name: "AES-GCM", iv: base64ToBuf(iv) }, key, ciphertextBytes);
   return new TextDecoder().decode(plainBuf);
 }
-function bufToBase64(buf) {
-  let binary = "";
-  for (let i = 0;i < buf.length; i++) {
-    binary += String.fromCharCode(buf[i]);
-  }
-  return btoa(binary);
-}
-function base64ToBuf(b64) {
-  const binary = atob(b64);
-  const buf = new Uint8Array(binary.length);
-  for (let i = 0;i < binary.length; i++) {
-    buf[i] = binary.charCodeAt(i);
-  }
-  return buf;
-}
-// src/mcp/McpAuthTypes.ts
-var mcpAuthTypes = [
-  "none",
-  "bearer",
-  "client_credentials",
-  "private_key_jwt",
-  "static_private_key_jwt",
-  "authorization_code"
-];
-var mcpAuthConfigSchema = {
-  properties: {
-    auth_type: {
-      type: "string",
-      enum: mcpAuthTypes,
-      title: "Auth Type",
-      description: "Authentication method for connecting to the MCP server",
-      default: "none"
-    },
-    auth_token: {
-      type: "string",
-      format: "credential",
-      title: "Bearer Token",
-      description: "Static bearer token or API key (for bearer auth)"
-    },
-    auth_client_id: {
-      type: "string",
-      title: "Client ID",
-      description: "OAuth client ID (for OAuth auth types)"
-    },
-    auth_client_secret: {
-      type: "string",
-      format: "credential",
-      title: "Client Secret",
-      description: "OAuth client secret (for client_credentials auth)"
-    },
-    auth_private_key: {
-      type: "string",
-      format: "credential",
-      title: "Private Key",
-      description: "PEM or JWK private key (for private_key_jwt auth)"
-    },
-    auth_algorithm: {
-      type: "string",
-      title: "Algorithm",
-      description: "JWT signing algorithm, e.g. RS256, ES256 (for private_key_jwt auth)"
-    },
-    auth_jwt_bearer_assertion: {
-      type: "string",
-      format: "credential",
-      title: "JWT Assertion",
-      description: "Pre-built JWT assertion (for static_private_key_jwt auth)"
-    },
-    auth_redirect_url: {
-      type: "string",
-      format: "uri",
-      title: "Redirect URL",
-      description: "OAuth redirect URL (for authorization_code auth)"
-    },
-    auth_scope: {
-      type: "string",
-      title: "Scope",
-      description: "OAuth scope (space-separated)"
-    },
-    auth_client_name: {
-      type: "string",
-      title: "Client Name",
-      description: "Optional OAuth client display name"
-    },
-    auth_jwt_lifetime_seconds: {
-      type: "number",
-      title: "JWT Lifetime",
-      description: "JWT lifetime in seconds (default: 300)",
-      minimum: 1
-    }
-  },
-  allOf: [
-    {
-      if: { properties: { auth_type: { const: "bearer" } }, required: ["auth_type"] },
-      then: {
-        required: ["auth_token"],
-        properties: { auth_token: true }
-      }
-    },
-    {
-      if: {
-        properties: { auth_type: { const: "client_credentials" } },
-        required: ["auth_type"]
-      },
-      then: {
-        required: ["auth_client_id", "auth_client_secret"],
-        properties: {
-          auth_client_id: true,
-          auth_client_secret: true,
-          auth_client_name: true,
-          auth_scope: true
-        }
-      }
-    },
-    {
-      if: { properties: { auth_type: { const: "private_key_jwt" } }, required: ["auth_type"] },
-      then: {
-        required: ["auth_client_id", "auth_private_key", "auth_algorithm"],
-        properties: {
-          auth_client_id: true,
-          auth_private_key: true,
-          auth_algorithm: true,
-          auth_client_name: true,
-          auth_jwt_lifetime_seconds: true,
-          auth_scope: true
-        }
-      }
-    },
-    {
-      if: {
-        properties: { auth_type: { const: "static_private_key_jwt" } },
-        required: ["auth_type"]
-      },
-      then: {
-        required: ["auth_client_id", "auth_jwt_bearer_assertion"],
-        properties: {
-          auth_client_id: true,
-          auth_jwt_bearer_assertion: true,
-          auth_client_name: true,
-          auth_scope: true
-        }
-      }
-    },
-    {
-      if: { properties: { auth_type: { const: "authorization_code" } }, required: ["auth_type"] },
-      then: {
-        required: ["auth_client_id", "auth_redirect_url"],
-        properties: {
-          auth_client_id: true,
-          auth_client_secret: true,
-          auth_redirect_url: true,
-          auth_scope: true
-        }
-      }
-    }
-  ]
-};
-function isMcpAuthType(value) {
-  return typeof value === "string" && mcpAuthTypes.includes(value);
-}
-function asNonEmptyString(value) {
-  if (typeof value !== "string")
-    return;
-  const trimmed = value.trim();
-  return trimmed === "" ? undefined : trimmed;
-}
-function asNumber(value) {
-  return typeof value === "number" ? value : undefined;
-}
-function buildAuthConfig(flat) {
-  const rawAuthType = flat.auth_type;
-  if (!isMcpAuthType(rawAuthType) || rawAuthType === "none") {
-    return;
-  }
-  const authType = rawAuthType;
-  switch (authType) {
-    case "bearer": {
-      const token = asNonEmptyString(flat.auth_token);
-      if (!token)
-        return;
-      return { type: "bearer", token };
-    }
-    case "client_credentials": {
-      const client_id = asNonEmptyString(flat.auth_client_id);
-      const client_secret = asNonEmptyString(flat.auth_client_secret);
-      if (!client_id || !client_secret)
-        return;
-      return {
-        type: "client_credentials",
-        client_id,
-        client_secret,
-        client_name: asNonEmptyString(flat.auth_client_name),
-        scope: asNonEmptyString(flat.auth_scope)
-      };
-    }
-    case "private_key_jwt": {
-      const client_id = asNonEmptyString(flat.auth_client_id);
-      const private_key = asNonEmptyString(flat.auth_private_key);
-      const algorithm = asNonEmptyString(flat.auth_algorithm);
-      if (!client_id || !private_key || !algorithm)
-        return;
-      return {
-        type: "private_key_jwt",
-        client_id,
-        private_key,
-        algorithm,
-        client_name: asNonEmptyString(flat.auth_client_name),
-        jwt_lifetime_seconds: asNumber(flat.auth_jwt_lifetime_seconds),
-        scope: asNonEmptyString(flat.auth_scope)
-      };
-    }
-    case "static_private_key_jwt": {
-      const client_id = asNonEmptyString(flat.auth_client_id);
-      const jwt_bearer_assertion = asNonEmptyString(flat.auth_jwt_bearer_assertion);
-      if (!client_id || !jwt_bearer_assertion)
-        return;
-      return {
-        type: "static_private_key_jwt",
-        client_id,
-        jwt_bearer_assertion,
-        client_name: asNonEmptyString(flat.auth_client_name),
-        scope: asNonEmptyString(flat.auth_scope)
-      };
-    }
-    case "authorization_code": {
-      const client_id = asNonEmptyString(flat.auth_client_id);
-      const redirect_url = asNonEmptyString(flat.auth_redirect_url);
-      if (!client_id || !redirect_url)
-        return;
-      return {
-        type: "authorization_code",
-        client_id,
-        client_secret: asNonEmptyString(flat.auth_client_secret),
-        redirect_url,
-        scope: asNonEmptyString(flat.auth_scope)
-      };
-    }
-    default:
-      return;
-  }
-}
-// src/mcp/McpAuthProvider.ts
-import {
-  ClientCredentialsProvider,
-  PrivateKeyJwtProvider,
-  StaticPrivateKeyJwtProvider,
-  createPrivateKeyJwtAuth
-} from "@modelcontextprotocol/sdk/client/auth-extensions.js";
-import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
-function normalizeServerUrl(serverUrl) {
-  try {
-    const u = new URL(serverUrl);
-    return u.origin + u.pathname.replace(/\/+$/, "");
-  } catch {
-    return serverUrl;
-  }
-}
-function storeKey(serverUrl, suffix) {
-  return `mcp:oauth:${normalizeServerUrl(serverUrl)}:${suffix}`;
-}
-
-class CredentialStoreOAuthProvider {
-  store;
-  serverUrl;
-  _clientMetadata;
-  _redirectUrl;
-  _initialClientInfo;
-  prepareTokenRequest;
-  addClientAuthentication;
-  constructor(options) {
-    this.store = options.store;
-    this.serverUrl = options.serverUrl;
-    this._clientMetadata = options.clientMetadata;
-    this._redirectUrl = options.redirectUrl;
-    this._initialClientInfo = options.initialClientInfo;
-    if (options.prepareTokenRequest) {
-      this.prepareTokenRequest = options.prepareTokenRequest;
-    }
-    if (options.addClientAuthentication) {
-      this.addClientAuthentication = options.addClientAuthentication;
-    }
-  }
-  get redirectUrl() {
-    return this._redirectUrl;
-  }
-  get clientMetadata() {
-    return this._clientMetadata;
-  }
-  async clientInformation() {
-    const raw = await this.store.get(storeKey(this.serverUrl, "client_info"));
-    if (!raw)
-      return this._initialClientInfo;
-    return JSON.parse(raw);
-  }
-  async saveClientInformation(info) {
-    await this.store.put(storeKey(this.serverUrl, "client_info"), JSON.stringify(info));
-  }
-  async tokens() {
-    const raw = await this.store.get(storeKey(this.serverUrl, "tokens"));
-    if (!raw)
-      return;
-    return JSON.parse(raw);
-  }
-  async saveTokens(tokens) {
-    const expiresAt = tokens.expires_in != null ? new Date(Date.now() + tokens.expires_in * 1000) : undefined;
-    await this.store.put(storeKey(this.serverUrl, "tokens"), JSON.stringify(tokens), {
-      expiresAt
-    });
-  }
-  async redirectToAuthorization(authorizationUrl) {
-    throw new Error(`MCP OAuth authorization required. ` + `Open this URL to authorize: ${authorizationUrl.toString()}`);
-  }
-  async saveCodeVerifier(codeVerifier) {
-    await this.store.put(storeKey(this.serverUrl, "code_verifier"), codeVerifier);
-  }
-  async codeVerifier() {
-    const v = await this.store.get(storeKey(this.serverUrl, "code_verifier"));
-    if (!v)
-      throw new Error("No code verifier saved for this session");
-    return v;
-  }
-  async saveDiscoveryState(state) {
-    await this.store.put(storeKey(this.serverUrl, "discovery"), JSON.stringify(state));
-  }
-  async discoveryState() {
-    const raw = await this.store.get(storeKey(this.serverUrl, "discovery"));
-    if (!raw)
-      return;
-    return JSON.parse(raw);
-  }
-  async invalidateCredentials(scope) {
-    const deleteKey = async (suffix) => {
-      await this.store.delete(storeKey(this.serverUrl, suffix));
-    };
-    switch (scope) {
-      case "all":
-        await deleteKey("tokens");
-        await deleteKey("client_info");
-        await deleteKey("code_verifier");
-        await deleteKey("discovery");
-        break;
-      case "client":
-        await deleteKey("client_info");
-        break;
-      case "tokens":
-        await deleteKey("tokens");
-        break;
-      case "verifier":
-        await deleteKey("code_verifier");
-        break;
-      case "discovery":
-        await deleteKey("discovery");
-        break;
-    }
-  }
-}
-function createAuthProvider(auth, serverUrl, credentialStore) {
-  switch (auth.type) {
-    case "none":
-    case "bearer":
-      return;
-    case "client_credentials": {
-      if (!credentialStore) {
-        return new ClientCredentialsProvider({
-          clientId: auth.client_id,
-          clientSecret: auth.client_secret,
-          clientName: auth.client_name,
-          scope: auth.scope
-        });
-      }
-      const prepareTokenRequest = (scope) => {
-        const params = new URLSearchParams({ grant_type: "client_credentials" });
-        const effectiveScope = scope ?? auth.scope;
-        if (effectiveScope)
-          params.set("scope", effectiveScope);
-        return params;
-      };
-      return new CredentialStoreOAuthProvider({
-        store: credentialStore,
-        serverUrl,
-        clientMetadata: {
-          redirect_uris: [],
-          grant_types: ["client_credentials"],
-          token_endpoint_auth_method: "client_secret_basic",
-          client_name: auth.client_name
-        },
-        initialClientInfo: {
-          client_id: auth.client_id,
-          client_secret: auth.client_secret
-        },
-        prepareTokenRequest
-      });
-    }
-    case "private_key_jwt": {
-      if (!credentialStore) {
-        return new PrivateKeyJwtProvider({
-          clientId: auth.client_id,
-          privateKey: auth.private_key,
-          algorithm: auth.algorithm,
-          clientName: auth.client_name,
-          jwtLifetimeSeconds: auth.jwt_lifetime_seconds,
-          scope: auth.scope
-        });
-      }
-      const addClientAuth = createPrivateKeyJwtAuth({
-        issuer: auth.client_id,
-        subject: auth.client_id,
-        privateKey: auth.private_key,
-        alg: auth.algorithm,
-        lifetimeSeconds: auth.jwt_lifetime_seconds
-      });
-      const prepareTokenRequest = (scope) => {
-        const params = new URLSearchParams({ grant_type: "client_credentials" });
-        const effectiveScope = scope ?? auth.scope;
-        if (effectiveScope)
-          params.set("scope", effectiveScope);
-        return params;
-      };
-      return new CredentialStoreOAuthProvider({
-        store: credentialStore,
-        serverUrl,
-        clientMetadata: {
-          redirect_uris: [],
-          grant_types: ["client_credentials"],
-          token_endpoint_auth_method: "private_key_jwt",
-          client_name: auth.client_name
-        },
-        initialClientInfo: { client_id: auth.client_id },
-        prepareTokenRequest,
-        addClientAuthentication: addClientAuth
-      });
-    }
-    case "static_private_key_jwt": {
-      if (!credentialStore) {
-        return new StaticPrivateKeyJwtProvider({
-          clientId: auth.client_id,
-          jwtBearerAssertion: auth.jwt_bearer_assertion,
-          clientName: auth.client_name,
-          scope: auth.scope
-        });
-      }
-      const assertion = auth.jwt_bearer_assertion;
-      const addClientAuth = (_headers, params) => {
-        params.set("client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer");
-        params.set("client_assertion", assertion);
-      };
-      const prepareTokenRequest = (scope) => {
-        const params = new URLSearchParams({ grant_type: "client_credentials" });
-        const effectiveScope = scope ?? auth.scope;
-        if (effectiveScope)
-          params.set("scope", effectiveScope);
-        return params;
-      };
-      return new CredentialStoreOAuthProvider({
-        store: credentialStore,
-        serverUrl,
-        clientMetadata: {
-          redirect_uris: [],
-          grant_types: ["client_credentials"],
-          token_endpoint_auth_method: "private_key_jwt",
-          client_name: auth.client_name
-        },
-        initialClientInfo: { client_id: auth.client_id },
-        prepareTokenRequest,
-        addClientAuthentication: addClientAuth
-      });
-    }
-    case "authorization_code": {
-      if (!credentialStore) {
-        throw new Error("authorization_code auth requires a credential store for token persistence");
-      }
-      return new CredentialStoreOAuthProvider({
-        store: credentialStore,
-        serverUrl,
-        clientMetadata: {
-          redirect_uris: [auth.redirect_url],
-          grant_types: ["authorization_code", "refresh_token"],
-          token_endpoint_auth_method: auth.client_secret ? "client_secret_basic" : "none",
-          scope: auth.scope
-        },
-        initialClientInfo: {
-          client_id: auth.client_id,
-          ...auth.client_secret ? { client_secret: auth.client_secret } : {}
-        },
-        redirectUrl: auth.redirect_url
-      });
-    }
-    default:
-      return;
+function bufToBase64(buf) {
+  let binary = "";
+  for (let i = 0;i < buf.length; i++) {
+    binary += String.fromCharCode(buf[i]);
   }
+  return btoa(binary);
 }
-async function resolveAuthSecrets(auth, credentialStore) {
-  if (auth.type === "none")
-    return auth;
-  const store = credentialStore ?? getGlobalCredentialStore();
-  async function resolve(value) {
-    if (!value)
-      return value;
-    const resolved = await store.get(value);
-    return resolved ?? value;
-  }
-  switch (auth.type) {
-    case "bearer":
-      return { ...auth, token: await resolve(auth.token) ?? auth.token };
-    case "client_credentials":
-      return {
-        ...auth,
-        client_secret: await resolve(auth.client_secret) ?? auth.client_secret
-      };
-    case "private_key_jwt":
-      return {
-        ...auth,
-        private_key: await resolve(auth.private_key) ?? auth.private_key
-      };
-    case "static_private_key_jwt":
-      return {
-        ...auth,
-        jwt_bearer_assertion: await resolve(auth.jwt_bearer_assertion) ?? auth.jwt_bearer_assertion
-      };
-    case "authorization_code":
-      return {
-        ...auth,
-        client_secret: await resolve(auth.client_secret)
-      };
-    default:
-      return auth;
+function base64ToBuf(b64) {
+  const binary = atob(b64);
+  const buf = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    buf[i] = binary.charCodeAt(i);
   }
+  return buf;
 }
 // src/telemetry/ITelemetryProvider.ts
 var SpanStatusCode = {
@@ -3253,97 +2232,6 @@ async function decompress(input, algorithm = "gzip") {
   const resultBuffer = await decompressAsyncTyped(sourceBuffer);
   return resultBuffer.toString();
 }
-// src/mcp/McpClientUtil.node.ts
-import { Client } from "@modelcontextprotocol/sdk/client";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-var mcpTransportTypes = ["stdio", "sse", "streamable-http"];
-var mcpServerConfigSchema = {
-  properties: {
-    transport: {
-      type: "string",
-      enum: mcpTransportTypes,
-      title: "Transport",
-      description: "The transport type to use for connecting to the MCP server"
-    },
-    server_url: {
-      type: "string",
-      format: "string:uri",
-      title: "Server URL",
-      description: "The URL of the MCP server (for sse and streamable-http transports)"
-    },
-    command: {
-      type: "string",
-      title: "Command",
-      description: "The command to run (for stdio transport)"
-    },
-    args: {
-      type: "array",
-      items: { type: "string" },
-      title: "Arguments",
-      description: "Command arguments (for stdio transport)"
-    },
-    env: {
-      type: "object",
-      additionalProperties: { type: "string" },
-      title: "Environment",
-      description: "Environment variables (for stdio transport)"
-    },
-    ...mcpAuthConfigSchema.properties
-  },
-  allOf: mcpAuthConfigSchema.allOf
-};
-async function createMcpClient(config, signal) {
-  let transport;
-  let auth = config.auth ?? buildAuthConfig({ ...config });
-  if (auth && auth.type !== "none") {
-    auth = await resolveAuthSecrets(auth, getGlobalCredentialStore());
-  }
-  const authProvider = config.authProvider ?? (auth && auth.type !== "none" && auth.type !== "bearer" ? createAuthProvider(auth, config.server_url ?? "", getGlobalCredentialStore()) : undefined);
-  const headers = {
-    ...auth?.type === "bearer" ? { Authorization: `Bearer ${auth.token}` } : {}
-  };
-  switch (config.transport) {
-    case "stdio":
-      if (auth && auth.type !== "none") {
-        getLogger().warn("MCP auth is not supported for stdio transport; auth config ignored. " + "Use env vars to pass credentials to stdio servers.");
-      }
-      transport = new StdioClientTransport({
-        command: config.command,
-        args: config.args,
-        env: config.env
-      });
-      break;
-    case "sse": {
-      transport = new SSEClientTransport(new URL(config.server_url), {
-        authProvider,
-        requestInit: { headers }
-      });
-      break;
-    }
-    case "streamable-http": {
-      transport = new StreamableHTTPClientTransport(new URL(config.server_url), {
-        authProvider,
-        requestInit: { headers }
-      });
-      break;
-    }
-    default:
-      throw new Error(`Unsupported transport type: ${config.transport}`);
-  }
-  const client = new Client({ name: "workglow-mcp-client", version: "1.0.0" });
-  if (signal) {
-    signal.addEventListener("abort", () => {
-      client.close().catch(() => {});
-    }, { once: true });
-  }
-  await client.connect(transport);
-  return { client, transport };
-}
-var mcpClientFactory = {
-  create: createMcpClient
-};
 // src/media/image.ts
 function parseDataUri(dataUri) {
   const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
@@ -3390,10 +2278,198 @@ async function convertImageDataToUseableForm(imageData, supports) {
   throw new Error(`Unsupported image data type: ${typeof imageData}`);
 }
 // src/worker/Worker.node.ts
-import { Worker as NodeWorker, isMainThread, parentPort as parentPort2 } from "worker_threads";
+import { Worker as NodeWorker, isMainThread, parentPort } from "worker_threads";
 import { pathToFileURL } from "url";
 import { URL as NodeURL } from "url";
 
+// src/worker/WorkerServerBase.ts
+var WORKER_SERVER = createServiceToken("worker.server");
+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 WorkerServerBase {
+  constructor() {}
+  functions = {};
+  streamFunctions = {};
+  reactiveFunctions = {};
+  requestControllers = new Map;
+  completedRequests = new Set;
+  postResult = (id, result) => {
+    if (this.completedRequests.has(id)) {
+      return;
+    }
+    this.completedRequests.add(id);
+    const transferables = extractTransferables(result);
+    const uniqueTransferables = [...new Set(transferables)];
+    postMessage({ id, type: "complete", data: result }, uniqueTransferables);
+  };
+  postError = (id, errorMessage) => {
+    if (this.completedRequests.has(id)) {
+      return;
+    }
+    this.completedRequests.add(id);
+    postMessage({ id, type: "error", data: errorMessage });
+  };
+  postStreamChunk = (id, event) => {
+    if (this.completedRequests.has(id)) {
+      return;
+    }
+    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;
+  }
+  registerReactiveFunction(name, fn) {
+    this.reactiveFunctions[name] = fn;
+  }
+  registerStreamFunction(name, fn) {
+    this.streamFunctions[name] = fn;
+  }
+  async handleMessage(event) {
+    const { id, type, functionName, args, stream, reactive } = event.data;
+    if (type === "abort") {
+      return await this.handleAbort(id);
+    }
+    if (type === "call") {
+      if (stream) {
+        return await this.handleStreamCall(id, functionName, args);
+      }
+      if (reactive) {
+        return await this.handleReactiveCall(id, functionName, args);
+      }
+      return await this.handleCall(id, functionName, args);
+    }
+  }
+  async handleAbort(id) {
+    if (this.requestControllers.has(id)) {
+      const controller = this.requestControllers.get(id);
+      controller?.abort();
+      this.requestControllers.delete(id);
+      this.postError(id, "Operation aborted");
+    }
+  }
+  async handleReactiveCall(id, functionName, [input, output, model]) {
+    if (!(functionName in this.reactiveFunctions)) {
+      this.postResult(id, undefined);
+      return;
+    }
+    try {
+      const fn = this.reactiveFunctions[functionName];
+      const result = await fn(input, output, model);
+      this.postResult(id, result);
+    } catch (error) {
+      this.postError(id, error.message);
+    }
+  }
+  async handleCall(id, functionName, [input, model]) {
+    if (!(functionName in this.functions)) {
+      this.postError(id, `Function ${functionName} not found`);
+      return;
+    }
+    try {
+      const abortController = new AbortController;
+      this.requestControllers.set(id, abortController);
+      const fn = this.functions[functionName];
+      const postProgress = (progress, message, details) => {
+        if (!this.completedRequests.has(id)) {
+          postMessage({ id, type: "progress", data: { progress, message, details } });
+        }
+      };
+      const result = await fn(input, model, postProgress, abortController.signal);
+      this.postResult(id, result);
+    } catch (error) {
+      this.postError(id, error.message);
+    } finally {
+      this.requestControllers.delete(id);
+      setTimeout(() => {
+        this.completedRequests.delete(id);
+      }, 1000);
+    }
+  }
+  async handleStreamCall(id, functionName, [input, model]) {
+    if (functionName in this.streamFunctions) {
+      try {
+        const abortController = new AbortController;
+        this.requestControllers.set(id, abortController);
+        const fn = this.streamFunctions[functionName];
+        const iterable = fn(input, model, abortController.signal);
+        for await (const event of iterable) {
+          if (this.completedRequests.has(id))
+            break;
+          this.postStreamChunk(id, event);
+        }
+        this.postResult(id, undefined);
+      } catch (error) {
+        this.postError(id, error.message);
+      } finally {
+        this.requestControllers.delete(id);
+        setTimeout(() => {
+          this.completedRequests.delete(id);
+        }, 1000);
+      }
+    } else if (functionName in this.functions) {
+      try {
+        const abortController = new AbortController;
+        this.requestControllers.set(id, abortController);
+        const fn = this.functions[functionName];
+        const noopProgress = () => {};
+        const result = await fn(input, model, noopProgress, abortController.signal);
+        this.postStreamChunk(id, { type: "finish", data: result });
+        this.postResult(id, undefined);
+      } catch (error) {
+        this.postError(id, error.message);
+      } finally {
+        this.requestControllers.delete(id);
+        setTimeout(() => {
+          this.completedRequests.delete(id);
+        }, 1000);
+      }
+    } else {
+      this.postError(id, `Function ${functionName} not found`);
+    }
+  }
+}
+
+// src/worker/Worker.node.ts
 class WorkerPolyfill extends NodeWorker {
   constructor(scriptUrl, options) {
     const resolved = scriptUrl instanceof NodeURL ? scriptUrl.toString() : pathToFileURL(scriptUrl).toString();
@@ -3412,7 +2488,20 @@ class WorkerPolyfill extends NodeWorker {
       this.off("error", listener);
   }
 }
-var Worker = isMainThread ? WorkerPolyfill : parentPort2;
+var Worker = isMainThread ? WorkerPolyfill : parentPort;
+class WorkerServer extends WorkerServerBase {
+  constructor() {
+    parentPort?.addEventListener("message", async (event) => {
+      const msg = {
+        type: event.type,
+        data: event.data
+      };
+      await this.handleMessage(msg);
+    });
+    super();
+  }
+}
+globalServiceRegistry.register(WORKER_SERVER, () => new WorkerServer, true);
 export {
   uuid4,
   toSQLiteTimestamp,
@@ -3424,19 +2513,13 @@ export {
   setGlobalCredentialStore,
   serialize,
   resolveCredential,
-  resolveAuthSecrets,
   registerInputResolver,
   parsePartialJson,
   parseDataUri,
-  parentPort2 as parentPort,
+  parentPort,
   objectOfArraysAsArrayOfObjects,
   normalizeNumberArray,
   normalize,
-  mcpTransportTypes,
-  mcpServerConfigSchema,
-  mcpClientFactory,
-  mcpAuthTypes,
-  mcpAuthConfigSchema,
   makeFingerprint,
   magnitude,
   jaccardSimilarity,
@@ -3458,24 +2541,17 @@ export {
   decompress,
   createTypedArrayFrom,
   createServiceToken,
-  createMcpClient,
-  createAuthProvider,
   cosineSimilarity,
   convertImageDataToUseableForm,
   compress,
-  compileSchema,
   collectPropertyValues,
-  buildAuthConfig,
   bufToBase64,
   base64ToBuf,
-  areSemanticallyCompatible,
-  areObjectSchemasSemanticallyCompatible,
   WorkerServer,
   WorkerManager,
   Worker,
   WORKER_SERVER,
   WORKER_MANAGER,
-  UnauthorizedError,
   TypedArraySchema,
   TensorType,
   TensorSchema,
@@ -3497,7 +2573,6 @@ export {
   DirectedGraph,
   DirectedAcyclicGraph,
   CycleError,
-  CredentialStoreOAuthProvider,
   Container,
   ConsoleTelemetryProvider,
   ConsoleLogger,
@@ -3506,4 +2581,4 @@ export {
   BaseError
 };
 
-//# debugId=C39DB93A7008D84764756E2164756E21
+//# debugId=7BB129A722446D6A64756E2164756E21