@workglow/tasks 0.0.102 → 0.0.103

package/dist/node.js

@@ -4,1090 +4,436 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/node.ts
 import { TaskRegistry as TaskRegistry2 } from "@workglow/task-graph";
 
-// src/task/FileLoaderTask.server.ts
-import {
-  CreateWorkflow as CreateWorkflow3,
-  TaskAbortedError as TaskAbortedError2,
-  Workflow as Workflow3
-} from "@workglow/task-graph";
-import { readFile } from "node:fs/promises";
+// src/task/adaptive.ts
+import { CreateAdaptiveWorkflow, Workflow as Workflow10 } from "@workglow/task-graph";
 
-// src/task/FileLoaderTask.ts
-import {
-  CreateWorkflow as CreateWorkflow2,
-  Task,
-  TaskAbortedError,
-  Workflow as Workflow2
-} from "@workglow/task-graph";
-import Papa from "papaparse";
+// src/task/scalar/ScalarAddTask.ts
+import { CreateWorkflow, Task, Workflow } from "@workglow/task-graph";
 
-// src/task/FetchUrlTask.ts
-import {
-  AbortSignalJobError,
-  Job,
-  PermanentJobError,
-  RetryableJobError
-} from "@workglow/job-queue";
-import {
-  CreateWorkflow,
-  JobQueueTask,
-  TaskConfigurationError,
-  TaskInvalidInputError,
-  Workflow
-} from "@workglow/task-graph";
+// src/task/scalar/sumPrecise.ts
+function kahanSum(values) {
+  let sum = 0;
+  let compensation = 0;
+  for (const value of values) {
+    const y = value - compensation;
+    const t = sum + y;
+    compensation = t - sum - y;
+    sum = t;
+  }
+  return sum;
+}
+var nativeSumPrecise = typeof Math.sumPrecise === "function" ? Math.sumPrecise : undefined;
+var sumPrecise = nativeSumPrecise ? nativeSumPrecise.bind(Math) : kahanSum;
+
+// src/task/scalar/ScalarAddTask.ts
 var inputSchema = {
   type: "object",
   properties: {
-    url: {
-      type: "string",
-      title: "URL",
-      description: "The URL to fetch from",
-      format: "uri"
-    },
-    method: {
-      enum: ["GET", "POST", "PUT", "DELETE", "PATCH"],
-      title: "Method",
-      description: "The HTTP method to use",
-      default: "GET"
-    },
-    headers: {
-      type: "object",
-      additionalProperties: {
-        type: "string"
-      },
-      title: "Headers",
-      description: "The headers to send with the request"
-    },
-    body: {
-      type: "string",
-      title: "Body",
-      description: "The body of the request"
-    },
-    response_type: {
-      anyOf: [{ type: "null" }, { enum: ["json", "text", "blob", "arraybuffer"] }],
-      title: "Response Type",
-      description: "The forced type of response to return. If null, the response type is inferred from the Content-Type header.",
-      default: null
-    },
-    timeout: {
+    a: {
       type: "number",
-      title: "Timeout",
-      description: "Request timeout in milliseconds"
+      title: "A",
+      description: "First number"
     },
-    queue: {
-      oneOf: [{ type: "boolean" }, { type: "string" }],
-      description: "Queue handling: false=run inline, true=use default, string=explicit queue name",
-      default: true,
-      "x-ui-hidden": true
+    b: {
+      type: "number",
+      title: "B",
+      description: "Second number"
     }
   },
-  required: ["url"],
+  required: ["a", "b"],
   additionalProperties: false
 };
 var outputSchema = {
   type: "object",
   properties: {
-    json: {
-      title: "JSON",
-      description: "The JSON response"
-    },
-    text: {
-      type: "string",
-      title: "Text",
-      description: "The text response"
-    },
-    blob: {
-      title: "Blob",
-      description: "The blob response"
-    },
-    arraybuffer: {
-      title: "ArrayBuffer",
-      description: "The arraybuffer response"
-    },
-    metadata: {
-      type: "object",
-      properties: {
-        contentType: { type: "string" },
-        headers: { type: "object", additionalProperties: { type: "string" } }
-      },
-      additionalProperties: false,
-      title: "Response Metadata",
-      description: "HTTP response metadata including content type and headers"
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Sum of a and b"
     }
   },
+  required: ["result"],
   additionalProperties: false
 };
-async function fetchWithProgress(url, options = {}, onProgress) {
-  if (!options.signal) {
-    throw new TaskConfigurationError("An AbortSignal must be provided.");
-  }
-  const response = await globalThis.fetch(url, options);
-  if (!response.body) {
-    throw new Error("ReadableStream not supported in this environment.");
-  }
-  const contentLength = response.headers.get("Content-Length");
-  const totalBytes = contentLength ? parseInt(contentLength, 10) : 0;
-  let receivedBytes = 0;
-  const reader = response.body.getReader();
-  const stream = new ReadableStream({
-    start(controller) {
-      async function push() {
-        try {
-          while (true) {
-            if (options.signal?.aborted) {
-              controller.error(new AbortSignalJobError("Fetch aborted"));
-              reader.cancel();
-              return;
-            }
-            const { done, value } = await reader.read();
-            if (done) {
-              controller.close();
-              break;
-            }
-            controller.enqueue(value);
-            receivedBytes += value.length;
-            if (onProgress && totalBytes) {
-              await onProgress(receivedBytes / totalBytes * 100);
-            }
-          }
-        } catch (error) {
-          controller.error(error);
-        }
-      }
-      push();
-    },
-    cancel() {
-      reader.cancel();
-    }
-  });
-  return new Response(stream, {
-    headers: response.headers,
-    status: response.status,
-    statusText: response.statusText
-  });
-}
-
-class FetchUrlJob extends Job {
-  constructor(config = { input: {} }) {
-    super(config);
-  }
-  static type = "FetchUrlJob";
-  async execute(input, context) {
-    const response = await fetchWithProgress(input.url, {
-      method: input.method,
-      headers: input.headers,
-      body: input.body,
-      signal: context.signal
-    }, async (progress) => await context.updateProgress(progress));
-    if (response.ok) {
-      const contentType = response.headers.get("content-type") ?? "";
-      const headers = {};
-      response.headers.forEach((value, key) => {
-        headers[key] = value;
-      });
-      const metadata = {
-        contentType,
-        headers
-      };
-      let responseType = input.response_type;
-      if (!responseType) {
-        if (contentType.includes("application/json")) {
-          responseType = "json";
-        } else if (contentType.includes("text/")) {
-          responseType = "text";
-        } else if (contentType.includes("application/octet-stream")) {
-          responseType = "arraybuffer";
-        } else if (contentType.includes("application/pdf") || contentType.includes("image/") || contentType.includes("application/zip")) {
-          responseType = "blob";
-        } else {
-          responseType = "json";
-        }
-        input.response_type = responseType;
-      }
-      if (responseType === "json") {
-        return { json: await response.json(), metadata };
-      } else if (responseType === "text") {
-        return { text: await response.text(), metadata };
-      } else if (responseType === "blob") {
-        return { blob: await response.blob(), metadata };
-      } else if (responseType === "arraybuffer") {
-        return { arraybuffer: await response.arrayBuffer(), metadata };
-      }
-      throw new TaskInvalidInputError(`Invalid response type: ${responseType}`);
-    } else {
-      if (response.status === 429 || response.status === 503 || response.headers.get("Retry-After")) {
-        let retryDate;
-        const retryAfterStr = response.headers.get("Retry-After");
-        if (retryAfterStr) {
-          const parsedDate = new Date(retryAfterStr);
-          if (!isNaN(parsedDate.getTime()) && parsedDate > new Date) {
-            retryDate = parsedDate;
-          } else {
-            const retryAfterSeconds = parseInt(retryAfterStr) * 1000;
-            if (!isNaN(retryAfterSeconds)) {
-              retryDate = new Date(Date.now() + retryAfterSeconds);
-            }
-          }
-        }
-        throw new RetryableJobError(`Failed to fetch ${input.url}: ${response.status} ${response.statusText}`, retryDate);
-      } else {
-        throw new PermanentJobError(`Failed to fetch ${input.url}: ${response.status} ${response.statusText}`);
-      }
-    }
-  }
-}
 
-class FetchUrlTask extends JobQueueTask {
-  static type = "FetchUrlTask";
-  static category = "Input";
-  static title = "Fetch";
-  static description = "Fetches data from a URL with progress tracking and automatic retry handling";
-  static hasDynamicSchemas = true;
+class ScalarAddTask extends Task {
+  static type = "ScalarAddTask";
+  static category = "Math";
+  static title = "Add";
+  static description = "Returns the sum of two numbers";
   static inputSchema() {
     return inputSchema;
   }
   static outputSchema() {
     return outputSchema;
   }
-  outputSchema() {
-    const responseType = this.runInputData?.response_type ?? this.defaults?.response_type ?? null;
-    if (responseType === null || responseType === undefined) {
-      return this.constructor.outputSchema();
-    }
-    const staticSchema = this.constructor.outputSchema();
-    if (typeof staticSchema === "boolean") {
-      return staticSchema;
-    }
-    if (!staticSchema.properties) {
-      return staticSchema;
-    }
-    const properties = {};
-    if (responseType === "json" && staticSchema.properties.json) {
-      properties.json = staticSchema.properties.json;
-    } else if (responseType === "text" && staticSchema.properties.text) {
-      properties.text = staticSchema.properties.text;
-    } else if (responseType === "blob" && staticSchema.properties.blob) {
-      properties.blob = staticSchema.properties.blob;
-    } else if (responseType === "arraybuffer" && staticSchema.properties.arraybuffer) {
-      properties.arraybuffer = staticSchema.properties.arraybuffer;
-    }
-    if (staticSchema.properties.metadata) {
-      properties.metadata = staticSchema.properties.metadata;
-    }
-    if (Object.keys(properties).length === 0) {
-      return staticSchema;
-    }
-    return {
-      type: "object",
-      properties,
-      additionalProperties: false
-    };
-  }
-  constructor(input = {}, config = {}) {
-    config.queue = input?.queue ?? config.queue;
-    if (config.queue === undefined) {
-      config.queue = false;
-    }
-    super(input, config);
-    this.jobClass = FetchUrlJob;
-  }
-  setInput(input) {
-    if (!("response_type" in input)) {
-      super.setInput(input);
-      return;
-    }
-    const getCurrentResponseType = () => {
-      return this.runInputData?.response_type ?? this.defaults?.response_type ?? null;
-    };
-    const previousResponseType = getCurrentResponseType();
-    super.setInput(input);
-    const newResponseType = getCurrentResponseType();
-    if (previousResponseType !== newResponseType) {
-      this.emitSchemaChange();
-    }
-  }
-  async getDefaultQueueName(input) {
-    if (!input.url) {
-      return `fetch:${this.type}`;
-    }
-    try {
-      const hostname = new URL(input.url).hostname.toLowerCase();
-      const parts = hostname.split(".").filter(Boolean);
-      if (parts.length === 0) {
-        return `fetch:${this.type}`;
-      }
-      const domain = parts.length <= 2 ? parts.join(".") : parts.slice(-2).join(".");
-      return `fetch:${domain}`;
-    } catch {
-      return `fetch:${this.type}`;
-    }
+  async execute(input, _context) {
+    return { result: sumPrecise([input.a, input.b]) };
   }
 }
-var fetchUrl = async (input, config = {}) => {
-  const result = await new FetchUrlTask({}, config).run(input);
-  return result;
-};
-Workflow.prototype.fetch = CreateWorkflow(FetchUrlTask);
+Workflow.prototype.scalarAdd = CreateWorkflow(ScalarAddTask);
 
-// src/task/FileLoaderTask.ts
+// src/task/scalar/ScalarDivideTask.ts
+import { CreateWorkflow as CreateWorkflow2, Task as Task2, Workflow as Workflow2 } from "@workglow/task-graph";
 var inputSchema2 = {
   type: "object",
   properties: {
-    url: {
-      type: "string",
-      title: "URL",
-      description: "URL to load document from (http://, https://)",
-      format: "uri"
+    a: {
+      type: "number",
+      title: "A",
+      description: "Numerator"
     },
-    format: {
-      type: "string",
-      enum: ["text", "markdown", "json", "csv", "pdf", "image", "html", "auto"],
-      title: "Format",
-      description: "File format (auto-detected from URL if 'auto')",
-      default: "auto"
+    b: {
+      type: "number",
+      title: "B",
+      description: "Denominator"
     }
   },
-  required: ["url"],
+  required: ["a", "b"],
   additionalProperties: false
 };
 var outputSchema2 = {
   type: "object",
   properties: {
-    text: {
-      type: "string",
-      title: "Text",
-      description: "Text content (for text, markdown, html formats)"
-    },
-    json: {
-      title: "JSON",
-      description: "Parsed JSON object or array"
-    },
-    csv: {
-      type: "array",
-      title: "CSV",
-      description: "Parsed CSV data as array of objects"
-    },
-    image: {
-      type: "string",
-      title: "Image",
-      description: "Base64 data URL for image files",
-      format: "image:data-uri"
-    },
-    pdf: {
-      type: "string",
-      title: "PDF",
-      description: "Base64 data URL for PDF files"
-    },
-    metadata: {
-      type: "object",
-      properties: {
-        url: { type: "string" },
-        format: { type: "string" },
-        size: { type: "number" },
-        title: { type: "string" },
-        mimeType: { type: "string" }
-      },
-      additionalProperties: false,
-      title: "Metadata",
-      description: "File metadata"
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Quotient (a / b)"
     }
   },
-  required: ["metadata"],
+  required: ["result"],
   additionalProperties: false
 };
 
-class FileLoaderTask extends Task {
-  static type = "FileLoaderTask";
-  static category = "Document";
-  static title = "File Loader";
-  static description = "Load documents from URLs (http://, https://)";
-  static cacheable = true;
+class ScalarDivideTask extends Task2 {
+  static type = "ScalarDivideTask";
+  static category = "Math";
+  static title = "Divide";
+  static description = "Returns the quotient of two numbers (a / b)";
   static inputSchema() {
     return inputSchema2;
   }
   static outputSchema() {
     return outputSchema2;
   }
-  async execute(input, context) {
-    const { url, format = "auto" } = input;
-    if (context.signal.aborted) {
-      throw new TaskAbortedError("Task aborted");
-    }
-    await context.updateProgress(0, "Detecting file format");
-    const detectedFormat = this.detectFormat(url, format);
-    const responseType = this.detectResponseType(detectedFormat);
-    if (context.signal.aborted) {
-      throw new TaskAbortedError("Task aborted");
-    }
-    await context.updateProgress(10, `Fetching ${detectedFormat} file from ${url}`);
-    const fetchTask = context.own(new FetchUrlTask({
-      url,
-      response_type: responseType,
-      queue: false
-    }));
-    const response = await fetchTask.run();
-    if (context.signal.aborted) {
-      throw new TaskAbortedError("Task aborted");
+  async execute(input, _context) {
+    return { result: input.a / input.b };
+  }
+}
+Workflow2.prototype.scalarDivide = CreateWorkflow2(ScalarDivideTask);
+
+// src/task/scalar/ScalarMultiplyTask.ts
+import { CreateWorkflow as CreateWorkflow3, Task as Task3, Workflow as Workflow3 } from "@workglow/task-graph";
+var inputSchema3 = {
+  type: "object",
+  properties: {
+    a: {
+      type: "number",
+      title: "A",
+      description: "First number"
+    },
+    b: {
+      type: "number",
+      title: "B",
+      description: "Second number"
     }
-    await context.updateProgress(60, "Parsing file content");
-    const title = url.split("/").pop() || url;
-    const { text, json, csv, image, pdf, size, mimeType } = await this.parseResponse(response, url, detectedFormat);
-    if (context.signal.aborted) {
-      throw new TaskAbortedError("Task aborted");
+  },
+  required: ["a", "b"],
+  additionalProperties: false
+};
+var outputSchema3 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Product of a and b"
     }
-    await context.updateProgress(100, "File loaded successfully");
-    return {
-      text,
-      json,
-      csv,
-      image,
-      pdf,
-      metadata: {
-        url,
-        format: detectedFormat,
-        size,
-        title,
-        mimeType
-      }
-    };
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarMultiplyTask extends Task3 {
+  static type = "ScalarMultiplyTask";
+  static category = "Math";
+  static title = "Multiply";
+  static description = "Returns the product of two numbers";
+  static inputSchema() {
+    return inputSchema3;
   }
-  parseJsonContent(content) {
-    return JSON.parse(content);
+  static outputSchema() {
+    return outputSchema3;
   }
-  parseCsvContent(content) {
-    try {
-      const result = Papa.parse(content, {
-        header: true,
-        skipEmptyLines: true,
-        transformHeader: (header) => header.trim()
-      });
-      return result.data;
-    } catch (error) {
-      throw new Error(`Failed to parse CSV: ${error}`);
-    }
+  async execute(input, _context) {
+    return { result: input.a * input.b };
   }
-  async parseResponse(response, url, detectedFormat) {
-    const responseMimeType = response.metadata?.contentType || "";
-    if (detectedFormat === "json") {
-      if (!response.json) {
-        throw new Error(`Failed to load JSON from ${url}`);
-      }
-      const jsonData = response.json;
-      const content2 = JSON.stringify(jsonData, null, 2);
-      return {
-        text: undefined,
-        json: jsonData,
-        csv: undefined,
-        image: undefined,
-        pdf: undefined,
-        size: content2.length,
-        mimeType: responseMimeType || "application/json"
-      };
-    }
-    if (detectedFormat === "csv") {
-      const content2 = response.text || "";
-      if (!content2) {
-        throw new Error(`Failed to load CSV from ${url}`);
-      }
-      const csvData = this.parseCsvContent(content2);
-      return {
-        text: undefined,
-        json: undefined,
-        csv: csvData,
-        image: undefined,
-        pdf: undefined,
-        size: content2.length,
-        mimeType: responseMimeType || "text/csv"
-      };
-    }
-    if (detectedFormat === "image") {
-      if (!response.blob) {
-        throw new Error(`Failed to load image from ${url}`);
-      }
-      const blob = response.blob;
-      const mimeType2 = responseMimeType || (blob.type && blob.type !== "" ? blob.type : this.getImageMimeType(url));
-      const imageData = await this.blobToBase64DataURL(blob, mimeType2);
-      return {
-        text: undefined,
-        json: undefined,
-        csv: undefined,
-        image: imageData,
-        pdf: undefined,
-        size: blob.size,
-        mimeType: mimeType2
-      };
-    }
-    if (detectedFormat === "pdf") {
-      if (!response.blob) {
-        throw new Error(`Failed to load PDF from ${url}`);
-      }
-      const blob = response.blob;
-      const mimeType2 = responseMimeType || "application/pdf";
-      const pdfData = await this.blobToBase64DataURL(blob, mimeType2);
-      return {
-        text: undefined,
-        json: undefined,
-        csv: undefined,
-        image: undefined,
-        pdf: pdfData,
-        size: blob.size,
-        mimeType: mimeType2
-      };
+}
+Workflow3.prototype.scalarMultiply = CreateWorkflow3(ScalarMultiplyTask);
+
+// src/task/scalar/ScalarSubtractTask.ts
+import { CreateWorkflow as CreateWorkflow4, Task as Task4, Workflow as Workflow4 } from "@workglow/task-graph";
+var inputSchema4 = {
+  type: "object",
+  properties: {
+    a: {
+      type: "number",
+      title: "A",
+      description: "First number"
+    },
+    b: {
+      type: "number",
+      title: "B",
+      description: "Second number"
     }
-    const content = response.text || "";
-    if (!content) {
-      throw new Error(`Failed to load content from ${url}`);
+  },
+  required: ["a", "b"],
+  additionalProperties: false
+};
+var outputSchema4 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Difference (a - b)"
     }
-    const mimeType = responseMimeType || (detectedFormat === "markdown" ? "text/markdown" : detectedFormat === "html" ? "text/html" : "text/plain");
-    return {
-      text: content,
-      json: undefined,
-      csv: undefined,
-      image: undefined,
-      pdf: undefined,
-      size: content.length,
-      mimeType
-    };
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarSubtractTask extends Task4 {
+  static type = "ScalarSubtractTask";
+  static category = "Math";
+  static title = "Subtract";
+  static description = "Returns the difference of two numbers (a - b)";
+  static inputSchema() {
+    return inputSchema4;
   }
-  detectResponseType(detectedFormat) {
-    let responseType = "text";
-    if (detectedFormat === "json") {
-      responseType = "json";
-    } else if (detectedFormat === "image" || detectedFormat === "pdf") {
-      responseType = "blob";
-    } else if (detectedFormat === "csv" || detectedFormat === "text" || detectedFormat === "markdown" || detectedFormat === "html") {
-      responseType = "text";
-    }
-    return responseType;
+  static outputSchema() {
+    return outputSchema4;
   }
-  detectFormat(url, format) {
-    if (format === "auto") {
-      const urlLower = url.toLowerCase();
-      if (urlLower.endsWith(".md") || urlLower.endsWith(".markdown")) {
-        return "markdown";
-      } else if (urlLower.endsWith(".json")) {
-        return "json";
-      } else if (urlLower.endsWith(".csv")) {
-        return "csv";
-      } else if (urlLower.endsWith(".pdf")) {
-        return "pdf";
-      } else if (urlLower.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg|ico)$/)) {
-        return "image";
-      } else if (urlLower.endsWith(".html") || urlLower.endsWith(".htm")) {
-        return "html";
-      } else {
-        return "text";
-      }
+  async execute(input, _context) {
+    return { result: input.a - input.b };
+  }
+}
+Workflow4.prototype.scalarSubtract = CreateWorkflow4(ScalarSubtractTask);
+
+// src/task/scalar/ScalarSumTask.ts
+import { CreateWorkflow as CreateWorkflow5, Task as Task5, Workflow as Workflow5 } from "@workglow/task-graph";
+var inputSchema5 = {
+  type: "object",
+  properties: {
+    values: {
+      type: "array",
+      items: { type: "number" },
+      title: "Values",
+      description: "Array of numbers to sum"
     }
-    return format;
+  },
+  required: ["values"],
+  additionalProperties: false
+};
+var outputSchema5 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Sum of all values"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarSumTask extends Task5 {
+  static type = "ScalarSumTask";
+  static category = "Math";
+  static title = "Sum";
+  static description = "Returns the sum of an array of numbers";
+  static inputSchema() {
+    return inputSchema5;
   }
-  getImageMimeType(url) {
-    const urlLower = url.toLowerCase();
-    if (urlLower.endsWith(".png"))
-      return "image/png";
-    if (urlLower.endsWith(".jpg") || urlLower.endsWith(".jpeg"))
-      return "image/jpeg";
-    if (urlLower.endsWith(".gif"))
-      return "image/gif";
-    if (urlLower.endsWith(".webp"))
-      return "image/webp";
-    if (urlLower.endsWith(".bmp"))
-      return "image/bmp";
-    if (urlLower.endsWith(".svg"))
-      return "image/svg+xml";
-    if (urlLower.endsWith(".ico"))
-      return "image/x-icon";
-    return "image/jpeg";
+  static outputSchema() {
+    return outputSchema5;
   }
-  async blobToBase64DataURL(blob, mimeType) {
-    if (typeof Buffer !== "undefined") {
-      const arrayBuffer = await blob.arrayBuffer();
-      const buffer = Buffer.from(arrayBuffer);
-      return `data:${mimeType};base64,${buffer.toString("base64")}`;
-    }
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader;
-      reader.onloadend = () => {
-        const result = reader.result;
-        if (result.startsWith("data:;base64,")) {
-          resolve(`data:${mimeType};base64,${result.substring(13)}`);
-        } else {
-          resolve(result);
-        }
-      };
-      reader.onerror = reject;
-      reader.readAsDataURL(blob);
-    });
+  async execute(input, _context) {
+    return { result: sumPrecise(input.values) };
   }
 }
-Workflow2.prototype.fileLoader = CreateWorkflow2(FileLoaderTask);
+Workflow5.prototype.scalarSum = CreateWorkflow5(ScalarSumTask);
 
-// src/task/FileLoaderTask.server.ts
-class FileLoaderTask2 extends FileLoaderTask {
-  async execute(input, context) {
-    let { url, format = "auto" } = input;
-    if (url.startsWith("http://") || url.startsWith("https://")) {
-      return super.execute(input, context);
+// src/task/vector/VectorDivideTask.ts
+import { CreateWorkflow as CreateWorkflow6, Task as Task6, Workflow as Workflow6 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom,
+  TypedArraySchema
+} from "@workglow/util";
+var inputSchema6 = {
+  type: "object",
+  properties: {
+    vectors: {
+      type: "array",
+      items: TypedArraySchema({
+        title: "Vector",
+        description: "Vector (first is numerator, rest are denominators)"
+      }),
+      title: "Vectors",
+      description: "Array of vectors: vectors[0] / vectors[1] / vectors[2] / ..."
     }
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
+  },
+  required: ["vectors"],
+  additionalProperties: false
+};
+var outputSchema6 = {
+  type: "object",
+  properties: {
+    result: TypedArraySchema({
+      title: "Result",
+      description: "Component-wise quotient"
+    })
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorDivideTask extends Task6 {
+  static type = "VectorDivideTask";
+  static category = "Vector";
+  static title = "Divide";
+  static description = "Returns component-wise quotient: vectors[0] / vectors[1] / vectors[2] / ...";
+  static inputSchema() {
+    return inputSchema6;
+  }
+  static outputSchema() {
+    return outputSchema6;
+  }
+  async execute(input, _context) {
+    const { vectors } = input;
+    if (vectors.length < 2) {
+      throw new Error("At least two vectors are required");
     }
-    await context.updateProgress(0, "Detecting file format");
-    if (url.startsWith("file://")) {
-      url = url.slice(7);
-    }
-    const detectedFormat = this.detectFormat(url, format);
-    const title = url.split("/").pop() || url;
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
-    }
-    await context.updateProgress(10, `Reading ${detectedFormat} file from filesystem`);
-    if (detectedFormat === "json") {
-      const fileContent2 = await readFile(url, { encoding: "utf-8" });
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(50, "Parsing JSON content");
-      const jsonData = this.parseJsonContent(fileContent2);
-      const content = JSON.stringify(jsonData, null, 2);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(100, "File loaded successfully");
-      return {
-        text: undefined,
-        json: jsonData,
-        csv: undefined,
-        image: undefined,
-        pdf: undefined,
-        metadata: {
-          url,
-          format: detectedFormat,
-          size: content.length,
-          title,
-          mimeType: "application/json"
-        }
-      };
-    }
-    if (detectedFormat === "csv") {
-      const fileContent2 = await readFile(url, { encoding: "utf-8" });
-      if (!fileContent2) {
-        throw new Error(`Failed to load CSV from ${url}`);
-      }
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(50, "Parsing CSV content");
-      const csvData = this.parseCsvContent(fileContent2);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(100, "File loaded successfully");
-      return {
-        text: undefined,
-        json: undefined,
-        csv: csvData,
-        image: undefined,
-        pdf: undefined,
-        metadata: {
-          url,
-          format: detectedFormat,
-          size: fileContent2.length,
-          title,
-          mimeType: "text/csv"
-        }
-      };
-    }
-    if (detectedFormat === "image") {
-      const fileBuffer = await readFile(url);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(50, "Converting image to base64");
-      const mimeType2 = this.getImageMimeType(url);
-      const blob = new Blob([fileBuffer], { type: mimeType2 });
-      const imageData = await this.blobToBase64DataURL(blob, mimeType2);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(100, "File loaded successfully");
-      return {
-        text: undefined,
-        json: undefined,
-        csv: undefined,
-        image: imageData,
-        pdf: undefined,
-        metadata: {
-          url,
-          format: detectedFormat,
-          size: fileBuffer.length,
-          title,
-          mimeType: mimeType2
-        }
-      };
-    }
-    if (detectedFormat === "pdf") {
-      const fileBuffer = await readFile(url);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
-      }
-      await context.updateProgress(50, "Converting PDF to base64");
-      const mimeType2 = "application/pdf";
-      const blob = new Blob([fileBuffer], { type: mimeType2 });
-      const pdfData = await this.blobToBase64DataURL(blob, mimeType2);
-      if (context.signal.aborted) {
-        throw new TaskAbortedError2("Task aborted");
+    const len = vectors[0].length;
+    for (let i = 1;i < vectors.length; i++) {
+      if (vectors[i].length !== len) {
+        throw new Error("All vectors must have the same length");
       }
-      await context.updateProgress(100, "File loaded successfully");
-      return {
-        text: undefined,
-        json: undefined,
-        csv: undefined,
-        image: undefined,
-        pdf: pdfData,
-        metadata: {
-          url,
-          format: detectedFormat,
-          size: fileBuffer.length,
-          title,
-          mimeType: mimeType2
-        }
-      };
-    }
-    const fileContent = await readFile(url, { encoding: "utf-8" });
-    if (!fileContent) {
-      throw new Error(`Failed to load content from ${url}`);
-    }
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
-    }
-    await context.updateProgress(50, `Parsing ${detectedFormat} content`);
-    const mimeType = detectedFormat === "markdown" ? "text/markdown" : detectedFormat === "html" ? "text/html" : "text/plain";
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
     }
-    await context.updateProgress(100, "File loaded successfully");
-    return {
-      text: fileContent,
-      json: undefined,
-      csv: undefined,
-      image: undefined,
-      pdf: undefined,
-      metadata: {
-        url,
-        format: detectedFormat,
-        size: fileContent.length,
-        title,
-        mimeType
+    const values = Array.from({ length: len }, (_, i) => {
+      let acc = Number(vectors[0][i]);
+      for (let j = 1;j < vectors.length; j++) {
+        acc /= Number(vectors[j][i]);
       }
-    };
-  }
-}
-var fileLoader = (input, config) => {
-  return new FileLoaderTask2({}, config).run(input);
-};
-Workflow3.prototype.fileLoader = CreateWorkflow3(FileLoaderTask2);
-
-// src/task/adaptive.ts
-import { CreateAdaptiveWorkflow, Workflow as Workflow13 } from "@workglow/task-graph";
-
-// src/task/scalar/ScalarAddTask.ts
-import { CreateWorkflow as CreateWorkflow4, Task as Task2, Workflow as Workflow4 } from "@workglow/task-graph";
-
-// src/task/scalar/sumPrecise.ts
-function kahanSum(values) {
-  let sum = 0;
-  let compensation = 0;
-  for (const value of values) {
-    const y = value - compensation;
-    const t = sum + y;
-    compensation = t - sum - y;
-    sum = t;
+      return acc;
+    });
+    return { result: createTypedArrayFrom(vectors, values) };
   }
-  return sum;
 }
-var nativeSumPrecise = typeof Math.sumPrecise === "function" ? Math.sumPrecise : undefined;
-var sumPrecise = nativeSumPrecise ? nativeSumPrecise.bind(Math) : kahanSum;
+Workflow6.prototype.vectorDivide = CreateWorkflow6(VectorDivideTask);
 
-// src/task/scalar/ScalarAddTask.ts
-var inputSchema3 = {
+// src/task/vector/VectorMultiplyTask.ts
+import { CreateWorkflow as CreateWorkflow7, Task as Task7, Workflow as Workflow7 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom as createTypedArrayFrom2,
+  TypedArraySchema as TypedArraySchema2
+} from "@workglow/util";
+var inputSchema7 = {
   type: "object",
   properties: {
-    a: {
-      type: "number",
-      title: "A",
-      description: "First number"
-    },
-    b: {
-      type: "number",
-      title: "B",
-      description: "Second number"
+    vectors: {
+      type: "array",
+      items: TypedArraySchema2({
+        title: "Vector",
+        description: "Vector for component-wise product"
+      }),
+      title: "Vectors",
+      description: "Array of vectors to multiply component-wise"
     }
   },
-  required: ["a", "b"],
+  required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema3 = {
+var outputSchema7 = {
   type: "object",
   properties: {
-    result: {
-      type: "number",
+    result: TypedArraySchema2({
       title: "Result",
-      description: "Sum of a and b"
-    }
+      description: "Component-wise product (Hadamard product)"
+    })
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class ScalarAddTask extends Task2 {
-  static type = "ScalarAddTask";
-  static category = "Math";
-  static title = "Add";
-  static description = "Returns the sum of two numbers";
+class VectorMultiplyTask extends Task7 {
+  static type = "VectorMultiplyTask";
+  static category = "Vector";
+  static title = "Multiply";
+  static description = "Returns the component-wise product (Hadamard product) of all vectors";
   static inputSchema() {
-    return inputSchema3;
+    return inputSchema7;
   }
   static outputSchema() {
-    return outputSchema3;
+    return outputSchema7;
   }
   async execute(input, _context) {
-    return { result: sumPrecise([input.a, input.b]) };
+    const { vectors } = input;
+    if (vectors.length === 0) {
+      throw new Error("At least one vector is required");
+    }
+    const len = vectors[0].length;
+    for (let i = 1;i < vectors.length; i++) {
+      if (vectors[i].length !== len) {
+        throw new Error("All vectors must have the same length");
+      }
+    }
+    const values = Array.from({ length: len }, (_, i) => vectors.reduce((acc, v) => acc * Number(v[i]), 1));
+    return { result: createTypedArrayFrom2(vectors, values) };
   }
 }
-Workflow4.prototype.scalarAdd = CreateWorkflow4(ScalarAddTask);
+Workflow7.prototype.vectorMultiply = CreateWorkflow7(VectorMultiplyTask);
 
-// src/task/scalar/ScalarDivideTask.ts
-import { CreateWorkflow as CreateWorkflow5, Task as Task3, Workflow as Workflow5 } from "@workglow/task-graph";
-var inputSchema4 = {
+// src/task/vector/VectorSubtractTask.ts
+import { CreateWorkflow as CreateWorkflow8, Task as Task8, Workflow as Workflow8 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom as createTypedArrayFrom3,
+  TypedArraySchema as TypedArraySchema3
+} from "@workglow/util";
+var inputSchema8 = {
   type: "object",
   properties: {
-    a: {
-      type: "number",
-      title: "A",
-      description: "Numerator"
-    },
-    b: {
-      type: "number",
-      title: "B",
-      description: "Denominator"
+    vectors: {
+      type: "array",
+      items: TypedArraySchema3({
+        title: "Vector",
+        description: "Vector (first is minuend, rest are subtrahends)"
+      }),
+      title: "Vectors",
+      description: "Array of vectors: vectors[0] - vectors[1] - vectors[2] - ..."
     }
   },
-  required: ["a", "b"],
-  additionalProperties: false
-};
-var outputSchema4 = {
-  type: "object",
-  properties: {
-    result: {
-      type: "number",
-      title: "Result",
-      description: "Quotient (a / b)"
-    }
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class ScalarDivideTask extends Task3 {
-  static type = "ScalarDivideTask";
-  static category = "Math";
-  static title = "Divide";
-  static description = "Returns the quotient of two numbers (a / b)";
-  static inputSchema() {
-    return inputSchema4;
-  }
-  static outputSchema() {
-    return outputSchema4;
-  }
-  async execute(input, _context) {
-    return { result: input.a / input.b };
-  }
-}
-Workflow5.prototype.scalarDivide = CreateWorkflow5(ScalarDivideTask);
-
-// src/task/scalar/ScalarMultiplyTask.ts
-import { CreateWorkflow as CreateWorkflow6, Task as Task4, Workflow as Workflow6 } from "@workglow/task-graph";
-var inputSchema5 = {
-  type: "object",
-  properties: {
-    a: {
-      type: "number",
-      title: "A",
-      description: "First number"
-    },
-    b: {
-      type: "number",
-      title: "B",
-      description: "Second number"
-    }
-  },
-  required: ["a", "b"],
-  additionalProperties: false
-};
-var outputSchema5 = {
-  type: "object",
-  properties: {
-    result: {
-      type: "number",
-      title: "Result",
-      description: "Product of a and b"
-    }
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class ScalarMultiplyTask extends Task4 {
-  static type = "ScalarMultiplyTask";
-  static category = "Math";
-  static title = "Multiply";
-  static description = "Returns the product of two numbers";
-  static inputSchema() {
-    return inputSchema5;
-  }
-  static outputSchema() {
-    return outputSchema5;
-  }
-  async execute(input, _context) {
-    return { result: input.a * input.b };
-  }
-}
-Workflow6.prototype.scalarMultiply = CreateWorkflow6(ScalarMultiplyTask);
-
-// src/task/scalar/ScalarSubtractTask.ts
-import { CreateWorkflow as CreateWorkflow7, Task as Task5, Workflow as Workflow7 } from "@workglow/task-graph";
-var inputSchema6 = {
-  type: "object",
-  properties: {
-    a: {
-      type: "number",
-      title: "A",
-      description: "First number"
-    },
-    b: {
-      type: "number",
-      title: "B",
-      description: "Second number"
-    }
-  },
-  required: ["a", "b"],
-  additionalProperties: false
-};
-var outputSchema6 = {
-  type: "object",
-  properties: {
-    result: {
-      type: "number",
-      title: "Result",
-      description: "Difference (a - b)"
-    }
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class ScalarSubtractTask extends Task5 {
-  static type = "ScalarSubtractTask";
-  static category = "Math";
-  static title = "Subtract";
-  static description = "Returns the difference of two numbers (a - b)";
-  static inputSchema() {
-    return inputSchema6;
-  }
-  static outputSchema() {
-    return outputSchema6;
-  }
-  async execute(input, _context) {
-    return { result: input.a - input.b };
-  }
-}
-Workflow7.prototype.scalarSubtract = CreateWorkflow7(ScalarSubtractTask);
-
-// src/task/scalar/ScalarSumTask.ts
-import { CreateWorkflow as CreateWorkflow8, Task as Task6, Workflow as Workflow8 } from "@workglow/task-graph";
-var inputSchema7 = {
-  type: "object",
-  properties: {
-    values: {
-      type: "array",
-      items: { type: "number" },
-      title: "Values",
-      description: "Array of numbers to sum"
-    }
-  },
-  required: ["values"],
-  additionalProperties: false
-};
-var outputSchema7 = {
-  type: "object",
-  properties: {
-    result: {
-      type: "number",
-      title: "Result",
-      description: "Sum of all values"
-    }
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class ScalarSumTask extends Task6 {
-  static type = "ScalarSumTask";
-  static category = "Math";
-  static title = "Sum";
-  static description = "Returns the sum of an array of numbers";
-  static inputSchema() {
-    return inputSchema7;
-  }
-  static outputSchema() {
-    return outputSchema7;
-  }
-  async execute(input, _context) {
-    return { result: sumPrecise(input.values) };
-  }
-}
-Workflow8.prototype.scalarSum = CreateWorkflow8(ScalarSumTask);
-
-// src/task/vector/VectorDivideTask.ts
-import { CreateWorkflow as CreateWorkflow9, Task as Task7, Workflow as Workflow9 } from "@workglow/task-graph";
-import {
-  createTypedArrayFrom,
-  TypedArraySchema
-} from "@workglow/util";
-var inputSchema8 = {
-  type: "object",
-  properties: {
-    vectors: {
-      type: "array",
-      items: TypedArraySchema({
-        title: "Vector",
-        description: "Vector (first is numerator, rest are denominators)"
-      }),
-      title: "Vectors",
-      description: "Array of vectors: vectors[0] / vectors[1] / vectors[2] / ..."
-    }
-  },
-  required: ["vectors"],
+  required: ["vectors"],
   additionalProperties: false
 };
 var outputSchema8 = {
   type: "object",
   properties: {
-    result: TypedArraySchema({
+    result: TypedArraySchema3({
       title: "Result",
-      description: "Component-wise quotient"
+      description: "Difference of vectors"
     })
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class VectorDivideTask extends Task7 {
-  static type = "VectorDivideTask";
+class VectorSubtractTask extends Task8 {
+  static type = "VectorSubtractTask";
   static category = "Vector";
-  static title = "Divide";
-  static description = "Returns component-wise quotient: vectors[0] / vectors[1] / vectors[2] / ...";
+  static title = "Subtract";
+  static description = "Returns component-wise difference: vectors[0] - vectors[1] - vectors[2] - ...";
   static inputSchema() {
     return inputSchema8;
   }
@@ -1108,32 +454,32 @@ class VectorDivideTask extends Task7 {
     const values = Array.from({ length: len }, (_, i) => {
       let acc = Number(vectors[0][i]);
       for (let j = 1;j < vectors.length; j++) {
-        acc /= Number(vectors[j][i]);
+        acc -= Number(vectors[j][i]);
       }
       return acc;
     });
-    return { result: createTypedArrayFrom(vectors, values) };
+    return { result: createTypedArrayFrom3(vectors, values) };
   }
 }
-Workflow9.prototype.vectorDivide = CreateWorkflow9(VectorDivideTask);
+Workflow8.prototype.vectorSubtract = CreateWorkflow8(VectorSubtractTask);
 
-// src/task/vector/VectorMultiplyTask.ts
-import { CreateWorkflow as CreateWorkflow10, Task as Task8, Workflow as Workflow10 } from "@workglow/task-graph";
+// src/task/vector/VectorSumTask.ts
+import { CreateWorkflow as CreateWorkflow9, Task as Task9, Workflow as Workflow9 } from "@workglow/task-graph";
 import {
-  createTypedArrayFrom as createTypedArrayFrom2,
-  TypedArraySchema as TypedArraySchema2
+  createTypedArrayFrom as createTypedArrayFrom4,
+  TypedArraySchema as TypedArraySchema4
 } from "@workglow/util";
 var inputSchema9 = {
   type: "object",
   properties: {
     vectors: {
       type: "array",
-      items: TypedArraySchema2({
+      items: TypedArraySchema4({
         title: "Vector",
-        description: "Vector for component-wise product"
+        description: "Vector to sum"
       }),
       title: "Vectors",
-      description: "Array of vectors to multiply component-wise"
+      description: "Array of vectors to sum component-wise"
     }
   },
   required: ["vectors"],
@@ -1142,20 +488,20 @@ var inputSchema9 = {
 var outputSchema9 = {
   type: "object",
   properties: {
-    result: TypedArraySchema2({
+    result: TypedArraySchema4({
       title: "Result",
-      description: "Component-wise product (Hadamard product)"
+      description: "Sum of vectors"
     })
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class VectorMultiplyTask extends Task8 {
-  static type = "VectorMultiplyTask";
+class VectorSumTask extends Task9 {
+  static type = "VectorSumTask";
   static category = "Vector";
-  static title = "Multiply";
-  static description = "Returns the component-wise product (Hadamard product) of all vectors";
+  static title = "Sum";
+  static description = "Returns the component-wise sum of an array of vectors";
   static inputSchema() {
     return inputSchema9;
   }
@@ -1173,152 +519,22 @@ class VectorMultiplyTask extends Task8 {
         throw new Error("All vectors must have the same length");
       }
     }
-    const values = Array.from({ length: len }, (_, i) => vectors.reduce((acc, v) => acc * Number(v[i]), 1));
-    return { result: createTypedArrayFrom2(vectors, values) };
+    const values = Array.from({ length: len }, (_, i) => sumPrecise(vectors.map((v) => Number(v[i]))));
+    return { result: createTypedArrayFrom4(vectors, values) };
   }
 }
-Workflow10.prototype.vectorMultiply = CreateWorkflow10(VectorMultiplyTask);
+Workflow9.prototype.vectorSum = CreateWorkflow9(VectorSumTask);
 
-// src/task/vector/VectorSubtractTask.ts
-import { CreateWorkflow as CreateWorkflow11, Task as Task9, Workflow as Workflow11 } from "@workglow/task-graph";
+// src/task/adaptive.ts
+Workflow10.prototype.add = CreateAdaptiveWorkflow(ScalarAddTask, VectorSumTask);
+Workflow10.prototype.subtract = CreateAdaptiveWorkflow(ScalarSubtractTask, VectorSubtractTask);
+Workflow10.prototype.multiply = CreateAdaptiveWorkflow(ScalarMultiplyTask, VectorMultiplyTask);
+Workflow10.prototype.divide = CreateAdaptiveWorkflow(ScalarDivideTask, VectorDivideTask);
+Workflow10.prototype.sum = CreateAdaptiveWorkflow(ScalarSumTask, VectorSumTask);
+
+// src/task/ArrayTask.ts
 import {
-  createTypedArrayFrom as createTypedArrayFrom3,
-  TypedArraySchema as TypedArraySchema3
-} from "@workglow/util";
-var inputSchema10 = {
-  type: "object",
-  properties: {
-    vectors: {
-      type: "array",
-      items: TypedArraySchema3({
-        title: "Vector",
-        description: "Vector (first is minuend, rest are subtrahends)"
-      }),
-      title: "Vectors",
-      description: "Array of vectors: vectors[0] - vectors[1] - vectors[2] - ..."
-    }
-  },
-  required: ["vectors"],
-  additionalProperties: false
-};
-var outputSchema10 = {
-  type: "object",
-  properties: {
-    result: TypedArraySchema3({
-      title: "Result",
-      description: "Difference of vectors"
-    })
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class VectorSubtractTask extends Task9 {
-  static type = "VectorSubtractTask";
-  static category = "Vector";
-  static title = "Subtract";
-  static description = "Returns component-wise difference: vectors[0] - vectors[1] - vectors[2] - ...";
-  static inputSchema() {
-    return inputSchema10;
-  }
-  static outputSchema() {
-    return outputSchema10;
-  }
-  async execute(input, _context) {
-    const { vectors } = input;
-    if (vectors.length < 2) {
-      throw new Error("At least two vectors are required");
-    }
-    const len = vectors[0].length;
-    for (let i = 1;i < vectors.length; i++) {
-      if (vectors[i].length !== len) {
-        throw new Error("All vectors must have the same length");
-      }
-    }
-    const values = Array.from({ length: len }, (_, i) => {
-      let acc = Number(vectors[0][i]);
-      for (let j = 1;j < vectors.length; j++) {
-        acc -= Number(vectors[j][i]);
-      }
-      return acc;
-    });
-    return { result: createTypedArrayFrom3(vectors, values) };
-  }
-}
-Workflow11.prototype.vectorSubtract = CreateWorkflow11(VectorSubtractTask);
-
-// src/task/vector/VectorSumTask.ts
-import { CreateWorkflow as CreateWorkflow12, Task as Task10, Workflow as Workflow12 } from "@workglow/task-graph";
-import {
-  createTypedArrayFrom as createTypedArrayFrom4,
-  TypedArraySchema as TypedArraySchema4
-} from "@workglow/util";
-var inputSchema11 = {
-  type: "object",
-  properties: {
-    vectors: {
-      type: "array",
-      items: TypedArraySchema4({
-        title: "Vector",
-        description: "Vector to sum"
-      }),
-      title: "Vectors",
-      description: "Array of vectors to sum component-wise"
-    }
-  },
-  required: ["vectors"],
-  additionalProperties: false
-};
-var outputSchema11 = {
-  type: "object",
-  properties: {
-    result: TypedArraySchema4({
-      title: "Result",
-      description: "Sum of vectors"
-    })
-  },
-  required: ["result"],
-  additionalProperties: false
-};
-
-class VectorSumTask extends Task10 {
-  static type = "VectorSumTask";
-  static category = "Vector";
-  static title = "Sum";
-  static description = "Returns the component-wise sum of an array of vectors";
-  static inputSchema() {
-    return inputSchema11;
-  }
-  static outputSchema() {
-    return outputSchema11;
-  }
-  async execute(input, _context) {
-    const { vectors } = input;
-    if (vectors.length === 0) {
-      throw new Error("At least one vector is required");
-    }
-    const len = vectors[0].length;
-    for (let i = 1;i < vectors.length; i++) {
-      if (vectors[i].length !== len) {
-        throw new Error("All vectors must have the same length");
-      }
-    }
-    const values = Array.from({ length: len }, (_, i) => sumPrecise(vectors.map((v) => Number(v[i]))));
-    return { result: createTypedArrayFrom4(vectors, values) };
-  }
-}
-Workflow12.prototype.vectorSum = CreateWorkflow12(VectorSumTask);
-
-// src/task/adaptive.ts
-Workflow13.prototype.add = CreateAdaptiveWorkflow(ScalarAddTask, VectorSumTask);
-Workflow13.prototype.subtract = CreateAdaptiveWorkflow(ScalarSubtractTask, VectorSubtractTask);
-Workflow13.prototype.multiply = CreateAdaptiveWorkflow(ScalarMultiplyTask, VectorMultiplyTask);
-Workflow13.prototype.divide = CreateAdaptiveWorkflow(ScalarDivideTask, VectorDivideTask);
-Workflow13.prototype.sum = CreateAdaptiveWorkflow(ScalarSumTask, VectorSumTask);
-
-// src/task/ArrayTask.ts
-import {
-  uuid4
+  uuid4
 } from "@workglow/util";
 import {
   GraphAsTask,
@@ -1350,12 +566,12 @@ class ArrayTask extends GraphAsTask {
   regenerateGraph() {
     const arrayInputs = new Map;
     let hasArrayInputs = false;
-    const inputSchema12 = this.inputSchema();
-    if (typeof inputSchema12 !== "boolean") {
-      const keys = Object.keys(inputSchema12.properties || {});
+    const inputSchema10 = this.inputSchema();
+    if (typeof inputSchema10 !== "boolean") {
+      const keys = Object.keys(inputSchema10.properties || {});
       for (const inputId of keys) {
         const inputValue = this.runInputData[inputId];
-        const inputDef = inputSchema12.properties?.[inputId];
+        const inputDef = inputSchema10.properties?.[inputId];
         if (typeof inputDef === "object" && inputDef !== null && "x-replicate" in inputDef && inputDef["x-replicate"] === true && Array.isArray(inputValue) && inputValue.length > 1) {
           arrayInputs.set(inputId, inputValue);
           hasArrayInputs = true;
@@ -1444,7 +660,7 @@ class ArrayTaskRunner extends GraphAsTaskRunner {
   }
 }
 // src/task/DebugLogTask.ts
-import { CreateWorkflow as CreateWorkflow13, Task as Task11, TaskConfigSchema, Workflow as Workflow14 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow10, Task as Task10, TaskConfigSchema, Workflow as Workflow11 } from "@workglow/task-graph";
 var log_levels = ["dir", "log", "debug", "info", "warn", "error"];
 var DEFAULT_LOG_LEVEL = "log";
 var debugLogTaskConfigSchema = {
@@ -1461,18 +677,18 @@ var debugLogTaskConfigSchema = {
   },
   additionalProperties: false
 };
-var inputSchema12 = {
+var inputSchema10 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
-var outputSchema12 = {
+var outputSchema10 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
 
-class DebugLogTask extends Task11 {
+class DebugLogTask extends Task10 {
   static type = "DebugLogTask";
   static category = "Utility";
   static title = "Debug Log";
@@ -1484,10 +700,10 @@ class DebugLogTask extends Task11 {
     return debugLogTaskConfigSchema;
   }
   static inputSchema() {
-    return inputSchema12;
+    return inputSchema10;
   }
   static outputSchema() {
-    return outputSchema12;
+    return outputSchema10;
   }
   async executeReactive(input, output) {
     const log_level = this.config.log_level ?? DEFAULT_LOG_LEVEL;
@@ -1505,14 +721,14 @@ var debugLog = (input, config = {}) => {
   const task = new DebugLogTask({}, config);
   return task.run(input);
 };
-Workflow14.prototype.debugLog = CreateWorkflow13(DebugLogTask);
+Workflow11.prototype.debugLog = CreateWorkflow10(DebugLogTask);
 // src/task/DelayTask.ts
 import {
-  CreateWorkflow as CreateWorkflow14,
-  Task as Task12,
-  TaskAbortedError as TaskAbortedError3,
+  CreateWorkflow as CreateWorkflow11,
+  Task as Task11,
+  TaskAbortedError,
   TaskConfigSchema as TaskConfigSchema2,
-  Workflow as Workflow15
+  Workflow as Workflow12
 } from "@workglow/task-graph";
 import { sleep } from "@workglow/util";
 var delayTaskConfigSchema = {
@@ -1527,18 +743,18 @@ var delayTaskConfigSchema = {
   },
   additionalProperties: false
 };
-var inputSchema13 = {
+var inputSchema11 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
-var outputSchema13 = {
+var outputSchema11 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
 
-class DelayTask extends Task12 {
+class DelayTask extends Task11 {
   static type = "DelayTask";
   static category = "Utility";
   static title = "Delay";
@@ -1550,10 +766,10 @@ class DelayTask extends Task12 {
     return delayTaskConfigSchema;
   }
   static inputSchema() {
-    return inputSchema13;
+    return inputSchema11;
   }
   static outputSchema() {
-    return outputSchema13;
+    return outputSchema11;
   }
   async execute(input, executeContext) {
     const delay = this.config.delay ?? 1;
@@ -1562,7 +778,7 @@ class DelayTask extends Task12 {
       const chunkSize = delay / iterations;
       for (let i = 0;i < iterations; i++) {
         if (executeContext.signal.aborted) {
-          throw new TaskAbortedError3("Task aborted");
+          throw new TaskAbortedError("Task aborted");
         }
         await sleep(chunkSize);
         await executeContext.updateProgress(100 * i / iterations, `Delaying for ${delay}ms`);
@@ -1577,53 +793,364 @@ var delay = (input, config = { delay: 1 }) => {
   const task = new DelayTask({}, config);
   return task.run(input);
 };
-Workflow15.prototype.delay = CreateWorkflow14(DelayTask);
-// src/task/InputTask.ts
-import { CreateWorkflow as CreateWorkflow15, Task as Task13, Workflow as Workflow16 } from "@workglow/task-graph";
-
-class InputTask extends Task13 {
-  static type = "InputTask";
-  static category = "Flow Control";
-  static title = "Input";
-  static description = "Starts the workflow";
-  static hasDynamicSchemas = true;
-  static cacheable = false;
-  static inputSchema() {
-    return {
+Workflow12.prototype.delay = CreateWorkflow11(DelayTask);
+// src/task/FetchUrlTask.ts
+import {
+  AbortSignalJobError,
+  Job,
+  PermanentJobError,
+  RetryableJobError
+} from "@workglow/job-queue";
+import {
+  CreateWorkflow as CreateWorkflow12,
+  JobQueueTask,
+  TaskConfigurationError,
+  TaskInvalidInputError,
+  Workflow as Workflow13
+} from "@workglow/task-graph";
+var inputSchema12 = {
+  type: "object",
+  properties: {
+    url: {
+      type: "string",
+      title: "URL",
+      description: "The URL to fetch from",
+      format: "uri"
+    },
+    method: {
+      enum: ["GET", "POST", "PUT", "DELETE", "PATCH"],
+      title: "Method",
+      description: "The HTTP method to use",
+      default: "GET"
+    },
+    headers: {
       type: "object",
-      properties: {},
-      additionalProperties: true
-    };
-  }
-  static outputSchema() {
-    return {
+      additionalProperties: {
+        type: "string"
+      },
+      title: "Headers",
+      description: "The headers to send with the request"
+    },
+    body: {
+      type: "string",
+      title: "Body",
+      description: "The body of the request"
+    },
+    response_type: {
+      anyOf: [{ type: "null" }, { enum: ["json", "text", "blob", "arraybuffer"] }],
+      title: "Response Type",
+      description: "The forced type of response to return. If null, the response type is inferred from the Content-Type header.",
+      default: null
+    },
+    timeout: {
+      type: "number",
+      title: "Timeout",
+      description: "Request timeout in milliseconds"
+    },
+    queue: {
+      oneOf: [{ type: "boolean" }, { type: "string" }],
+      description: "Queue handling: false=run inline, true=use default, string=explicit queue name",
+      default: true,
+      "x-ui-hidden": true
+    }
+  },
+  required: ["url"],
+  additionalProperties: false
+};
+var outputSchema12 = {
+  type: "object",
+  properties: {
+    json: {
+      title: "JSON",
+      description: "The JSON response"
+    },
+    text: {
+      type: "string",
+      title: "Text",
+      description: "The text response"
+    },
+    blob: {
+      title: "Blob",
+      description: "The blob response"
+    },
+    arraybuffer: {
+      title: "ArrayBuffer",
+      description: "The arraybuffer response"
+    },
+    metadata: {
       type: "object",
-      properties: {},
-      additionalProperties: true
-    };
-  }
-  inputSchema() {
-    return this.config?.inputSchema ?? this.constructor.inputSchema();
-  }
-  outputSchema() {
-    return this.config?.outputSchema ?? this.constructor.outputSchema();
-  }
-  async execute(input) {
-    return input;
+      properties: {
+        contentType: { type: "string" },
+        headers: { type: "object", additionalProperties: { type: "string" } }
+      },
+      additionalProperties: false,
+      title: "Response Metadata",
+      description: "HTTP response metadata including content type and headers"
+    }
+  },
+  additionalProperties: false
+};
+async function fetchWithProgress(url, options = {}, onProgress) {
+  if (!options.signal) {
+    throw new TaskConfigurationError("An AbortSignal must be provided.");
   }
-  async executeReactive(input) {
-    return input;
+  const response = await globalThis.fetch(url, options);
+  if (!response.body) {
+    throw new Error("ReadableStream not supported in this environment.");
   }
-  async* executeStream(input, context) {
-    if (context.inputStreams) {
-      for (const [, stream] of context.inputStreams) {
-        const reader = stream.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-              break;
-            if (value.type === "finish")
+  const contentLength = response.headers.get("Content-Length");
+  const totalBytes = contentLength ? parseInt(contentLength, 10) : 0;
+  let receivedBytes = 0;
+  const reader = response.body.getReader();
+  const stream = new ReadableStream({
+    start(controller) {
+      async function push() {
+        try {
+          while (true) {
+            if (options.signal?.aborted) {
+              controller.error(new AbortSignalJobError("Fetch aborted"));
+              reader.cancel();
+              return;
+            }
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+              break;
+            }
+            controller.enqueue(value);
+            receivedBytes += value.length;
+            if (onProgress && totalBytes) {
+              await onProgress(receivedBytes / totalBytes * 100);
+            }
+          }
+        } catch (error) {
+          controller.error(error);
+        }
+      }
+      push();
+    },
+    cancel() {
+      reader.cancel();
+    }
+  });
+  return new Response(stream, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+
+class FetchUrlJob extends Job {
+  constructor(config = { input: {} }) {
+    super(config);
+  }
+  static type = "FetchUrlJob";
+  async execute(input, context) {
+    const response = await fetchWithProgress(input.url, {
+      method: input.method,
+      headers: input.headers,
+      body: input.body,
+      signal: context.signal
+    }, async (progress) => await context.updateProgress(progress));
+    if (response.ok) {
+      const contentType = response.headers.get("content-type") ?? "";
+      const headers = {};
+      response.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      const metadata = {
+        contentType,
+        headers
+      };
+      let responseType = input.response_type;
+      if (!responseType) {
+        if (contentType.includes("application/json")) {
+          responseType = "json";
+        } else if (contentType.includes("text/")) {
+          responseType = "text";
+        } else if (contentType.includes("application/octet-stream")) {
+          responseType = "arraybuffer";
+        } else if (contentType.includes("application/pdf") || contentType.includes("image/") || contentType.includes("application/zip")) {
+          responseType = "blob";
+        } else {
+          responseType = "json";
+        }
+        input.response_type = responseType;
+      }
+      if (responseType === "json") {
+        return { json: await response.json(), metadata };
+      } else if (responseType === "text") {
+        return { text: await response.text(), metadata };
+      } else if (responseType === "blob") {
+        return { blob: await response.blob(), metadata };
+      } else if (responseType === "arraybuffer") {
+        return { arraybuffer: await response.arrayBuffer(), metadata };
+      }
+      throw new TaskInvalidInputError(`Invalid response type: ${responseType}`);
+    } else {
+      if (response.status === 429 || response.status === 503 || response.headers.get("Retry-After")) {
+        let retryDate;
+        const retryAfterStr = response.headers.get("Retry-After");
+        if (retryAfterStr) {
+          const parsedDate = new Date(retryAfterStr);
+          if (!isNaN(parsedDate.getTime()) && parsedDate > new Date) {
+            retryDate = parsedDate;
+          } else {
+            const retryAfterSeconds = parseInt(retryAfterStr) * 1000;
+            if (!isNaN(retryAfterSeconds)) {
+              retryDate = new Date(Date.now() + retryAfterSeconds);
+            }
+          }
+        }
+        throw new RetryableJobError(`Failed to fetch ${input.url}: ${response.status} ${response.statusText}`, retryDate);
+      } else {
+        throw new PermanentJobError(`Failed to fetch ${input.url}: ${response.status} ${response.statusText}`);
+      }
+    }
+  }
+}
+
+class FetchUrlTask extends JobQueueTask {
+  static type = "FetchUrlTask";
+  static category = "Input";
+  static title = "Fetch";
+  static description = "Fetches data from a URL with progress tracking and automatic retry handling";
+  static hasDynamicSchemas = true;
+  static inputSchema() {
+    return inputSchema12;
+  }
+  static outputSchema() {
+    return outputSchema12;
+  }
+  outputSchema() {
+    const responseType = this.runInputData?.response_type ?? this.defaults?.response_type ?? null;
+    if (responseType === null || responseType === undefined) {
+      return this.constructor.outputSchema();
+    }
+    const staticSchema = this.constructor.outputSchema();
+    if (typeof staticSchema === "boolean") {
+      return staticSchema;
+    }
+    if (!staticSchema.properties) {
+      return staticSchema;
+    }
+    const properties = {};
+    if (responseType === "json" && staticSchema.properties.json) {
+      properties.json = staticSchema.properties.json;
+    } else if (responseType === "text" && staticSchema.properties.text) {
+      properties.text = staticSchema.properties.text;
+    } else if (responseType === "blob" && staticSchema.properties.blob) {
+      properties.blob = staticSchema.properties.blob;
+    } else if (responseType === "arraybuffer" && staticSchema.properties.arraybuffer) {
+      properties.arraybuffer = staticSchema.properties.arraybuffer;
+    }
+    if (staticSchema.properties.metadata) {
+      properties.metadata = staticSchema.properties.metadata;
+    }
+    if (Object.keys(properties).length === 0) {
+      return staticSchema;
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: false
+    };
+  }
+  constructor(input = {}, config = {}) {
+    config.queue = input?.queue ?? config.queue;
+    if (config.queue === undefined) {
+      config.queue = false;
+    }
+    super(input, config);
+    this.jobClass = FetchUrlJob;
+  }
+  setInput(input) {
+    if (!("response_type" in input)) {
+      super.setInput(input);
+      return;
+    }
+    const getCurrentResponseType = () => {
+      return this.runInputData?.response_type ?? this.defaults?.response_type ?? null;
+    };
+    const previousResponseType = getCurrentResponseType();
+    super.setInput(input);
+    const newResponseType = getCurrentResponseType();
+    if (previousResponseType !== newResponseType) {
+      this.emitSchemaChange();
+    }
+  }
+  async getDefaultQueueName(input) {
+    if (!input.url) {
+      return `fetch:${this.type}`;
+    }
+    try {
+      const hostname = new URL(input.url).hostname.toLowerCase();
+      const parts = hostname.split(".").filter(Boolean);
+      if (parts.length === 0) {
+        return `fetch:${this.type}`;
+      }
+      const domain = parts.length <= 2 ? parts.join(".") : parts.slice(-2).join(".");
+      return `fetch:${domain}`;
+    } catch {
+      return `fetch:${this.type}`;
+    }
+  }
+}
+var fetchUrl = async (input, config = {}) => {
+  const result = await new FetchUrlTask({}, config).run(input);
+  return result;
+};
+Workflow13.prototype.fetch = CreateWorkflow12(FetchUrlTask);
+// src/task/InputTask.ts
+import {
+  CreateWorkflow as CreateWorkflow13,
+  Task as Task12,
+  Workflow as Workflow14
+} from "@workglow/task-graph";
+
+class InputTask extends Task12 {
+  static type = "InputTask";
+  static category = "Flow Control";
+  static title = "Input";
+  static description = "Starts the workflow";
+  static hasDynamicSchemas = true;
+  static cacheable = false;
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  inputSchema() {
+    return this.config?.inputSchema ?? this.constructor.inputSchema();
+  }
+  outputSchema() {
+    return this.config?.outputSchema ?? this.constructor.outputSchema();
+  }
+  async execute(input) {
+    return input;
+  }
+  async executeReactive(input) {
+    return input;
+  }
+  async* executeStream(input, context) {
+    if (context.inputStreams) {
+      for (const [, stream] of context.inputStreams) {
+        const reader = stream.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            if (value.type === "finish")
               continue;
             yield value;
           }
@@ -1635,9 +1162,9 @@ class InputTask extends Task13 {
     yield { type: "finish", data: input };
   }
 }
-Workflow16.prototype.input = CreateWorkflow15(InputTask);
+Workflow14.prototype.input = CreateWorkflow13(InputTask);
 // src/task/JavaScriptTask.ts
-import { CreateWorkflow as CreateWorkflow16, Task as Task14, TaskConfigSchema as TaskConfigSchema3, Workflow as Workflow17 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow14, Task as Task13, TaskConfigSchema as TaskConfigSchema3, Workflow as Workflow15 } from "@workglow/task-graph";
 
 // src/util/acorn.js
 var options;
@@ -6114,7 +5641,7 @@ var configSchema = {
   },
   additionalProperties: false
 };
-var inputSchema14 = {
+var inputSchema13 = {
   type: "object",
   properties: {
     javascript_code: {
@@ -6128,7 +5655,7 @@ var inputSchema14 = {
   required: ["javascript_code"],
   additionalProperties: true
 };
-var outputSchema14 = {
+var outputSchema13 = {
   type: "object",
   properties: {
     output: {
@@ -6140,7 +5667,7 @@ var outputSchema14 = {
   additionalProperties: false
 };
 
-class JavaScriptTask extends Task14 {
+class JavaScriptTask extends Task13 {
   static type = "JavaScriptTask";
   static category = "Utility";
   static title = "JavaScript Interpreter";
@@ -6150,10 +5677,10 @@ class JavaScriptTask extends Task14 {
     return configSchema;
   }
   static inputSchema() {
-    return inputSchema14;
+    return inputSchema13;
   }
   static outputSchema() {
-    return outputSchema14;
+    return outputSchema13;
   }
   constructor(input2 = {}, config = {}) {
     super(input2, config);
@@ -6169,7 +5696,7 @@ class JavaScriptTask extends Task14 {
         additionalProperties: true
       };
     }
-    return inputSchema14;
+    return inputSchema13;
   }
   async executeReactive(input2, output) {
     if (this.config.javascript_code || input2.javascript_code) {
@@ -6188,18 +5715,18 @@ class JavaScriptTask extends Task14 {
 var javaScript = (input2, config = {}) => {
   return new JavaScriptTask({}, config).run(input2);
 };
-Workflow17.prototype.javaScript = CreateWorkflow16(JavaScriptTask);
+Workflow15.prototype.javaScript = CreateWorkflow14(JavaScriptTask);
 // src/task/JsonTask.ts
 import {
   createGraphFromDependencyJSON,
   createGraphFromGraphJSON,
-  CreateWorkflow as CreateWorkflow17,
+  CreateWorkflow as CreateWorkflow15,
   Dataflow,
   GraphAsTask as GraphAsTask2,
   TaskConfigurationError as TaskConfigurationError2,
-  Workflow as Workflow18
+  Workflow as Workflow16
 } from "@workglow/task-graph";
-var inputSchema15 = {
+var inputSchema14 = {
   type: "object",
   properties: {
     json: {
@@ -6210,7 +5737,7 @@ var inputSchema15 = {
   },
   additionalProperties: false
 };
-var outputSchema15 = {
+var outputSchema14 = {
   type: "object",
   properties: {
     output: {
@@ -6227,10 +5754,10 @@ class JsonTask extends GraphAsTask2 {
   static title = "JSON Task";
   static description = "A task that creates and manages task graphs from JSON configurations";
   static inputSchema() {
-    return inputSchema15;
+    return inputSchema14;
   }
   static outputSchema() {
-    return outputSchema15;
+    return outputSchema14;
   }
   regenerateGraph() {
     if (!this.runInputData.json)
@@ -6253,7 +5780,7 @@ class JsonTask extends GraphAsTask2 {
           if (!sourceTask) {
             throw new TaskConfigurationError2(`Dependency id ${dep.id} not found`);
           }
-          const df = new Dataflow(sourceTask.config.id, dep.output, item.id, input2);
+          const df = new Dataflow(sourceTask.id, dep.output, item.id, input2);
           this.subGraph.addDataflow(df);
         }
       }
@@ -6264,15 +5791,15 @@ class JsonTask extends GraphAsTask2 {
 var json = (input2, config = {}) => {
   return new JsonTask({}, config).run(input2);
 };
-Workflow18.prototype.json = CreateWorkflow17(JsonTask);
+Workflow16.prototype.json = CreateWorkflow15(JsonTask);
 // src/task/LambdaTask.ts
 import {
-  CreateWorkflow as CreateWorkflow18,
+  CreateWorkflow as CreateWorkflow16,
   DATAFLOW_ALL_PORTS,
-  Task as Task15,
+  Task as Task14,
   TaskConfigSchema as TaskConfigSchema4,
   TaskConfigurationError as TaskConfigurationError3,
-  Workflow as Workflow19
+  Workflow as Workflow17
 } from "@workglow/task-graph";
 var lambdaTaskConfigSchema = {
   type: "object",
@@ -6283,7 +5810,7 @@ var lambdaTaskConfigSchema = {
   },
   additionalProperties: false
 };
-var inputSchema16 = {
+var inputSchema15 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -6293,7 +5820,7 @@ var inputSchema16 = {
   },
   additionalProperties: true
 };
-var outputSchema16 = {
+var outputSchema15 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -6304,7 +5831,7 @@ var outputSchema16 = {
   additionalProperties: true
 };
 
-class LambdaTask extends Task15 {
+class LambdaTask extends Task14 {
   static type = "LambdaTask";
   static title = "Lambda Task";
   static description = "A task that wraps a provided function and its input";
@@ -6314,10 +5841,10 @@ class LambdaTask extends Task15 {
     return lambdaTaskConfigSchema;
   }
   static inputSchema() {
-    return inputSchema16;
+    return inputSchema15;
   }
   static outputSchema() {
-    return outputSchema16;
+    return outputSchema15;
   }
   constructor(input2 = {}, config = {}) {
     if (!config.execute && !config.executeReactive) {
@@ -6355,15 +5882,15 @@ function lambda(input2, config) {
   const task = new LambdaTask(input2, config);
   return task.run();
 }
-Workflow19.prototype.lambda = CreateWorkflow18(LambdaTask);
+Workflow17.prototype.lambda = CreateWorkflow16(LambdaTask);
 // src/task/MergeTask.ts
-import { CreateWorkflow as CreateWorkflow19, Task as Task16, Workflow as Workflow20 } from "@workglow/task-graph";
-var inputSchema17 = {
+import { CreateWorkflow as CreateWorkflow17, Task as Task15, Workflow as Workflow18 } from "@workglow/task-graph";
+var inputSchema16 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
-var outputSchema17 = {
+var outputSchema16 = {
   type: "object",
   properties: {
     output: {
@@ -6375,17 +5902,17 @@ var outputSchema17 = {
   additionalProperties: false
 };
 
-class MergeTask extends Task16 {
+class MergeTask extends Task15 {
   static type = "MergeTask";
   static category = "Utility";
   static title = "Merge";
   static description = "Merges multiple inputs into a single array output";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema17;
+    return inputSchema16;
   }
   static outputSchema() {
-    return outputSchema17;
+    return outputSchema16;
   }
   async execute(input2, _context) {
     const keys = Object.keys(input2).sort();
@@ -6399,11 +5926,15 @@ var merge = (input2, config = {}) => {
   const task = new MergeTask({}, config);
   return task.run(input2);
 };
-Workflow20.prototype.merge = CreateWorkflow19(MergeTask);
+Workflow18.prototype.merge = CreateWorkflow17(MergeTask);
 // src/task/OutputTask.ts
-import { CreateWorkflow as CreateWorkflow20, Task as Task17, Workflow as Workflow21 } from "@workglow/task-graph";
+import {
+  CreateWorkflow as CreateWorkflow18,
+  Task as Task16,
+  Workflow as Workflow19
+} from "@workglow/task-graph";
 
-class OutputTask extends Task17 {
+class OutputTask extends Task16 {
   static type = "OutputTask";
   static category = "Flow Control";
   static title = "Output";
@@ -6457,10 +5988,10 @@ class OutputTask extends Task17 {
     yield { type: "finish", data: input2 };
   }
 }
-Workflow21.prototype.output = CreateWorkflow20(OutputTask);
+Workflow19.prototype.output = CreateWorkflow18(OutputTask);
 // src/task/SplitTask.ts
-import { CreateWorkflow as CreateWorkflow21, Task as Task18, Workflow as Workflow22 } from "@workglow/task-graph";
-var inputSchema18 = {
+import { CreateWorkflow as CreateWorkflow19, Task as Task17, Workflow as Workflow20 } from "@workglow/task-graph";
+var inputSchema17 = {
   type: "object",
   properties: {
     input: {
@@ -6470,13 +6001,13 @@ var inputSchema18 = {
   },
   additionalProperties: false
 };
-var outputSchema18 = {
+var outputSchema17 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
 
-class SplitTask extends Task18 {
+class SplitTask extends Task17 {
   static type = "SplitTask";
   static category = "Utility";
   static title = "Split";
@@ -6484,13 +6015,13 @@ class SplitTask extends Task18 {
   static hasDynamicSchemas = true;
   static cacheable = false;
   static inputSchema() {
-    return inputSchema18;
+    return inputSchema17;
   }
   static outputSchema() {
-    return outputSchema18;
+    return outputSchema17;
   }
   outputSchema() {
-    return outputSchema18;
+    return outputSchema17;
   }
   async executeReactive(input2) {
     const inputValue = input2.input;
@@ -6509,15 +6040,15 @@ var split = (input2, config = {}) => {
   const task = new SplitTask({}, config);
   return task.run(input2);
 };
-Workflow22.prototype.split = CreateWorkflow21(SplitTask);
+Workflow20.prototype.split = CreateWorkflow19(SplitTask);
 // src/task/mcp/McpListTask.ts
-import { CreateWorkflow as CreateWorkflow22, Task as Task19, Workflow as Workflow23 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow20, Task as Task18, Workflow as Workflow21 } from "@workglow/task-graph";
 import {
   mcpClientFactory,
   mcpServerConfigSchema
 } from "@workglow/util";
 var mcpListTypes = ["tools", "resources", "prompts"];
-var inputSchema19 = {
+var inputSchema18 = {
   type: "object",
   properties: {
     ...mcpServerConfigSchema,
@@ -6686,7 +6217,7 @@ var outputSchemaAll = {
   additionalProperties: false
 };
 
-class McpListTask extends Task19 {
+class McpListTask extends Task18 {
   static type = "McpListTask";
   static category = "MCP";
   static title = "MCP List";
@@ -6694,7 +6225,7 @@ class McpListTask extends Task19 {
   static cacheable = false;
   static hasDynamicSchemas = true;
   static inputSchema() {
-    return inputSchema19;
+    return inputSchema18;
   }
   static outputSchema() {
     return outputSchemaAll;
@@ -6754,13 +6285,13 @@ class McpListTask extends Task19 {
 var mcpList = async (input2, config = {}) => {
   return new McpListTask({}, config).run(input2);
 };
-Workflow23.prototype.mcpList = CreateWorkflow22(McpListTask);
+Workflow21.prototype.mcpList = CreateWorkflow20(McpListTask);
 // src/task/mcp/McpPromptGetTask.ts
 import {
-  CreateWorkflow as CreateWorkflow23,
-  Task as Task20,
+  CreateWorkflow as CreateWorkflow21,
+  Task as Task19,
   TaskConfigSchema as TaskConfigSchema5,
-  Workflow as Workflow24
+  Workflow as Workflow22
 } from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory2,
@@ -6917,7 +6448,7 @@ var fallbackInputSchema = {
   additionalProperties: false
 };
 
-class McpPromptGetTask extends Task20 {
+class McpPromptGetTask extends Task19 {
   static type = "McpPromptGetTask";
   static category = "MCP";
   static title = "MCP Get Prompt";
@@ -7001,13 +6532,13 @@ class McpPromptGetTask extends Task20 {
 var mcpPromptGet = async (input2, config) => {
   return new McpPromptGetTask({}, config).run(input2);
 };
-Workflow24.prototype.mcpPromptGet = CreateWorkflow23(McpPromptGetTask);
+Workflow22.prototype.mcpPromptGet = CreateWorkflow21(McpPromptGetTask);
 // src/task/mcp/McpResourceReadTask.ts
 import {
-  CreateWorkflow as CreateWorkflow24,
-  Task as Task21,
+  CreateWorkflow as CreateWorkflow22,
+  Task as Task20,
   TaskConfigSchema as TaskConfigSchema6,
-  Workflow as Workflow25
+  Workflow as Workflow23
 } from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory3,
@@ -7057,12 +6588,12 @@ var contentItemSchema = {
     }
   ]
 };
-var inputSchema20 = {
+var inputSchema19 = {
   type: "object",
   properties: {},
   additionalProperties: false
 };
-var outputSchema19 = {
+var outputSchema18 = {
   type: "object",
   properties: {
     contents: {
@@ -7076,7 +6607,7 @@ var outputSchema19 = {
   additionalProperties: false
 };
 
-class McpResourceReadTask extends Task21 {
+class McpResourceReadTask extends Task20 {
   static type = "McpResourceReadTask";
   static category = "MCP";
   static title = "MCP Read Resource";
@@ -7084,10 +6615,10 @@ class McpResourceReadTask extends Task21 {
   static cacheable = false;
   static customizable = true;
   static inputSchema() {
-    return inputSchema20;
+    return inputSchema19;
   }
   static outputSchema() {
-    return outputSchema19;
+    return outputSchema18;
   }
   static configSchema() {
     return configSchema3;
@@ -7105,13 +6636,13 @@ class McpResourceReadTask extends Task21 {
 var mcpResourceRead = async (config) => {
   return new McpResourceReadTask({}, config).run({});
 };
-Workflow25.prototype.mcpResourceRead = CreateWorkflow24(McpResourceReadTask);
+Workflow23.prototype.mcpResourceRead = CreateWorkflow22(McpResourceReadTask);
 // src/task/mcp/McpToolCallTask.ts
 import {
-  CreateWorkflow as CreateWorkflow25,
-  Task as Task22,
+  CreateWorkflow as CreateWorkflow23,
+  Task as Task21,
   TaskConfigSchema as TaskConfigSchema7,
-  Workflow as Workflow26
+  Workflow as Workflow24
 } from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory4,
@@ -7260,7 +6791,7 @@ var fallbackInputSchema2 = {
   additionalProperties: true
 };
 
-class McpToolCallTask extends Task22 {
+class McpToolCallTask extends Task21 {
   static type = "McpToolCallTask";
   static category = "MCP";
   static title = "MCP Call Tool";
@@ -7359,10 +6890,10 @@ class McpToolCallTask extends Task22 {
 var mcpToolCall = async (input2, config) => {
   return new McpToolCallTask({}, config).run(input2);
 };
-Workflow26.prototype.mcpToolCall = CreateWorkflow25(McpToolCallTask);
+Workflow24.prototype.mcpToolCall = CreateWorkflow23(McpToolCallTask);
 // src/task/scalar/ScalarAbsTask.ts
-import { CreateWorkflow as CreateWorkflow26, Task as Task23, Workflow as Workflow27 } from "@workglow/task-graph";
-var inputSchema21 = {
+import { CreateWorkflow as CreateWorkflow24, Task as Task22, Workflow as Workflow25 } from "@workglow/task-graph";
+var inputSchema20 = {
   type: "object",
   properties: {
     value: {
@@ -7374,7 +6905,7 @@ var inputSchema21 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema20 = {
+var outputSchema19 = {
   type: "object",
   properties: {
     result: {
@@ -7387,25 +6918,25 @@ var outputSchema20 = {
   additionalProperties: false
 };
 
-class ScalarAbsTask extends Task23 {
+class ScalarAbsTask extends Task22 {
   static type = "ScalarAbsTask";
   static category = "Math";
   static title = "Abs";
   static description = "Returns the absolute value of a number";
   static inputSchema() {
-    return inputSchema21;
+    return inputSchema20;
   }
   static outputSchema() {
-    return outputSchema20;
+    return outputSchema19;
   }
   async execute(input2, _context) {
     return { result: Math.abs(input2.value) };
   }
 }
-Workflow27.prototype.scalarAbs = CreateWorkflow26(ScalarAbsTask);
+Workflow25.prototype.scalarAbs = CreateWorkflow24(ScalarAbsTask);
 // src/task/scalar/ScalarCeilTask.ts
-import { CreateWorkflow as CreateWorkflow27, Task as Task24, Workflow as Workflow28 } from "@workglow/task-graph";
-var inputSchema22 = {
+import { CreateWorkflow as CreateWorkflow25, Task as Task23, Workflow as Workflow26 } from "@workglow/task-graph";
+var inputSchema21 = {
   type: "object",
   properties: {
     value: {
@@ -7417,7 +6948,7 @@ var inputSchema22 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema21 = {
+var outputSchema20 = {
   type: "object",
   properties: {
     result: {
@@ -7430,25 +6961,25 @@ var outputSchema21 = {
   additionalProperties: false
 };
 
-class ScalarCeilTask extends Task24 {
+class ScalarCeilTask extends Task23 {
   static type = "ScalarCeilTask";
   static category = "Math";
   static title = "Ceil";
   static description = "Returns the smallest integer greater than or equal to a number";
   static inputSchema() {
-    return inputSchema22;
+    return inputSchema21;
   }
   static outputSchema() {
-    return outputSchema21;
+    return outputSchema20;
   }
   async execute(input2, _context) {
     return { result: Math.ceil(input2.value) };
   }
 }
-Workflow28.prototype.scalarCeil = CreateWorkflow27(ScalarCeilTask);
+Workflow26.prototype.scalarCeil = CreateWorkflow25(ScalarCeilTask);
 // src/task/scalar/ScalarFloorTask.ts
-import { CreateWorkflow as CreateWorkflow28, Task as Task25, Workflow as Workflow29 } from "@workglow/task-graph";
-var inputSchema23 = {
+import { CreateWorkflow as CreateWorkflow26, Task as Task24, Workflow as Workflow27 } from "@workglow/task-graph";
+var inputSchema22 = {
   type: "object",
   properties: {
     value: {
@@ -7460,7 +6991,7 @@ var inputSchema23 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema22 = {
+var outputSchema21 = {
   type: "object",
   properties: {
     result: {
@@ -7473,25 +7004,25 @@ var outputSchema22 = {
   additionalProperties: false
 };
 
-class ScalarFloorTask extends Task25 {
+class ScalarFloorTask extends Task24 {
   static type = "ScalarFloorTask";
   static category = "Math";
   static title = "Floor";
   static description = "Returns the largest integer less than or equal to a number";
   static inputSchema() {
-    return inputSchema23;
+    return inputSchema22;
   }
   static outputSchema() {
-    return outputSchema22;
+    return outputSchema21;
   }
   async execute(input2, _context) {
     return { result: Math.floor(input2.value) };
   }
 }
-Workflow29.prototype.scalarFloor = CreateWorkflow28(ScalarFloorTask);
+Workflow27.prototype.scalarFloor = CreateWorkflow26(ScalarFloorTask);
 // src/task/scalar/ScalarMaxTask.ts
-import { CreateWorkflow as CreateWorkflow29, Task as Task26, Workflow as Workflow30 } from "@workglow/task-graph";
-var inputSchema24 = {
+import { CreateWorkflow as CreateWorkflow27, Task as Task25, Workflow as Workflow28 } from "@workglow/task-graph";
+var inputSchema23 = {
   type: "object",
   properties: {
     values: {
@@ -7504,7 +7035,7 @@ var inputSchema24 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema23 = {
+var outputSchema22 = {
   type: "object",
   properties: {
     result: {
@@ -7517,25 +7048,25 @@ var outputSchema23 = {
   additionalProperties: false
 };
 
-class ScalarMaxTask extends Task26 {
+class ScalarMaxTask extends Task25 {
   static type = "ScalarMaxTask";
   static category = "Math";
   static title = "Max";
   static description = "Returns the largest of the given numbers";
   static inputSchema() {
-    return inputSchema24;
+    return inputSchema23;
   }
   static outputSchema() {
-    return outputSchema23;
+    return outputSchema22;
   }
   async execute(input2, _context) {
     return { result: Math.max(...input2.values) };
   }
 }
-Workflow30.prototype.scalarMax = CreateWorkflow29(ScalarMaxTask);
+Workflow28.prototype.scalarMax = CreateWorkflow27(ScalarMaxTask);
 // src/task/scalar/ScalarMinTask.ts
-import { CreateWorkflow as CreateWorkflow30, Task as Task27, Workflow as Workflow31 } from "@workglow/task-graph";
-var inputSchema25 = {
+import { CreateWorkflow as CreateWorkflow28, Task as Task26, Workflow as Workflow29 } from "@workglow/task-graph";
+var inputSchema24 = {
   type: "object",
   properties: {
     values: {
@@ -7548,7 +7079,7 @@ var inputSchema25 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema24 = {
+var outputSchema23 = {
   type: "object",
   properties: {
     result: {
@@ -7561,25 +7092,25 @@ var outputSchema24 = {
   additionalProperties: false
 };
 
-class ScalarMinTask extends Task27 {
+class ScalarMinTask extends Task26 {
   static type = "ScalarMinTask";
   static category = "Math";
   static title = "Min";
   static description = "Returns the smallest of the given numbers";
   static inputSchema() {
-    return inputSchema25;
+    return inputSchema24;
   }
   static outputSchema() {
-    return outputSchema24;
+    return outputSchema23;
   }
   async execute(input2, _context) {
     return { result: Math.min(...input2.values) };
   }
 }
-Workflow31.prototype.scalarMin = CreateWorkflow30(ScalarMinTask);
+Workflow29.prototype.scalarMin = CreateWorkflow28(ScalarMinTask);
 // src/task/scalar/ScalarRoundTask.ts
-import { CreateWorkflow as CreateWorkflow31, Task as Task28, Workflow as Workflow32 } from "@workglow/task-graph";
-var inputSchema26 = {
+import { CreateWorkflow as CreateWorkflow29, Task as Task27, Workflow as Workflow30 } from "@workglow/task-graph";
+var inputSchema25 = {
   type: "object",
   properties: {
     value: {
@@ -7591,7 +7122,7 @@ var inputSchema26 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema25 = {
+var outputSchema24 = {
   type: "object",
   properties: {
     result: {
@@ -7604,25 +7135,25 @@ var outputSchema25 = {
   additionalProperties: false
 };
 
-class ScalarRoundTask extends Task28 {
+class ScalarRoundTask extends Task27 {
   static type = "ScalarRoundTask";
   static category = "Math";
   static title = "Round";
   static description = "Returns the value of a number rounded to the nearest integer";
   static inputSchema() {
-    return inputSchema26;
+    return inputSchema25;
   }
   static outputSchema() {
-    return outputSchema25;
+    return outputSchema24;
   }
   async execute(input2, _context) {
     return { result: Math.round(input2.value) };
   }
 }
-Workflow32.prototype.scalarRound = CreateWorkflow31(ScalarRoundTask);
+Workflow30.prototype.scalarRound = CreateWorkflow29(ScalarRoundTask);
 // src/task/scalar/ScalarTruncTask.ts
-import { CreateWorkflow as CreateWorkflow32, Task as Task29, Workflow as Workflow33 } from "@workglow/task-graph";
-var inputSchema27 = {
+import { CreateWorkflow as CreateWorkflow30, Task as Task28, Workflow as Workflow31 } from "@workglow/task-graph";
+var inputSchema26 = {
   type: "object",
   properties: {
     value: {
@@ -7634,7 +7165,7 @@ var inputSchema27 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema26 = {
+var outputSchema25 = {
   type: "object",
   properties: {
     result: {
@@ -7647,28 +7178,28 @@ var outputSchema26 = {
   additionalProperties: false
 };
 
-class ScalarTruncTask extends Task29 {
+class ScalarTruncTask extends Task28 {
   static type = "ScalarTruncTask";
   static category = "Math";
   static title = "Truncate";
   static description = "Returns the integer part of a number by removing fractional digits";
   static inputSchema() {
-    return inputSchema27;
+    return inputSchema26;
   }
   static outputSchema() {
-    return outputSchema26;
+    return outputSchema25;
   }
   async execute(input2, _context) {
     return { result: Math.trunc(input2.value) };
   }
 }
-Workflow33.prototype.scalarTrunc = CreateWorkflow32(ScalarTruncTask);
+Workflow31.prototype.scalarTrunc = CreateWorkflow30(ScalarTruncTask);
 // src/task/vector/VectorDistanceTask.ts
-import { CreateWorkflow as CreateWorkflow33, Task as Task30, Workflow as Workflow34 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow31, Task as Task29, Workflow as Workflow32 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema5
 } from "@workglow/util";
-var inputSchema28 = {
+var inputSchema27 = {
   type: "object",
   properties: {
     vectors: {
@@ -7684,7 +7215,7 @@ var inputSchema28 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema27 = {
+var outputSchema26 = {
   type: "object",
   properties: {
     result: {
@@ -7697,16 +7228,16 @@ var outputSchema27 = {
   additionalProperties: false
 };
 
-class VectorDistanceTask extends Task30 {
+class VectorDistanceTask extends Task29 {
   static type = "VectorDistanceTask";
   static category = "Vector";
   static title = "Distance";
   static description = "Returns the Euclidean distance between the first two vectors";
   static inputSchema() {
-    return inputSchema28;
+    return inputSchema27;
   }
   static outputSchema() {
-    return outputSchema27;
+    return outputSchema26;
   }
   async execute(input2, _context) {
     const { vectors } = input2;
@@ -7724,13 +7255,13 @@ class VectorDistanceTask extends Task30 {
     return { result: Math.sqrt(sumPrecise(diffs)) };
   }
 }
-Workflow34.prototype.vectorDistance = CreateWorkflow33(VectorDistanceTask);
+Workflow32.prototype.vectorDistance = CreateWorkflow31(VectorDistanceTask);
 // src/task/vector/VectorDotProductTask.ts
-import { CreateWorkflow as CreateWorkflow34, Task as Task31, Workflow as Workflow35 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow32, Task as Task30, Workflow as Workflow33 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema6
 } from "@workglow/util";
-var inputSchema29 = {
+var inputSchema28 = {
   type: "object",
   properties: {
     vectors: {
@@ -7746,7 +7277,7 @@ var inputSchema29 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema28 = {
+var outputSchema27 = {
   type: "object",
   properties: {
     result: {
@@ -7759,16 +7290,16 @@ var outputSchema28 = {
   additionalProperties: false
 };
 
-class VectorDotProductTask extends Task31 {
+class VectorDotProductTask extends Task30 {
   static type = "VectorDotProductTask";
   static category = "Vector";
   static title = "Dot Product";
   static description = "Returns the dot (inner) product of the first two vectors";
   static inputSchema() {
-    return inputSchema29;
+    return inputSchema28;
   }
   static outputSchema() {
-    return outputSchema28;
+    return outputSchema27;
   }
   async execute(input2, _context) {
     const { vectors } = input2;
@@ -7783,14 +7314,14 @@ class VectorDotProductTask extends Task31 {
     return { result: sumPrecise(products) };
   }
 }
-Workflow35.prototype.vectorDotProduct = CreateWorkflow34(VectorDotProductTask);
+Workflow33.prototype.vectorDotProduct = CreateWorkflow32(VectorDotProductTask);
 // src/task/vector/VectorNormalizeTask.ts
-import { CreateWorkflow as CreateWorkflow35, Task as Task32, Workflow as Workflow36 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow33, Task as Task31, Workflow as Workflow34 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema7,
   normalize
 } from "@workglow/util";
-var inputSchema30 = {
+var inputSchema29 = {
   type: "object",
   properties: {
     vector: TypedArraySchema7({
@@ -7801,7 +7332,7 @@ var inputSchema30 = {
   required: ["vector"],
   additionalProperties: false
 };
-var outputSchema29 = {
+var outputSchema28 = {
   type: "object",
   properties: {
     result: TypedArraySchema7({
@@ -7813,29 +7344,29 @@ var outputSchema29 = {
   additionalProperties: false
 };
 
-class VectorNormalizeTask extends Task32 {
+class VectorNormalizeTask extends Task31 {
   static type = "VectorNormalizeTask";
   static category = "Vector";
   static title = "Normalize";
   static description = "Returns the L2-normalized (unit length) vector";
   static inputSchema() {
-    return inputSchema30;
+    return inputSchema29;
   }
   static outputSchema() {
-    return outputSchema29;
+    return outputSchema28;
   }
   async execute(input2, _context) {
     return { result: normalize(input2.vector) };
   }
 }
-Workflow36.prototype.vectorNormalize = CreateWorkflow35(VectorNormalizeTask);
+Workflow34.prototype.vectorNormalize = CreateWorkflow33(VectorNormalizeTask);
 // src/task/vector/VectorScaleTask.ts
-import { CreateWorkflow as CreateWorkflow36, Task as Task33, Workflow as Workflow37 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow34, Task as Task32, Workflow as Workflow35 } from "@workglow/task-graph";
 import {
   createTypedArrayFrom as createTypedArrayFrom5,
   TypedArraySchema as TypedArraySchema8
 } from "@workglow/util";
-var inputSchema31 = {
+var inputSchema30 = {
   type: "object",
   properties: {
     vector: TypedArraySchema8({
@@ -7851,7 +7382,7 @@ var inputSchema31 = {
   required: ["vector", "scalar"],
   additionalProperties: false
 };
-var outputSchema30 = {
+var outputSchema29 = {
   type: "object",
   properties: {
     result: TypedArraySchema8({
@@ -7863,16 +7394,16 @@ var outputSchema30 = {
   additionalProperties: false
 };
 
-class VectorScaleTask extends Task33 {
+class VectorScaleTask extends Task32 {
   static type = "VectorScaleTask";
   static category = "Vector";
   static title = "Scale";
   static description = "Multiplies each element of a vector by a scalar";
   static inputSchema() {
-    return inputSchema31;
+    return inputSchema30;
   }
   static outputSchema() {
-    return outputSchema30;
+    return outputSchema29;
   }
   async execute(input2, _context) {
     const { vector, scalar } = input2;
@@ -7880,7 +7411,7 @@ class VectorScaleTask extends Task33 {
     return { result: createTypedArrayFrom5([vector], values) };
   }
 }
-Workflow37.prototype.vectorScale = CreateWorkflow36(VectorScaleTask);
+Workflow35.prototype.vectorScale = CreateWorkflow34(VectorScaleTask);
 
 // src/common.ts
 import { TaskRegistry } from "@workglow/task-graph";
@@ -7925,11 +7456,656 @@ var registerCommonTasks = () => {
   return tasks;
 };
 
-// src/node.ts
-[FileLoaderTask2].map(TaskRegistry2.registerTask);
+// src/task/FileLoaderTask.server.ts
+import {
+  CreateWorkflow as CreateWorkflow36,
+  TaskAbortedError as TaskAbortedError3,
+  Workflow as Workflow37
+} from "@workglow/task-graph";
+import { readFile } from "node:fs/promises";
+
+// src/task/FileLoaderTask.ts
+import {
+  CreateWorkflow as CreateWorkflow35,
+  Task as Task33,
+  TaskAbortedError as TaskAbortedError2,
+  Workflow as Workflow36
+} from "@workglow/task-graph";
+import Papa from "papaparse";
+var inputSchema31 = {
+  type: "object",
+  properties: {
+    url: {
+      type: "string",
+      title: "URL",
+      description: "URL to load document from (http://, https://)",
+      format: "uri"
+    },
+    format: {
+      type: "string",
+      enum: ["text", "markdown", "json", "csv", "pdf", "image", "html", "auto"],
+      title: "Format",
+      description: "File format (auto-detected from URL if 'auto')",
+      default: "auto"
+    }
+  },
+  required: ["url"],
+  additionalProperties: false
+};
+var outputSchema30 = {
+  type: "object",
+  properties: {
+    text: {
+      type: "string",
+      title: "Text",
+      description: "Text content (for text, markdown, html formats)"
+    },
+    json: {
+      title: "JSON",
+      description: "Parsed JSON object or array"
+    },
+    csv: {
+      type: "array",
+      title: "CSV",
+      description: "Parsed CSV data as array of objects"
+    },
+    image: {
+      type: "string",
+      title: "Image",
+      description: "Base64 data URL for image files",
+      format: "image:data-uri"
+    },
+    pdf: {
+      type: "string",
+      title: "PDF",
+      description: "Base64 data URL for PDF files"
+    },
+    frontmatter: {
+      type: "object",
+      title: "Frontmatter",
+      description: "Parsed YAML frontmatter from markdown/MDX files"
+    },
+    metadata: {
+      type: "object",
+      properties: {
+        url: { type: "string" },
+        format: { type: "string" },
+        size: { type: "number" },
+        title: { type: "string" },
+        mimeType: { type: "string" }
+      },
+      additionalProperties: false,
+      title: "Metadata",
+      description: "File metadata"
+    }
+  },
+  required: ["metadata"],
+  additionalProperties: false
+};
+
+class FileLoaderTask extends Task33 {
+  static type = "FileLoaderTask";
+  static category = "Document";
+  static title = "File Loader";
+  static description = "Load documents from URLs (http://, https://)";
+  static cacheable = true;
+  static inputSchema() {
+    return inputSchema31;
+  }
+  static outputSchema() {
+    return outputSchema30;
+  }
+  async execute(input2, context) {
+    const { url, format = "auto" } = input2;
+    if (context.signal.aborted) {
+      throw new TaskAbortedError2("Task aborted");
+    }
+    await context.updateProgress(0, "Detecting file format");
+    const detectedFormat = this.detectFormat(url, format);
+    const responseType = this.detectResponseType(detectedFormat);
+    if (context.signal.aborted) {
+      throw new TaskAbortedError2("Task aborted");
+    }
+    await context.updateProgress(10, `Fetching ${detectedFormat} file from ${url}`);
+    const fetchTask = context.own(new FetchUrlTask({
+      url,
+      response_type: responseType,
+      queue: false
+    }));
+    const response = await fetchTask.run();
+    if (context.signal.aborted) {
+      throw new TaskAbortedError2("Task aborted");
+    }
+    await context.updateProgress(60, "Parsing file content");
+    const title = url.split("/").pop() || url;
+    const { text, json: json2, csv, image, pdf, frontmatter, size, mimeType } = await this.parseResponse(response, url, detectedFormat);
+    if (context.signal.aborted) {
+      throw new TaskAbortedError2("Task aborted");
+    }
+    await context.updateProgress(100, "File loaded successfully");
+    return {
+      text,
+      json: json2,
+      csv,
+      image,
+      pdf,
+      frontmatter,
+      metadata: {
+        url,
+        format: detectedFormat,
+        size,
+        title,
+        mimeType
+      }
+    };
+  }
+  parseJsonContent(content) {
+    return JSON.parse(content);
+  }
+  parseCsvContent(content) {
+    try {
+      const result = Papa.parse(content, {
+        header: true,
+        skipEmptyLines: true,
+        transformHeader: (header) => header.trim()
+      });
+      return result.data;
+    } catch (error) {
+      throw new Error(`Failed to parse CSV: ${error}`);
+    }
+  }
+  parseFrontmatter(content) {
+    const trimmed = content.replace(/^\uFEFF/, "");
+    if (!trimmed.startsWith(`---
+`) && !trimmed.startsWith(`---\r
+`)) {
+      return { frontmatter: undefined, body: content };
+    }
+    const firstDelimEnd = trimmed.indexOf(`
+`) + 1;
+    const closingIdx = trimmed.indexOf(`
+---`, firstDelimEnd);
+    if (closingIdx === -1) {
+      return { frontmatter: undefined, body: content };
+    }
+    const yamlBlock = trimmed.slice(firstDelimEnd, closingIdx);
+    const afterClosing = closingIdx + 4;
+    let bodyStart = afterClosing;
+    if (trimmed[bodyStart] === "\r")
+      bodyStart++;
+    if (trimmed[bodyStart] === `
+`)
+      bodyStart++;
+    const body = trimmed.slice(bodyStart).replace(/^\r?\n/, "");
+    const frontmatter = this.parseSimpleYaml(yamlBlock);
+    return { frontmatter, body };
+  }
+  parseSimpleYaml(yaml) {
+    const result = {};
+    const lines = yaml.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length) {
+      i = this.parseYamlLine(lines, i, result, 0);
+    }
+    return result;
+  }
+  parseYamlLine(lines, index, target, indent) {
+    if (index >= lines.length)
+      return index + 1;
+    const line = lines[index];
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      return index + 1;
+    }
+    const lineIndent = line.length - line.trimStart().length;
+    if (lineIndent < indent)
+      return index;
+    const match = line.match(/^(\s*)([^:#]+?)\s*:\s*(.*)?$/);
+    if (!match)
+      return index + 1;
+    const key = match[2].trim();
+    const rawValue = (match[3] ?? "").trim();
+    if (rawValue === "" || rawValue === "|" || rawValue === ">") {
+      const nextIndex = index + 1;
+      if (nextIndex < lines.length) {
+        const nextLine = lines[nextIndex];
+        const nextTrimmed = nextLine.trimStart();
+        const nextIndent = nextLine.length - nextTrimmed.length;
+        if (nextIndent > lineIndent && nextTrimmed.startsWith("- ")) {
+          const arr = [];
+          let j = nextIndex;
+          while (j < lines.length) {
+            const arrLine = lines[j];
+            const arrTrimmed = arrLine.trimStart();
+            const arrIndent = arrLine.length - arrTrimmed.length;
+            if (arrTrimmed === "" || arrTrimmed.startsWith("#")) {
+              j++;
+              continue;
+            }
+            if (arrIndent < nextIndent)
+              break;
+            if (arrTrimmed.startsWith("- ")) {
+              arr.push(this.parseYamlValue(arrTrimmed.slice(2).trim()));
+              j++;
+            } else {
+              break;
+            }
+          }
+          target[key] = arr;
+          return j;
+        } else if (nextIndent > lineIndent) {
+          const nested = {};
+          let j = nextIndex;
+          while (j < lines.length) {
+            const nestedLine = lines[j];
+            const nestedTrimmed = nestedLine.trimStart();
+            const nestedIndent = nestedLine.length - nestedTrimmed.length;
+            if (nestedTrimmed === "" || nestedTrimmed.startsWith("#")) {
+              j++;
+              continue;
+            }
+            if (nestedIndent < nextIndent)
+              break;
+            j = this.parseYamlLine(lines, j, nested, nextIndent);
+          }
+          target[key] = nested;
+          return j;
+        }
+      }
+      target[key] = rawValue === "" ? null : rawValue;
+      return index + 1;
+    }
+    target[key] = this.parseYamlValue(rawValue);
+    return index + 1;
+  }
+  parseYamlValue(raw) {
+    if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+      return raw.slice(1, -1);
+    }
+    if (raw === "true" || raw === "True" || raw === "TRUE")
+      return true;
+    if (raw === "false" || raw === "False" || raw === "FALSE")
+      return false;
+    if (raw === "null" || raw === "~")
+      return null;
+    if (/^-?\d+(\.\d+)?$/.test(raw))
+      return Number(raw);
+    if (raw.startsWith("[") && raw.endsWith("]")) {
+      return raw.slice(1, -1).split(",").map((item) => this.parseYamlValue(item.trim()));
+    }
+    return raw;
+  }
+  async parseResponse(response, url, detectedFormat) {
+    const responseMimeType = response.metadata?.contentType || "";
+    if (detectedFormat === "json") {
+      if (!response.json) {
+        throw new Error(`Failed to load JSON from ${url}`);
+      }
+      const jsonData = response.json;
+      const content2 = JSON.stringify(jsonData, null, 2);
+      return {
+        text: undefined,
+        json: jsonData,
+        csv: undefined,
+        image: undefined,
+        pdf: undefined,
+        frontmatter: undefined,
+        size: content2.length,
+        mimeType: responseMimeType || "application/json"
+      };
+    }
+    if (detectedFormat === "csv") {
+      const content2 = response.text || "";
+      if (!content2) {
+        throw new Error(`Failed to load CSV from ${url}`);
+      }
+      const csvData = this.parseCsvContent(content2);
+      return {
+        text: undefined,
+        json: undefined,
+        csv: csvData,
+        image: undefined,
+        pdf: undefined,
+        frontmatter: undefined,
+        size: content2.length,
+        mimeType: responseMimeType || "text/csv"
+      };
+    }
+    if (detectedFormat === "image") {
+      if (!response.blob) {
+        throw new Error(`Failed to load image from ${url}`);
+      }
+      const blob = response.blob;
+      const mimeType2 = responseMimeType || (blob.type && blob.type !== "" ? blob.type : this.getImageMimeType(url));
+      const imageData = await this.blobToBase64DataURL(blob, mimeType2);
+      return {
+        text: undefined,
+        json: undefined,
+        csv: undefined,
+        image: imageData,
+        pdf: undefined,
+        frontmatter: undefined,
+        size: blob.size,
+        mimeType: mimeType2
+      };
+    }
+    if (detectedFormat === "pdf") {
+      if (!response.blob) {
+        throw new Error(`Failed to load PDF from ${url}`);
+      }
+      const blob = response.blob;
+      const mimeType2 = responseMimeType || "application/pdf";
+      const pdfData = await this.blobToBase64DataURL(blob, mimeType2);
+      return {
+        text: undefined,
+        json: undefined,
+        csv: undefined,
+        image: undefined,
+        pdf: pdfData,
+        frontmatter: undefined,
+        size: blob.size,
+        mimeType: mimeType2
+      };
+    }
+    const content = response.text || "";
+    if (!content) {
+      throw new Error(`Failed to load content from ${url}`);
+    }
+    const mimeType = responseMimeType || (detectedFormat === "markdown" ? "text/markdown" : detectedFormat === "html" ? "text/html" : "text/plain");
+    if (detectedFormat === "markdown") {
+      const { frontmatter, body } = this.parseFrontmatter(content);
+      return {
+        text: body,
+        json: undefined,
+        csv: undefined,
+        image: undefined,
+        pdf: undefined,
+        frontmatter,
+        size: content.length,
+        mimeType
+      };
+    }
+    return {
+      text: content,
+      json: undefined,
+      csv: undefined,
+      image: undefined,
+      pdf: undefined,
+      frontmatter: undefined,
+      size: content.length,
+      mimeType
+    };
+  }
+  detectResponseType(detectedFormat) {
+    let responseType = "text";
+    if (detectedFormat === "json") {
+      responseType = "json";
+    } else if (detectedFormat === "image" || detectedFormat === "pdf") {
+      responseType = "blob";
+    } else if (detectedFormat === "csv" || detectedFormat === "text" || detectedFormat === "markdown" || detectedFormat === "html") {
+      responseType = "text";
+    }
+    return responseType;
+  }
+  detectFormat(url, format) {
+    if (format === "auto") {
+      const urlLower = url.toLowerCase();
+      if (urlLower.endsWith(".md") || urlLower.endsWith(".mdx") || urlLower.endsWith(".markdown")) {
+        return "markdown";
+      } else if (urlLower.endsWith(".json")) {
+        return "json";
+      } else if (urlLower.endsWith(".csv")) {
+        return "csv";
+      } else if (urlLower.endsWith(".pdf")) {
+        return "pdf";
+      } else if (urlLower.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg|ico)$/)) {
+        return "image";
+      } else if (urlLower.endsWith(".html") || urlLower.endsWith(".htm")) {
+        return "html";
+      } else {
+        return "text";
+      }
+    }
+    return format;
+  }
+  getImageMimeType(url) {
+    const urlLower = url.toLowerCase();
+    if (urlLower.endsWith(".png"))
+      return "image/png";
+    if (urlLower.endsWith(".jpg") || urlLower.endsWith(".jpeg"))
+      return "image/jpeg";
+    if (urlLower.endsWith(".gif"))
+      return "image/gif";
+    if (urlLower.endsWith(".webp"))
+      return "image/webp";
+    if (urlLower.endsWith(".bmp"))
+      return "image/bmp";
+    if (urlLower.endsWith(".svg"))
+      return "image/svg+xml";
+    if (urlLower.endsWith(".ico"))
+      return "image/x-icon";
+    return "image/jpeg";
+  }
+  async blobToBase64DataURL(blob, mimeType) {
+    if (typeof Buffer !== "undefined") {
+      const arrayBuffer = await blob.arrayBuffer();
+      const buffer = Buffer.from(arrayBuffer);
+      return `data:${mimeType};base64,${buffer.toString("base64")}`;
+    }
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader;
+      reader.onloadend = () => {
+        const result = reader.result;
+        if (result.startsWith("data:;base64,")) {
+          resolve(`data:${mimeType};base64,${result.substring(13)}`);
+        } else {
+          resolve(result);
+        }
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  }
+}
+Workflow36.prototype.fileLoader = CreateWorkflow35(FileLoaderTask);
+
+// src/task/FileLoaderTask.server.ts
+class FileLoaderTask2 extends FileLoaderTask {
+  async execute(input2, context) {
+    let { url, format = "auto" } = input2;
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      return super.execute(input2, context);
+    }
+    if (context.signal.aborted) {
+      throw new TaskAbortedError3("Task aborted");
+    }
+    await context.updateProgress(0, "Detecting file format");
+    if (url.startsWith("file://")) {
+      url = url.slice(7);
+    }
+    const detectedFormat = this.detectFormat(url, format);
+    const title = url.split("/").pop() || url;
+    if (context.signal.aborted) {
+      throw new TaskAbortedError3("Task aborted");
+    }
+    await context.updateProgress(10, `Reading ${detectedFormat} file from filesystem`);
+    if (detectedFormat === "json") {
+      const fileContent2 = await readFile(url, { encoding: "utf-8" });
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(50, "Parsing JSON content");
+      const jsonData = this.parseJsonContent(fileContent2);
+      const content = JSON.stringify(jsonData, null, 2);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(100, "File loaded successfully");
+      return {
+        text: undefined,
+        json: jsonData,
+        csv: undefined,
+        image: undefined,
+        pdf: undefined,
+        frontmatter: undefined,
+        metadata: {
+          url,
+          format: detectedFormat,
+          size: content.length,
+          title,
+          mimeType: "application/json"
+        }
+      };
+    }
+    if (detectedFormat === "csv") {
+      const fileContent2 = await readFile(url, { encoding: "utf-8" });
+      if (!fileContent2) {
+        throw new Error(`Failed to load CSV from ${url}`);
+      }
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(50, "Parsing CSV content");
+      const csvData = this.parseCsvContent(fileContent2);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(100, "File loaded successfully");
+      return {
+        text: undefined,
+        json: undefined,
+        csv: csvData,
+        image: undefined,
+        pdf: undefined,
+        frontmatter: undefined,
+        metadata: {
+          url,
+          format: detectedFormat,
+          size: fileContent2.length,
+          title,
+          mimeType: "text/csv"
+        }
+      };
+    }
+    if (detectedFormat === "image") {
+      const fileBuffer = await readFile(url);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(50, "Converting image to base64");
+      const mimeType2 = this.getImageMimeType(url);
+      const blob = new Blob([fileBuffer], { type: mimeType2 });
+      const imageData = await this.blobToBase64DataURL(blob, mimeType2);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(100, "File loaded successfully");
+      return {
+        text: undefined,
+        json: undefined,
+        csv: undefined,
+        image: imageData,
+        pdf: undefined,
+        frontmatter: undefined,
+        metadata: {
+          url,
+          format: detectedFormat,
+          size: fileBuffer.length,
+          title,
+          mimeType: mimeType2
+        }
+      };
+    }
+    if (detectedFormat === "pdf") {
+      const fileBuffer = await readFile(url);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(50, "Converting PDF to base64");
+      const mimeType2 = "application/pdf";
+      const blob = new Blob([fileBuffer], { type: mimeType2 });
+      const pdfData = await this.blobToBase64DataURL(blob, mimeType2);
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted");
+      }
+      await context.updateProgress(100, "File loaded successfully");
+      return {
+        text: undefined,
+        json: undefined,
+        csv: undefined,
+        image: undefined,
+        pdf: pdfData,
+        frontmatter: undefined,
+        metadata: {
+          url,
+          format: detectedFormat,
+          size: fileBuffer.length,
+          title,
+          mimeType: mimeType2
+        }
+      };
+    }
+    const fileContent = await readFile(url, { encoding: "utf-8" });
+    if (!fileContent) {
+      throw new Error(`Failed to load content from ${url}`);
+    }
+    if (context.signal.aborted) {
+      throw new TaskAbortedError3("Task aborted");
+    }
+    await context.updateProgress(50, `Parsing ${detectedFormat} content`);
+    const mimeType = detectedFormat === "markdown" ? "text/markdown" : detectedFormat === "html" ? "text/html" : "text/plain";
+    if (context.signal.aborted) {
+      throw new TaskAbortedError3("Task aborted");
+    }
+    await context.updateProgress(100, "File loaded successfully");
+    if (detectedFormat === "markdown") {
+      const { frontmatter, body } = this.parseFrontmatter(fileContent);
+      return {
+        text: body,
+        json: undefined,
+        csv: undefined,
+        image: undefined,
+        pdf: undefined,
+        frontmatter,
+        metadata: {
+          url,
+          format: detectedFormat,
+          size: fileContent.length,
+          title,
+          mimeType
+        }
+      };
+    }
+    return {
+      text: fileContent,
+      json: undefined,
+      csv: undefined,
+      image: undefined,
+      pdf: undefined,
+      frontmatter: undefined,
+      metadata: {
+        url,
+        format: detectedFormat,
+        size: fileContent.length,
+        title,
+        mimeType
+      }
+    };
+  }
+}
+var fileLoader = (input2, config) => {
+  return new FileLoaderTask2({}, config).run(input2);
+};
+Workflow37.prototype.fileLoader = CreateWorkflow36(FileLoaderTask2);
+
+// src/node.ts
+var registerCommonTasks2 = () => {
+  const tasks = registerCommonTasks();
+  TaskRegistry2.registerTask(FileLoaderTask2);
+  return [...tasks, FileLoaderTask2];
+};
 export {
   split,
-  registerCommonTasks,
+  registerCommonTasks2 as registerCommonTasks,
   process,
   merge,
   mcpToolCall,
@@ -7984,4 +8160,4 @@ export {
   ArrayTask
 };
 
-//# debugId=017044E656C85CB364756E2164756E21
+//# debugId=A6B33698A9E8527664756E2164756E21