@hatchet-dev/typescript-sdk 1.22.3 → 1.23.1

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

@@ -42,16 +42,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 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');
+        const temperatureTool = (0, workflow_1.createTemperatureWorkflowToolOpenai)();
         // 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')));

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

@@ -7,20 +7,24 @@ declare const TemperatureInput: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type TemperatureInputWithZod = z.infer<typeof TemperatureInput>;
-export declare const getTemperature: import("../..").TaskWorkflowDeclaration<{
+export declare const getTemperatureWorkflow: import("../..").WorkflowDeclaration<{
     locationName: string;
     coords: {
         latitude: number;
         longitude: number;
     };
-}, {
-    text: string;
-}, {}, {}, {}, {}>;
-export declare const getTemperatureWorkflow: import("../..").WorkflowDeclaration<{
+}, {}, {}>;
+export declare const getTemperature: import("../..").TaskWorkflowDeclaration<{
     locationName: string;
     coords: {
         latitude: number;
         longitude: number;
     };
-}, {}, {}>;
+}, {
+    text: string;
+}, {}, {}, {}, {}>;
+export declare function createTemperatureWorkflowToolClaude(): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition;
+export declare function createTemperatureWorkflowToolOpenai(): import("@openai/agents").FunctionTool;
+export declare function createTemperatureTaskToolClaude(): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition;
+export declare function createTemperatureTaskToolOpenai(): import("@openai/agents").FunctionTool;
 export {};

package/v1/examples/agent/workflow.js

@@ -9,11 +9,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTemperatureWorkflow = exports.getTemperature = void 0;
-// > Declaring a Task
+exports.getTemperature = exports.getTemperatureWorkflow = void 0;
+exports.createTemperatureWorkflowToolClaude = createTemperatureWorkflowToolClaude;
+exports.createTemperatureWorkflowToolOpenai = createTemperatureWorkflowToolOpenai;
+exports.createTemperatureTaskToolClaude = createTemperatureTaskToolClaude;
+exports.createTemperatureTaskToolOpenai = createTemperatureTaskToolOpenai;
 const hatchet_client_1 = require("../hatchet-client");
 const v4_1 = require("zod/v4");
