@workglow/tasks 0.0.120 → 0.0.122

package/dist/bun.js

@@ -1,9 +1,6 @@
 // @bun
 var __require = import.meta.require;
 
-// src/bun.ts
-import { TaskRegistry as TaskRegistry2 } from "@workglow/task-graph";
-
 // src/task/adaptive.ts
 import { CreateAdaptiveWorkflow, Workflow as Workflow10 } from "@workglow/task-graph";
 
@@ -542,14 +539,16 @@ import {
   PROPERTY_ARRAY,
   TaskGraph
 } from "@workglow/task-graph";
-var TypeReplicateArray = (type, annotations = {}) => ({
-  oneOf: [type, { type: "array", items: type }],
-  title: type.title,
-  description: type.description,
-  ...type.format ? { format: type.format } : {},
-  ...annotations,
-  "x-replicate": true
-});
+function TypeReplicateArray(type, annotations = {}) {
+  return {
+    oneOf: [type, { type: "array", items: type }],
+    title: type.title,
+    description: type.description,
+    ...type.format ? { format: type.format } : {},
+    ...annotations,
+    "x-replicate": true
+  };
+}
 
 class ArrayTask extends GraphAsTask {
   static type = "ArrayTask";
@@ -1152,9 +1151,6 @@ class InputTask extends Task12 {
   outputSchema() {
     return this.config?.outputSchema ?? this.constructor.outputSchema();
   }
-  async execute(input) {
-    return input;
-  }
   async executeReactive(input) {
     return input;
   }
@@ -5978,9 +5974,6 @@ class OutputTask extends Task16 {
   outputSchema() {
     return this.config?.outputSchema ?? this.constructor.outputSchema();
   }
-  async execute(input2) {
-    return input2;
-  }
   async executeReactive(input2) {
     return input2;
   }
@@ -6372,26 +6365,22 @@ class TemplateTask extends Task21 {
 Workflow24.prototype.template = CreateWorkflow23(TemplateTask);
 // src/task/mcp/McpListTask.ts
 import { CreateWorkflow as CreateWorkflow24, Task as Task22, Workflow as Workflow25 } from "@workglow/task-graph";
-import {
-  mcpClientFactory,
-  mcpServerConfigSchema
-} from "@workglow/util";
+
+// src/util/McpTaskDeps.ts
+import { createServiceToken, globalServiceRegistry } from "@workglow/util";
+var MCP_TASK_DEPS = createServiceToken("@workglow/tasks/mcp");
+function registerMcpTaskDeps(deps) {
+  globalServiceRegistry.registerInstance(MCP_TASK_DEPS, deps);
+}
+function getMcpTaskDeps() {
+  if (!globalServiceRegistry.has(MCP_TASK_DEPS)) {
+    throw new Error("MCP task dependencies not registered. Import @workglow/tasks from a platform entry (browser, node, or bun) before using MCP tasks.");
+  }
+  return globalServiceRegistry.get(MCP_TASK_DEPS);
+}
+
+// src/task/mcp/McpListTask.ts
 var mcpListTypes = ["tools", "resources", "prompts"];
-var inputSchema22 = {
-  type: "object",
-  properties: {
-    ...mcpServerConfigSchema.properties,
-    list_type: {
-      type: "string",
-      enum: mcpListTypes,
-      title: "List Type",
-      description: "The type of items to list from the MCP server"
-    }
-  },
-  required: ["transport", "list_type"],
-  allOf: mcpServerConfigSchema.allOf,
-  additionalProperties: false
-};
 var iconSchema = {
   type: "object",
   properties: {
@@ -6555,7 +6544,22 @@ class McpListTask extends Task22 {
   static cacheable = false;
   static hasDynamicSchemas = true;
   static inputSchema() {
-    return inputSchema22;
+    const { mcpServerConfigSchema } = getMcpTaskDeps();
+    return {
+      type: "object",
+      properties: {
+        ...mcpServerConfigSchema.properties,
+        list_type: {
+          type: "string",
+          enum: mcpListTypes,
+          title: "List Type",
+          description: "The type of items to list from the MCP server"
+        }
+      },
+      required: ["transport", "list_type"],
+      allOf: mcpServerConfigSchema.allOf,
+      additionalProperties: false
+    };
   }
   static outputSchema() {
     return outputSchemaAll;
@@ -6589,9 +6593,11 @@ class McpListTask extends Task22 {
     }
   }
   async execute(input2, context) {
+    const { mcpClientFactory } = getMcpTaskDeps();
     const { client } = await mcpClientFactory.create(input2, context.signal);
+    const listType = input2.list_type;
     try {
-      switch (input2.list_type) {
+      switch (listType) {
         case "tools": {
           const result = await client.listTools();
           return { tools: result.tools };
@@ -6605,7 +6611,7 @@ class McpListTask extends Task22 {
           return { prompts: result.prompts };
         }
         default:
-          throw new Error(`Unsupported list type: ${input2.list_type}`);
+          throw new Error(`Unsupported list type: ${String(listType)}`);
       }
     } finally {
       await client.close();
@@ -6623,29 +6629,6 @@ import {
   TaskConfigSchema as TaskConfigSchema5,
   Workflow as Workflow26
 } from "@workglow/task-graph";
-import {
-  mcpClientFactory as mcpClientFactory2,
-  mcpServerConfigSchema as mcpServerConfigSchema2
-} from "@workglow/util";
-var configSchema2 = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema5["properties"],
-    ...mcpServerConfigSchema2.properties,
-    prompt_name: {
-      type: "string",
-      title: "Prompt Name",
-      description: "The name of the prompt to get",
-      format: "string:mcp-promptname"
-    }
-  },
-  required: ["transport", "prompt_name"],
-  if: { properties: { transport: { const: "stdio" } }, required: ["transport"] },
-  then: { required: ["command"] },
-  else: { required: ["server_url"] },
-  allOf: mcpServerConfigSchema2.allOf,
-  additionalProperties: false
-};
 var annotationsSchema = {
   type: "object",
   properties: {
@@ -6794,7 +6777,26 @@ class McpPromptGetTask extends Task23 {
     return fallbackOutputSchema;
   }
   static configSchema() {
-    return configSchema2;
+    const { mcpServerConfigSchema } = getMcpTaskDeps();
+    return {
+      type: "object",
+      properties: {
+        ...TaskConfigSchema5["properties"],
+        ...mcpServerConfigSchema.properties,
+        prompt_name: {
+          type: "string",
+          title: "Prompt Name",
+          description: "The name of the prompt to get",
+          format: "string:mcp-promptname"
+        }
+      },
+      required: ["transport", "prompt_name"],
+      if: { properties: { transport: { const: "stdio" } }, required: ["transport"] },
+      then: { required: ["command"] },
+      else: { required: ["server_url"] },
+      allOf: mcpServerConfigSchema.allOf,
+      additionalProperties: false
+    };
   }
   inputSchema() {
     return this.config?.inputSchema ?? fallbackInputSchema;
@@ -6845,10 +6847,11 @@ class McpPromptGetTask extends Task23 {
   }
   async execute(input2, context) {
     await this.discoverSchemas(context.signal);
-    const { client } = await mcpClientFactory2.create(this.config, context.signal);
+    const { mcpClientFactory } = getMcpTaskDeps();
+    const { client } = await mcpClientFactory.create(this.config, context.signal);
     try {
       const result = await client.getPrompt({
-        name: this.config.prompt_name,
+        name: String(this.config.prompt_name ?? ""),
         arguments: input2
       });
       return {
@@ -6871,29 +6874,6 @@ import {
   TaskConfigSchema as TaskConfigSchema6,
   Workflow as Workflow27
 } from "@workglow/task-graph";
-import {
-  mcpClientFactory as mcpClientFactory3,
-  mcpServerConfigSchema as mcpServerConfigSchema3
-} from "@workglow/util";
-var configSchema3 = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema6["properties"],
-    ...mcpServerConfigSchema3.properties,
-    resource_uri: {
-      type: "string",
-      title: "Resource URI",
-      description: "The URI of the resource to read",
-      format: "string:uri:mcp-resourceuri"
-    }
-  },
-  required: ["transport", "resource_uri"],
-  if: { properties: { transport: { const: "stdio" } }, required: ["transport"] },
-  then: { required: ["command"] },
-  else: { required: ["server_url"] },
-  allOf: mcpServerConfigSchema3.allOf,
-  additionalProperties: false
-};
 var contentItemSchema = {
   anyOf: [
     {
@@ -6920,7 +6900,7 @@ var contentItemSchema = {
     }
   ]
 };
-var inputSchema23 = {
+var inputSchema22 = {
   type: "object",
   properties: {},
   additionalProperties: false
@@ -6947,18 +6927,40 @@ class McpResourceReadTask extends Task24 {
   static cacheable = false;
   static customizable = true;
   static inputSchema() {
-    return inputSchema23;
+    return inputSchema22;
   }
   static outputSchema() {
     return outputSchema22;
   }
   static configSchema() {
-    return configSchema3;
+    const { mcpServerConfigSchema } = getMcpTaskDeps();
+    return {
+      type: "object",
+      properties: {
+        ...TaskConfigSchema6["properties"],
+        ...mcpServerConfigSchema.properties,
+        resource_uri: {
+          type: "string",
+          title: "Resource URI",
+          description: "The URI of the resource to read",
+          format: "string:uri:mcp-resourceuri"
+        }
+      },
+      required: ["transport", "resource_uri"],
+      if: { properties: { transport: { const: "stdio" } }, required: ["transport"] },
+      then: { required: ["command"] },
+      else: { required: ["server_url"] },
+      allOf: mcpServerConfigSchema.allOf,
+      additionalProperties: false
+    };
   }
   async execute(_input, context) {
-    const { client } = await mcpClientFactory3.create(this.config, context.signal);
+    const { mcpClientFactory } = getMcpTaskDeps();
+    const { client } = await mcpClientFactory.create(this.config, context.signal);
     try {
-      const result = await client.readResource({ uri: this.config.resource_uri });
+      const result = await client.readResource({
+        uri: String(this.config.resource_uri ?? "")
+      });
       return { contents: result.contents };
     } finally {
       await client.close();
@@ -6969,36 +6971,174 @@ var mcpResourceRead = async (config) => {
   return new McpResourceReadTask({}, config).run({});
 };
 Workflow27.prototype.mcpResourceRead = CreateWorkflow26(McpResourceReadTask);
-// src/task/mcp/McpToolCallTask.ts
-import {
-  CreateWorkflow as CreateWorkflow27,
-  Task as Task25,
-  TaskConfigSchema as TaskConfigSchema7,
-  Workflow as Workflow28
-} from "@workglow/task-graph";
-import {
-  mcpClientFactory as mcpClientFactory4,
-  mcpServerConfigSchema as mcpServerConfigSchema4
-} from "@workglow/util";
-var configSchema4 = {
+// src/task/mcp/McpSearchTask.ts
+import { CreateWorkflow as CreateWorkflow27, Task as Task25, Workflow as Workflow28 } from "@workglow/task-graph";
+var MCP_REGISTRY_BASE = "https://registry.modelcontextprotocol.io/v0.1";
+var McpSearchInputSchema = {
   type: "object",
   properties: {
-    ...TaskConfigSchema7["properties"],
-    ...mcpServerConfigSchema4.properties,
-    tool_name: {
+    query: {
       type: "string",
-      title: "Tool Name",
-      description: "The name of the tool to call",
-      format: "string:mcp-toolname"
+      title: "Query",
+      description: "Search query for the MCP registry"
     }
   },
-  required: ["transport", "tool_name"],
-  if: { properties: { transport: { const: "stdio" } }, required: ["transport"] },
-  then: { required: ["command"] },
-  else: { required: ["server_url"] },
-  allOf: mcpServerConfigSchema4.allOf,
+  required: ["query"],
   additionalProperties: false
 };
+var McpSearchOutputSchema = {
+  type: "object",
+  properties: {
+    results: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          label: { type: "string" },
+          description: { type: "string" },
+          config: { type: "object", additionalProperties: true }
+        },
+        required: ["id", "label", "description", "config"],
+        additionalProperties: false
+      }
+    }
+  },
+  required: ["results"],
+  additionalProperties: false
+};
+function mapMcpRegistryResult(server) {
+  const name = server.name.split("/").pop() ?? server.name;
+  if (server.remotes && server.remotes.length > 0) {
+    const remote = server.remotes[0];
+    return {
+      name,
+      transport: remote.type,
+      server_url: remote.url
+    };
+  }
+  const pkg = server.packages?.[0];
+  if (!pkg)
+    return { name };
+  let command;
+  let args;
+  switch (pkg.registryType) {
+    case "npm":
+      command = "npx";
+      args = ["-y", pkg.identifier];
+      break;
+    case "pypi":
+      command = "uvx";
+      args = [pkg.identifier];
+      break;
+    case "oci":
+      command = "docker";
+      args = ["run", "-i", "--rm", pkg.identifier];
+      break;
+    default:
+      command = pkg.identifier;
+      args = [];
+  }
+  if (pkg.runtimeArguments) {
+    for (const arg of pkg.runtimeArguments) {
+      if (arg.name)
+        args.push(arg.name);
+      if (arg.value)
+        args.push(arg.value);
+    }
+  }
+  const result = {
+    name,
+    transport: "stdio",
+    command,
+    args
+  };
+  if (pkg.environmentVariables && pkg.environmentVariables.length > 0) {
+    const env = {};
+    for (const envVar of pkg.environmentVariables) {
+      env[envVar.name] = "";
+    }
+    result.env = env;
+  }
+  return result;
+}
+function mapRegistryServersToResults(servers) {
+  return (servers ?? []).map((entry) => {
+    const s = entry.server;
+    const pkg = s.packages?.[0];
+    const remote = s.remotes?.[0];
+    const badges = [pkg?.registryType, pkg?.transport?.type ?? remote?.type].filter(Boolean).join(" | ");
+    return {
+      id: `${s.name}:${s.version}`,
+      label: `${s.title ?? s.name}${badges ? `  ${badges}` : ""}`,
+      description: s.description,
+      config: mapMcpRegistryResult(s)
+    };
+  });
+}
+async function searchMcpRegistryPage(query, options2) {
+  const params = new URLSearchParams({
+    search: query,
+    limit: "100",
+    version: "latest"
+  });
+  if (options2?.cursor) {
+    params.set("cursor", options2.cursor);
+  }
+  const res = await fetch(`${MCP_REGISTRY_BASE}/servers?${params}`, {
+    signal: options2?.signal
+  });
+  if (!res.ok) {
+    let detail = `Registry returned ${res.status}`;
+    try {
+      const errBody = await res.json();
+      if (typeof errBody.detail === "string") {
+        detail = `${detail}: ${errBody.detail}`;
+      } else if (Array.isArray(errBody.errors) && errBody.errors.length > 0) {
+        detail = `${detail}: ${errBody.errors.map((e) => e.message).filter(Boolean).join("; ")}`;
+      }
+    } catch {}
+    throw new Error(detail);
+  }
+  const data = await res.json();
+  return {
+    results: mapRegistryServersToResults(data.servers),
+    nextCursor: data.metadata?.nextCursor
+  };
+}
+async function searchMcpRegistry(query, signal) {
+  const page = await searchMcpRegistryPage(query, { signal });
+  return page.results;
+}
+
+class McpSearchTask extends Task25 {
+  static type = "McpSearchTask";
+  static category = "MCP";
+  static title = "MCP Search";
+  static description = "Search the MCP server registry for servers matching a query";
+  static cacheable = false;
+  static inputSchema() {
+    return McpSearchInputSchema;
+  }
+  static outputSchema() {
+    return McpSearchOutputSchema;
+  }
+  async execute(input2, context) {
+    const results = await searchMcpRegistry(input2.query, context.signal);
+    return { results };
+  }
+}
+var mcpSearch = (input2, config) => {
+  return new McpSearchTask({}, config).run(input2);
+};
+Workflow28.prototype.mcpSearch = CreateWorkflow27(McpSearchTask);
+// src/task/mcp/McpToolCallTask.ts
+import {
+  CreateWorkflow as CreateWorkflow28,
+  Task as Task26,
+  TaskConfigSchema as TaskConfigSchema7,
+  Workflow as Workflow29
+} from "@workglow/task-graph";
 var annotationsSchema2 = {
   type: "object",
   properties: {
@@ -7124,7 +7264,7 @@ var fallbackInputSchema2 = {
   additionalProperties: true
 };
 
-class McpToolCallTask extends Task25 {
+class McpToolCallTask extends Task26 {
   static type = "McpToolCallTask";
   static category = "MCP";
   static title = "MCP Call Tool";
@@ -7139,7 +7279,26 @@ class McpToolCallTask extends Task25 {
     return fallbackOutputSchema2;
   }
   static configSchema() {
-    return configSchema4;
+    const { mcpServerConfigSchema } = getMcpTaskDeps();
+    return {
+      type: "object",
+      properties: {
+        ...TaskConfigSchema7["properties"],
+        ...mcpServerConfigSchema.properties,
+        tool_name: {
+          type: "string",
+          title: "Tool Name",
+          description: "The name of the tool to call",
+          format: "string:mcp-toolname"
+        }
+      },
+      required: ["transport", "tool_name"],
+      if: { properties: { transport: { const: "stdio" } }, required: ["transport"] },
+      then: { required: ["command"] },
+      else: { required: ["server_url"] },
+      allOf: mcpServerConfigSchema.allOf,
+      additionalProperties: false
+    };
   }
   inputSchema() {
     return this.config?.inputSchema ?? fallbackInputSchema2;
@@ -7181,10 +7340,11 @@ class McpToolCallTask extends Task25 {
   }
   async execute(input2, context) {
     await this.discoverSchemas(context.signal);
-    const { client } = await mcpClientFactory4.create(this.config, context.signal);
+    const { mcpClientFactory } = getMcpTaskDeps();
+    const { client } = await mcpClientFactory.create(this.config, context.signal);
     try {
       const result = await client.callTool({
-        name: this.config.tool_name,
+        name: String(this.config.tool_name ?? ""),
         arguments: input2
       });
       if (!("content" in result) || !Array.isArray(result.content)) {
@@ -7223,14 +7383,14 @@ class McpToolCallTask extends Task25 {
 var mcpToolCall = async (input2, config) => {
   return new McpToolCallTask({}, config).run(input2);
 };
-Workflow28.prototype.mcpToolCall = CreateWorkflow27(McpToolCallTask);
+Workflow29.prototype.mcpToolCall = CreateWorkflow28(McpToolCallTask);
 // src/task/string/StringConcatTask.ts
 import {
-  CreateWorkflow as CreateWorkflow28,
-  Task as Task26,
-  Workflow as Workflow29
+  CreateWorkflow as CreateWorkflow29,
+  Task as Task27,
+  Workflow as Workflow30
 } from "@workglow/task-graph";
-var inputSchema24 = {
+var inputSchema23 = {
   type: "object",
   properties: {},
   additionalProperties: { type: "string" }
@@ -7248,13 +7408,13 @@ var outputSchema23 = {
   additionalProperties: false
 };
 
-class StringConcatTask extends Task26 {
+class StringConcatTask extends Task27 {
   static type = "StringConcatTask";
   static category = "String";
   static title = "Concat";
   static description = "Concatenates all input strings";
   static inputSchema() {
-    return inputSchema24;
+    return inputSchema23;
   }
   static outputSchema() {
     return outputSchema23;
@@ -7263,14 +7423,14 @@ class StringConcatTask extends Task26 {
     return { result: Object.values(input2).join("") };
   }
 }
-Workflow29.prototype.stringConcat = CreateWorkflow28(StringConcatTask);
+Workflow30.prototype.stringConcat = CreateWorkflow29(StringConcatTask);
 // src/task/string/StringIncludesTask.ts
 import {
-  CreateWorkflow as CreateWorkflow29,
-  Task as Task27,
-  Workflow as Workflow30
+  CreateWorkflow as CreateWorkflow30,
+  Task as Task28,
+  Workflow as Workflow31
 } from "@workglow/task-graph";
-var inputSchema25 = {
+var inputSchema24 = {
   type: "object",
   properties: {
     value: {
@@ -7300,13 +7460,13 @@ var outputSchema24 = {
   additionalProperties: false
 };
 
-class StringIncludesTask extends Task27 {
+class StringIncludesTask extends Task28 {
   static type = "StringIncludesTask";
   static category = "String";
   static title = "Includes";
   static description = "Checks if a string contains a substring";
   static inputSchema() {
-    return inputSchema25;
+    return inputSchema24;
   }
   static outputSchema() {
     return outputSchema24;
@@ -7315,14 +7475,14 @@ class StringIncludesTask extends Task27 {
     return { result: input2.value.includes(input2.search) };
   }
 }
-Workflow30.prototype.stringIncludes = CreateWorkflow29(StringIncludesTask);
+Workflow31.prototype.stringIncludes = CreateWorkflow30(StringIncludesTask);
 // src/task/string/StringJoinTask.ts
 import {
-  CreateWorkflow as CreateWorkflow30,
-  Task as Task28,
-  Workflow as Workflow31
+  CreateWorkflow as CreateWorkflow31,
+  Task as Task29,
+  Workflow as Workflow32
 } from "@workglow/task-graph";
-var inputSchema26 = {
+var inputSchema25 = {
   type: "object",
   properties: {
     values: {
@@ -7354,13 +7514,13 @@ var outputSchema25 = {
   additionalProperties: false
 };
 
-class StringJoinTask extends Task28 {
+class StringJoinTask extends Task29 {
   static type = "StringJoinTask";
   static category = "String";
   static title = "Join";
   static description = "Joins an array of strings with a separator";
   static inputSchema() {
-    return inputSchema26;
+    return inputSchema25;
   }
   static outputSchema() {
     return outputSchema25;
@@ -7370,14 +7530,14 @@ class StringJoinTask extends Task28 {
     return { result: input2.values.join(separator) };
   }
 }
-Workflow31.prototype.stringJoin = CreateWorkflow30(StringJoinTask);
+Workflow32.prototype.stringJoin = CreateWorkflow31(StringJoinTask);
 // src/task/string/StringLengthTask.ts
 import {
-  CreateWorkflow as CreateWorkflow31,
-  Task as Task29,
-  Workflow as Workflow32
+  CreateWorkflow as CreateWorkflow32,
+  Task as Task30,
+  Workflow as Workflow33
 } from "@workglow/task-graph";
-var inputSchema27 = {
+var inputSchema26 = {
   type: "object",
   properties: {
     value: {
@@ -7402,13 +7562,13 @@ var outputSchema26 = {
   additionalProperties: false
 };
 
-class StringLengthTask extends Task29 {
+class StringLengthTask extends Task30 {
   static type = "StringLengthTask";
   static category = "String";
   static title = "Length";
   static description = "Returns the length of a string";
   static inputSchema() {
-    return inputSchema27;
+    return inputSchema26;
   }
   static outputSchema() {
     return outputSchema26;
@@ -7417,14 +7577,14 @@ class StringLengthTask extends Task29 {
     return { result: input2.value.length };
   }
 }
-Workflow32.prototype.stringLength = CreateWorkflow31(StringLengthTask);
+Workflow33.prototype.stringLength = CreateWorkflow32(StringLengthTask);
 // src/task/string/StringLowerCaseTask.ts
 import {
-  CreateWorkflow as CreateWorkflow32,
-  Task as Task30,
-  Workflow as Workflow33
+  CreateWorkflow as CreateWorkflow33,
+  Task as Task31,
+  Workflow as Workflow34
 } from "@workglow/task-graph";
-var inputSchema28 = {
+var inputSchema27 = {
   type: "object",
   properties: {
     value: {
@@ -7449,13 +7609,13 @@ var outputSchema27 = {
   additionalProperties: false
 };
 
-class StringLowerCaseTask extends Task30 {
+class StringLowerCaseTask extends Task31 {
   static type = "StringLowerCaseTask";
   static category = "String";
   static title = "Lower Case";
   static description = "Converts a string to lower case";
   static inputSchema() {
-    return inputSchema28;
+    return inputSchema27;
   }
   static outputSchema() {
     return outputSchema27;
@@ -7464,14 +7624,14 @@ class StringLowerCaseTask extends Task30 {
     return { result: input2.value.toLowerCase() };
   }
 }
-Workflow33.prototype.stringLowerCase = CreateWorkflow32(StringLowerCaseTask);
+Workflow34.prototype.stringLowerCase = CreateWorkflow33(StringLowerCaseTask);
 // src/task/string/StringReplaceTask.ts
 import {
-  CreateWorkflow as CreateWorkflow33,
-  Task as Task31,
-  Workflow as Workflow34
+  CreateWorkflow as CreateWorkflow34,
+  Task as Task32,
+  Workflow as Workflow35
 } from "@workglow/task-graph";
-var inputSchema29 = {
+var inputSchema28 = {
   type: "object",
   properties: {
     value: {
@@ -7506,13 +7666,13 @@ var outputSchema28 = {
   additionalProperties: false
 };
 
-class StringReplaceTask extends Task31 {
+class StringReplaceTask extends Task32 {
   static type = "StringReplaceTask";
   static category = "String";
   static title = "Replace";
   static description = "Replaces all occurrences of a substring";
   static inputSchema() {
-    return inputSchema29;
+    return inputSchema28;
   }
   static outputSchema() {
     return outputSchema28;
@@ -7521,14 +7681,14 @@ class StringReplaceTask extends Task31 {
     return { result: input2.value.replaceAll(input2.search, input2.replace) };
   }
 }
-Workflow34.prototype.stringReplace = CreateWorkflow33(StringReplaceTask);
+Workflow35.prototype.stringReplace = CreateWorkflow34(StringReplaceTask);
 // src/task/string/StringSliceTask.ts
 import {
-  CreateWorkflow as CreateWorkflow34,
-  Task as Task32,
-  Workflow as Workflow35
+  CreateWorkflow as CreateWorkflow35,
+  Task as Task33,
+  Workflow as Workflow36
 } from "@workglow/task-graph";
-var inputSchema30 = {
+var inputSchema29 = {
   type: "object",
   properties: {
     value: {
@@ -7563,13 +7723,13 @@ var outputSchema29 = {
   additionalProperties: false
 };
 
-class StringSliceTask extends Task32 {
+class StringSliceTask extends Task33 {
   static type = "StringSliceTask";
   static category = "String";
   static title = "Slice";
   static description = "Extracts a substring by start and optional end index";
   static inputSchema() {
-    return inputSchema30;
+    return inputSchema29;
   }
   static outputSchema() {
     return outputSchema29;
@@ -7578,14 +7738,14 @@ class StringSliceTask extends Task32 {
     return { result: input2.value.slice(input2.start, input2.end) };
   }
 }
-Workflow35.prototype.stringSlice = CreateWorkflow34(StringSliceTask);
+Workflow36.prototype.stringSlice = CreateWorkflow35(StringSliceTask);
 // src/task/string/StringTemplateTask.ts
 import {
-  CreateWorkflow as CreateWorkflow35,
-  Task as Task33,
-  Workflow as Workflow36
+  CreateWorkflow as CreateWorkflow36,
+  Task as Task34,
+  Workflow as Workflow37
 } from "@workglow/task-graph";
-var inputSchema31 = {
+var inputSchema30 = {
   type: "object",
   properties: {
     template: {
@@ -7616,13 +7776,13 @@ var outputSchema30 = {
   additionalProperties: false
 };
 
-class StringTemplateTask extends Task33 {
+class StringTemplateTask extends Task34 {
   static type = "StringTemplateTask";
   static category = "String";
   static title = "Template";
   static description = "Replaces {{key}} placeholders in a template string with values";
   static inputSchema() {
-    return inputSchema31;
+    return inputSchema30;
   }
   static outputSchema() {
     return outputSchema30;
@@ -7635,14 +7795,14 @@ class StringTemplateTask extends Task33 {
     return { result };
   }
 }
-Workflow36.prototype.stringTemplate = CreateWorkflow35(StringTemplateTask);
+Workflow37.prototype.stringTemplate = CreateWorkflow36(StringTemplateTask);
 // src/task/string/StringTrimTask.ts
 import {
-  CreateWorkflow as CreateWorkflow36,
-  Task as Task34,
-  Workflow as Workflow37
+  CreateWorkflow as CreateWorkflow37,
+  Task as Task35,
+  Workflow as Workflow38
 } from "@workglow/task-graph";
-var inputSchema32 = {
+var inputSchema31 = {
   type: "object",
   properties: {
     value: {
@@ -7667,13 +7827,13 @@ var outputSchema31 = {
   additionalProperties: false
 };
 
-class StringTrimTask extends Task34 {
+class StringTrimTask extends Task35 {
   static type = "StringTrimTask";
   static category = "String";
   static title = "Trim";
   static description = "Removes leading and trailing whitespace from a string";
   static inputSchema() {
-    return inputSchema32;
+    return inputSchema31;
   }
   static outputSchema() {
     return outputSchema31;
@@ -7682,14 +7842,14 @@ class StringTrimTask extends Task34 {
     return { result: input2.value.trim() };
   }
 }
-Workflow37.prototype.stringTrim = CreateWorkflow36(StringTrimTask);
+Workflow38.prototype.stringTrim = CreateWorkflow37(StringTrimTask);
 // src/task/string/StringUpperCaseTask.ts
 import {
-  CreateWorkflow as CreateWorkflow37,
-  Task as Task35,
-  Workflow as Workflow38
+  CreateWorkflow as CreateWorkflow38,
+  Task as Task36,
+  Workflow as Workflow39
 } from "@workglow/task-graph";
-var inputSchema33 = {
+var inputSchema32 = {
   type: "object",
   properties: {
     value: {
@@ -7714,13 +7874,13 @@ var outputSchema32 = {
   additionalProperties: false
 };
 
-class StringUpperCaseTask extends Task35 {
+class StringUpperCaseTask extends Task36 {
   static type = "StringUpperCaseTask";
   static category = "String";
   static title = "Upper Case";
   static description = "Converts a string to upper case";
   static inputSchema() {
-    return inputSchema33;
+    return inputSchema32;
   }
   static outputSchema() {
     return outputSchema32;
@@ -7729,10 +7889,10 @@ class StringUpperCaseTask extends Task35 {
     return { result: input2.value.toUpperCase() };
   }
 }
-Workflow38.prototype.stringUpperCase = CreateWorkflow37(StringUpperCaseTask);
+Workflow39.prototype.stringUpperCase = CreateWorkflow38(StringUpperCaseTask);
 // src/task/scalar/ScalarAbsTask.ts
-import { CreateWorkflow as CreateWorkflow38, Task as Task36, Workflow as Workflow39 } from "@workglow/task-graph";
-var inputSchema34 = {
+import { CreateWorkflow as CreateWorkflow39, Task as Task37, Workflow as Workflow40 } from "@workglow/task-graph";
+var inputSchema33 = {
   type: "object",
   properties: {
     value: {
@@ -7757,13 +7917,13 @@ var outputSchema33 = {
   additionalProperties: false
 };
 
-class ScalarAbsTask extends Task36 {
+class ScalarAbsTask extends Task37 {
   static type = "ScalarAbsTask";
   static category = "Math";
   static title = "Abs";
   static description = "Returns the absolute value of a number";
   static inputSchema() {
-    return inputSchema34;
+    return inputSchema33;
   }
   static outputSchema() {
     return outputSchema33;
@@ -7772,10 +7932,10 @@ class ScalarAbsTask extends Task36 {
     return { result: Math.abs(input2.value) };
   }
 }
-Workflow39.prototype.scalarAbs = CreateWorkflow38(ScalarAbsTask);
+Workflow40.prototype.scalarAbs = CreateWorkflow39(ScalarAbsTask);
 // src/task/scalar/ScalarCeilTask.ts
-import { CreateWorkflow as CreateWorkflow39, Task as Task37, Workflow as Workflow40 } from "@workglow/task-graph";
-var inputSchema35 = {
+import { CreateWorkflow as CreateWorkflow40, Task as Task38, Workflow as Workflow41 } from "@workglow/task-graph";
+var inputSchema34 = {
   type: "object",
   properties: {
     value: {
@@ -7800,13 +7960,13 @@ var outputSchema34 = {
   additionalProperties: false
 };
 
-class ScalarCeilTask extends Task37 {
+class ScalarCeilTask extends Task38 {
   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 inputSchema35;
+    return inputSchema34;
   }
   static outputSchema() {
     return outputSchema34;
@@ -7815,10 +7975,10 @@ class ScalarCeilTask extends Task37 {
     return { result: Math.ceil(input2.value) };
   }
 }
-Workflow40.prototype.scalarCeil = CreateWorkflow39(ScalarCeilTask);
+Workflow41.prototype.scalarCeil = CreateWorkflow40(ScalarCeilTask);
 // src/task/scalar/ScalarFloorTask.ts
-import { CreateWorkflow as CreateWorkflow40, Task as Task38, Workflow as Workflow41 } from "@workglow/task-graph";
-var inputSchema36 = {
+import { CreateWorkflow as CreateWorkflow41, Task as Task39, Workflow as Workflow42 } from "@workglow/task-graph";
+var inputSchema35 = {
   type: "object",
   properties: {
     value: {
@@ -7843,13 +8003,13 @@ var outputSchema35 = {
   additionalProperties: false
 };
 
-class ScalarFloorTask extends Task38 {
+class ScalarFloorTask extends Task39 {
   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 inputSchema36;
+    return inputSchema35;
   }
   static outputSchema() {
     return outputSchema35;
@@ -7858,10 +8018,10 @@ class ScalarFloorTask extends Task38 {
     return { result: Math.floor(input2.value) };
   }
 }
-Workflow41.prototype.scalarFloor = CreateWorkflow40(ScalarFloorTask);
+Workflow42.prototype.scalarFloor = CreateWorkflow41(ScalarFloorTask);
 // src/task/scalar/ScalarMaxTask.ts
-import { CreateWorkflow as CreateWorkflow41, Task as Task39, Workflow as Workflow42 } from "@workglow/task-graph";
-var inputSchema37 = {
+import { CreateWorkflow as CreateWorkflow42, Task as Task40, Workflow as Workflow43 } from "@workglow/task-graph";
+var inputSchema36 = {
   type: "object",
   properties: {
     values: {
@@ -7887,13 +8047,13 @@ var outputSchema36 = {
   additionalProperties: false
 };
 
-class ScalarMaxTask extends Task39 {
+class ScalarMaxTask extends Task40 {
   static type = "ScalarMaxTask";
   static category = "Math";
   static title = "Max";
   static description = "Returns the largest of the given numbers";
   static inputSchema() {
-    return inputSchema37;
+    return inputSchema36;
   }
   static outputSchema() {
     return outputSchema36;
@@ -7902,10 +8062,10 @@ class ScalarMaxTask extends Task39 {
     return { result: Math.max(...input2.values) };
   }
 }
-Workflow42.prototype.scalarMax = CreateWorkflow41(ScalarMaxTask);
+Workflow43.prototype.scalarMax = CreateWorkflow42(ScalarMaxTask);
 // src/task/scalar/ScalarMinTask.ts
-import { CreateWorkflow as CreateWorkflow42, Task as Task40, Workflow as Workflow43 } from "@workglow/task-graph";
-var inputSchema38 = {
+import { CreateWorkflow as CreateWorkflow43, Task as Task41, Workflow as Workflow44 } from "@workglow/task-graph";
+var inputSchema37 = {
   type: "object",
   properties: {
     values: {
@@ -7931,13 +8091,13 @@ var outputSchema37 = {
   additionalProperties: false
 };
 
-class ScalarMinTask extends Task40 {
+class ScalarMinTask extends Task41 {
   static type = "ScalarMinTask";
   static category = "Math";
   static title = "Min";
   static description = "Returns the smallest of the given numbers";
   static inputSchema() {
-    return inputSchema38;
+    return inputSchema37;
   }
   static outputSchema() {
     return outputSchema37;
@@ -7946,10 +8106,10 @@ class ScalarMinTask extends Task40 {
     return { result: Math.min(...input2.values) };
   }
 }
-Workflow43.prototype.scalarMin = CreateWorkflow42(ScalarMinTask);
+Workflow44.prototype.scalarMin = CreateWorkflow43(ScalarMinTask);
 // src/task/scalar/ScalarRoundTask.ts
-import { CreateWorkflow as CreateWorkflow43, Task as Task41, Workflow as Workflow44 } from "@workglow/task-graph";
-var inputSchema39 = {
+import { CreateWorkflow as CreateWorkflow44, Task as Task42, Workflow as Workflow45 } from "@workglow/task-graph";
+var inputSchema38 = {
   type: "object",
   properties: {
     value: {
@@ -7974,13 +8134,13 @@ var outputSchema38 = {
   additionalProperties: false
 };
 
-class ScalarRoundTask extends Task41 {
+class ScalarRoundTask extends Task42 {
   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 inputSchema39;
+    return inputSchema38;
   }
   static outputSchema() {
     return outputSchema38;
@@ -7989,10 +8149,10 @@ class ScalarRoundTask extends Task41 {
     return { result: Math.round(input2.value) };
   }
 }
-Workflow44.prototype.scalarRound = CreateWorkflow43(ScalarRoundTask);
+Workflow45.prototype.scalarRound = CreateWorkflow44(ScalarRoundTask);
 // src/task/scalar/ScalarTruncTask.ts
-import { CreateWorkflow as CreateWorkflow44, Task as Task42, Workflow as Workflow45 } from "@workglow/task-graph";
-var inputSchema40 = {
+import { CreateWorkflow as CreateWorkflow45, Task as Task43, Workflow as Workflow46 } from "@workglow/task-graph";
+var inputSchema39 = {
   type: "object",
   properties: {
     value: {
@@ -8017,13 +8177,13 @@ var outputSchema39 = {
   additionalProperties: false
 };
 
-class ScalarTruncTask extends Task42 {
+class ScalarTruncTask extends Task43 {
   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 inputSchema40;
+    return inputSchema39;
   }
   static outputSchema() {
     return outputSchema39;
@@ -8032,13 +8192,13 @@ class ScalarTruncTask extends Task42 {
     return { result: Math.trunc(input2.value) };
   }
 }
-Workflow45.prototype.scalarTrunc = CreateWorkflow44(ScalarTruncTask);
+Workflow46.prototype.scalarTrunc = CreateWorkflow45(ScalarTruncTask);
 // src/task/vector/VectorDistanceTask.ts
-import { CreateWorkflow as CreateWorkflow45, Task as Task43, Workflow as Workflow46 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow46, Task as Task44, Workflow as Workflow47 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema5
 } from "@workglow/util";
-var inputSchema41 = {
+var inputSchema40 = {
   type: "object",
   properties: {
     vectors: {
@@ -8067,13 +8227,13 @@ var outputSchema40 = {
   additionalProperties: false
 };
 
-class VectorDistanceTask extends Task43 {
+class VectorDistanceTask extends Task44 {
   static type = "VectorDistanceTask";
   static category = "Vector";
   static title = "Distance";
   static description = "Returns the Euclidean distance between the first two vectors";
   static inputSchema() {
-    return inputSchema41;
+    return inputSchema40;
   }
   static outputSchema() {
     return outputSchema40;
@@ -8094,13 +8254,13 @@ class VectorDistanceTask extends Task43 {
     return { result: Math.sqrt(sumPrecise(diffs)) };
   }
 }
-Workflow46.prototype.vectorDistance = CreateWorkflow45(VectorDistanceTask);
+Workflow47.prototype.vectorDistance = CreateWorkflow46(VectorDistanceTask);
 // src/task/vector/VectorDotProductTask.ts
-import { CreateWorkflow as CreateWorkflow46, Task as Task44, Workflow as Workflow47 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow47, Task as Task45, Workflow as Workflow48 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema6
 } from "@workglow/util";
-var inputSchema42 = {
+var inputSchema41 = {
   type: "object",
   properties: {
     vectors: {
@@ -8129,13 +8289,13 @@ var outputSchema41 = {
   additionalProperties: false
 };
 
-class VectorDotProductTask extends Task44 {
+class VectorDotProductTask extends Task45 {
   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 inputSchema42;
+    return inputSchema41;
   }
   static outputSchema() {
     return outputSchema41;
@@ -8153,14 +8313,14 @@ class VectorDotProductTask extends Task44 {
     return { result: sumPrecise(products) };
   }
 }
-Workflow47.prototype.vectorDotProduct = CreateWorkflow46(VectorDotProductTask);
+Workflow48.prototype.vectorDotProduct = CreateWorkflow47(VectorDotProductTask);
 // src/task/vector/VectorNormalizeTask.ts
-import { CreateWorkflow as CreateWorkflow47, Task as Task45, Workflow as Workflow48 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow48, Task as Task46, Workflow as Workflow49 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema7,
   normalize
 } from "@workglow/util";
-var inputSchema43 = {
+var inputSchema42 = {
   type: "object",
   properties: {
     vector: TypedArraySchema7({
@@ -8183,13 +8343,13 @@ var outputSchema42 = {
   additionalProperties: false
 };
 
-class VectorNormalizeTask extends Task45 {
+class VectorNormalizeTask extends Task46 {
   static type = "VectorNormalizeTask";
   static category = "Vector";
   static title = "Normalize";
   static description = "Returns the L2-normalized (unit length) vector";
   static inputSchema() {
-    return inputSchema43;
+    return inputSchema42;
   }
   static outputSchema() {
     return outputSchema42;
@@ -8198,14 +8358,14 @@ class VectorNormalizeTask extends Task45 {
     return { result: normalize(input2.vector) };
   }
 }
-Workflow48.prototype.vectorNormalize = CreateWorkflow47(VectorNormalizeTask);
+Workflow49.prototype.vectorNormalize = CreateWorkflow48(VectorNormalizeTask);
 // src/task/vector/VectorScaleTask.ts
-import { CreateWorkflow as CreateWorkflow48, Task as Task46, Workflow as Workflow49 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow49, Task as Task47, Workflow as Workflow50 } from "@workglow/task-graph";
 import {
   createTypedArrayFrom as createTypedArrayFrom5,
   TypedArraySchema as TypedArraySchema8
 } from "@workglow/util";
-var inputSchema44 = {
+var inputSchema43 = {
   type: "object",
   properties: {
     vector: TypedArraySchema8({
@@ -8233,13 +8393,13 @@ var outputSchema43 = {
   additionalProperties: false
 };
 
-class VectorScaleTask extends Task46 {
+class VectorScaleTask extends Task47 {
   static type = "VectorScaleTask";
   static category = "Vector";
   static title = "Scale";
   static description = "Multiplies each element of a vector by a scalar";
   static inputSchema() {
-    return inputSchema44;
+    return inputSchema43;
   }
   static outputSchema() {
     return outputSchema43;
@@ -8250,7 +8410,7 @@ class VectorScaleTask extends Task46 {
     return { result: createTypedArrayFrom5([vector], values) };
   }
 }
-Workflow49.prototype.vectorScale = CreateWorkflow48(VectorScaleTask);
+Workflow50.prototype.vectorScale = CreateWorkflow49(VectorScaleTask);
 
 // src/common.ts
 import { TaskRegistry } from "@workglow/task-graph";
@@ -8289,6 +8449,7 @@ var registerCommonTasks = () => {
     McpToolCallTask,
     McpResourceReadTask,
     McpPromptGetTask,
+    McpSearchTask,
     McpListTask,
     StringConcatTask,
     StringIncludesTask,
@@ -8308,24 +8469,646 @@ var registerCommonTasks = () => {
   tasks.map(TaskRegistry.registerTask);
   return tasks;
 };
+// src/util/McpAuthTypes.ts
+var mcpAuthTypes = [
+  "none",
+  "bearer",
+  "client_credentials",
+  "private_key_jwt",
+  "static_private_key_jwt",
+  "authorization_code"
+];
+var mcpAuthConfigSchema = {
+  properties: {
+    auth_type: {
+      type: "string",
+      enum: mcpAuthTypes,
+      title: "Auth Type",
+      description: "Authentication method for connecting to the MCP server",
+      default: "none"
+    },
+    auth_token: {
+      type: "string",
+      format: "credential",
+      title: "Bearer Token",
+      description: "Static bearer token or API key (for bearer auth)"
+    },
+    auth_client_id: {
+      type: "string",
+      title: "Client ID",
+      description: "OAuth client ID (for OAuth auth types)"
+    },
+    auth_client_secret: {
+      type: "string",
+      format: "credential",
+      title: "Client Secret",
+      description: "OAuth client secret (for client_credentials auth)"
+    },
+    auth_private_key: {
+      type: "string",
+      format: "credential",
+      title: "Private Key",
+      description: "PEM or JWK private key (for private_key_jwt auth)"
+    },
+    auth_algorithm: {
+      type: "string",
+      title: "Algorithm",
+      description: "JWT signing algorithm, e.g. RS256, ES256 (for private_key_jwt auth)"
+    },
+    auth_jwt_bearer_assertion: {
+      type: "string",
+      format: "credential",
+      title: "JWT Assertion",
+      description: "Pre-built JWT assertion (for static_private_key_jwt auth)"
+    },
+    auth_redirect_url: {
+      type: "string",
+      format: "uri",
+      title: "Redirect URL",
+      description: "OAuth redirect URL (for authorization_code auth)"
+    },
+    auth_scope: {
+      type: "string",
+      title: "Scope",
+      description: "OAuth scope (space-separated)"
+    },
+    auth_client_name: {
+      type: "string",
+      title: "Client Name",
+      description: "Optional OAuth client display name"
+    },
+    auth_jwt_lifetime_seconds: {
+      type: "number",
+      title: "JWT Lifetime",
+      description: "JWT lifetime in seconds (default: 300)",
+      minimum: 1
+    }
+  },
+  allOf: [
+    {
+      if: { properties: { auth_type: { const: "bearer" } }, required: ["auth_type"] },
+      then: {
+        required: ["auth_token"],
+        properties: { auth_token: true }
+      }
+    },
+    {
+      if: {
+        properties: { auth_type: { const: "client_credentials" } },
+        required: ["auth_type"]
+      },
+      then: {
+        required: ["auth_client_id", "auth_client_secret"],
+        properties: {
+          auth_client_id: true,
+          auth_client_secret: true,
+          auth_client_name: true,
+          auth_scope: true
+        }
+      }
+    },
+    {
+      if: { properties: { auth_type: { const: "private_key_jwt" } }, required: ["auth_type"] },
+      then: {
+        required: ["auth_client_id", "auth_private_key", "auth_algorithm"],
+        properties: {
+          auth_client_id: true,
+          auth_private_key: true,
+          auth_algorithm: true,
+          auth_client_name: true,
+          auth_jwt_lifetime_seconds: true,
+          auth_scope: true
+        }
+      }
+    },
+    {
+      if: {
+        properties: { auth_type: { const: "static_private_key_jwt" } },
+        required: ["auth_type"]
+      },
+      then: {
+        required: ["auth_client_id", "auth_jwt_bearer_assertion"],
+        properties: {
+          auth_client_id: true,
+          auth_jwt_bearer_assertion: true,
+          auth_client_name: true,
+          auth_scope: true
+        }
+      }
+    },
+    {
+      if: { properties: { auth_type: { const: "authorization_code" } }, required: ["auth_type"] },
+      then: {
+        required: ["auth_client_id", "auth_redirect_url"],
+        properties: {
+          auth_client_id: true,
+          auth_client_secret: true,
+          auth_redirect_url: true,
+          auth_scope: true
+        }
+      }
+    }
+  ]
+};
+function isMcpAuthType(value) {
+  return typeof value === "string" && mcpAuthTypes.includes(value);
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed === "" ? undefined : trimmed;
+}
+function asNumber(value) {
+  return typeof value === "number" ? value : undefined;
+}
+function buildAuthConfig(flat) {
+  const rawAuthType = flat.auth_type;
+  if (!isMcpAuthType(rawAuthType) || rawAuthType === "none") {
+    return;
+  }
+  const authType = rawAuthType;
+  switch (authType) {
+    case "bearer": {
+      const token = asNonEmptyString(flat.auth_token);
+      if (!token)
+        return;
+      return { type: "bearer", token };
+    }
+    case "client_credentials": {
+      const client_id = asNonEmptyString(flat.auth_client_id);
+      const client_secret = asNonEmptyString(flat.auth_client_secret);
+      if (!client_id || !client_secret)
+        return;
+      return {
+        type: "client_credentials",
+        client_id,
+        client_secret,
+        client_name: asNonEmptyString(flat.auth_client_name),
+        scope: asNonEmptyString(flat.auth_scope)
+      };
+    }
+    case "private_key_jwt": {
+      const client_id = asNonEmptyString(flat.auth_client_id);
+      const private_key = asNonEmptyString(flat.auth_private_key);
+      const algorithm = asNonEmptyString(flat.auth_algorithm);
+      if (!client_id || !private_key || !algorithm)
+        return;
+      return {
+        type: "private_key_jwt",
+        client_id,
+        private_key,
+        algorithm,
+        client_name: asNonEmptyString(flat.auth_client_name),
+        jwt_lifetime_seconds: asNumber(flat.auth_jwt_lifetime_seconds),
+        scope: asNonEmptyString(flat.auth_scope)
+      };
+    }
+    case "static_private_key_jwt": {
+      const client_id = asNonEmptyString(flat.auth_client_id);
+      const jwt_bearer_assertion = asNonEmptyString(flat.auth_jwt_bearer_assertion);
+      if (!client_id || !jwt_bearer_assertion)
+        return;
+      return {
+        type: "static_private_key_jwt",
+        client_id,
+        jwt_bearer_assertion,
+        client_name: asNonEmptyString(flat.auth_client_name),
+        scope: asNonEmptyString(flat.auth_scope)
+      };
+    }
+    case "authorization_code": {
+      const client_id = asNonEmptyString(flat.auth_client_id);
+      const redirect_url = asNonEmptyString(flat.auth_redirect_url);
+      if (!client_id || !redirect_url)
+        return;
+      return {
+        type: "authorization_code",
+        client_id,
+        client_secret: asNonEmptyString(flat.auth_client_secret),
+        redirect_url,
+        scope: asNonEmptyString(flat.auth_scope)
+      };
+    }
+    default:
+      return;
+  }
+}
+// src/util/McpAuthProvider.ts
+import {
+  ClientCredentialsProvider,
+  PrivateKeyJwtProvider,
+  StaticPrivateKeyJwtProvider,
+  createPrivateKeyJwtAuth
+} from "@modelcontextprotocol/sdk/client/auth-extensions.js";
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import { getGlobalCredentialStore } from "@workglow/util";
+function normalizeServerUrl(serverUrl) {
+  try {
+    const u = new URL(serverUrl);
+    return u.origin + u.pathname.replace(/\/+$/, "");
+  } catch {
+    return serverUrl;
+  }
+}
+function storeKey(serverUrl, suffix) {
+  return `mcp:oauth:${normalizeServerUrl(serverUrl)}:${suffix}`;
+}
 
+class CredentialStoreOAuthProvider {
+  store;
+  serverUrl;
+  _clientMetadata;
+  _redirectUrl;
+  _initialClientInfo;
+  prepareTokenRequest;
+  addClientAuthentication;
+  constructor(options2) {
+    this.store = options2.store;
+    this.serverUrl = options2.serverUrl;
+    this._clientMetadata = options2.clientMetadata;
+    this._redirectUrl = options2.redirectUrl;
+    this._initialClientInfo = options2.initialClientInfo;
+    if (options2.prepareTokenRequest) {
+      this.prepareTokenRequest = options2.prepareTokenRequest;
+    }
+    if (options2.addClientAuthentication) {
+      this.addClientAuthentication = options2.addClientAuthentication;
+    }
+  }
+  get redirectUrl() {
+    return this._redirectUrl;
+  }
+  get clientMetadata() {
+    return this._clientMetadata;
+  }
+  async clientInformation() {
+    const raw = await this.store.get(storeKey(this.serverUrl, "client_info"));
+    if (!raw)
+      return this._initialClientInfo;
+    return JSON.parse(raw);
+  }
+  async saveClientInformation(info) {
+    await this.store.put(storeKey(this.serverUrl, "client_info"), JSON.stringify(info));
+  }
+  async tokens() {
+    const raw = await this.store.get(storeKey(this.serverUrl, "tokens"));
+    if (!raw)
+      return;
+    return JSON.parse(raw);
+  }
+  async saveTokens(tokens) {
+    const expiresAt = tokens.expires_in != null ? new Date(Date.now() + tokens.expires_in * 1000) : undefined;
+    await this.store.put(storeKey(this.serverUrl, "tokens"), JSON.stringify(tokens), {
+      expiresAt
+    });
+  }
+  async redirectToAuthorization(authorizationUrl) {
+    throw new Error(`MCP OAuth authorization required. ` + `Open this URL to authorize: ${authorizationUrl.toString()}`);
+  }
+  async saveCodeVerifier(codeVerifier) {
+    await this.store.put(storeKey(this.serverUrl, "code_verifier"), codeVerifier);
+  }
+  async codeVerifier() {
+    const v = await this.store.get(storeKey(this.serverUrl, "code_verifier"));
+    if (!v)
+      throw new Error("No code verifier saved for this session");
+    return v;
+  }
+  async saveDiscoveryState(state) {
+    await this.store.put(storeKey(this.serverUrl, "discovery"), JSON.stringify(state));
+  }
+  async discoveryState() {
+    const raw = await this.store.get(storeKey(this.serverUrl, "discovery"));
+    if (!raw)
+      return;
+    return JSON.parse(raw);
+  }
+  async invalidateCredentials(scope) {
+    const deleteKey = async (suffix) => {
+      await this.store.delete(storeKey(this.serverUrl, suffix));
+    };
+    switch (scope) {
+      case "all":
+        await deleteKey("tokens");
+        await deleteKey("client_info");
+        await deleteKey("code_verifier");
+        await deleteKey("discovery");
+        break;
+      case "client":
+        await deleteKey("client_info");
+        break;
+      case "tokens":
+        await deleteKey("tokens");
+        break;
+      case "verifier":
+        await deleteKey("code_verifier");
+        break;
+      case "discovery":
+        await deleteKey("discovery");
+        break;
+    }
+  }
+}
+function createAuthProvider(auth, serverUrl, credentialStore) {
+  switch (auth.type) {
+    case "none":
+    case "bearer":
+      return;
+    case "client_credentials": {
+      if (!credentialStore) {
+        return new ClientCredentialsProvider({
+          clientId: auth.client_id,
+          clientSecret: auth.client_secret,
+          clientName: auth.client_name,
+          scope: auth.scope
+        });
+      }
+      const prepareTokenRequest = (scope) => {
+        const params = new URLSearchParams({ grant_type: "client_credentials" });
+        const effectiveScope = scope ?? auth.scope;
+        if (effectiveScope)
+          params.set("scope", effectiveScope);
+        return params;
+      };
+      return new CredentialStoreOAuthProvider({
+        store: credentialStore,
+        serverUrl,
+        clientMetadata: {
+          redirect_uris: [],
+          grant_types: ["client_credentials"],
+          token_endpoint_auth_method: "client_secret_basic",
+          client_name: auth.client_name
+        },
+        initialClientInfo: {
+          client_id: auth.client_id,
+          client_secret: auth.client_secret
+        },
+        prepareTokenRequest
+      });
+    }
+    case "private_key_jwt": {
+      if (!credentialStore) {
+        return new PrivateKeyJwtProvider({
+          clientId: auth.client_id,
+          privateKey: auth.private_key,
+          algorithm: auth.algorithm,
+          clientName: auth.client_name,
+          jwtLifetimeSeconds: auth.jwt_lifetime_seconds,
+          scope: auth.scope
+        });
+      }
+      const addClientAuth = createPrivateKeyJwtAuth({
+        issuer: auth.client_id,
+        subject: auth.client_id,
+        privateKey: auth.private_key,
+        alg: auth.algorithm,
+        lifetimeSeconds: auth.jwt_lifetime_seconds
+      });
+      const prepareTokenRequest = (scope) => {
+        const params = new URLSearchParams({ grant_type: "client_credentials" });
+        const effectiveScope = scope ?? auth.scope;
+        if (effectiveScope)
+          params.set("scope", effectiveScope);
+        return params;
+      };
+      return new CredentialStoreOAuthProvider({
+        store: credentialStore,
+        serverUrl,
+        clientMetadata: {
+          redirect_uris: [],
+          grant_types: ["client_credentials"],
+          token_endpoint_auth_method: "private_key_jwt",
+          client_name: auth.client_name
+        },
+        initialClientInfo: { client_id: auth.client_id },
+        prepareTokenRequest,
+        addClientAuthentication: addClientAuth
+      });
+    }
+    case "static_private_key_jwt": {
+      if (!credentialStore) {
+        return new StaticPrivateKeyJwtProvider({
+          clientId: auth.client_id,
+          jwtBearerAssertion: auth.jwt_bearer_assertion,
+          clientName: auth.client_name,
+          scope: auth.scope
+        });
+      }
+      const assertion = auth.jwt_bearer_assertion;
+      const addClientAuth = (_headers, params) => {
+        params.set("client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer");
+        params.set("client_assertion", assertion);
+      };
+      const prepareTokenRequest = (scope) => {
+        const params = new URLSearchParams({ grant_type: "client_credentials" });
+        const effectiveScope = scope ?? auth.scope;
+        if (effectiveScope)
+          params.set("scope", effectiveScope);
+        return params;
+      };
+      return new CredentialStoreOAuthProvider({
+        store: credentialStore,
+        serverUrl,
+        clientMetadata: {
+          redirect_uris: [],
+          grant_types: ["client_credentials"],
+          token_endpoint_auth_method: "private_key_jwt",
+          client_name: auth.client_name
+        },
+        initialClientInfo: { client_id: auth.client_id },
+        prepareTokenRequest,
+        addClientAuthentication: addClientAuth
+      });
+    }
+    case "authorization_code": {
+      if (!credentialStore) {
+        throw new Error("authorization_code auth requires a credential store for token persistence");
+      }
+      return new CredentialStoreOAuthProvider({
+        store: credentialStore,
+        serverUrl,
+        clientMetadata: {
+          redirect_uris: [auth.redirect_url],
+          grant_types: ["authorization_code", "refresh_token"],
+          token_endpoint_auth_method: auth.client_secret ? "client_secret_basic" : "none",
+          scope: auth.scope
+        },
+        initialClientInfo: {
+          client_id: auth.client_id,
+          ...auth.client_secret ? { client_secret: auth.client_secret } : {}
+        },
+        redirectUrl: auth.redirect_url
+      });
+    }
+    default:
+      return;
+  }
+}
+async function resolveAuthSecrets(auth, credentialStore) {
+  if (auth.type === "none")
+    return auth;
+  const store = credentialStore ?? getGlobalCredentialStore();
+  async function resolve(value) {
+    if (!value)
+      return value;
+    const resolved = await store.get(value);
+    return resolved ?? value;
+  }
+  switch (auth.type) {
+    case "bearer":
+      return { ...auth, token: await resolve(auth.token) ?? auth.token };
+    case "client_credentials":
+      return {
+        ...auth,
+        client_secret: await resolve(auth.client_secret) ?? auth.client_secret
+      };
+    case "private_key_jwt":
+      return {
+        ...auth,
+        private_key: await resolve(auth.private_key) ?? auth.private_key
+      };
+    case "static_private_key_jwt":
+      return {
+        ...auth,
+        jwt_bearer_assertion: await resolve(auth.jwt_bearer_assertion) ?? auth.jwt_bearer_assertion
+      };
+    case "authorization_code":
+      return {
+        ...auth,
+        client_secret: await resolve(auth.client_secret)
+      };
+    default:
+      return auth;
+  }
+}
+// src/util/McpClientUtil.node.ts
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { getGlobalCredentialStore as getGlobalCredentialStore2, getLogger } from "@workglow/util";
+var mcpTransportTypes = ["stdio", "sse", "streamable-http"];
+var mcpServerConfigSchema = {
+  properties: {
+    transport: {
+      type: "string",
+      enum: mcpTransportTypes,
+      title: "Transport",
+      description: "The transport type to use for connecting to the MCP server"
+    },
+    server_url: {
+      type: "string",
+      format: "string:uri",
+      title: "Server URL",
+      description: "The URL of the MCP server (for sse and streamable-http transports)"
+    },
+    command: {
+      type: "string",
+      title: "Command",
+      description: "The command to run (for stdio transport)"
+    },
+    args: {
+      type: "array",
+      items: { type: "string" },
+      title: "Arguments",
+      description: "Command arguments (for stdio transport)"
+    },
+    env: {
+      type: "object",
+      additionalProperties: { type: "string" },
+      title: "Environment",
+      description: "Environment variables (for stdio transport)"
+    },
+    ...mcpAuthConfigSchema.properties
+  },
+  allOf: [
+    {
+      if: { properties: { transport: { const: "stdio" } }, required: ["transport"] },
+      then: { required: ["command"] }
+    },
+    {
+      if: { properties: { transport: { const: "sse" } }, required: ["transport"] },
+      then: { required: ["server_url"] }
+    },
+    {
+      if: {
+        properties: { transport: { const: "streamable-http" } },
+        required: ["transport"]
+      },
+      then: { required: ["server_url"] }
+    },
+    ...mcpAuthConfigSchema.allOf
+  ]
+};
+async function createMcpClient(config, signal) {
+  const typed = config;
+  let transport;
+  let auth = typed.auth ?? buildAuthConfig({ ...typed });
+  if (auth && auth.type !== "none") {
+    auth = await resolveAuthSecrets(auth, getGlobalCredentialStore2());
+  }
+  const authProvider = typed.authProvider ?? (auth && auth.type !== "none" && auth.type !== "bearer" ? createAuthProvider(auth, typed.server_url ?? "", getGlobalCredentialStore2()) : undefined);
+  const headers = {
+    ...auth?.type === "bearer" ? { Authorization: `Bearer ${auth.token}` } : {}
+  };
+  switch (typed.transport) {
+    case "stdio":
+      if (auth && auth.type !== "none") {
+        getLogger().warn("MCP auth is not supported for stdio transport; auth config ignored. " + "Use env vars to pass credentials to stdio servers.");
+      }
+      transport = new StdioClientTransport({
+        command: typed.command,
+        args: typed.args,
+        env: typed.env
+      });
+      break;
+    case "sse": {
+      transport = new SSEClientTransport(new URL(typed.server_url), {
+        authProvider,
+        requestInit: { headers }
+      });
+      break;
+    }
+    case "streamable-http": {
+      transport = new StreamableHTTPClientTransport(new URL(typed.server_url), {
+        authProvider,
+        requestInit: { headers }
+      });
+      break;
+    }
+    default:
+      throw new Error(`Unsupported transport type: ${typed.transport}`);
+  }
+  const client = new Client({ name: "workglow-mcp-client", version: "1.0.0" });
+  if (signal) {
+    signal.addEventListener("abort", () => {
+      client.close().catch(() => {});
+    }, { once: true });
+  }
+  await client.connect(transport);
+  return { client, transport };
+}
+var mcpClientFactory = {
+  create: createMcpClient
+};
 // src/task/FileLoaderTask.server.ts
 import {
-  CreateWorkflow as CreateWorkflow50,
+  CreateWorkflow as CreateWorkflow51,
   TaskAbortedError as TaskAbortedError3,
-  Workflow as Workflow51
+  Workflow as Workflow52
 } from "@workglow/task-graph";
 import { readFile } from "fs/promises";
 
 // src/task/FileLoaderTask.ts
 import {
-  CreateWorkflow as CreateWorkflow49,
-  Task as Task47,
+  CreateWorkflow as CreateWorkflow50,
+  Task as Task48,
   TaskAbortedError as TaskAbortedError2,
-  Workflow as Workflow50
+  Workflow as Workflow51
 } from "@workglow/task-graph";
 import Papa from "papaparse";
-var inputSchema45 = {
+var inputSchema44 = {
   type: "object",
   properties: {
     url: {
@@ -8396,14 +9179,14 @@ var outputSchema44 = {
   additionalProperties: false
 };
 
-class FileLoaderTask extends Task47 {
+class FileLoaderTask extends Task48 {
   static type = "FileLoaderTask";
   static category = "Document";
   static title = "File Loader";
   static description = "Load documents from URLs (http://, https://)";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema45;
+    return inputSchema44;
   }
   static outputSchema() {
     return outputSchema44;
@@ -8759,7 +9542,7 @@ class FileLoaderTask extends Task47 {
     });
   }
 }
-Workflow50.prototype.fileLoader = CreateWorkflow49(FileLoaderTask);
+Workflow51.prototype.fileLoader = CreateWorkflow50(FileLoaderTask);
 
 // src/task/FileLoaderTask.server.ts
 class FileLoaderTask2 extends FileLoaderTask {
@@ -8948,9 +9731,10 @@ class FileLoaderTask2 extends FileLoaderTask {
 var fileLoader = (input2, config) => {
   return new FileLoaderTask2({}, config).run(input2);
 };
-Workflow51.prototype.fileLoader = CreateWorkflow50(FileLoaderTask2);
-
+Workflow52.prototype.fileLoader = CreateWorkflow51(FileLoaderTask2);
 // src/bun.ts
+import { TaskRegistry as TaskRegistry2 } from "@workglow/task-graph";
+registerMcpTaskDeps({ mcpClientFactory, mcpServerConfigSchema });
 var registerCommonTasks2 = () => {
   const tasks = registerCommonTasks();
   TaskRegistry2.registerTask(FileLoaderTask2);
@@ -8958,21 +9742,36 @@ var registerCommonTasks2 = () => {
 };
 export {
   split,
+  searchMcpRegistryPage,
+  searchMcpRegistry,
+  resolveAuthSecrets,
+  registerMcpTaskDeps,
   registerCommonTasks2 as registerCommonTasks,
   process,
   merge,
+  mcpTransportTypes,
   mcpToolCall,
+  mcpServerConfigSchema,
+  mcpSearch,
   mcpResourceRead,
   mcpPromptGet,
   mcpList,
+  mcpClientFactory,
+  mcpAuthTypes,
+  mcpAuthConfigSchema,
+  mapMcpRegistryResult,
   lambdaTaskConfigSchema,
   lambda,
   json,
   javaScript,
+  getMcpTaskDeps,
   fileLoader,
   fetchUrl,
   delay,
   debugLog,
+  createMcpClient,
+  createAuthProvider,
+  buildAuthConfig,
   VectorSumTask,
   VectorSubtractTask,
   VectorScaleTask,
@@ -8981,6 +9780,7 @@ export {
   VectorDotProductTask,
   VectorDivideTask,
   VectorDistanceTask,
+  UnauthorizedError,
   TypeReplicateArray,
   TemplateTask,
   StringUpperCaseTask,
@@ -9010,9 +9810,11 @@ export {
   OutputTask,
   MergeTask,
   McpToolCallTask,
+  McpSearchTask,
   McpResourceReadTask,
   McpPromptGetTask,
   McpListTask,
+  MCP_TASK_DEPS,
   LambdaTask,
   JsonTask,
   JsonPathTask,
@@ -9024,7 +9826,8 @@ export {
   DelayTask,
   DebugLogTask,
   DateFormatTask,
+  CredentialStoreOAuthProvider,
   ArrayTask
 };
 
-//# debugId=4ADABD0550E093CE64756E2164756E21
+//# debugId=2BCBC1FFD24282DF64756E2164756E21