@hatchet-dev/typescript-sdk 1.21.2 → 1.22.1

package/v1/agent/claude.d.ts

@@ -0,0 +1,17 @@
+import { BaseWorkflowDeclaration, InputType, OutputType } from './..';
+import type { SdkMcpToolDefinition } from '@anthropic-ai/claude-agent-sdk';
+import type { CallToolResult, ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';
+export type ClaudeToolFuncT = <I extends InputType, O extends OutputType>(runnable: BaseWorkflowDeclaration<I, O>, annotations?: ToolAnnotations) => SdkMcpToolDefinition;
+export declare const ClaudeToolFunc: <I extends InputType, O extends OutputType>(runnable: BaseWorkflowDeclaration<I, O>, annotations?: ToolAnnotations) => {
+    annotations: {
+        title?: string | undefined;
+        readOnlyHint?: boolean | undefined;
+        destructiveHint?: boolean | undefined;
+        idempotentHint?: boolean | undefined;
+        openWorldHint?: boolean | undefined;
+    } | undefined;
+    description: string;
+    handler: (args: any, _: unknown) => Promise<CallToolResult>;
+    name: string;
+    inputSchema: any;
+};

package/v1/agent/claude.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeToolFunc = void 0;
+const z = __importStar(require("zod/v4"));
+const ClaudeToolFunc = (runnable, annotations) => {
+    const hasZodV4 = '_zod' in z.string();
+    let hasClaudeAgentSdk = true;
+    try {
+        require.resolve('@anthropic-ai/claude-agent-sdk');
+    }
+    catch (_a) {
+        hasClaudeAgentSdk = false;
+    }
+    if (!hasZodV4 || !hasClaudeAgentSdk) {
+        throw new Error("To use Hatchet's Claude agent SDK integration, you must install Zod v4 and @anthropic-ai/claude-agent-sdk: npm install zod@^4.0.0 @anthropic-ai/claude-agent-sdk @modelcontextprotocol/sdk");
+    }
+    if (!runnable.definition.inputValidator) {
+        throw new Error('inputValidator must be defined');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const inputValidatorV4 = runnable.definition.inputValidator;
+    const { description } = runnable.definition;
+    if (description === undefined) {
+        throw new Error('Runnable description must be defined');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const handler = (args, _) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield runnable.run(args);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result) }],
+        };
+    });
+    return {
+        annotations: annotations,
+        description: description,
+        handler: handler,
+        name: runnable.name,
+        inputSchema: inputValidatorV4.shape,
+    };
+};
+exports.ClaudeToolFunc = ClaudeToolFunc;

package/v1/agent/openai.d.ts

@@ -0,0 +1,4 @@
+import { BaseWorkflowDeclaration, InputType, OutputType } from './..';
+import type { FunctionTool } from '@openai/agents';
+export type OpenAIToolFuncT = <I extends InputType, O extends OutputType>(runnable: BaseWorkflowDeclaration<I, O>) => FunctionTool;
+export declare const OpenAIToolFunc: <I extends InputType, O extends OutputType>(runnable: BaseWorkflowDeclaration<I, O>) => any;

package/v1/agent/openai.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIToolFunc = void 0;
+const z = __importStar(require("zod/v4"));
+const OpenAIToolFunc = (runnable) => {
+    // Check both requirements before loading @openai/agents — it crashes at load time with Zod v3.
+    // z is imported from 'zod', so '_zod' in z.string() reflects the user's actual installed version.
+    const hasZodV4 = '_zod' in z.string();
+    let hasOpenAIAgents = true;
+    try {
+        require.resolve('@openai/agents');
+    }
+    catch (_a) {
+        hasOpenAIAgents = false;
+    }
+    if (!hasZodV4 || !hasOpenAIAgents) {
+        throw new Error("To use Hatchet's OpenAI agent SDK integration, you must install Zod v4 and @openai/agents: npm install zod@^4.0.0 @openai/agents");
+    }
+    if (!runnable.definition.inputValidator) {
+        throw new Error('inputValidator must be defined');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { tool } = require('@openai/agents');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const inputValidatorV4 = runnable.definition.inputValidator;
+    const { description } = runnable.definition;
+    if (description === undefined) {
+        throw new Error('Runnable description must be defined');
+    }
+    return tool({
+        name: runnable.name,
+        description: description,
+        parameters: z.toJSONSchema(inputValidatorV4),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        execute: (input) => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield runnable.run(input);
+            return JSON.stringify(result);
+        }),
+    });
+};
+exports.OpenAIToolFunc = OpenAIToolFunc;

