@workglow/ai 0.0.126 → 0.1.1

package/dist/worker.js

@@ -7,14 +7,199 @@ import {
 // src/provider/AiProviderRegistry.ts
 import { globalServiceRegistry, WORKER_MANAGER } from "@workglow/util/worker";
 
+// src/job/AiJob.ts
+import {
+  AbortSignalJobError,
+  Job,
+  JobStatus,
+  PermanentJobError,
+  RetryableJobError
+} from "@workglow/job-queue";
+import { getLogger } from "@workglow/util/worker";
+var DEFAULT_AI_TIMEOUT_MS = 120000;
+var LOCAL_MODEL_DEFAULT_TIMEOUT_MS = 600000;
+function resolveAiJobTimeoutMs(aiProvider, explicitMs) {
+  if (explicitMs !== undefined) {
+    return explicitMs;
+  }
+  if (aiProvider === "LOCAL_LLAMACPP") {
+    return LOCAL_MODEL_DEFAULT_TIMEOUT_MS;
+  }
+  if (aiProvider === "HF_TRANSFORMERS_ONNX" || aiProvider.startsWith("HF_TRANSFORMERS_ONNX")) {
+    return LOCAL_MODEL_DEFAULT_TIMEOUT_MS;
+  }
+  return DEFAULT_AI_TIMEOUT_MS;
+}
+function classifyProviderError(err, taskType, provider) {
+  if (err instanceof PermanentJobError || err instanceof RetryableJobError || err instanceof AbortSignalJobError) {
+    return err;
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  const status = typeof err?.status === "number" ? err.status : typeof err?.statusCode === "number" ? err.statusCode : (() => {
+    const m = message.match(/\b([45]\d{2})\b/);
+    return m ? parseInt(m[1], 10) : undefined;
+  })();
+  if (err instanceof DOMException && err.name === "AbortError") {
+    return new AbortSignalJobError(`Provider call aborted for ${taskType} (${provider})`);
+  }
+  if (err instanceof DOMException && err.name === "TimeoutError") {
+    return new AbortSignalJobError(`Provider call timed out for ${taskType} (${provider})`);
+  }
+  if (message.includes("Pipeline download aborted") || message.includes("Operation aborted") || message.includes("operation was aborted") || message.includes("The operation was aborted")) {
+    return new AbortSignalJobError(`Provider call aborted for ${taskType} (${provider}): ${message}`);
+  }
+  if (message.startsWith("HFT_NULL_PROCESSOR:")) {
+    return new RetryableJobError(message);
+  }
+  if (status === 429) {
+    const retryAfterMatch = message.match(/retry.after[:\s]*(\d+)/i);
+    const retryMs = retryAfterMatch ? parseInt(retryAfterMatch[1], 10) * 1000 : 30000;
+    return new RetryableJobError(`Rate limited by ${provider} for ${taskType}: ${message}`, new Date(Date.now() + retryMs));
+  }
+  if (status === 401 || status === 403) {
+    return new PermanentJobError(`Authentication failed for ${provider} (${taskType}): ${message}`);
+  }
+  if (status === 400 || status === 404) {
+    return new PermanentJobError(`Invalid request to ${provider} for ${taskType}: ${message}`);
+  }
+  if (status && status >= 500) {
+    return new RetryableJobError(`Server error from ${provider} for ${taskType} (HTTP ${status}): ${message}`);
+  }
+  if (message.includes("ECONNREFUSED") || message.includes("ECONNRESET") || message.includes("ETIMEDOUT") || message.includes("fetch failed") || message.includes("network") || err instanceof TypeError && message.includes("fetch")) {
+    return new RetryableJobError(`Network error calling ${provider} for ${taskType}: ${message}`);
+  }
+  if (message.includes("timed out") || message.includes("timeout")) {
+    return new RetryableJobError(`Timeout calling ${provider} for ${taskType}: ${message}`);
+  }
+  return new PermanentJobError(`Provider ${provider} failed for ${taskType}: ${message}`);
+}
+
+class AiJob extends Job {
+  async execute(input, context) {
+    if (context.signal.aborted || this.status === JobStatus.ABORTING) {
+      throw new AbortSignalJobError("Abort signal aborted before execution of job");
+    }
+    let abortHandler;
+    try {
+      const abortPromise = new Promise((_resolve, reject) => {
+        const handler = () => {
+          reject(new AbortSignalJobError("Abort signal seen, ending job"));
+        };
+        context.signal.addEventListener("abort", handler, { once: true });
+        abortHandler = () => context.signal.removeEventListener("abort", handler);
+      });
+      const runFn = async () => {
+        const fn = getAiProviderRegistry().getDirectRunFn(input.aiProvider, input.taskType);
+        const model = input.taskInput.model;
+        if (context.signal.aborted) {
+          throw new AbortSignalJobError("Job aborted");
+        }
+        const timeoutMs = resolveAiJobTimeoutMs(input.aiProvider, input.timeoutMs);
+        const timeoutSignal = AbortSignal.timeout(timeoutMs);
+        const combinedSignal = AbortSignal.any([context.signal, timeoutSignal]);
+        return await fn(input.taskInput, model, context.updateProgress, combinedSignal, input.outputSchema);
+      };
+      const runFnPromise = runFn();
+      return await Promise.race([runFnPromise, abortPromise]);
+    } catch (err) {
+      throw classifyProviderError(err, input.taskType, input.aiProvider);
+    } finally {
+      if (abortHandler) {
+        abortHandler();
+      }
+    }
+  }
+  async* executeStream(input, context) {
+    if (context.signal.aborted || this.status === JobStatus.ABORTING) {
+      throw new AbortSignalJobError("Abort signal aborted before streaming execution of job");
+    }
+    const streamFn = getAiProviderRegistry().getStreamFn(input.aiProvider, input.taskType);
+    if (!streamFn) {
+      const result = await this.execute(input, context);
+      yield { type: "finish", data: result };
+      return;
+    }
+    const model = input.taskInput.model;
+    let lastFinishData;
+    const timeoutMs = resolveAiJobTimeoutMs(input.aiProvider, input.timeoutMs);
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const combinedSignal = AbortSignal.any([context.signal, timeoutSignal]);
+    try {
+      for await (const event of streamFn(input.taskInput, model, combinedSignal, input.outputSchema)) {
+        if (event.type === "finish") {
+          lastFinishData = event.data;
+        }
+        yield event;
+      }
+    } catch (err) {
+      const logger = getLogger();
+      logger.warn(`AiJob: Stream error for ${input.taskType} (${input.aiProvider}): ${err instanceof Error ? err.message : String(err)}`);
+      if (lastFinishData === undefined) {
+        yield { type: "finish", data: {} };
+      }
+      throw classifyProviderError(err, input.taskType, input.aiProvider);
+    }
+  }
+}
+
+// src/execution/DirectExecutionStrategy.ts
+class DirectExecutionStrategy {
+  async execute(jobInput, context, runnerId) {
+    const job = new AiJob({
+      queueName: jobInput.aiProvider,
+      jobRunId: runnerId,
+      input: jobInput
+    });
+    const cleanup = job.onJobProgress((progress, message, details) => {
+      context.updateProgress(progress, message, details);
+    });
+    try {
+      return await job.execute(jobInput, {
+        signal: context.signal,
+        updateProgress: context.updateProgress
+      });
+    } finally {
+      cleanup();
+    }
+  }
+  async* executeStream(jobInput, context, runnerId) {
+    const job = new AiJob({
+      queueName: jobInput.aiProvider,
+      jobRunId: runnerId,
+      input: jobInput
+    });
+    yield* job.executeStream(jobInput, {
+      signal: context.signal,
+      updateProgress: context.updateProgress
+    });
+  }
+  abort() {}
+}
+
+// src/provider/AiProviderRegistry.ts
 class AiProviderRegistry {
   runFnRegistry = new Map;
   streamFnRegistry = new Map;
   reactiveRunFnRegistry = new Map;
   providers = new Map;
+  strategyResolvers = new Map;
+  defaultStrategy;
   registerProvider(provider) {
     this.providers.set(provider.name, provider);
   }
+  unregisterProvider(name) {
+    this.providers.delete(name);
+    this.strategyResolvers.delete(name);
+    for (const [, providerMap] of this.runFnRegistry) {
+      providerMap.delete(name);
+    }
+    for (const [, providerMap] of this.streamFnRegistry) {
+      providerMap.delete(name);
+    }
+    for (const [, providerMap] of this.reactiveRunFnRegistry) {
+      providerMap.delete(name);
+    }
+  }
   getProvider(name) {
     return this.providers.get(name);
   }
@@ -24,6 +209,18 @@ class AiProviderRegistry {
   getInstalledProviderIds() {
     return [...this.providers.keys()].sort();
   }
+  registerStrategyResolver(providerName, resolver) {
+    this.strategyResolvers.set(providerName, resolver);
+  }
+  getStrategy(model) {
+    const resolver = this.strategyResolvers.get(model.provider);
+    if (resolver)
+      return resolver(model);
+    if (!this.defaultStrategy) {
+      this.defaultStrategy = new DirectExecutionStrategy;
+    }
+    return this.defaultStrategy;
+  }
   getProviderIdsForTask(taskType) {
     const taskMap = this.runFnRegistry.get(taskType);
     if (!taskMap)
@@ -89,15 +286,16 @@ class AiProviderRegistry {
     const taskTypeMap = this.runFnRegistry.get(taskType);
     const runFn = taskTypeMap?.get(modelProvider);
     if (!runFn) {
-      throw new Error(`No run function found for task type ${taskType} and model provider ${modelProvider}`);
+      const installedProviders = this.getInstalledProviderIds();
+      const providersForTask = this.getProviderIdsForTask(taskType);
+      const hint = providersForTask.length > 0 ? ` Providers supporting "${taskType}": [${providersForTask.join(", ")}].` : installedProviders.length > 0 ? ` Installed providers: [${installedProviders.join(", ")}] (none support "${taskType}").` : " No providers are registered. Call provider.register() before running AI tasks.";
+      throw new Error(`No run function found for task type "${taskType}" and provider "${modelProvider}".${hint}`);
     }
     return runFn;
   }
 }
-var providerRegistry;
+var providerRegistry = new AiProviderRegistry;
 function getAiProviderRegistry() {
-  if (!providerRegistry)
-    providerRegistry = new AiProviderRegistry;
   return providerRegistry;
 }
 function setAiProviderRegistry(pr) {
@@ -105,6 +303,16 @@ function setAiProviderRegistry(pr) {
 }
 
 // src/provider/AiProvider.ts
+function resolveAiProviderGpuQueueConcurrency(concurrency) {
+  if (concurrency === undefined) {
+    return 1;
+  }
+  if (typeof concurrency === "number") {
+    return concurrency;
+  }
+  return concurrency.gpu ?? 1;
+}
+
 class AiProvider {
   tasks;
   streamTasks;
@@ -164,7 +372,12 @@ class AiProvider {
       }
     }
     registry.registerProvider(this);
-    await this.afterRegister(options);
+    try {
+      await this.afterRegister(options);
+    } catch (err) {
+      registry.unregisterProvider(this.name);
+      throw err;
+    }
   }
   registerOnWorkerServer(workerServer) {
     if (!this.tasks) {
@@ -188,228 +401,6 @@ class AiProvider {
   async dispose() {}
   async afterRegister(_options) {}
 }
-// src/task/ToolCallingUtils.ts
-import { getLogger } from "@workglow/util/worker";
-function buildToolDescription(tool) {
-  let desc = tool.description;
-  if (tool.outputSchema && typeof tool.outputSchema === "object") {
-    desc += `
-
-Returns: ${JSON.stringify(tool.outputSchema)}`;
-  }
-  return desc;
-}
-function isAllowedToolName(name, allowedTools) {
-  return allowedTools.some((t) => t.name === name);
-}
-function filterValidToolCalls(toolCalls, allowedTools) {
-  return toolCalls.filter((tc) => {
-    if (tc.name && isAllowedToolName(tc.name, allowedTools)) {
-      return true;
-    }
-    getLogger().warn(`Filtered out tool call with unknown name "${tc.name ?? "(missing)"}"`, {
-      callId: tc.id,
-      toolName: tc.name
-    });
-    return false;
-  });
-}
-// src/task/MessageConversion.ts
-function getInputMessages(input) {
-  const messages = input.messages;
-  if (!messages || messages.length === 0)
-    return;
-  return messages;
-}
-function toOpenAIMessages(input) {
-  const messages = [];
-  if (input.systemPrompt) {
-    messages.push({ role: "system", content: input.systemPrompt });
-  }
-  const inputMessages = getInputMessages(input);
-  if (!inputMessages) {
-    if (!Array.isArray(input.prompt)) {
-      messages.push({ role: "user", content: input.prompt });
-    } else if (input.prompt.every((item) => typeof item === "string")) {
-      messages.push({ role: "user", content: input.prompt.join(`
-`) });
-    } else {
-      const parts = [];
-      for (const item of input.prompt) {
-        if (typeof item === "string") {
-          parts.push({ type: "text", text: item });
-        } else {
-          const b = item;
-          if (b.type === "text") {
-            parts.push({ type: "text", text: b.text });
-          } else if (b.type === "image") {
-            parts.push({
-              type: "image_url",
-              image_url: { url: `data:${b.mimeType};base64,${b.data}` }
-            });
-          } else if (b.type === "audio") {
-            const format = b.mimeType.replace(/^audio\//, "");
-            parts.push({
-              type: "input_audio",
-              input_audio: { data: b.data, format }
-            });
-          }
-        }
-      }
-      messages.push({ role: "user", content: parts });
-    }
-    return messages;
-  }
-  for (const msg of inputMessages) {
-    if (msg.role === "user") {
-      if (typeof msg.content === "string") {
-        messages.push({ role: "user", content: msg.content });
-      } else if (Array.isArray(msg.content) && msg.content.length > 0 && typeof msg.content[0]?.type === "string") {
-        const parts = [];
-        for (const block of msg.content) {
-          const b = block;
-          if (b.type === "text") {
-            parts.push({ type: "text", text: b.text });
-          } else if (b.type === "image") {
-            parts.push({
-              type: "image_url",
-              image_url: { url: `data:${b.mimeType};base64,${b.data}` }
-            });
-          } else if (b.type === "audio") {
-            const format = b.mimeType.replace(/^audio\//, "");
-            parts.push({
-              type: "input_audio",
-              input_audio: { data: b.data, format }
-            });
-          }
-        }
-        messages.push({ role: "user", content: parts });
-      } else {
-        try {
-          messages.push({ role: "user", content: JSON.stringify(msg.content) });
-        } catch {
-          messages.push({ role: "user", content: String(msg.content) });
-        }
-      }
-    } else if (msg.role === "assistant") {
-      if (typeof msg.content === "string") {
-        messages.push({ role: "assistant", content: msg.content.length > 0 ? msg.content : null });
-      } else if (Array.isArray(msg.content)) {
-        const textParts = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-        const toolCalls = msg.content.filter((b) => b.type === "tool_use").map((b) => ({
-          id: b.id,
-          type: "function",
-          function: {
-            name: b.name,
-            arguments: JSON.stringify(b.input)
-          }
-        }));
-        const entry = {
-          role: "assistant",
-          content: textParts.length > 0 ? textParts : null
-        };
-        if (toolCalls.length > 0) {
-          entry.tool_calls = toolCalls;
-        }
-        messages.push(entry);
-      }
-    } else if (msg.role === "tool" && Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        const b = block;
-        let content;
-        if (typeof b.content === "string") {
-          content = b.content;
-        } else if (Array.isArray(b.content)) {
-          const parts = [];
-          for (const inner of b.content) {
-            if (inner.type === "text") {
-              parts.push({ type: "text", text: inner.text });
-            } else if (inner.type === "image") {
-              parts.push({
-                type: "image_url",
-                image_url: { url: `data:${inner.mimeType};base64,${inner.data}` }
-              });
-            }
-          }
-          content = parts;
-        } else {
-          content = "";
-        }
-        messages.push({
-          role: "tool",
-          content,
-          tool_call_id: b.tool_use_id
-        });
-      }
-    }
-  }
-  return messages;
-}
-function toTextFlatMessages(input) {
-  const messages = [];
-  if (input.systemPrompt) {
-    messages.push({ role: "system", content: input.systemPrompt });
-  }
-  const inputMessages = getInputMessages(input);
-  if (!inputMessages) {
-    let promptContent;
-    if (!Array.isArray(input.prompt)) {
-      promptContent = input.prompt;
-    } else {
-      promptContent = input.prompt.map((item) => {
-        if (typeof item === "string")
-          return item;
-        const b = item;
-        return b.type === "text" ? b.text : "";
-      }).filter((s) => s !== "").join(`
-`);
-    }
-    messages.push({ role: "user", content: promptContent });
-    return messages;
-  }
-  for (const msg of inputMessages) {
-    if (msg.role === "user") {
-      let content = "";
-      if (typeof msg.content === "string") {
-        content = msg.content;
-      } else if (Array.isArray(msg.content) && msg.content.length > 0 && typeof msg.content[0]?.type === "string") {
-        content = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-      } else if (msg.content != null) {
-        try {
-          content = JSON.stringify(msg.content);
-        } catch {
-          content = String(msg.content);
-        }
-      }
-      messages.push({ role: "user", content });
-    } else if (msg.role === "assistant") {
-      if (typeof msg.content === "string") {
-        if (msg.content) {
-          messages.push({ role: "assistant", content: msg.content });
-        }
-      } else if (Array.isArray(msg.content)) {
-        const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-        if (text) {
-          messages.push({ role: "assistant", content: text });
-        }
-      }
-    } else if (msg.role === "tool" && Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        const b = block;
-        let content;
-        if (typeof b.content === "string") {
-          content = b.content;
-        } else if (Array.isArray(b.content)) {
-          content = b.content.filter((inner) => inner.type === "text").map((inner) => inner.text).join("");
-        } else {
-          content = "";
-        }
-        messages.push({ role: "tool", content });
-      }
-    }
-  }
-  return messages;
-}
 // src/model/ModelSchema.ts
 var ModelConfigSchema = {
   type: "object",
@@ -452,13 +443,9 @@ var ModelRecordSchema = {
 };
 var ModelPrimaryKeyNames = ["model_id"];
 export {
-  toTextFlatMessages,
-  toOpenAIMessages,
   setAiProviderRegistry,
-  isAllowedToolName,
+  resolveAiProviderGpuQueueConcurrency,
   getAiProviderRegistry,
-  filterValidToolCalls,
-  buildToolDescription,
   ModelRecordSchema,
   ModelPrimaryKeyNames,
   ModelConfigSchema,
@@ -466,4 +453,4 @@ export {
   AiProvider
 };
 
-//# debugId=A00532924041A69D64756E2164756E21
+//# debugId=EA397FAD8CAF3E1B64756E2164756E21