@workglow/ai 0.1.1 → 0.2.0

package/dist/worker.js

@@ -1,8 +1,5 @@
 // src/provider/AiProvider.ts
-import {
-  globalServiceRegistry as globalServiceRegistry2,
-  WORKER_MANAGER as WORKER_MANAGER2
-} from "@workglow/util/worker";
+import { globalServiceRegistry as globalServiceRegistry2, WORKER_MANAGER as WORKER_MANAGER2 } from "@workglow/util/worker";
 
 // src/provider/AiProviderRegistry.ts
 import { globalServiceRegistry, WORKER_MANAGER } from "@workglow/util/worker";
@@ -13,20 +10,18 @@ import {
   Job,
   JobStatus,
   PermanentJobError,
-  RetryableJobError
+  RetryableJobError,
+  withJobErrorDiagnostics
 } from "@workglow/job-queue";
 import { getLogger } from "@workglow/util/worker";
 var DEFAULT_AI_TIMEOUT_MS = 120000;
-var LOCAL_MODEL_DEFAULT_TIMEOUT_MS = 600000;
+var LOCAL_INFERENCE_DEFAULT_TIMEOUT_MS = 300000;
 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;
+  if (aiProvider === "LOCAL_LLAMACPP" || aiProvider === "HF_TRANSFORMERS_ONNX") {
+    return LOCAL_INFERENCE_DEFAULT_TIMEOUT_MS;
   }
   return DEFAULT_AI_TIMEOUT_MS;
 }
@@ -39,39 +34,39 @@ function classifyProviderError(err, taskType, provider) {
     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 Error && err.name === "AbortError") {
+    return new AbortSignalJobError(withJobErrorDiagnostics(`Provider call aborted for ${taskType} (${provider})`, err));
   }
-  if (err instanceof DOMException && err.name === "TimeoutError") {
-    return new AbortSignalJobError(`Provider call timed out for ${taskType} (${provider})`);
+  if (err instanceof Error && err.name === "TimeoutError") {
+    return new AbortSignalJobError(withJobErrorDiagnostics(`Provider call timed out for ${taskType} (${provider})`, err));
   }
   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}`);
+    return new AbortSignalJobError(withJobErrorDiagnostics(`Provider call aborted for ${taskType} (${provider}): ${message}`, err));
   }
   if (message.startsWith("HFT_NULL_PROCESSOR:")) {
-    return new RetryableJobError(message);
+    return new RetryableJobError(withJobErrorDiagnostics(message, err));
   }
   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));
+    return new RetryableJobError(withJobErrorDiagnostics(`Rate limited by ${provider} for ${taskType}: ${message}`, err), new Date(Date.now() + retryMs));
   }
   if (status === 401 || status === 403) {
-    return new PermanentJobError(`Authentication failed for ${provider} (${taskType}): ${message}`);
+    return new PermanentJobError(withJobErrorDiagnostics(`Authentication failed for ${provider} (${taskType}): ${message}`, err));
   }
   if (status === 400 || status === 404) {
-    return new PermanentJobError(`Invalid request to ${provider} for ${taskType}: ${message}`);
+    return new PermanentJobError(withJobErrorDiagnostics(`Invalid request to ${provider} for ${taskType}: ${message}`, err));
   }
   if (status && status >= 500) {
-    return new RetryableJobError(`Server error from ${provider} for ${taskType} (HTTP ${status}): ${message}`);
+    return new RetryableJobError(withJobErrorDiagnostics(`Server error from ${provider} for ${taskType} (HTTP ${status}): ${message}`, err));
   }
   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}`);
+    return new RetryableJobError(withJobErrorDiagnostics(`Network error calling ${provider} for ${taskType}: ${message}`, err));
   }
   if (message.includes("timed out") || message.includes("timeout")) {
-    return new RetryableJobError(`Timeout calling ${provider} for ${taskType}: ${message}`);
+    return new RetryableJobError(withJobErrorDiagnostics(`Timeout calling ${provider} for ${taskType}: ${message}`, err));
   }
-  return new PermanentJobError(`Provider ${provider} failed for ${taskType}: ${message}`);
+  return new PermanentJobError(withJobErrorDiagnostics(`Provider ${provider} failed for ${taskType}: ${message}`, err));
 }
 
 class AiJob extends Job {
@@ -401,6 +396,228 @@ class AiProvider {
   async dispose() {}
   async afterRegister(_options) {}
 }
+// src/task/ToolCallingUtils.ts
+import { getLogger as getLogger2 } 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;
+    }
+    getLogger2().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",
@@ -443,9 +660,14 @@ var ModelRecordSchema = {
 };
 var ModelPrimaryKeyNames = ["model_id"];
 export {
+  toTextFlatMessages,
+  toOpenAIMessages,
   setAiProviderRegistry,
   resolveAiProviderGpuQueueConcurrency,
+  isAllowedToolName,
   getAiProviderRegistry,
+  filterValidToolCalls,
+  buildToolDescription,
   ModelRecordSchema,
   ModelPrimaryKeyNames,
   ModelConfigSchema,
@@ -453,4 +675,4 @@ export {
   AiProvider
 };
 
-//# debugId=EA397FAD8CAF3E1B64756E2164756E21
+//# debugId=D34633C7196C310D64756E2164756E21