-// Note that for agent tools, Zod must be used to create the input and output types for workflows/tasks
+// > Models
+// Agent tools require a Zod v4 inputValidator so the SDK can generate the tool input schema.
 const TemperatureCoordinates = v4_1.z.object({
     latitude: v4_1.z.number(),
     longitude: v4_1.z.number(),
@@ -22,20 +26,15 @@ const TemperatureInput = v4_1.z.object({
     locationName: v4_1.z.string(),
     coords: TemperatureCoordinates,
 });
+// !!
 const temperatureRequest = (input) => __awaiter(void 0, void 0, void 0, function* () {
     const response = yield fetch(`https://api.open-meteo.com/v1/forecast?latitude=${input.coords.latitude}&longitude=${input.coords.longitude}&current=temperature_2m&temperature_unit=fahrenheit`);
     const data = yield response.json();
     return {
-        text: `Temperature: ${data.current.temperature_2m}°F`,
+        text: `Temperature in ${input.locationName}: ${data.current.temperature_2m}°F`,
     };
 });
-exports.getTemperature = hatchet_client_1.hatchet.task({
-    name: 'getTemperature',
-    retries: 3,
-    fn: temperatureRequest,
-    inputValidator: TemperatureInput,
-    description: 'Get the current temperature at a location',
-});
+// > Workflow definition
 exports.getTemperatureWorkflow = hatchet_client_1.hatchet.workflow({
     name: 'getTemperatureWorkflow',
     inputValidator: TemperatureInput,
@@ -46,3 +45,26 @@ exports.getTemperatureWorkflow.task({
     fn: temperatureRequest,
 });
 // !!
+// > Standalone task
+exports.getTemperature = hatchet_client_1.hatchet.task({
+    name: 'getTemperature',
+    retries: 3,
+    fn: temperatureRequest,
+    inputValidator: TemperatureInput,
+    description: 'Get the current temperature at a location',
+});
+// !!
+// > Create MCP tools
+function createTemperatureWorkflowToolClaude() {
+    return exports.getTemperatureWorkflow.mcpTool('claude');
+}
+function createTemperatureWorkflowToolOpenai() {
+    return exports.getTemperatureWorkflow.mcpTool('openai');
+}
+function createTemperatureTaskToolClaude() {
+    return exports.getTemperature.mcpTool('claude');
+}
+function createTemperatureTaskToolOpenai() {
+    return exports.getTemperature.mcpTool('openai');
+}
+// !!

package/v1/examples/aws/s3/worker.d.ts

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

package/v1/examples/aws/s3/worker.js

@@ -0,0 +1,177 @@
+"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); }
+};
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_s3_1 = require("@aws-sdk/client-s3");
+const v1_1 = require("../../..");
+const hatchet_client_1 = require("../../hatchet-client");
+const BUCKET_PREFIX = (_a = process.env.S3_WORKER_BUCKET_PREFIX) !== null && _a !== void 0 ? _a : 'bucket-';
+const MAX_CONCURRENT_BUCKET_POLLERS = parseInt((_b = process.env.S3_WORKER_MAX_CONCURRENT_BUCKET_POLLERS) !== null && _b !== void 0 ? _b : '10');
+const MAX_RUNS_PER_BUCKET = parseInt((_c = process.env.S3_WORKER_MAX_RUNS_PER_BUCKET) !== null && _c !== void 0 ? _c : '20');
+const SLOTS = parseInt((_d = process.env.S3_WORKER_SLOTS) !== null && _d !== void 0 ? _d : '40');
+// > Client Setup
+const s3 = new client_s3_1.S3Client({ forcePathStyle: true });
+// !!
+// > Fetch S3 Buckets
+const fetchBucketsWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'fetch_s3_buckets',
+    on: {
+        cron: '* * * * *',
+    },
+    concurrency: {
+        expression: "'singleton'",
+        maxRuns: 1,
+        limitStrategy: v1_1.ConcurrencyLimitStrategy.CANCEL_NEWEST,
+    },
+});
+// !!
+// > Fetch S3 Objects
+const fetchObjectsWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'fetch_s3_objects',
+    concurrency: [
+        {
+            expression: 'input.bucket',
+            maxRuns: 1,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.CANCEL_NEWEST,
+        },
+        {
+            expression: "'constant'",
+            maxRuns: MAX_CONCURRENT_BUCKET_POLLERS,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        },
+    ],
+});
+// !!
+// > Process S3 Objects
+const processObjectWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'process_object',
+    concurrency: {
+        expression: 'input.bucket',
+        maxRuns: MAX_RUNS_PER_BUCKET,
+        limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+    },
+});
+// !!
+// > Fetch S3 Buckets Task
+fetchBucketsWorkflow.task({
+    name: 'fetch_buckets',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        var _d;
+        try {
+            for (var _e = true, _f = __asyncValues((0, client_s3_1.paginateListBuckets)({ client: s3, pageSize: 10 }, { Prefix: BUCKET_PREFIX })), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+                _c = _g.value;
+                _e = false;
+                const page = _c;
+                const items = ((_d = page.Buckets) !== null && _d !== void 0 ? _d : [])
+                    .filter((bucket) => bucket.Name !== undefined)
+                    .map((bucket) => ({
+                    input: { bucket: bucket.Name },
+                    opts: {
+                        childKey: bucket.Name,
+                        additionalMetadata: { 'bucket-name': bucket.Name },
+                    },
+                }));
+                if (items.length > 0) {
+                    yield fetchObjectsWorkflow.runManyNoWait(items);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return {};
+    }),
+});
+// !!
+// > Fetch S3 Objects Task
+fetchObjectsWorkflow.task({
+    name: 'fetch_objects',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, e_2, _b, _c;
+        var _d;
+        try {
+            for (var _e = true, _f = __asyncValues((0, client_s3_1.paginateListObjectsV2)({ client: s3, pageSize: 100 }, { Bucket: input.bucket })), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+                _c = _g.value;
+                _e = false;
+                const page = _c;
+                const items = ((_d = page.Contents) !== null && _d !== void 0 ? _d : [])
+                    .filter((obj) => obj.Key !== undefined)
+                    .map((obj) => ({
+                    input: { bucket: input.bucket, key: obj.Key },
+                    opts: {
+                        childKey: `${input.bucket}/${obj.Key}`,
+                    },
+                }));
+                if (items.length > 0) {
+                    yield processObjectWorkflow.runManyNoWait(items);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return {};
+    }),
+});
+// !!
+// > Download and Process S3 Objects Task
+processObjectWorkflow.task({
+    name: 'process_object',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        let body;
+        try {
+            const response = yield s3.send(new client_s3_1.GetObjectCommand({ Bucket: input.bucket, Key: input.key }));
+            if (!response.Body) {
+                return {};
+            }
+            body = Buffer.from(yield response.Body.transformToByteArray());
+        }
+        catch (err) {
+            if (err instanceof client_s3_1.NoSuchKey || err instanceof client_s3_1.NoSuchBucket) {
+                yield ctx.log(`skipping ${input.bucket}/${input.key}: not found`);
+                return {};
+            }
+            throw err;
+        }
+        // TODO: actual image processing here
+        yield s3.send(new client_s3_1.DeleteObjectCommand({ Bucket: input.bucket, Key: input.key }));
+        return {};
+    }),
+});
+// !!
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('s3-worker', {
+            workflows: [fetchBucketsWorkflow, fetchObjectsWorkflow, processObjectWorkflow],
+            slots: SLOTS,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/bulk_operations/workflow.js

@@ -15,7 +15,7 @@ exports.bulkReplayTest1 = hatchet_client_1.hatchet.task({
     name: 'bulk-replay-test-1',
     retries: 1,
     fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        console.log('retrying bulk replay test task', ctx.retryCount());
+        ctx.logger.info('retrying bulk replay test task', { retryCount: ctx.retryCount() });
         if (ctx.retryCount() === 0) {
             throw new Error('This is a test error to trigger a retry.');
         }
@@ -25,7 +25,7 @@ exports.bulkReplayTest2 = hatchet_client_1.hatchet.task({
     name: 'bulk-replay-test-2',
     retries: 1,
     fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        console.log('retrying bulk replay test task', ctx.retryCount());
+        ctx.logger.info('retrying bulk replay test task', { retryCount: ctx.retryCount() });
         if (ctx.retryCount() === 0) {
             throw new Error('This is a test error to trigger a retry.');
         }
@@ -35,7 +35,7 @@ exports.bulkReplayTest3 = hatchet_client_1.hatchet.task({
     name: 'bulk-replay-test-3',
     retries: 1,
     fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        console.log('retrying bulk replay test task', ctx.retryCount());
+        ctx.logger.info('retrying bulk replay test task', { retryCount: ctx.retryCount() });
         if (ctx.retryCount() === 0) {
             throw new Error('This is a test error to trigger a retry.');
         }

package/v1/examples/cancellation/cancellation-workflow.js

@@ -47,17 +47,17 @@ exports.cancellationWorkflow.task({
 // > Abort Signal
 exports.abortSignal = hatchet_client_1.hatchet.task({
     name: 'abort-signal',
-    fn: (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { abortController }) {
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             const response = yield axios_1.default.get('https://api.example.com/data', {
-                signal: abortController.signal,
+                signal: ctx.abortController.signal,
             });
             // Handle the response
         }
         catch (error) {
             if (axios_1.default.isCancel(error)) {
                 // Request was canceled
-                console.log('Request canceled');
+                ctx.logger.info('Request canceled');
             }
             else {
                 // Handle other errors

package/v1/examples/cancellations/workflow.js

@@ -33,17 +33,17 @@ exports.cancellation = hatchet_client_1.hatchet.task({
 // > Abort Signal
 exports.abortSignal = hatchet_client_1.hatchet.task({
     name: 'abort-signal',
-    fn: (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { abortController }) {
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             const response = yield axios_1.default.get('https://api.example.com/data', {
-                signal: abortController.signal,
+                signal: ctx.abortController.signal,
             });
             // Handle the response
         }
         catch (error) {
             if (axios_1.default.isCancel(error)) {
                 // Request was canceled
-                console.log('Request canceled');
+                ctx.logger.info('Request canceled');
             }
             else {
                 // Handle other errors

package/v1/examples/conditions/workflow.js

@@ -33,7 +33,7 @@ exports.dagWithConditions.task({
     parents: [firstTask],
     waitFor: (0, conditions_1.Or)({ eventKey: 'user:event' }, { sleepFor: '10s' }),
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        console.log('triggered by condition', ctx.triggers());
+        ctx.logger.info('triggered by condition', { triggers: ctx.triggers() });
         return {
             Completed: true,
         };

package/v1/examples/dag_match_condition/workflow.js

@@ -33,7 +33,7 @@ exports.dagWithConditions.task({
     parents: [firstTask],
     waitFor: (0, conditions_1.Or)({ eventKey: 'user:event' }, { sleepFor: '10s' }),
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        console.log('triggered by condition', ctx.triggers());
+        ctx.logger.info('triggered by condition', { triggers: ctx.triggers() });
         return {
             Completed: true,
         };

package/v1/examples/durable/workflow.js

@@ -29,20 +29,20 @@ exports.durableWorkflow = hatchet_client_1.hatchet.workflow({
 // !!
 exports.durableWorkflow.task({
     name: 'ephemeral_task',
-    fn: () => __awaiter(void 0, void 0, void 0, function* () {
-        console.log('Running non-durable task');
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        ctx.logger.info('Running non-durable task');
     }),
 });
 exports.durableWorkflow.durableTask({
     name: 'durable_task',
     executionTimeout: '10m',
     fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        console.log('Waiting for sleep');
+        ctx.logger.info('Waiting for sleep');
         const sleepResult = yield ctx.sleepFor(exports.SLEEP_TIME, { label: 'waiting for sleep' });
-        console.log('Sleep finished');
-        console.log('Waiting for event');
+        ctx.logger.info('Sleep finished');
+        ctx.logger.info('Waiting for event');
         const event = yield ctx.waitForEvent(exports.EVENT_KEY, 'true');
-        console.log('Event received');
+        ctx.logger.info('Event received');
         return {
             status: 'success',
             event: event,

package/v1/examples/durable-event/workflow.js

@@ -18,7 +18,7 @@ exports.durableEvent = hatchet_client_1.hatchet.durableTask({
     executionTimeout: '10m',
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         const res = yield ctx.waitForEvent('user:update');
-        console.log('res', res);
+        ctx.logger.info('res', { res });
         return {
             Value: 'done',
         };
@@ -32,7 +32,7 @@ exports.durableEventWithFilter = hatchet_client_1.hatchet.durableTask({
         // > Durable Event With Filter
         const res = yield ctx.waitForEvent('user:update', "input.userId == '1234'");
         // !!
-        console.log('res', res);
+        ctx.logger.info('res', { res });
         return {
             Value: 'done',
         };

package/v1/examples/durable-sleep/workflow.js

@@ -20,9 +20,9 @@ exports.durableSleep.durableTask({
     name: 'durable-sleep',
     executionTimeout: '10m',
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        console.log('sleeping for 5s');
+        ctx.logger.info('sleeping for 5s');
         const sleepRes = yield ctx.sleepFor('5s');
-        console.log('done sleeping for 5s', sleepRes);
+        ctx.logger.info('done sleeping for 5s', { sleepRes });
         return {
             Value: 'done',
         };

package/v1/examples/durable_event/workflow.js

@@ -19,7 +19,7 @@ exports.durableEvent = hatchet_client_1.hatchet.durableTask({
     executionTimeout: '10m',
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         const res = yield ctx.waitForEvent(exports.EVENT_KEY);
-        console.log('res', res);
+        ctx.logger.info('res', { res });
         return {
             Value: 'done',
         };
@@ -33,7 +33,7 @@ exports.durableEventWithFilter = hatchet_client_1.hatchet.durableTask({
         // > Durable Event With Filter
         const res = yield ctx.waitForEvent(exports.EVENT_KEY, "input.userId == '1234'");
         // !!
-        console.log('res', res);
+        ctx.logger.info('res', { res });
         return {
             Value: 'done',
         };
@@ -46,7 +46,7 @@ exports.durableEventWithLookback = hatchet_client_1.hatchet.durableTask({
     executionTimeout: '10m',
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         const res = yield ctx.waitForEvent(exports.EVENT_KEY, undefined, undefined, exports.SCOPE, '1m');
-        console.log('res', res);
+        ctx.logger.info('res', { res });
         return {
             Value: 'done',
         };

package/v1/examples/durable_sleep/workflow.js

@@ -20,9 +20,9 @@ exports.durableSleep.durableTask({
     name: 'durable-sleep',
     executionTimeout: '10m',
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        console.log('sleeping for 5s');
+        ctx.logger.info('sleeping for 5s');
         const sleepRes = yield ctx.sleepFor('5s');
-        console.log('done sleeping for 5s', sleepRes);
+        ctx.logger.info('done sleeping for 5s', { sleepRes });
         return {
             Value: 'done',
         };

package/v1/examples/events/workflow.js

@@ -54,7 +54,7 @@ exports.upper.task({
 exports.lowerWithFilter.task({
     name: 'lowerWithFilter',
     fn: (input, ctx) => {
-        console.log(ctx.filterPayload());
+        ctx.logger.info('filterPayload', { filterPayload: ctx.filterPayload() });
     },
 });
 // !!

package/v1/examples/middleware/client.js

@@ -5,7 +5,7 @@ exports.hatchetWithMiddlewareChaining = exports.hatchetWithMiddleware = void 0;
 const v1_1 = require("../..");
 const myMiddleware = {
     before: (input, ctx) => {
-        console.log('before', input.first);
+        ctx.logger.info('before', { first: input.first });
         return Object.assign(Object.assign({}, input), { dependency: 'abc-123' });
     },
     after: (output, ctx, input) => {
@@ -17,7 +17,7 @@ exports.hatchetWithMiddleware = v1_1.HatchetClient.init().withMiddleware(myMiddl
 // > Chaining middleware
 const firstMiddleware = {
     before: (input, ctx) => {
-        console.log('before', input.first);
+        ctx.logger.info('before', { first: input.first });
         return Object.assign(Object.assign({}, input), { dependency: 'abc-123' });
     },
     after: (output, ctx, input) => {
@@ -26,7 +26,7 @@ const firstMiddleware = {
 };
 const secondMiddleware = {
     before: (input, ctx) => {
-        console.log('before', input.dependency); // available from previous middleware
+        ctx.logger.info('before', { dependency: input.dependency }); // available from previous middleware
         return Object.assign(Object.assign({}, input), { anotherDep: true });
     },
     after: (output, ctx, input) => {

package/v1/examples/middleware/workflow.js

@@ -4,11 +4,11 @@ exports.taskWithMiddleware = void 0;
 const client_1 = require("./client");
 exports.taskWithMiddleware = client_1.hatchetWithMiddleware.task({
     name: 'task-with-middleware',
-    fn: (input, _ctx) => {
-        console.log('task', input.message); // string  (from TaskInput)
-        console.log('task', input.first); // number  (from GlobalInputType)
-        console.log('task', input.second); // number  (from GlobalInputType)
-        console.log('task', input.dependency); // string  (from Pre Middleware)
+    fn: (input, ctx) => {
+        ctx.logger.info('task', { message: input.message }); // string  (from TaskInput)
+        ctx.logger.info('task', { first: input.first }); // number  (from GlobalInputType)
+        ctx.logger.info('task', { second: input.second }); // number  (from GlobalInputType)
+        ctx.logger.info('task', { dependency: input.dependency }); // string  (from Pre Middleware)
         return {
             message: input.message,
             extra: 1,

package/v1/examples/on_event/workflow.js

@@ -54,7 +54,7 @@ exports.upper.task({
 exports.lowerWithFilter.task({
     name: 'lowerWithFilter',
     fn: (input, ctx) => {
-        console.log(ctx.filterPayload());
+        ctx.logger.info('filterPayload', { filterPayload: ctx.filterPayload() });
     },
 });
 // !!

package/v1/examples/on_failure/workflow.js

@@ -28,8 +28,8 @@ exports.failureWorkflow.task({
 exports.failureWorkflow.onFailure({
     name: 'on_failure',
     fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        console.log('onFailure for run:', ctx.workflowRunId());
-        console.log('upstream errors:', ctx.errors());
+        ctx.logger.info(`onFailure for run: ${ctx.workflowRunId()}`);
+        ctx.logger.info('upstream errors', { errors: ctx.errors() });
         return {
             status: 'success',
         };

package/v1/examples/on_success/workflow.js

@@ -34,7 +34,7 @@ exports.onSuccessDag.task({
 // 👀 onSuccess handler will run if all tasks in the workflow succeed
 exports.onSuccessDag.onSuccess({
     fn: (_, ctx) => {
-        console.log('onSuccess for run:', ctx.workflowRunId());
+        ctx.logger.info(`onSuccess for run: ${ctx.workflowRunId()}`);
         return {
             'on-success': 'success',
         };

package/v1/examples/rate_limit/workflow.js

@@ -19,16 +19,16 @@ const task1 = hatchet_client_1.hatchet.task({
             units: 1,
         },
     ],
-    fn: (input) => {
-        console.log('executed task1');
+    fn: (_input, ctx) => {
+        ctx.logger.info('executed task1');
     },
 });
 // !!
 // > Dynamic
 const task2 = hatchet_client_1.hatchet.task({
     name: 'task2',
-    fn: (input) => {
-        console.log('executed task2 for user: ', input.userId);
+    fn: (input, ctx) => {
+        ctx.logger.info(`executed task2 for user: ${input.userId}`);
     },
     rateLimits: [
         {

package/v1/examples/retries/workflow.js

@@ -27,7 +27,7 @@ exports.retriesWithCount = hatchet_client_1.hatchet.task({
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         // > Get the current retry count
         const retryCount = ctx.retryCount();
-        console.log(`Retry count: ${retryCount}`);
+        ctx.logger.info(`Retry count: ${retryCount}`);
         if (retryCount < 2) {
             throw new Error('intentional failure');
         }

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

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