@hatchet-dev/typescript-sdk 1.31.1 → 1.32.0

package/v1/client/worker/worker-internal.d.ts

@@ -1,17 +1,15 @@
-import { Action, ActionKey, ActionListener } from '../../../clients/dispatcher/action-listener';
+import { ActionListener } from '../../../clients/dispatcher/action-listener';
+import { Action, ActionKey } from '../../../clients/dispatcher/action';
 import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActionEventType, BatchActionEvent } from '../../../protoc/dispatcher';
 import HatchetPromise from '../../../util/hatchet-promise/hatchet-promise';
-import { CreateStepRateLimit } from '../../../protoc/workflows';
 import { Logger } from '../../../util/logger';
 import { BaseWorkflowDeclaration, WorkflowDefinition, HatchetClient } from '../..';
-import { TaskBatchConfig } from '../../../protoc/v1/workflows';
-import { Concurrency, CreateWorkflowTaskOpts } from '../../task';
 import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
-import { Duration } from '../duration';
 import { Context } from './context';
 import { SlotConfig } from '../../slot-types';
 import { DurableEvictionManager } from './eviction/eviction-manager';
 import { EvictionPolicy } from './eviction/eviction-policy';
+export { assertValidConcurrencyArr, mapBatchConfigPb, mapConcurrencyPb, mapRateLimitPb, mapSlotRequestsPb, resolveExecutionTimeout, resolveScheduleTimeout, taskConcurrencyArr, } from './workflow-proto';
 export type ActionRegistry = Record<Action['actionId'], Function>;
 export interface WorkerOpts {
     name: string;
@@ -107,37 +105,3 @@ export declare class InternalWorker {
     handleAction(action: Action): Promise<void | Error>;
     upsertLabels(labels: WorkerLabels): Promise<WorkerLabels>;
 }
-/** Durable tasks stay on the durable pool; slotCost applies only to the default pool. */
-export declare function mapSlotRequestsPb(task: {
-    slotRequests?: Record<string, number>;
-    slotCost?: number;
-}, isDurable: boolean): Record<string, number>;
-export declare function mapRateLimitPb(limits: CreateWorkflowTaskOpts<any, any>['rateLimits']): CreateStepRateLimit[];
-export declare function mapConcurrencyPb(entries: Concurrency[]): {
-    expression: string;
-    maxRuns: number | undefined;
-    limitStrategy: import("../..").ConcurrencyLimitStrategy | undefined;
-    name: string | undefined;
-    isTenantScoped: boolean | undefined;
-    maxRunsExpression: string | undefined;
-}[];
-export declare function taskConcurrencyArr(task: {
-    concurrency?: Concurrency | Concurrency[];
-}, workflow: {
-    taskDefaults?: {
-        concurrency?: Concurrency | Concurrency[];
-    };
-}): Concurrency[];
-export declare function assertValidConcurrencyArr(concurrency: Concurrency[] | undefined): void;
-export declare function mapBatchConfigPb(batch: CreateWorkflowTaskOpts<any, any>['batch']): TaskBatchConfig | undefined;
-export declare function resolveExecutionTimeout(task: {
-    executionTimeout?: Duration;
-    timeout?: Duration;
-}, workflowDefaults?: {
-    executionTimeout?: Duration;
-}): string;
-export declare function resolveScheduleTimeout(task: {
-    scheduleTimeout?: Duration;
-}, workflowDefaults?: {
-    scheduleTimeout?: Duration;
-}): string | undefined;

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

@@ -52,35 +52,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InternalWorker = void 0;
-exports.mapSlotRequestsPb = mapSlotRequestsPb;
-exports.mapRateLimitPb = mapRateLimitPb;
-exports.mapConcurrencyPb = mapConcurrencyPb;
-exports.taskConcurrencyArr = taskConcurrencyArr;
-exports.assertValidConcurrencyArr = assertValidConcurrencyArr;
-exports.mapBatchConfigPb = mapBatchConfigPb;
-exports.resolveExecutionTimeout = resolveExecutionTimeout;
-exports.resolveScheduleTimeout = resolveScheduleTimeout;
+exports.InternalWorker = exports.taskConcurrencyArr = exports.resolveScheduleTimeout = exports.resolveExecutionTimeout = exports.mapSlotRequestsPb = exports.mapRateLimitPb = exports.mapConcurrencyPb = exports.mapBatchConfigPb = exports.assertValidConcurrencyArr = void 0;
 const hatchet_error_1 = __importDefault(require("../../../util/errors/hatchet-error"));
 const task_run_terminated_error_1 = require("../../../util/errors/task-run-terminated-error");
+const action_1 = require("../../../clients/dispatcher/action");
 const dispatcher_1 = require("../../../protoc/dispatcher");
 const hatchet_promise_1 = __importStar(require("../../../util/hatchet-promise/hatchet-promise"));
-const workflows_1 = require("../../../protoc/workflows");
 const logger_1 = require("../../../util/logger");
-const workflows_2 = require("../../../protoc/v1/workflows");
 const task_1 = require("../../task");
-const transformer_1 = require("../../conditions/transformer");
-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");
-const duration_1 = require("../duration");
 const context_1 = require("./context");
 const parent_run_context_vars_1 = require("../../parent-run-context-vars");
+const parent_run_context_storage_1 = require("../../parent-run-context-storage");
+const workflow_proto_1 = require("./workflow-proto");
 const health_server_1 = require("./health-server");
 const eviction_manager_1 = require("./eviction/eviction-manager");
 const eviction_policy_1 = require("./eviction/eviction-policy");
 const engine_version_1 = require("./engine-version");
+var workflow_proto_2 = require("./workflow-proto");
+Object.defineProperty(exports, "assertValidConcurrencyArr", { enumerable: true, get: function () { return workflow_proto_2.assertValidConcurrencyArr; } });
+Object.defineProperty(exports, "mapBatchConfigPb", { enumerable: true, get: function () { return workflow_proto_2.mapBatchConfigPb; } });
+Object.defineProperty(exports, "mapConcurrencyPb", { enumerable: true, get: function () { return workflow_proto_2.mapConcurrencyPb; } });
+Object.defineProperty(exports, "mapRateLimitPb", { enumerable: true, get: function () { return workflow_proto_2.mapRateLimitPb; } });
+Object.defineProperty(exports, "mapSlotRequestsPb", { enumerable: true, get: function () { return workflow_proto_2.mapSlotRequestsPb; } });
+Object.defineProperty(exports, "resolveExecutionTimeout", { enumerable: true, get: function () { return workflow_proto_2.resolveExecutionTimeout; } });
+Object.defineProperty(exports, "resolveScheduleTimeout", { enumerable: true, get: function () { return workflow_proto_2.resolveScheduleTimeout; } });
+Object.defineProperty(exports, "taskConcurrencyArr", { enumerable: true, get: function () { return workflow_proto_2.taskConcurrencyArr; } });
+// Tasks read the parent run context across awaits; the worker is the only place that
+// enters it, so it installs the AsyncLocalStorage store before any task can run.
+(0, parent_run_context_storage_1.installAsyncLocalParentRunContext)();
 class InternalWorker {
     constructor(client, options) {
         var _a, _b, _c, _d;
@@ -143,7 +145,7 @@ class InternalWorker {
         const newActions = workflow._durableTasks
             .filter((task) => !!task.fn)
             .reduce((acc, task) => {
-            const actionId = `${(0, apply_namespace_1.applyNamespace)(workflow.name, this.client.config.namespace).toLowerCase()}:${task.name.toLowerCase()}`;
+            const actionId = (0, action_1.createActionId)((0, apply_namespace_1.applyNamespace)(workflow.name, this.client.config.namespace), task.name);
             acc[actionId] = (ctx) => task.fn(ctx.input, ctx);
             this.durable_action_set.add(actionId);
             this.eviction_policies.set(actionId, task.evictionPolicy !== undefined
@@ -157,7 +159,7 @@ class InternalWorker {
         const newActions = workflow._tasks
             .filter((task) => !!task.fn)
             .reduce((acc, task) => {
-            const actionId = `${workflow.name}:${task.name.toLowerCase()}`;
+            const actionId = (0, action_1.createActionId)(workflow.name, task.name);
             if (task.batch) {
                 acc[actionId] = (ctx) => task.fn(decodeBatchItems(ctx.action.actionPayload), ctx);
             }
@@ -173,192 +175,17 @@ class InternalWorker {
             : undefined;
         const onFailureAction = onFailureFn
             ? {
-                [onFailureTaskName(workflow)]: (ctx) => onFailureFn(ctx.input, ctx),
+                [(0, workflow_proto_1.onFailureTaskName)(workflow)]: (ctx) => onFailureFn(ctx.input, ctx),
             }
             : {};
         this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
     }
     registerWorkflow(initWorkflow_1) {
         return __awaiter(this, arguments, void 0, function* (initWorkflow, durable = false) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
-            // patch the namespace
-            const workflow = Object.assign(Object.assign({}, initWorkflow.definition), { name: (0, apply_namespace_1.applyNamespace)(initWorkflow.definition.name, this.client.config.namespace).toLowerCase() });
+            const { namespace } = this.client.config;
+            const workflow = (0, workflow_proto_1.normalizeWorkflowDefinition)(initWorkflow, { namespace, durable });
             try {
-                const { concurrency } = workflow;
-                let onFailureTask;
-                if (workflow.onFailure && typeof workflow.onFailure === 'function') {
-                    onFailureTask = {
-                        readableId: 'on-failure-task',
-                        action: onFailureTaskName(workflow),
-                        timeout: '60s',
-                        inputs: '{}',
-                        parents: [],
-                        retries: 0,
-                        rateLimits: [],
-                        workerLabels: {},
-                        concurrency: [],
-                        isDurable: false,
-                        slotRequests: { default: 1 },
-                    };
-                }
-                if (workflow.onFailure && typeof workflow.onFailure === 'object') {
-                    const onFailure = workflow.onFailure;
-                    const scheduleTimeout = (_a = onFailure.scheduleTimeout) !== null && _a !== void 0 ? _a : (_b = workflow.taskDefaults) === null || _b === void 0 ? void 0 : _b.scheduleTimeout;
-                    onFailureTask = {
-                        readableId: 'on-failure-task',
-                        action: onFailureTaskName(workflow),
-                        timeout: (0, duration_1.durationToString)(onFailure.executionTimeout || ((_c = workflow.taskDefaults) === null || _c === void 0 ? void 0 : _c.executionTimeout) || '60s'),
-                        scheduleTimeout: scheduleTimeout ? (0, duration_1.durationToString)(scheduleTimeout) : undefined,
-                        inputs: '{}',
-                        parents: [],
-                        retries: onFailure.retries || ((_d = workflow.taskDefaults) === null || _d === void 0 ? void 0 : _d.retries) || 0,
-                        rateLimits: mapRateLimitPb(onFailure.rateLimits || ((_e = workflow.taskDefaults) === null || _e === void 0 ? void 0 : _e.rateLimits)),
-                        workerLabels: mapWorkerLabelPb(onFailure.desiredWorkerLabels || ((_f = workflow.taskDefaults) === null || _f === void 0 ? void 0 : _f.workerLabels)),
-                        concurrency: [],
-                        backoffFactor: ((_g = onFailure.backoff) === null || _g === void 0 ? void 0 : _g.factor) || ((_j = (_h = workflow.taskDefaults) === null || _h === void 0 ? void 0 : _h.backoff) === null || _j === void 0 ? void 0 : _j.factor),
-                        backoffMaxSeconds: ((_k = onFailure.backoff) === null || _k === void 0 ? void 0 : _k.maxSeconds) || ((_m = (_l = workflow.taskDefaults) === null || _l === void 0 ? void 0 : _l.backoff) === null || _m === void 0 ? void 0 : _m.maxSeconds),
-                        isDurable: false,
-                        slotRequests: mapSlotRequestsPb(onFailure, false),
-                    };
-                }
-                let onSuccessTask;
-                if (!durable && workflow.onSuccess && typeof workflow.onSuccess === 'function') {
-                    const parents = getLeaves([...workflow._tasks, ...workflow._durableTasks]);
-                    onSuccessTask = {
-                        name: 'on-success-task',
-                        fn: workflow.onSuccess,
-                        executionTimeout: '60s',
-                        parents,
-                        retries: 0,
-                        rateLimits: [],
-                        desiredWorkerLabels: undefined,
-                        concurrency: [],
-                    };
-                }
-                if (!durable && workflow.onSuccess && typeof workflow.onSuccess === 'object') {
-                    const onSuccess = workflow.onSuccess;
-                    const parents = getLeaves([...workflow._tasks, ...workflow._durableTasks]);
-                    onSuccessTask = {
-                        name: 'on-success-task',
-                        fn: onSuccess.fn,
-                        executionTimeout: onSuccess.executionTimeout || ((_o = workflow.taskDefaults) === null || _o === void 0 ? void 0 : _o.executionTimeout) || '60s',
-                        scheduleTimeout: onSuccess.scheduleTimeout || ((_p = workflow.taskDefaults) === null || _p === void 0 ? void 0 : _p.scheduleTimeout),
-                        parents,
-                        retries: onSuccess.retries || ((_q = workflow.taskDefaults) === null || _q === void 0 ? void 0 : _q.retries) || 0,
-                        rateLimits: onSuccess.rateLimits || ((_r = workflow.taskDefaults) === null || _r === void 0 ? void 0 : _r.rateLimits),
-                        desiredWorkerLabels: onSuccess.desiredWorkerLabels || ((_s = workflow.taskDefaults) === null || _s === void 0 ? void 0 : _s.workerLabels),
-                        concurrency: onSuccess.concurrency || ((_t = workflow.taskDefaults) === null || _t === void 0 ? void 0 : _t.concurrency),
-                        backoff: onSuccess.backoff || ((_u = workflow.taskDefaults) === null || _u === void 0 ? void 0 : _u.backoff),
-                    };
-                }
-                if (onSuccessTask) {
-                    workflow._tasks.push(onSuccessTask);
-                }
-                const eventTriggers = [
-                    ...(workflow.onEvents || []).map((event) => (0, apply_namespace_1.applyNamespace)(event, this.client.config.namespace)),
-                    ...(workflow.on && 'event' in workflow.on && workflow.on.event
-                        ? Array.isArray(workflow.on.event)
-                            ? workflow.on.event.map((event) => (0, apply_namespace_1.applyNamespace)(event, this.client.config.namespace))
-                            : [(0, apply_namespace_1.applyNamespace)(workflow.on.event, this.client.config.namespace)]
-                        : []),
-                ];
-                const cronTriggers = [
-                    ...(workflow.onCrons || []),
-                    ...(workflow.on && 'cron' in workflow.on && workflow.on.cron
-                        ? Array.isArray(workflow.on.cron)
-                            ? workflow.on.cron
-                            : [workflow.on.cron]
-                        : []),
-                ];
-                const concurrencyArr = Array.isArray(concurrency) ? concurrency : [];
-                const concurrencySolo = !Array.isArray(concurrency) ? concurrency : undefined;
-                assertValidConcurrencyArr(concurrencyArr);
-                assertValidConcurrencyArr(concurrencySolo ? [concurrencySolo] : undefined);
-                // Convert Zod schema to JSON Schema if provided
-                let inputJsonSchema;
-                if (workflow.inputValidator) {
-                    const jsonSchema = z.toJSONSchema(workflow.inputValidator);
-                    inputJsonSchema = new TextEncoder().encode(JSON.stringify(jsonSchema));
-                }
-                const durableTaskSet = new Set(workflow._durableTasks);
-                let stickyStrategy;
-                // `workflow.sticky` is optional. When omitted, we don't set any sticky strategy.
-                //
-                // When provided, `workflow.sticky` is a v1 (non-protobuf) config which may also include
-                // legacy protobuf enum values for backwards compatibility.
-                if (workflow.sticky != null) {
-                    switch (workflow.sticky) {
-                        case 'soft':
-                        case 'SOFT':
-                        case 0:
-                            stickyStrategy = workflows_1.StickyStrategy.SOFT;
-                            break;
-                        case 'hard':
-                        case 'HARD':
-                        case 1:
-                            stickyStrategy = workflows_1.StickyStrategy.HARD;
-                            break;
-                        default:
-                            throw new hatchet_error_1.default(`Invalid sticky strategy: ${workflow.sticky}`);
-                    }
-                }
-                const registeredWorkflow = this.client.admin.putWorkflow({
-                    name: workflow.name,
-                    description: workflow.description || '',
-                    version: workflow.version || '',
-                    eventTriggers,
-                    cronTriggers,
-                    sticky: stickyStrategy,
-                    concurrencyArr: mapConcurrencyPb(concurrencyArr),
-                    onFailureTask,
-                    defaultPriority: workflow.defaultPriority,
-                    inputJsonSchema,
-                    tasks: [...workflow._tasks, ...workflow._durableTasks].map((task) => {
-                        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
-                        return ({
-                            readableId: task.name,
-                            action: `${workflow.name}:${task.name}`,
-                            timeout: resolveExecutionTimeout(task, workflow.taskDefaults),
-                            scheduleTimeout: resolveScheduleTimeout(task, workflow.taskDefaults),
-                            inputs: '{}',
-                            parents: (_b = (_a = task.parents) === null || _a === void 0 ? void 0 : _a.map((p) => p.name)) !== null && _b !== void 0 ? _b : [],
-                            userData: '{}',
-                            // Batch tasks buffer many concurrent runs into a single execution; per-item retry
-                            // semantics don't apply, so retries is always forced to 0.
-                            retries: batchOf(task) ? 0 : task.retries || ((_c = workflow.taskDefaults) === null || _c === void 0 ? void 0 : _c.retries) || 0,
-                            rateLimits: mapRateLimitPb(task.rateLimits || ((_d = workflow.taskDefaults) === null || _d === void 0 ? void 0 : _d.rateLimits)),
-                            workerLabels: mapWorkerLabelPb(task.desiredWorkerLabels || ((_e = workflow.taskDefaults) === null || _e === void 0 ? void 0 : _e.workerLabels)),
-                            backoffFactor: ((_f = task.backoff) === null || _f === void 0 ? void 0 : _f.factor) || ((_h = (_g = workflow.taskDefaults) === null || _g === void 0 ? void 0 : _g.backoff) === null || _h === void 0 ? void 0 : _h.factor),
-                            backoffMaxSeconds: ((_j = task.backoff) === null || _j === void 0 ? void 0 : _j.maxSeconds) || ((_l = (_k = workflow.taskDefaults) === null || _k === void 0 ? void 0 : _k.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds),
-                            conditions: (0, transformer_1.taskConditionsToPb)(task, this.client.config.namespace),
-                            isDurable: durableTaskSet.has(task),
-                            slotRequests: mapSlotRequestsPb(task, durableTaskSet.has(task)),
-                            batch: mapBatchConfigPb(batchOf(task)),
-                            concurrency: (() => {
-                                const taskConcurrency = taskConcurrencyArr(task, workflow);
-                                assertValidConcurrencyArr(taskConcurrency);
-                                return mapConcurrencyPb(taskConcurrency);
-                            })(),
-                        });
-                    }),
-                    concurrency: concurrencySolo ? mapConcurrencyPb([concurrencySolo])[0] : undefined,
-                    defaultFilters: (_w = (_v = workflow.defaultFilters) === null || _v === void 0 ? void 0 : _v.map((f) => ({
-                        scope: f.scope,
-                        expression: f.expression,
-                        payload: f.payload ? new TextEncoder().encode(JSON.stringify(f.payload)) : undefined,
-                    }))) !== null && _w !== void 0 ? _w : [],
-                    idempotency: workflow.idempotency
-                        ? {
-                            expression: workflow.idempotency.expression,
-                            ttlMs: workflow.idempotency.strategy === 'status'
-                                ? workflow.idempotency.fallbackTtlMs
-                                : workflow.idempotency.ttlMs,
-                            method: workflow.idempotency.strategy === 'status'
-                                ? workflows_2.IdempotencyMethod.STATUS
-                                : workflows_2.IdempotencyMethod.TTL,
-                        }
-                        : undefined,
-                });
+                const registeredWorkflow = this.client.admin.putWorkflow((0, workflow_proto_1.workflowToProto)(workflow, { namespace, durable }));
                 this.registeredWorkflowPromises.push(registeredWorkflow);
                 yield registeredWorkflow;
                 this.workflow_registry.push(workflow);
@@ -960,125 +787,6 @@ class InternalWorker {
     }
 }
 exports.InternalWorker = InternalWorker;
-function mapWorkerLabelPb(in_) {
-    if (!in_) {
-        return {};
-    }
-    return Object.entries(in_).reduce((acc, [key, label]) => {
-        if (!label) {
-            return Object.assign(Object.assign({}, acc), { [key]: {
-                    strValue: undefined,
-                    intValue: undefined,
-                } });
-        }
-        if (typeof label === 'string') {
-            return Object.assign(Object.assign({}, acc), { [key]: {
-                    strValue: label,
-                    intValue: undefined,
-                } });
-        }
-        if (typeof label === 'number') {
-            return Object.assign(Object.assign({}, acc), { [key]: {
-                    strValue: undefined,
-                    intValue: label,
-                } });
-        }
-        return Object.assign(Object.assign({}, acc), { [key]: {
-                strValue: typeof label.value === 'string' ? label.value : undefined,
-                intValue: typeof label.value === 'number' ? label.value : undefined,
-                required: label.required,
-                weight: label.weight,
-                comparator: label.comparator,
-            } });
-    }, {});
-}
-function onFailureTaskName(workflow) {
-    return `${workflow.name}:on-failure-task`;
-}
-function getLeaves(tasks) {
-    return tasks.filter((task) => isLeafTask(task, tasks));
-}
-function isLeafTask(task, allTasks) {
-    return !allTasks.some((t) => { var _a; return (_a = t.parents) === null || _a === void 0 ? void 0 : _a.some((p) => p.name === task.name); });
-}
-/** Durable tasks stay on the durable pool; slotCost applies only to the default pool. */
-function mapSlotRequestsPb(task, isDurable) {
-    if (task.slotRequests) {
-        return task.slotRequests;
-    }
-    if (isDurable) {
-        return { durable: 1 };
-    }
-    if (task.slotCost !== undefined) {
-        if (!Number.isInteger(task.slotCost) || task.slotCost <= 0) {
-            throw new Error(`slotCost must be a positive integer, got: ${task.slotCost}`);
-        }
-        return { default: task.slotCost };
-    }
-    return { default: 1 };
-}
-function mapRateLimitPb(limits) {
-    if (!limits) {
-        return [];
-    }
-    return limits.map((l) => {
-        let key = l.staticKey;
-        const keyExpression = l.dynamicKey;
-        if (l.key !== undefined) {
-            console.warn('key is deprecated and will be removed in a future release, please use staticKey instead');
-            ({ key } = l);
-        }
-        if (keyExpression !== undefined) {
-            if (key !== undefined) {
-                throw new Error('Cannot have both static key and dynamic key set');
-            }
-            key = keyExpression;
-            if (!validateCelExpression(keyExpression)) {
-                throw new Error(`Invalid CEL expression: ${keyExpression}`);
-            }
-        }
-        if (key === undefined) {
-            throw new Error(`Invalid key`);
-        }
-        let units;
-        let unitsExpression;
-        if (typeof l.units === 'number') {
-            ({ units } = l);
-        }
-        else {
-            if (!validateCelExpression(l.units)) {
-                throw new Error(`Invalid CEL expression: ${l.units}`);
-            }
-            unitsExpression = l.units;
-        }
-        let limitExpression;
-        if (l.limit !== undefined) {
-            if (typeof l.limit === 'number') {
-                limitExpression = `${l.limit}`;
-            }
-            else {
-                if (!validateCelExpression(l.limit)) {
-                    throw new Error(`Invalid CEL expression: ${l.limit}`);
-                }
-                limitExpression = l.limit;
-            }
-        }
-        if (keyExpression !== undefined && limitExpression === undefined) {
-            throw new Error('CEL based keys requires limit to be set');
-        }
-        if (limitExpression === undefined) {
-            limitExpression = `-1`;
-        }
-        return {
-            key,
-            keyExpr: keyExpression,
-            units,
-            unitsExpr: unitsExpression,
-            limitValuesExpr: limitExpression,
-            duration: l.duration,
-        };
-    });
-}
 /**
  * Decodes the buffered items of a batch task's START_BATCH action into a Record keyed by
  * each buffered item's task-run external id, mapping to that item's input. The wire shape
@@ -1105,82 +813,3 @@ function parseBatchPayload(actionPayload) {
         return {};
     }
 }
-/** Batch tasks are only available on non-durable tasks; durable tasks never carry `batch`. */
-function batchOf(task) {
-    return 'batch' in task ? task.batch : undefined;
-}
-// mapConcurrencyPb maps SDK concurrency entries onto the proto shape; entries keep their
-// declared order, which is the chain order.
-function mapConcurrencyPb(entries) {
-    return entries.map((c) => ({
-        expression: c.expression,
-        // a string maxRuns is a CEL expression; the static field then carries the default
-        // of 1, which only governs slots created before the expression existed
-        maxRuns: typeof c.maxRuns === 'string' ? 1 : c.maxRuns,
-        limitStrategy: c.limitStrategy,
-        name: c.name,
-        isTenantScoped: c.isTenantScoped,
-        maxRunsExpression: typeof c.maxRuns === 'string' ? c.maxRuns : undefined,
-    }));
-}
-function taskConcurrencyArr(task, workflow) {
-    var _a;
-    if (task.concurrency) {
-        return Array.isArray(task.concurrency) ? task.concurrency : [task.concurrency];
-    }
-    if ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.concurrency) {
-        return Array.isArray(workflow.taskDefaults.concurrency)
-            ? workflow.taskDefaults.concurrency
-            : [workflow.taskDefaults.concurrency];
-    }
-    return [];
-}
-function assertValidConcurrencyArr(concurrency) {
-    concurrency === null || concurrency === void 0 ? void 0 : concurrency.forEach((c) => {
-        if (typeof c.maxRuns === 'string') {
-            if (!c.maxRuns.trim()) {
-                throw new Error('concurrency.maxRuns expression must be non-empty');
-            }
-            return;
-        }
-        if (c.maxRuns !== undefined && (!Number.isInteger(c.maxRuns) || c.maxRuns <= 0)) {
-            throw new Error(`concurrency.maxRuns must be a positive integer or a CEL expression, got: ${c.maxRuns}`);
-        }
-    });
-}
-function mapBatchConfigPb(batch) {
-    if (!batch) {
-        return undefined;
-    }
-    if (!Number.isInteger(batch.maxSize) || batch.maxSize <= 0) {
-        throw new Error(`batch.maxSize must be a positive integer, got: ${batch.maxSize}`);
-    }
-    const batchMaxIntervalMs = batch.maxInterval !== undefined ? (0, duration_1.durationToMs)(batch.maxInterval) : undefined;
-    if (batchMaxIntervalMs !== undefined && batchMaxIntervalMs <= 0) {
-        throw new Error('batch.maxInterval must be positive when provided');
-    }
-    if (batch.groupMaxRuns !== undefined &&
-        (!Number.isInteger(batch.groupMaxRuns) || batch.groupMaxRuns <= 0)) {
-        throw new Error(`batch.groupMaxRuns must be a positive integer when provided, got: ${batch.groupMaxRuns}`);
-    }
-    return {
-        batchMaxSize: batch.maxSize,
-        batchMaxIntervalMs,
-        batchGroupKey: batch.groupKey,
-        batchGroupMaxRuns: batch.groupMaxRuns,
-        broadcastOutput: batch.broadcastOutput,
-    };
-}
-// Helper function to validate CEL expressions
-function validateCelExpression(_expr) {
-    // FIXME: this is a placeholder. In a real implementation, you'd need to use a CEL parser or validator.
-    // For now, we'll just return true to mimic the behavior.
-    return true;
-}
-function resolveExecutionTimeout(task, workflowDefaults) {
-    return (0, duration_1.durationToString)(task.executionTimeout || task.timeout || (workflowDefaults === null || workflowDefaults === void 0 ? void 0 : workflowDefaults.executionTimeout) || '60s');
-}
-function resolveScheduleTimeout(task, workflowDefaults) {
-    const value = task.scheduleTimeout || (workflowDefaults === null || workflowDefaults === void 0 ? void 0 : workflowDefaults.scheduleTimeout);
-    return value ? (0, duration_1.durationToString)(value) : undefined;
-}

package/v1/client/worker/worker-runtime.d.ts

@@ -0,0 +1,8 @@
+import type { HatchetClient } from '../client';
+import type { InternalWorker } from './worker-internal';
+import type { ContextRuntime } from './runtime';
+/** A `ContextRuntime` that also exposes the client it wraps, for `ctx.v1`. */
+export interface WorkerContextRuntime extends ContextRuntime {
+    readonly client: HatchetClient;
+}
+export declare function createWorkerContextRuntime(client: HatchetClient, worker: InternalWorker): WorkerContextRuntime;

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

@@ -0,0 +1,67 @@
+"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 });
+exports.createWorkerContextRuntime = createWorkerContextRuntime;
+/**
+ * `ContextRuntime` for a worker process: adapts the `HatchetClient` and `InternalWorker`
+ * a task runs on to the seam `Context` consumes.
+ */
+const dispatcher_1 = require("../../../protoc/dispatcher");
+// The event client's LogLevel enum has the same string values as the logger's LogLevel
+// union; casting keeps the event client (and its gRPC imports) out of this module's
+// runtime graph.
+function toEventLogLevel(level) {
+    if (level === undefined || level === 'OFF') {
+        return undefined;
+    }
+    return level;
+}
+function createWorkerContextRuntime(client, worker) {
+    return {
+        client,
+        get namespace() {
+            return client.config.namespace;
+        },
+        logger: (name) => client.config.logger(name, client.config.log_level),
+        cancelRun: (taskRunExternalId) => __awaiter(this, void 0, void 0, function* () {
+            yield client.runs.cancel({ ids: [taskRunExternalId] });
+        }),
+        cancelBatch: (_a) => __awaiter(this, [_a], void 0, function* ({ workerId, jobId, actionId, batchId, memberIds }) {
+            yield client.dispatcher.sendBatchActionEvent({
+                workerId,
+                jobId,
+                actionId,
+                batchId,
+                eventTimestamp: new Date(),
+                eventType: dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_CANCELLED,
+                items: memberIds.map((id) => ({ taskRunExternalId: id, eventPayload: '' })),
+            });
+        }),
+        putLog: (taskRunExternalId, message, level, retryCount, extra) => __awaiter(this, void 0, void 0, function* () {
+            yield client.events.putLog(taskRunExternalId, message, toEventLogLevel(level), retryCount, extra);
+        }),
+        refreshTimeout: (taskRunExternalId, incrementBy) => __awaiter(this, void 0, void 0, function* () {
+            yield client.dispatcher.refreshTimeout(incrementBy, taskRunExternalId);
+        }),
+        releaseSlot: (taskRunExternalId) => __awaiter(this, void 0, void 0, function* () {
+            yield client.dispatcher.client.releaseSlot({ taskRunExternalId });
+        }),
+        putStream: (taskRunExternalId, data, index) => __awaiter(this, void 0, void 0, function* () {
+            yield client.events.putStream(taskRunExternalId, data, index);
+        }),
+        runWorkflow: (workflowName, input, options) => client.admin.runWorkflow(workflowName, input, options),
+        runWorkflows: (runs) => client.admin.runWorkflows(runs),
+        workerId: () => worker.workerId,
+        hasWorkflow: (workflowName) => !!worker.workflow_registry.find((workflow) => 'id' in workflow ? workflow.id === workflowName : workflow.name === workflowName),
+        workerLabels: () => worker.labels,
+        upsertWorkerLabels: (labels) => worker.upsertLabels(labels),
+    };
+}