package/v1/client/client.js

@@ -23,7 +23,7 @@ const hatchet_client_1 = require("../../clients/hatchet-client");
 const rest_1 = __importDefault(require("../../clients/rest"));
 const config_loader_1 = require("../../util/config-loader");
 const hatchet_logger_1 = require("../../clients/hatchet-client/hatchet-logger");
-const zod_1 = require("zod");
+const v4_1 = require("zod/v4");
 const event_client_1 = require("../../clients/event/event-client");
 const dispatcher_client_1 = require("../../clients/dispatcher/dispatcher-client");
 const child_listener_client_1 = require("../../clients/listeners/run-listener/child-listener-client");
@@ -89,7 +89,7 @@ class HatchetClient {
             this._axiosConfig = axiosConfig;
         }
         catch (e) {
-            if (e instanceof zod_1.z.ZodError) {
+            if (e instanceof v4_1.z.ZodError) {
                 throw new Error(`Invalid client config: ${e.message}`, { cause: e });
             }
             throw e;

package/v1/client/features/crons.d.ts

@@ -1,5 +1,5 @@
 import { CronWorkflows, CronWorkflowsList } from '../../../clients/rest/generated/data-contracts';
-import { z } from 'zod';
+import { z } from 'zod/v4';
 import { BaseWorkflowDeclaration } from '../..';
 import type { LegacyWorkflow } from '../../../legacy/legacy-transformer';
 import { HatchetClient } from '../client';
@@ -11,22 +11,10 @@ import { WorkflowsClient } from './workflows';
 export declare const CreateCronTriggerSchema: z.ZodObject<{
     name: z.ZodString;
     expression: z.ZodString;
-    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodAny, z.ZodAny>>;
     additionalMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     priority: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    expression: string;
-    additionalMetadata?: Record<string, string> | undefined;
-    priority?: number | undefined;
-    input?: Record<string, any> | undefined;
-}, {
-    name: string;
-    expression: string;
-    additionalMetadata?: Record<string, string> | undefined;
-    priority?: number | undefined;
-    input?: Record<string, any> | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Type representing the input for creating a Cron.
  * @internal

package/v1/client/features/crons.js

@@ -21,7 +21,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CronClient = exports.CreateCronTriggerSchema = void 0;
-const zod_1 = require("zod");
+const v4_1 = require("zod/v4");
 const axios_1 = require("axios");
 const uuid_1 = require("../../../util/uuid");
 const apply_namespace_1 = require("../../../util/apply-namespace");
@@ -30,12 +30,12 @@ const workflows_1 = require("./workflows");
  * Schema for creating a Cron Trigger.
  * @internal
  */
-exports.CreateCronTriggerSchema = zod_1.z.object({
-    name: zod_1.z.string(),
-    expression: zod_1.z.string(),
-    input: zod_1.z.record(zod_1.z.any()).optional(),
-    additionalMetadata: zod_1.z.record(zod_1.z.string()).optional(),
-    priority: zod_1.z.number().optional(),
+exports.CreateCronTriggerSchema = v4_1.z.object({
+    name: v4_1.z.string(),
+    expression: v4_1.z.string(),
+    input: v4_1.z.record(v4_1.z.any(), v4_1.z.any()).optional(),
+    additionalMetadata: v4_1.z.record(v4_1.z.string(), v4_1.z.string()).optional(),
+    priority: v4_1.z.number().optional(),
 });
 /**
  * The cron client is a client for managing cron workflows within Hatchet.
@@ -83,7 +83,7 @@ class CronClient {
                 return response.data;
             }
             catch (err) {
-                if (err instanceof zod_1.z.ZodError) {
+                if (err instanceof v4_1.z.ZodError) {
                     throw new Error(`Invalid cron input: ${err.message}`, { cause: err });
                 }
                 if (err instanceof axios_1.AxiosError) {

package/v1/client/features/schedules.d.ts

@@ -1,5 +1,5 @@
 import { ScheduledWorkflows, ScheduledWorkflowsBulkDeleteFilter, ScheduledWorkflowsBulkDeleteResponse, ScheduledWorkflowsBulkUpdateResponse, ScheduledWorkflowsList } from '../../../clients/rest/generated/data-contracts';
-import { z } from 'zod';
+import { z } from 'zod/v4';
 import { Workflow } from '../../../workflow';
 import { BaseWorkflowDeclaration, WorkflowDefinition } from '../..';
 import { HatchetClient } from '../client';
@@ -9,21 +9,11 @@ import { WorkflowsClient } from './workflows';
  * @internal
  */
 export declare const CreateScheduledRunTriggerSchema: z.ZodObject<{
-    triggerAt: z.ZodDate;
-    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    triggerAt: z.ZodCoercedDate<unknown>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodAny, z.ZodAny>>;
     additionalMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     priority: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    triggerAt: Date;
-    additionalMetadata?: Record<string, string> | undefined;
-    priority?: number | undefined;
-    input?: Record<string, any> | undefined;
-}, {
-    triggerAt: Date;
-    additionalMetadata?: Record<string, string> | undefined;
-    priority?: number | undefined;
-    input?: Record<string, any> | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Type representing the input for creating a Cron.
  * @internal
@@ -34,12 +24,8 @@ export type CreateScheduledRunInput = z.infer<typeof CreateScheduledRunTriggerSc
  * @internal
  */
 export declare const UpdateScheduledRunTriggerSchema: z.ZodObject<{
-    triggerAt: z.ZodDate;
-}, "strip", z.ZodTypeAny, {
-    triggerAt: Date;
-}, {
-    triggerAt: Date;
-}>;
+    triggerAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
 export type UpdateScheduledRunInput = z.infer<typeof UpdateScheduledRunTriggerSchema>;
 /**
  * The scheduled client is a client for managing scheduled workflows within Hatchet

package/v1/client/features/schedules.js

@@ -21,7 +21,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScheduleClient = exports.UpdateScheduledRunTriggerSchema = exports.CreateScheduledRunTriggerSchema = void 0;
-const zod_1 = require("zod");
+const v4_1 = require("zod/v4");
 const axios_1 = require("axios");
 const uuid_1 = require("../../../util/uuid");
 const apply_namespace_1 = require("../../../util/apply-namespace");
@@ -30,18 +30,18 @@ const workflows_1 = require("./workflows");
  * Schema for creating a Scheduled Run Trigger.
  * @internal
  */
-exports.CreateScheduledRunTriggerSchema = zod_1.z.object({
-    triggerAt: zod_1.z.coerce.date(),
-    input: zod_1.z.record(zod_1.z.any()).optional(),
-    additionalMetadata: zod_1.z.record(zod_1.z.string()).optional(),
-    priority: zod_1.z.number().optional(),
+exports.CreateScheduledRunTriggerSchema = v4_1.z.object({
+    triggerAt: v4_1.z.coerce.date(),
+    input: v4_1.z.record(v4_1.z.any(), v4_1.z.any()).optional(),
+    additionalMetadata: v4_1.z.record(v4_1.z.string(), v4_1.z.string()).optional(),
+    priority: v4_1.z.number().optional(),
 });
 /**
  * Schema for updating (rescheduling) a Scheduled Run Trigger.
  * @internal
  */
-exports.UpdateScheduledRunTriggerSchema = zod_1.z.object({
-    triggerAt: zod_1.z.coerce.date(),
+exports.UpdateScheduledRunTriggerSchema = v4_1.z.object({
+    triggerAt: v4_1.z.coerce.date(),
 });
 /**
  * The scheduled client is a client for managing scheduled workflows within Hatchet
@@ -91,7 +91,7 @@ class ScheduleClient {
                 return response.data;
             }
             catch (err) {
-                if (err instanceof zod_1.z.ZodError) {
+                if (err instanceof v4_1.z.ZodError) {
                     throw new Error(`Invalid cron input: ${err.message}`, { cause: err });
                 }
                 if (err instanceof axios_1.AxiosError) {
@@ -119,7 +119,7 @@ class ScheduleClient {
                 return response.data;
             }
             catch (err) {
-                if (err instanceof zod_1.z.ZodError) {
+                if (err instanceof v4_1.z.ZodError) {
                     throw new Error(`Invalid update input: ${err.message}`, { cause: err });
                 }
                 if (err instanceof axios_1.AxiosError) {

package/v1/client/worker/context.d.ts

@@ -18,7 +18,7 @@ import { HatchetClient } from '../..';
 import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
 import { NextStep } from '../../../legacy/step';
 import { DurableListenerClient } from '../../../clients/listeners/durable-listener/durable-listener-client';
-import { z } from 'zod';
+import { z } from 'zod/v4';
 import { InternalWorker } from './worker-internal';
 import { Duration } from '../duration';
 import { DurableEvictionManager } from './eviction/eviction-manager';

package/v1/client/worker/worker-internal.js

@@ -64,7 +64,7 @@ const workflows_1 = require("../../../protoc/workflows");
 const logger_1 = require("../../../util/logger");
 const task_1 = require("../../task");
 const transformer_1 = require("../../conditions/transformer");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
+const z = __importStar(require("zod/v4"));
 const apply_namespace_1 = require("../../../util/apply-namespace");
 const sleep_1 = __importDefault(require("../../../util/sleep"));
 const abort_error_1 = require("../../../util/abort-error");
@@ -263,7 +263,7 @@ class InternalWorker {
                 // Convert Zod schema to JSON Schema if provided
                 let inputJsonSchema;
                 if (workflow.inputValidator) {
-                    const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(workflow.inputValidator);
+                    const jsonSchema = z.toJSONSchema(workflow.inputValidator);
                     inputJsonSchema = new TextEncoder().encode(JSON.stringify(jsonSchema));
                 }
                 const durableTaskSet = new Set(workflow._durableTasks);

package/v1/declaration.d.ts

@@ -7,7 +7,7 @@
  */
 import WorkflowRunRef from '../util/workflow-run-ref';
 import { CronWorkflows, ScheduledWorkflows, V1CreateFilterRequest } from '../clients/rest/generated/data-contracts';
-import { z } from 'zod';
+import * as z from 'zod/v4';
 import { IHatchetClient } from './client/client.interface';
 import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, Concurrency, DurableTaskFn, WorkerLabelComparator } from './task';
 import { Duration } from './client/duration';
@@ -15,11 +15,20 @@ import { MetricsClient } from './client/features/metrics';
 import { InputType, OutputType, UnknownInputType, JsonObject, Resolved } from './types';
 import { Context, DurableContext } from './client/worker/context';
 import { EvictionPolicy } from './client/worker/eviction/eviction-policy';
+import type { FunctionTool } from '@openai/agents';
+import type { SdkMcpToolDefinition } from '@anthropic-ai/claude-agent-sdk';
+import type { OpenAIToolFuncT } from './agent/openai';
+import type { ClaudeToolFuncT } from './agent/claude';
 export declare enum Priority {
     LOW = 1,
     MEDIUM = 2,
     HIGH = 3
 }
+type AgentSdkFuncMap = {
+    claude: ClaudeToolFuncT;
+    openai: OpenAIToolFuncT;
+};
+type Tail<T extends any[]> = T extends [any, ...infer R] ? R : never;
 /**
  * Additional metadata that can be attached to a workflow run.
  */
@@ -358,6 +367,14 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      * @returns The name of the workflow.
      */
     get name(): string;
+    /**
+     * Create an MCP tool from a workflow. Supports both Claude and OpenAI agent sdks.
+     * @param sdk The agent SDK the tool will be used with.
+     * @param args Optional arguments passed to create the MCP tool object.
+     * @returns The MCP tool object.
+     **/
+    mcpTool(sdk: 'claude', ...args: Tail<Parameters<AgentSdkFuncMap['claude']>>): SdkMcpToolDefinition;
+    mcpTool(sdk: 'openai', ...args: Tail<Parameters<AgentSdkFuncMap['openai']>>): FunctionTool;
 }
 /**
  * A Hatchet workflow, which lets you define tasks and perform actions on the workflow.

package/v1/declaration.js

@@ -409,6 +409,16 @@ class BaseWorkflowDeclaration {
     get name() {
         return this.definition.name;
     }
+    mcpTool(sdk, ...args) {
+        if (sdk === 'openai') {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { OpenAIToolFunc } = require('./agent/openai');
+            return OpenAIToolFunc(this, ...args);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { ClaudeToolFunc } = require('./agent/claude');
+        return ClaudeToolFunc(this, ...args);
+    }
 }
 exports.BaseWorkflowDeclaration = BaseWorkflowDeclaration;
 /**

package/v1/examples/agent/agent-claude.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/agent/agent-claude.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line
+const workflow_1 = require("./workflow");
+const claude_agent_sdk_1 = require("@anthropic-ai/claude-agent-sdk");
+const claude_agent_sdk_2 = require("@anthropic-ai/claude-agent-sdk");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Generate a tool from a standalone task
+        // const temperatureTool = getTemperature.mcpTool('claude');
+        var _a, e_1, _b, _c;
+        // Or from a workflow
+        const temperatureTool = workflow_1.getTemperatureWorkflow.mcpTool('claude');
+        // Wrap the tool in an in-process MCP server
+        const weatherServer = (0, claude_agent_sdk_2.createSdkMcpServer)({
+            name: 'weather',
+            version: '1.0.0',
+            tools: [temperatureTool],
+        });
+        try {
+            for (var _d = true, _e = __asyncValues((0, claude_agent_sdk_1.query)({
+                prompt: "What's the temperature in San Francisco?",
+                options: {
+                    mcpServers: { weather: weatherServer },
+                    allowedTools: [`mcp__${weatherServer.name}__${temperatureTool.name}`],
+                },
+            })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const message = _c;
+                // "result" is the final message after all tool calls complete
+                if (message.type === 'result' && message.subtype === 'success') {
+                    console.log(message.result);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => {
+        process.exit(0);
+    });
+}

package/v1/examples/agent/agent-openai.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/agent/agent-openai.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Generate a tool from a standalone task
+        // const temperatureTool = getTemperature.mcpTool('openai');
+        // Or from a workflow.
+        // mcpTool validates Zod v4 is installed before loading @openai/agents, so call it first
+        // to get a clear error message if the wrong Zod version is present.
+        const temperatureTool = workflow_1.getTemperatureWorkflow.mcpTool('openai');
+        // Dynamic import — @openai/agents crashes at load time with Zod v3, so we delay
+        // the import until after mcpTool has already verified Zod v4 is available.
+        const { Agent, run } = yield Promise.resolve().then(() => __importStar(require('@openai/agents')));
+        const agent = new Agent({
+            name: 'Agent',
+            tools: [temperatureTool],
+        });
+        const result = yield run(agent, 'What is the weather in San Francisco?');
+        console.log(result.finalOutput);
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => {
+        process.exit(0);
+    });
+}

package/v1/examples/agent/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/agent/worker.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('temperature-worker', {
+            workflows: [workflow_1.getTemperature, workflow_1.getTemperatureWorkflow],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}