@workglow/tasks 0.0.103 → 0.0.104

package/dist/node.js

@@ -847,6 +847,13 @@ var inputSchema12 = {
       title: "Timeout",
       description: "Request timeout in milliseconds"
     },
+    credential_key: {
+      type: "string",
+      format: "credential",
+      title: "Credential Key",
+      description: "Key to look up in the credential store. The resolved value is sent as a Bearer token in the Authorization header.",
+      "x-ui-hidden": true
+    },
     queue: {
       oneOf: [{ type: "boolean" }, { type: "string" }],
       description: "Queue handling: false=run inline, true=use default, string=explicit queue name",
@@ -954,13 +961,13 @@ class FetchUrlJob extends Job {
     }, async (progress) => await context.updateProgress(progress));
     if (response.ok) {
       const contentType = response.headers.get("content-type") ?? "";
-      const headers = {};
+      const responseHeaders = {};
       response.headers.forEach((value, key) => {
-        headers[key] = value;
+        responseHeaders[key] = value;
       });
       const metadata = {
         contentType,
-        headers
+        headers: responseHeaders
       };
       let responseType = input.response_type;
       if (!responseType) {
@@ -1064,6 +1071,16 @@ class FetchUrlTask extends JobQueueTask {
     super(input, config);
     this.jobClass = FetchUrlJob;
   }
+  async execute(input, executeContext) {
+    const credential = input.credential_key;
+    if (credential) {
+      input = {
+        ...input,
+        headers: { ...input.headers, Authorization: `Bearer ${credential}` }
+      };
+    }
+    return super.execute(input, executeContext);
+  }
   setInput(input) {
     if (!("response_type" in input)) {
       super.setInput(input);
@@ -6041,14 +6058,326 @@ var split = (input2, config = {}) => {
   return task.run(input2);
 };
 Workflow20.prototype.split = CreateWorkflow19(SplitTask);
+// src/task/DateFormatTask.ts
+import {
+  CreateWorkflow as CreateWorkflow20,
+  Task as Task18,
+  Workflow as Workflow21
+} from "@workglow/task-graph";
+var inputSchema18 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Date string, ISO 8601 timestamp, or Unix timestamp in milliseconds"
+    },
+    format: {
+      type: "string",
+      title: "Format",
+      enum: ["iso", "date", "time", "datetime", "unix"],
+      description: "Output format: 'iso', 'date', 'time', 'datetime', 'unix'",
+      default: "iso"
+    },
+    locale: {
+      type: "string",
+      title: "Locale",
+      description: "Locale string (e.g. 'en-US')",
+      default: "en-US"
+    },
+    timeZone: {
+      type: "string",
+      title: "Time Zone",
+      description: "IANA time zone (e.g. 'America/New_York', 'UTC')"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema18 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      title: "Result",
+      description: "Formatted date string"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class DateFormatTask extends Task18 {
+  static type = "DateFormatTask";
+  static category = "Utility";
+  static title = "Date Format";
+  static description = "Parses and formats a date string";
+  static inputSchema() {
+    return inputSchema18;
+  }
+  static outputSchema() {
+    return outputSchema18;
+  }
+  async executeReactive(input2, _output, _context) {
+    const dateInput = /^\d+$/.test(input2.value) ? Number(input2.value) : input2.value;
+    const date = new Date(dateInput);
+    if (isNaN(date.getTime())) {
+      throw new Error(`Invalid date: ${input2.value}`);
+    }
+    const format = input2.format ?? "iso";
+    const locale = input2.locale;
+    const timeZone = input2.timeZone;
+    let result;
+    switch (format) {
+      case "iso":
+        result = date.toISOString();
+        break;
+      case "date":
+        result = date.toLocaleDateString(locale, timeZone ? { timeZone } : undefined);
+        break;
+      case "time":
+        result = date.toLocaleTimeString(locale, timeZone ? { timeZone } : undefined);
+        break;
+      case "unix":
+        result = String(date.getTime());
+        break;
+      case "datetime":
+      default:
+        result = date.toLocaleString(locale, timeZone ? { timeZone } : undefined);
+        break;
+    }
+    return { result };
+  }
+}
+Workflow21.prototype.dateFormat = CreateWorkflow20(DateFormatTask);
+// src/task/JsonPathTask.ts
+import {
+  CreateWorkflow as CreateWorkflow21,
+  Task as Task19,
+  Workflow as Workflow22
+} from "@workglow/task-graph";
+var inputSchema19 = {
+  type: "object",
+  properties: {
+    value: {
+      title: "Value",
+      description: "Input object or array to query"
+    },
+    path: {
+      type: "string",
+      title: "Path",
+      description: "Dot-notation path to extract (e.g. 'a.b.c', 'items.0.name', 'items.*.name')"
+    }
+  },
+  required: ["value", "path"],
+  additionalProperties: false
+};
+var outputSchema19 = {
+  type: "object",
+  properties: {
+    result: {
+      title: "Result",
+      description: "Extracted value(s) from the path"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+function resolvePath(obj, segments) {
+  if (segments.length === 0)
+    return obj;
+  const [head, ...tail] = segments;
+  if (head === "*") {
+    if (Array.isArray(obj)) {
+      return obj.map((item) => resolvePath(item, tail));
+    }
+    if (obj !== null && typeof obj === "object") {
+      return Object.values(obj).map((v) => resolvePath(v, tail));
+    }
+    return;
+  }
+  if (obj === null || obj === undefined || typeof obj !== "object") {
+    return;
+  }
+  const next2 = obj[head];
+  return resolvePath(next2, tail);
+}
+
+class JsonPathTask extends Task19 {
+  static type = "JsonPathTask";
+  static category = "Utility";
+  static title = "JSON Path";
+  static description = "Extracts a value from an object using a dot-notation path";
+  static inputSchema() {
+    return inputSchema19;
+  }
+  static outputSchema() {
+    return outputSchema19;
+  }
+  async executeReactive(input2, _output, _context) {
+    const segments = input2.path.split(".");
+    const result = resolvePath(input2.value, segments);
+    return { result };
+  }
+}
+Workflow22.prototype.jsonPath = CreateWorkflow21(JsonPathTask);
+// src/task/RegexTask.ts
+import {
+  CreateWorkflow as CreateWorkflow22,
+  Task as Task20,
+  Workflow as Workflow23
+} from "@workglow/task-graph";
+var inputSchema20 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string to match against"
+    },
+    pattern: {
+      type: "string",
+      title: "Pattern",
+      description: "Regular expression pattern"
+    },
+    flags: {
+      type: "string",
+      title: "Flags",
+      description: "Regex flags (e.g. 'g', 'i', 'gi')",
+      default: ""
+    }
+  },
+  required: ["value", "pattern"],
+  additionalProperties: false
+};
+var outputSchema20 = {
+  type: "object",
+  properties: {
+    match: {
+      type: "boolean",
+      title: "Match",
+      description: "Whether the pattern matched"
+    },
+    matches: {
+      type: "array",
+      items: { type: "string" },
+      title: "Matches",
+      description: "Array of matched strings (full matches when global, groups when not)"
+    }
+  },
+  required: ["match", "matches"],
+  additionalProperties: false
+};
+
+class RegexTask extends Task20 {
+  static type = "RegexTask";
+  static category = "String";
+  static title = "Regex";
+  static description = "Matches a string against a regular expression pattern";
+  static inputSchema() {
+    return inputSchema20;
+  }
+  static outputSchema() {
+    return outputSchema20;
+  }
+  async executeReactive(input2, _output, _context) {
+    const flags = input2.flags ?? "";
+    const regex = new RegExp(input2.pattern, flags);
+    if (flags.includes("g")) {
+      const allMatches = Array.from(input2.value.matchAll(new RegExp(input2.pattern, flags)));
+      return {
+        match: allMatches.length > 0,
+        matches: allMatches.map((m) => m[0])
+      };
+    }
+    const result = regex.exec(input2.value);
+    if (!result) {
+      return { match: false, matches: [] };
+    }
+    return {
+      match: true,
+      matches: result.slice(0)
+    };
+  }
+}
+Workflow23.prototype.regex = CreateWorkflow22(RegexTask);
+// src/task/TemplateTask.ts
+import {
+  CreateWorkflow as CreateWorkflow23,
+  Task as Task21,
+  Workflow as Workflow24
+} from "@workglow/task-graph";
+var inputSchema21 = {
+  type: "object",
+  properties: {
+    template: {
+      type: "string",
+      title: "Template",
+      description: "Template string with {{key}} placeholders; supports {{key|default}} for defaults"
+    },
+    values: {
+      type: "object",
+      title: "Values",
+      description: "Key-value pairs to substitute into the template",
+      additionalProperties: true
+    }
+  },
+  required: ["template", "values"],
+  additionalProperties: false
+};
+var outputSchema21 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      title: "Result",
+      description: "Rendered template string"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class TemplateTask extends Task21 {
+  static type = "TemplateTask";
+  static category = "Utility";
+  static title = "Template";
+  static description = "Renders a template string with {{key}} placeholders and optional defaults";
+  static inputSchema() {
+    return inputSchema21;
+  }
+  static outputSchema() {
+    return outputSchema21;
+  }
+  async executeReactive(input2, _output, _context) {
+    const result = input2.template.replace(/\{\{([^}]+)\}\}/g, (_match, expr) => {
+      const [path, defaultValue] = expr.split("|").map((s) => s.trim());
+      const segments = path.split(".");
+      let current = input2.values;
+      for (const segment of segments) {
+        if (current === null || current === undefined || typeof current !== "object") {
+          current = undefined;
+          break;
+        }
+        current = current[segment];
+      }
+      if (current !== undefined && current !== null) {
+        return String(current);
+      }
+      return defaultValue !== undefined ? defaultValue : "";
+    });
+    return { result };
+  }
+}
+Workflow24.prototype.template = CreateWorkflow23(TemplateTask);
 // src/task/mcp/McpListTask.ts
-import { CreateWorkflow as CreateWorkflow20, Task as Task18, Workflow as Workflow21 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow24, Task as Task22, Workflow as Workflow25 } from "@workglow/task-graph";
 import {
   mcpClientFactory,
   mcpServerConfigSchema
 } from "@workglow/util";
 var mcpListTypes = ["tools", "resources", "prompts"];
-var inputSchema18 = {
+var inputSchema22 = {
   type: "object",
   properties: {
     ...mcpServerConfigSchema,
@@ -6217,7 +6546,7 @@ var outputSchemaAll = {
   additionalProperties: false
 };
 
-class McpListTask extends Task18 {
+class McpListTask extends Task22 {
   static type = "McpListTask";
   static category = "MCP";
   static title = "MCP List";
@@ -6225,7 +6554,7 @@ class McpListTask extends Task18 {
   static cacheable = false;
   static hasDynamicSchemas = true;
   static inputSchema() {
-    return inputSchema18;
+    return inputSchema22;
   }
   static outputSchema() {
     return outputSchemaAll;
@@ -6285,13 +6614,13 @@ class McpListTask extends Task18 {
 var mcpList = async (input2, config = {}) => {
   return new McpListTask({}, config).run(input2);
 };
-Workflow21.prototype.mcpList = CreateWorkflow20(McpListTask);
+Workflow25.prototype.mcpList = CreateWorkflow24(McpListTask);
 // src/task/mcp/McpPromptGetTask.ts
 import {
-  CreateWorkflow as CreateWorkflow21,
-  Task as Task19,
+  CreateWorkflow as CreateWorkflow25,
+  Task as Task23,
   TaskConfigSchema as TaskConfigSchema5,
-  Workflow as Workflow22
+  Workflow as Workflow26
 } from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory2,
@@ -6448,7 +6777,7 @@ var fallbackInputSchema = {
   additionalProperties: false
 };
 
-class McpPromptGetTask extends Task19 {
+class McpPromptGetTask extends Task23 {
   static type = "McpPromptGetTask";
   static category = "MCP";
   static title = "MCP Get Prompt";
@@ -6532,13 +6861,13 @@ class McpPromptGetTask extends Task19 {
 var mcpPromptGet = async (input2, config) => {
   return new McpPromptGetTask({}, config).run(input2);
 };
-Workflow22.prototype.mcpPromptGet = CreateWorkflow21(McpPromptGetTask);
+Workflow26.prototype.mcpPromptGet = CreateWorkflow25(McpPromptGetTask);
 // src/task/mcp/McpResourceReadTask.ts
 import {
-  CreateWorkflow as CreateWorkflow22,
-  Task as Task20,
+  CreateWorkflow as CreateWorkflow26,
+  Task as Task24,
   TaskConfigSchema as TaskConfigSchema6,
-  Workflow as Workflow23
+  Workflow as Workflow27
 } from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory3,
@@ -6588,12 +6917,12 @@ var contentItemSchema = {
     }
   ]
 };
-var inputSchema19 = {
+var inputSchema23 = {
   type: "object",
   properties: {},
   additionalProperties: false
 };
-var outputSchema18 = {
+var outputSchema22 = {
   type: "object",
   properties: {
     contents: {
@@ -6607,7 +6936,7 @@ var outputSchema18 = {
   additionalProperties: false
 };
 
-class McpResourceReadTask extends Task20 {
+class McpResourceReadTask extends Task24 {
   static type = "McpResourceReadTask";
   static category = "MCP";
   static title = "MCP Read Resource";
@@ -6615,10 +6944,10 @@ class McpResourceReadTask extends Task20 {
   static cacheable = false;
   static customizable = true;
   static inputSchema() {
-    return inputSchema19;
+    return inputSchema23;
   }
   static outputSchema() {
-    return outputSchema18;
+    return outputSchema22;
   }
   static configSchema() {
     return configSchema3;
@@ -6636,13 +6965,13 @@ class McpResourceReadTask extends Task20 {
 var mcpResourceRead = async (config) => {
   return new McpResourceReadTask({}, config).run({});
 };
-Workflow23.prototype.mcpResourceRead = CreateWorkflow22(McpResourceReadTask);
+Workflow27.prototype.mcpResourceRead = CreateWorkflow26(McpResourceReadTask);
 // src/task/mcp/McpToolCallTask.ts
 import {
-  CreateWorkflow as CreateWorkflow23,
-  Task as Task21,
+  CreateWorkflow as CreateWorkflow27,
+  Task as Task25,
   TaskConfigSchema as TaskConfigSchema7,
-  Workflow as Workflow24
+  Workflow as Workflow28
 } from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory4,
@@ -6791,7 +7120,7 @@ var fallbackInputSchema2 = {
   additionalProperties: true
 };
 
-class McpToolCallTask extends Task21 {
+class McpToolCallTask extends Task25 {
   static type = "McpToolCallTask";
   static category = "MCP";
   static title = "MCP Call Tool";
@@ -6890,69 +7219,575 @@ class McpToolCallTask extends Task21 {
 var mcpToolCall = async (input2, config) => {
   return new McpToolCallTask({}, config).run(input2);
 };
-Workflow24.prototype.mcpToolCall = CreateWorkflow23(McpToolCallTask);
-// src/task/scalar/ScalarAbsTask.ts
-import { CreateWorkflow as CreateWorkflow24, Task as Task22, Workflow as Workflow25 } from "@workglow/task-graph";
-var inputSchema20 = {
+Workflow28.prototype.mcpToolCall = CreateWorkflow27(McpToolCallTask);
+// src/task/string/StringConcatTask.ts
+import {
+  CreateWorkflow as CreateWorkflow28,
+  Task as Task26,
+  Workflow as Workflow29
+} from "@workglow/task-graph";
+var inputSchema24 = {
   type: "object",
-  properties: {
-    value: {
-      type: "number",
-      title: "Value",
-      description: "Input number"
-    }
-  },
-  required: ["value"],
-  additionalProperties: false
+  properties: {},
+  additionalProperties: { type: "string" }
 };
-var outputSchema19 = {
+var outputSchema23 = {
   type: "object",
   properties: {
     result: {
-      type: "number",
+      type: "string",
       title: "Result",
-      description: "Absolute value"
+      description: "Concatenation of all input strings"
     }
   },
   required: ["result"],
   additionalProperties: false
 };
 
-class ScalarAbsTask extends Task22 {
-  static type = "ScalarAbsTask";
-  static category = "Math";
-  static title = "Abs";
-  static description = "Returns the absolute value of a number";
+class StringConcatTask extends Task26 {
+  static type = "StringConcatTask";
+  static category = "String";
+  static title = "Concat";
+  static description = "Concatenates all input strings";
   static inputSchema() {
-    return inputSchema20;
+    return inputSchema24;
   }
   static outputSchema() {
-    return outputSchema19;
+    return outputSchema23;
   }
-  async execute(input2, _context) {
-    return { result: Math.abs(input2.value) };
+  async executeReactive(input2, _output, _context) {
+    return { result: Object.values(input2).join("") };
   }
 }
-Workflow25.prototype.scalarAbs = CreateWorkflow24(ScalarAbsTask);
-// src/task/scalar/ScalarCeilTask.ts
-import { CreateWorkflow as CreateWorkflow25, Task as Task23, Workflow as Workflow26 } from "@workglow/task-graph";
-var inputSchema21 = {
+Workflow29.prototype.stringConcat = CreateWorkflow28(StringConcatTask);
+// src/task/string/StringIncludesTask.ts
+import {
+  CreateWorkflow as CreateWorkflow29,
+  Task as Task27,
+  Workflow as Workflow30
+} from "@workglow/task-graph";
+var inputSchema25 = {
   type: "object",
   properties: {
     value: {
-      type: "number",
+      type: "string",
       title: "Value",
-      description: "Input number"
+      description: "Input string to search in"
+    },
+    search: {
+      type: "string",
+      title: "Search",
+      description: "Substring to search for"
     }
   },
-  required: ["value"],
+  required: ["value", "search"],
   additionalProperties: false
 };
-var outputSchema20 = {
+var outputSchema24 = {
   type: "object",
   properties: {
     result: {
-      type: "number",
+      type: "boolean",
+      title: "Result",
+      description: "Whether the string contains the search substring"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class StringIncludesTask extends Task27 {
+  static type = "StringIncludesTask";
+  static category = "String";
+  static title = "Includes";
+  static description = "Checks if a string contains a substring";
+  static inputSchema() {
+    return inputSchema25;
+  }
+  static outputSchema() {
+    return outputSchema24;
+  }
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.includes(input2.search) };
+  }
+}
+Workflow30.prototype.stringIncludes = CreateWorkflow29(StringIncludesTask);
+// src/task/string/StringJoinTask.ts
+import {
+  CreateWorkflow as CreateWorkflow30,
+  Task as Task28,
+  Workflow as Workflow31
+} from "@workglow/task-graph";
+var inputSchema26 = {
+  type: "object",
+  properties: {
+    values: {
+      type: "array",
+      items: { type: "string" },
+      title: "Values",
+      description: "Array of strings to join"
+    },
+    separator: {
+      type: "string",
+      title: "Separator",
+      description: "Separator between elements",
+      default: ""
+    }
+  },
+  required: ["values"],
+  additionalProperties: false
+};
+var outputSchema25 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      title: "Result",
+      description: "Joined string"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class StringJoinTask extends Task28 {
+  static type = "StringJoinTask";
+  static category = "String";
+  static title = "Join";
+  static description = "Joins an array of strings with a separator";
+  static inputSchema() {
+    return inputSchema26;
+  }
+  static outputSchema() {
+    return outputSchema25;
+  }
+  async executeReactive(input2, output, _context) {
+    const separator = input2.separator ?? "";
+    return { result: input2.values.join(separator) };
+  }
+}
+Workflow31.prototype.stringJoin = CreateWorkflow30(StringJoinTask);
+// src/task/string/StringLengthTask.ts
+import {
+  CreateWorkflow as CreateWorkflow31,
+  Task as Task29,
+  Workflow as Workflow32
+} from "@workglow/task-graph";
+var inputSchema27 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema26 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "integer",
+      title: "Result",
+      description: "Length of the string"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class StringLengthTask extends Task29 {
+  static type = "StringLengthTask";
+  static category = "String";
+  static title = "Length";
+  static description = "Returns the length of a string";
+  static inputSchema() {
+    return inputSchema27;
+  }
+  static outputSchema() {
+    return outputSchema26;
+  }
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.length };
+  }
+}
+Workflow32.prototype.stringLength = CreateWorkflow31(StringLengthTask);
+// src/task/string/StringLowerCaseTask.ts
+import {
+  CreateWorkflow as CreateWorkflow32,
+  Task as Task30,
+  Workflow as Workflow33
+} from "@workglow/task-graph";
+var inputSchema28 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema27 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      title: "Result",
+      description: "Lowercased string"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class StringLowerCaseTask extends Task30 {
+  static type = "StringLowerCaseTask";
+  static category = "String";
+  static title = "Lower Case";
+  static description = "Converts a string to lower case";
+  static inputSchema() {
+    return inputSchema28;
+  }
+  static outputSchema() {
+    return outputSchema27;
+  }
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.toLowerCase() };
+  }
+}
+Workflow33.prototype.stringLowerCase = CreateWorkflow32(StringLowerCaseTask);
+// src/task/string/StringReplaceTask.ts
+import {
+  CreateWorkflow as CreateWorkflow33,
+  Task as Task31,
+  Workflow as Workflow34
+} from "@workglow/task-graph";
+var inputSchema29 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string"
+    },
+    search: {
+      type: "string",
+      title: "Search",
+      description: "Substring to search for"
+    },
+    replace: {
+      type: "string",
+      title: "Replace",
+      description: "Replacement string"
+    }
+  },
+  required: ["value", "search", "replace"],
+  additionalProperties: false
+};
+var outputSchema28 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      title: "Result",
+      description: "String with all occurrences replaced"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class StringReplaceTask extends Task31 {
+  static type = "StringReplaceTask";
+  static category = "String";
+  static title = "Replace";
+  static description = "Replaces all occurrences of a substring";
+  static inputSchema() {
+    return inputSchema29;
+  }
+  static outputSchema() {
+    return outputSchema28;
+  }
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.replaceAll(input2.search, input2.replace) };
+  }
+}
+Workflow34.prototype.stringReplace = CreateWorkflow33(StringReplaceTask);
+// src/task/string/StringSliceTask.ts
+import {
+  CreateWorkflow as CreateWorkflow34,
+  Task as Task32,
+  Workflow as Workflow35
+} from "@workglow/task-graph";
+var inputSchema30 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string"
+    },
+    start: {
+      type: "integer",
+      title: "Start",
+      description: "Start index (inclusive, supports negative indexing)"
+    },
+    end: {
+      type: "integer",
+      title: "End",
+      description: "End index (exclusive, supports negative indexing)"
+    }
+  },
+  required: ["value", "start"],
+  additionalProperties: false
+};
+var outputSchema29 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      title: "Result",
+      description: "Extracted substring"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class StringSliceTask extends Task32 {
+  static type = "StringSliceTask";
+  static category = "String";
+  static title = "Slice";
+  static description = "Extracts a substring by start and optional end index";
+  static inputSchema() {
+    return inputSchema30;
+  }
+  static outputSchema() {
+    return outputSchema29;
+  }
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.slice(input2.start, input2.end) };
+  }
+}
+Workflow35.prototype.stringSlice = CreateWorkflow34(StringSliceTask);
+// src/task/string/StringTemplateTask.ts
+import {
+  CreateWorkflow as CreateWorkflow35,
+  Task as Task33,
+  Workflow as Workflow36
+} from "@workglow/task-graph";
+var inputSchema31 = {
+  type: "object",
+  properties: {
+    template: {
+      type: "string",
+      title: "Template",
+      description: "Template string with {{key}} placeholders"
+    },
+    values: {
+      type: "object",
+      title: "Values",
+      description: "Key-value pairs to substitute into the template",
+      additionalProperties: true
+    }
+  },
+  required: ["template", "values"],
+  additionalProperties: false
+};
+var outputSchema30 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      title: "Result",
+      description: "Template with placeholders replaced by values"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class StringTemplateTask extends Task33 {
+  static type = "StringTemplateTask";
+  static category = "String";
+  static title = "Template";
+  static description = "Replaces {{key}} placeholders in a template string with values";
+  static inputSchema() {
+    return inputSchema31;
+  }
+  static outputSchema() {
+    return outputSchema30;
+  }
+  async executeReactive(input2, output, _context) {
+    let result = input2.template;
+    for (const [key, value] of Object.entries(input2.values)) {
+      result = result.replaceAll(`{{${key}}}`, String(value));
+    }
+    return { result };
+  }
+}
+Workflow36.prototype.stringTemplate = CreateWorkflow35(StringTemplateTask);
+// src/task/string/StringTrimTask.ts
+import {
+  CreateWorkflow as CreateWorkflow36,
+  Task as Task34,
+  Workflow as Workflow37
+} from "@workglow/task-graph";
+var inputSchema32 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema31 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      title: "Result",
+      description: "Trimmed string"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class StringTrimTask extends Task34 {
+  static type = "StringTrimTask";
+  static category = "String";
+  static title = "Trim";
+  static description = "Removes leading and trailing whitespace from a string";
+  static inputSchema() {
+    return inputSchema32;
+  }
+  static outputSchema() {
+    return outputSchema31;
+  }
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.trim() };
+  }
+}
+Workflow37.prototype.stringTrim = CreateWorkflow36(StringTrimTask);
+// src/task/string/StringUpperCaseTask.ts
+import {
+  CreateWorkflow as CreateWorkflow37,
+  Task as Task35,
+  Workflow as Workflow38
+} from "@workglow/task-graph";
+var inputSchema33 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Input string"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema32 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      title: "Result",
+      description: "Uppercased string"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class StringUpperCaseTask extends Task35 {
+  static type = "StringUpperCaseTask";
+  static category = "String";
+  static title = "Upper Case";
+  static description = "Converts a string to upper case";
+  static inputSchema() {
+    return inputSchema33;
+  }
+  static outputSchema() {
+    return outputSchema32;
+  }
+  async executeReactive(input2, output, _context) {
+    return { result: input2.value.toUpperCase() };
+  }
+}
+Workflow38.prototype.stringUpperCase = CreateWorkflow37(StringUpperCaseTask);
+// src/task/scalar/ScalarAbsTask.ts
+import { CreateWorkflow as CreateWorkflow38, Task as Task36, Workflow as Workflow39 } from "@workglow/task-graph";
+var inputSchema34 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "number",
+      title: "Value",
+      description: "Input number"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema33 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Absolute value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarAbsTask extends Task36 {
+  static type = "ScalarAbsTask";
+  static category = "Math";
+  static title = "Abs";
+  static description = "Returns the absolute value of a number";
+  static inputSchema() {
+    return inputSchema34;
+  }
+  static outputSchema() {
+    return outputSchema33;
+  }
+  async execute(input2, _context) {
+    return { result: Math.abs(input2.value) };
+  }
+}
+Workflow39.prototype.scalarAbs = CreateWorkflow38(ScalarAbsTask);
+// src/task/scalar/ScalarCeilTask.ts
+import { CreateWorkflow as CreateWorkflow39, Task as Task37, Workflow as Workflow40 } from "@workglow/task-graph";
+var inputSchema35 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "number",
+      title: "Value",
+      description: "Input number"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema34 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
       title: "Result",
       description: "Ceiling value"
     }
@@ -6961,25 +7796,25 @@ var outputSchema20 = {
   additionalProperties: false
 };
 
-class ScalarCeilTask extends Task23 {
+class ScalarCeilTask extends Task37 {
   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 inputSchema21;
+    return inputSchema35;
   }
   static outputSchema() {
-    return outputSchema20;
+    return outputSchema34;
   }
   async execute(input2, _context) {
     return { result: Math.ceil(input2.value) };
   }
 }
-Workflow26.prototype.scalarCeil = CreateWorkflow25(ScalarCeilTask);
+Workflow40.prototype.scalarCeil = CreateWorkflow39(ScalarCeilTask);
 // src/task/scalar/ScalarFloorTask.ts
-import { CreateWorkflow as CreateWorkflow26, Task as Task24, Workflow as Workflow27 } from "@workglow/task-graph";
-var inputSchema22 = {
+import { CreateWorkflow as CreateWorkflow40, Task as Task38, Workflow as Workflow41 } from "@workglow/task-graph";
+var inputSchema36 = {
   type: "object",
   properties: {
     value: {
@@ -6991,7 +7826,7 @@ var inputSchema22 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema21 = {
+var outputSchema35 = {
   type: "object",
   properties: {
     result: {
@@ -7004,25 +7839,25 @@ var outputSchema21 = {
   additionalProperties: false
 };
 
-class ScalarFloorTask extends Task24 {
+class ScalarFloorTask extends Task38 {
   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 inputSchema22;
+    return inputSchema36;
   }
   static outputSchema() {
-    return outputSchema21;
+    return outputSchema35;
   }
   async execute(input2, _context) {
     return { result: Math.floor(input2.value) };
   }
 }
-Workflow27.prototype.scalarFloor = CreateWorkflow26(ScalarFloorTask);
+Workflow41.prototype.scalarFloor = CreateWorkflow40(ScalarFloorTask);
 // src/task/scalar/ScalarMaxTask.ts
-import { CreateWorkflow as CreateWorkflow27, Task as Task25, Workflow as Workflow28 } from "@workglow/task-graph";
-var inputSchema23 = {
+import { CreateWorkflow as CreateWorkflow41, Task as Task39, Workflow as Workflow42 } from "@workglow/task-graph";
+var inputSchema37 = {
   type: "object",
   properties: {
     values: {
@@ -7035,7 +7870,7 @@ var inputSchema23 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema22 = {
+var outputSchema36 = {
   type: "object",
   properties: {
     result: {
@@ -7048,25 +7883,25 @@ var outputSchema22 = {
   additionalProperties: false
 };
 
-class ScalarMaxTask extends Task25 {
+class ScalarMaxTask extends Task39 {
   static type = "ScalarMaxTask";
   static category = "Math";
   static title = "Max";
   static description = "Returns the largest of the given numbers";
   static inputSchema() {
-    return inputSchema23;
+    return inputSchema37;
   }
   static outputSchema() {
-    return outputSchema22;
+    return outputSchema36;
   }
   async execute(input2, _context) {
     return { result: Math.max(...input2.values) };
   }
 }
-Workflow28.prototype.scalarMax = CreateWorkflow27(ScalarMaxTask);
+Workflow42.prototype.scalarMax = CreateWorkflow41(ScalarMaxTask);
 // src/task/scalar/ScalarMinTask.ts
-import { CreateWorkflow as CreateWorkflow28, Task as Task26, Workflow as Workflow29 } from "@workglow/task-graph";
-var inputSchema24 = {
+import { CreateWorkflow as CreateWorkflow42, Task as Task40, Workflow as Workflow43 } from "@workglow/task-graph";
+var inputSchema38 = {
   type: "object",
   properties: {
     values: {
@@ -7079,7 +7914,7 @@ var inputSchema24 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema23 = {
+var outputSchema37 = {
   type: "object",
   properties: {
     result: {
@@ -7092,25 +7927,25 @@ var outputSchema23 = {
   additionalProperties: false
 };
 
-class ScalarMinTask extends Task26 {
+class ScalarMinTask extends Task40 {
   static type = "ScalarMinTask";
   static category = "Math";
   static title = "Min";
   static description = "Returns the smallest of the given numbers";
   static inputSchema() {
-    return inputSchema24;
+    return inputSchema38;
   }
   static outputSchema() {
-    return outputSchema23;
+    return outputSchema37;
   }
   async execute(input2, _context) {
     return { result: Math.min(...input2.values) };
   }
 }
-Workflow29.prototype.scalarMin = CreateWorkflow28(ScalarMinTask);
+Workflow43.prototype.scalarMin = CreateWorkflow42(ScalarMinTask);
 // src/task/scalar/ScalarRoundTask.ts
-import { CreateWorkflow as CreateWorkflow29, Task as Task27, Workflow as Workflow30 } from "@workglow/task-graph";
-var inputSchema25 = {
+import { CreateWorkflow as CreateWorkflow43, Task as Task41, Workflow as Workflow44 } from "@workglow/task-graph";
+var inputSchema39 = {
   type: "object",
   properties: {
     value: {
@@ -7122,7 +7957,7 @@ var inputSchema25 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema24 = {
+var outputSchema38 = {
   type: "object",
   properties: {
     result: {
@@ -7135,25 +7970,25 @@ var outputSchema24 = {
   additionalProperties: false
 };
 
-class ScalarRoundTask extends Task27 {
+class ScalarRoundTask extends Task41 {
   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 inputSchema25;
+    return inputSchema39;
   }
   static outputSchema() {
-    return outputSchema24;
+    return outputSchema38;
   }
   async execute(input2, _context) {
     return { result: Math.round(input2.value) };
   }
 }
-Workflow30.prototype.scalarRound = CreateWorkflow29(ScalarRoundTask);
+Workflow44.prototype.scalarRound = CreateWorkflow43(ScalarRoundTask);
 // src/task/scalar/ScalarTruncTask.ts
-import { CreateWorkflow as CreateWorkflow30, Task as Task28, Workflow as Workflow31 } from "@workglow/task-graph";
-var inputSchema26 = {
+import { CreateWorkflow as CreateWorkflow44, Task as Task42, Workflow as Workflow45 } from "@workglow/task-graph";
+var inputSchema40 = {
   type: "object",
   properties: {
     value: {
@@ -7165,7 +8000,7 @@ var inputSchema26 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema25 = {
+var outputSchema39 = {
   type: "object",
   properties: {
     result: {
@@ -7178,28 +8013,28 @@ var outputSchema25 = {
   additionalProperties: false
 };
 
-class ScalarTruncTask extends Task28 {
+class ScalarTruncTask extends Task42 {
   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 inputSchema26;
+    return inputSchema40;
   }
   static outputSchema() {
-    return outputSchema25;
+    return outputSchema39;
   }
   async execute(input2, _context) {
     return { result: Math.trunc(input2.value) };
   }
 }
-Workflow31.prototype.scalarTrunc = CreateWorkflow30(ScalarTruncTask);
+Workflow45.prototype.scalarTrunc = CreateWorkflow44(ScalarTruncTask);
 // src/task/vector/VectorDistanceTask.ts
-import { CreateWorkflow as CreateWorkflow31, Task as Task29, Workflow as Workflow32 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow45, Task as Task43, Workflow as Workflow46 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema5
 } from "@workglow/util";
-var inputSchema27 = {
+var inputSchema41 = {
   type: "object",
   properties: {
     vectors: {
@@ -7215,7 +8050,7 @@ var inputSchema27 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema26 = {
+var outputSchema40 = {
   type: "object",
   properties: {
     result: {
@@ -7228,16 +8063,16 @@ var outputSchema26 = {
   additionalProperties: false
 };
 
-class VectorDistanceTask extends Task29 {
+class VectorDistanceTask extends Task43 {
   static type = "VectorDistanceTask";
   static category = "Vector";
   static title = "Distance";
   static description = "Returns the Euclidean distance between the first two vectors";
   static inputSchema() {
-    return inputSchema27;
+    return inputSchema41;
   }
   static outputSchema() {
-    return outputSchema26;
+    return outputSchema40;
   }
   async execute(input2, _context) {
     const { vectors } = input2;
@@ -7255,13 +8090,13 @@ class VectorDistanceTask extends Task29 {
     return { result: Math.sqrt(sumPrecise(diffs)) };
   }
 }
-Workflow32.prototype.vectorDistance = CreateWorkflow31(VectorDistanceTask);
+Workflow46.prototype.vectorDistance = CreateWorkflow45(VectorDistanceTask);
 // src/task/vector/VectorDotProductTask.ts
-import { CreateWorkflow as CreateWorkflow32, Task as Task30, Workflow as Workflow33 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow46, Task as Task44, Workflow as Workflow47 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema6
 } from "@workglow/util";
-var inputSchema28 = {
+var inputSchema42 = {
   type: "object",
   properties: {
     vectors: {
@@ -7277,7 +8112,7 @@ var inputSchema28 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema27 = {
+var outputSchema41 = {
   type: "object",
   properties: {
     result: {
@@ -7290,16 +8125,16 @@ var outputSchema27 = {
   additionalProperties: false
 };
 
-class VectorDotProductTask extends Task30 {
+class VectorDotProductTask extends Task44 {
   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 inputSchema28;
+    return inputSchema42;
   }
   static outputSchema() {
-    return outputSchema27;
+    return outputSchema41;
   }
   async execute(input2, _context) {
     const { vectors } = input2;
@@ -7314,14 +8149,14 @@ class VectorDotProductTask extends Task30 {
     return { result: sumPrecise(products) };
   }
 }
-Workflow33.prototype.vectorDotProduct = CreateWorkflow32(VectorDotProductTask);
+Workflow47.prototype.vectorDotProduct = CreateWorkflow46(VectorDotProductTask);
 // src/task/vector/VectorNormalizeTask.ts
-import { CreateWorkflow as CreateWorkflow33, Task as Task31, Workflow as Workflow34 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow47, Task as Task45, Workflow as Workflow48 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema7,
   normalize
 } from "@workglow/util";
-var inputSchema29 = {
+var inputSchema43 = {
   type: "object",
   properties: {
     vector: TypedArraySchema7({
@@ -7332,7 +8167,7 @@ var inputSchema29 = {
   required: ["vector"],
   additionalProperties: false
 };
-var outputSchema28 = {
+var outputSchema42 = {
   type: "object",
   properties: {
     result: TypedArraySchema7({
@@ -7344,29 +8179,29 @@ var outputSchema28 = {
   additionalProperties: false
 };
 
-class VectorNormalizeTask extends Task31 {
+class VectorNormalizeTask extends Task45 {
   static type = "VectorNormalizeTask";
   static category = "Vector";
   static title = "Normalize";
   static description = "Returns the L2-normalized (unit length) vector";
   static inputSchema() {
-    return inputSchema29;
+    return inputSchema43;
   }
   static outputSchema() {
-    return outputSchema28;
+    return outputSchema42;
   }
   async execute(input2, _context) {
     return { result: normalize(input2.vector) };
   }
 }
-Workflow34.prototype.vectorNormalize = CreateWorkflow33(VectorNormalizeTask);
+Workflow48.prototype.vectorNormalize = CreateWorkflow47(VectorNormalizeTask);
 // src/task/vector/VectorScaleTask.ts
-import { CreateWorkflow as CreateWorkflow34, Task as Task32, Workflow as Workflow35 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow48, Task as Task46, Workflow as Workflow49 } from "@workglow/task-graph";
 import {
   createTypedArrayFrom as createTypedArrayFrom5,
   TypedArraySchema as TypedArraySchema8
 } from "@workglow/util";
-var inputSchema30 = {
+var inputSchema44 = {
   type: "object",
   properties: {
     vector: TypedArraySchema8({
@@ -7382,7 +8217,7 @@ var inputSchema30 = {
   required: ["vector", "scalar"],
   additionalProperties: false
 };
-var outputSchema29 = {
+var outputSchema43 = {
   type: "object",
   properties: {
     result: TypedArraySchema8({
@@ -7394,16 +8229,16 @@ var outputSchema29 = {
   additionalProperties: false
 };
 
-class VectorScaleTask extends Task32 {
+class VectorScaleTask extends Task46 {
   static type = "VectorScaleTask";
   static category = "Vector";
   static title = "Scale";
   static description = "Multiplies each element of a vector by a scalar";
   static inputSchema() {
-    return inputSchema30;
+    return inputSchema44;
   }
   static outputSchema() {
-    return outputSchema29;
+    return outputSchema43;
   }
   async execute(input2, _context) {
     const { vector, scalar } = input2;
@@ -7411,7 +8246,7 @@ class VectorScaleTask extends Task32 {
     return { result: createTypedArrayFrom5([vector], values) };
   }
 }
-Workflow35.prototype.vectorScale = CreateWorkflow34(VectorScaleTask);
+Workflow49.prototype.vectorScale = CreateWorkflow48(VectorScaleTask);
 
 // src/common.ts
 import { TaskRegistry } from "@workglow/task-graph";
@@ -7450,7 +8285,21 @@ var registerCommonTasks = () => {
     McpToolCallTask,
     McpResourceReadTask,
     McpPromptGetTask,
-    McpListTask
+    McpListTask,
+    StringConcatTask,
+    StringIncludesTask,
+    StringJoinTask,
+    StringLengthTask,
+    StringLowerCaseTask,
+    StringReplaceTask,
+    StringSliceTask,
+    StringTemplateTask,
+    StringTrimTask,
+    StringUpperCaseTask,
+    JsonPathTask,
+    TemplateTask,
+    DateFormatTask,
+    RegexTask
   ];
   tasks.map(TaskRegistry.registerTask);
   return tasks;
@@ -7458,21 +8307,21 @@ var registerCommonTasks = () => {
 
 // src/task/FileLoaderTask.server.ts
 import {
-  CreateWorkflow as CreateWorkflow36,
+  CreateWorkflow as CreateWorkflow50,
   TaskAbortedError as TaskAbortedError3,
-  Workflow as Workflow37
+  Workflow as Workflow51
 } from "@workglow/task-graph";
 import { readFile } from "node:fs/promises";
 
 // src/task/FileLoaderTask.ts
 import {
-  CreateWorkflow as CreateWorkflow35,
-  Task as Task33,
+  CreateWorkflow as CreateWorkflow49,
+  Task as Task47,
   TaskAbortedError as TaskAbortedError2,
-  Workflow as Workflow36
+  Workflow as Workflow50
 } from "@workglow/task-graph";
 import Papa from "papaparse";
-var inputSchema31 = {
+var inputSchema45 = {
   type: "object",
   properties: {
     url: {
@@ -7492,7 +8341,7 @@ var inputSchema31 = {
   required: ["url"],
   additionalProperties: false
 };
-var outputSchema30 = {
+var outputSchema44 = {
   type: "object",
   properties: {
     text: {
@@ -7543,17 +8392,17 @@ var outputSchema30 = {
   additionalProperties: false
 };
 
-class FileLoaderTask extends Task33 {
+class FileLoaderTask extends Task47 {
   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;
+    return inputSchema45;
   }
   static outputSchema() {
-    return outputSchema30;
+    return outputSchema44;
   }
   async execute(input2, context) {
     const { url, format = "auto" } = input2;
@@ -7906,7 +8755,7 @@ class FileLoaderTask extends Task33 {
     });
   }
 }
-Workflow36.prototype.fileLoader = CreateWorkflow35(FileLoaderTask);
+Workflow50.prototype.fileLoader = CreateWorkflow49(FileLoaderTask);
 
 // src/task/FileLoaderTask.server.ts
 class FileLoaderTask2 extends FileLoaderTask {
@@ -8095,7 +8944,7 @@ class FileLoaderTask2 extends FileLoaderTask {
 var fileLoader = (input2, config) => {
   return new FileLoaderTask2({}, config).run(input2);
 };
-Workflow37.prototype.fileLoader = CreateWorkflow36(FileLoaderTask2);
+Workflow51.prototype.fileLoader = CreateWorkflow50(FileLoaderTask2);
 
 // src/node.ts
 var registerCommonTasks2 = () => {
@@ -8129,6 +8978,17 @@ export {
   VectorDivideTask,
   VectorDistanceTask,
   TypeReplicateArray,
+  TemplateTask,
+  StringUpperCaseTask,
+  StringTrimTask,
+  StringTemplateTask,
+  StringSliceTask,
+  StringReplaceTask,
+  StringLowerCaseTask,
+  StringLengthTask,
+  StringJoinTask,
+  StringIncludesTask,
+  StringConcatTask,
   SplitTask,
   ScalarTruncTask,
   ScalarSumTask,
@@ -8142,6 +9002,7 @@ export {
   ScalarCeilTask,
   ScalarAddTask,
   ScalarAbsTask,
+  RegexTask,
   OutputTask,
   MergeTask,
   McpToolCallTask,
@@ -8150,6 +9011,7 @@ export {
   McpListTask,
   LambdaTask,
   JsonTask,
+  JsonPathTask,
   JavaScriptTask,
   InputTask,
   FileLoaderTask2 as FileLoaderTask,
@@ -8157,7 +9019,8 @@ export {
   FetchUrlJob,
   DelayTask,
   DebugLogTask,
+  DateFormatTask,
   ArrayTask
 };
 
-//# debugId=A6B33698A9E8527664756E2164756E21
+//# debugId=7A3E87B880771F0564756E2164756E21