@temporalio/lambda-worker 1.17.0

package/lib/logger-factory.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePowertoolsLogger = makePowertoolsLogger;
+const json_logger_1 = require("./json-logger");
+/**
+ * Create a Powertools-based logger for the Lambda worker.
+ *
+ * If `@aws-lambda-powertools/logger` is installed, returns a
+ * {@link PowertoolsLoggerAdapter} wrapping a Powertools Logger.
+ * Otherwise, returns `undefined`, causing the Runtime to fall back
+ * to its default logger.
+ */
+function makePowertoolsLogger() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { Logger: PtLogger } = require('@aws-lambda-powertools/logger');
+        return new json_logger_1.PowertoolsLoggerAdapter(new PtLogger({
+            serviceName: process.env['AWS_LAMBDA_FUNCTION_NAME'] ?? 'temporal-lambda-worker',
+        }));
+    }
+    catch (err) {
+        if (err.code !== 'MODULE_NOT_FOUND') {
+            throw err;
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=logger-factory.js.map

package/lib/logger-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-factory.js","sourceRoot":"","sources":["../src/logger-factory.ts"],"names":[],"mappings":";;AAWA,oDAeC;AAzBD,+CAAwD;AAExD;;;;;;;GAOG;AACH,SAAgB,oBAAoB;IAClC,IAAI,CAAC;QACH,iEAAiE;QACjE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,+BAA+B,CAAC,CAAC;QACtE,OAAO,IAAI,qCAAuB,CAChC,IAAI,QAAQ,CAAC;YACX,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,IAAI,wBAAwB;SACjF,CAAC,CACH,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAK,GAA6B,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;YAC/D,MAAM,GAAG,CAAC;QACZ,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC"}

package/lib/otel.d.ts

@@ -0,0 +1,83 @@
+import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { OpenTelemetryPlugin } from '@temporalio/interceptors-opentelemetry';
+import type { LambdaWorkerConfig } from './types';
+/**
+ * Options for the batteries-included OTel setup.
+ */
+export interface OtelOptions {
+    /**
+     * OTLP gRPC collector endpoint for Core SDK metrics and SDK trace span export.
+     * Defaults to `OTEL_EXPORTER_OTLP_ENDPOINT` env var, then `grpc://localhost:4317`.
+     */
+    endpoint?: string;
+    /**
+     * OTel service name. Falls back to `OTEL_SERVICE_NAME` env var,
+     * then `AWS_LAMBDA_FUNCTION_NAME`, then `'temporal-lambda-worker'`.
+     */
+    serviceName?: string;
+}
+/**
+ * Configure OpenTelemetry for a Lambda worker:
+ *
+ * - Registers Temporal SDK interceptors (`@temporalio/interceptors-opentelemetry`) for
+ *   tracing Workflow, Activity, and Nexus calls via the `OpenTelemetryPlugin`.
+ * - Configures Core-side telemetry so the Temporal Rust SDK exports its own metrics
+ *   (workflow/activity task latencies, poll counts, etc.) via OTLP.
+ *
+ * Node.js-side Lambda auto-instrumentation (root spans, HTTP calls, etc.) is handled
+ * by the ADOT JS Lambda layer — this function does not set up a separate `NodeSDK` or
+ * `TracerProvider` to avoid conflicting with the layer.
+ *
+ * **Required AWS setup**: attach both Lambda layers:
+ *
+ * 1. [ADOT JavaScript layer](https://aws-otel.github.io/docs/getting-started/lambda/lambda-js)
+ *    — auto-instruments the handler and exports Node.js-side traces.
+ * 2. [ADOT Collector layer](https://aws-otel.github.io/docs/getting-started/lambda)
+ *    (`aws-otel-collector-amd64`) — runs the OTel Collector as a Lambda extension,
+ *    receiving Core SDK metrics via OTLP on `localhost:4317` and forwarding them to
+ *    CloudWatch/X-Ray.
+ *
+ * Then set these environment variables:
+ *
+ * - `AWS_LAMBDA_EXEC_WRAPPER=/opt/otel-instrument`
+ * - `OPENTELEMETRY_COLLECTOR_CONFIG_URI=/var/task/otel-collector-config.yaml`
+ *
+ * **Important**: When pre-bundling Workflow code with `bundleWorkflowCode()`, you must
+ * pass `makeOtelPlugin()` so Workflow interceptor modules are included in the bundle.
+ * See {@link makeOtelPlugin}.
+ *
+ * @example
+ * ```ts
+ * import { runWorker } from '@temporalio/lambda-worker';
+ * import { applyDefaults } from '@temporalio/lambda-worker/otel';
+ *
+ * export const handler = runWorker(version, (config) => {
+ *   applyDefaults(config);
+ *   config.workerOptions.taskQueue = 'my-queue';
+ *   // ...
+ * });
+ * ```
+ */
+export declare function applyDefaults(config: LambdaWorkerConfig, options?: OtelOptions): void;
+/**
+ * Create the OpenTelemetry plugin for use with `Worker.create()` and
+ * `bundleWorkflowCode()`. When pre-bundling workflows, pass the returned plugin
+ * to `bundleWorkflowCode({ plugins: [plugin] })` so workflow interceptor modules
+ * are included in the bundle.
+ *
+ * @example
+ * ```ts
+ * import { bundleWorkflowCode } from '@temporalio/worker';
+ * import { makeOtelPlugin } from '@temporalio/lambda-worker/otel';
+ *
+ * const { plugin } = makeOtelPlugin();
+ * const bundle = await bundleWorkflowCode({
+ *   workflowsPath: require.resolve('./workflows'),
+ *   plugins: [plugin],
+ * });
+ * ```
+ */
+export declare function makeOtelPlugin(endpoint?: string, serviceName?: string): {
+    plugin: OpenTelemetryPlugin;
+    spanProcessor: SimpleSpanProcessor;
+};

package/lib/otel.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDefaults = applyDefaults;
+exports.makeOtelPlugin = makeOtelPlugin;
+const exporter_trace_otlp_grpc_1 = require("@opentelemetry/exporter-trace-otlp-grpc");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const interceptors_opentelemetry_1 = require("@temporalio/interceptors-opentelemetry");
+/**
+ * Configure OpenTelemetry for a Lambda worker:
+ *
+ * - Registers Temporal SDK interceptors (`@temporalio/interceptors-opentelemetry`) for
+ *   tracing Workflow, Activity, and Nexus calls via the `OpenTelemetryPlugin`.
+ * - Configures Core-side telemetry so the Temporal Rust SDK exports its own metrics
+ *   (workflow/activity task latencies, poll counts, etc.) via OTLP.
+ *
+ * Node.js-side Lambda auto-instrumentation (root spans, HTTP calls, etc.) is handled
+ * by the ADOT JS Lambda layer — this function does not set up a separate `NodeSDK` or
+ * `TracerProvider` to avoid conflicting with the layer.
+ *
+ * **Required AWS setup**: attach both Lambda layers:
+ *
+ * 1. [ADOT JavaScript layer](https://aws-otel.github.io/docs/getting-started/lambda/lambda-js)
+ *    — auto-instruments the handler and exports Node.js-side traces.
+ * 2. [ADOT Collector layer](https://aws-otel.github.io/docs/getting-started/lambda)
+ *    (`aws-otel-collector-amd64`) — runs the OTel Collector as a Lambda extension,
+ *    receiving Core SDK metrics via OTLP on `localhost:4317` and forwarding them to
+ *    CloudWatch/X-Ray.
+ *
+ * Then set these environment variables:
+ *
+ * - `AWS_LAMBDA_EXEC_WRAPPER=/opt/otel-instrument`
+ * - `OPENTELEMETRY_COLLECTOR_CONFIG_URI=/var/task/otel-collector-config.yaml`
+ *
+ * **Important**: When pre-bundling Workflow code with `bundleWorkflowCode()`, you must
+ * pass `makeOtelPlugin()` so Workflow interceptor modules are included in the bundle.
+ * See {@link makeOtelPlugin}.
+ *
+ * @example
+ * ```ts
+ * import { runWorker } from '@temporalio/lambda-worker';
+ * import { applyDefaults } from '@temporalio/lambda-worker/otel';
+ *
+ * export const handler = runWorker(version, (config) => {
+ *   applyDefaults(config);
+ *   config.workerOptions.taskQueue = 'my-queue';
+ *   // ...
+ * });
+ * ```
+ */
+function applyDefaults(config, options) {
+    const endpoint = options?.endpoint ?? process.env['OTEL_EXPORTER_OTLP_ENDPOINT'] ?? 'grpc://localhost:4317';
+    // Configure Core-side telemetry so the Temporal Rust SDK exports its own
+    // metrics (workflow/activity task latencies, poll counts, etc.) to the
+    // standalone ADOT collector extension running as a Lambda layer.
+    config.runtimeOptions.telemetryOptions = {
+        ...config.runtimeOptions.telemetryOptions,
+        metrics: {
+            otel: {
+                url: endpoint,
+            },
+        },
+    };
+    // Set up the OpenTelemetry plugin for Temporal SDK interceptors.
+    // This traces Workflow, Activity, and Nexus calls.
+    const { plugin, spanProcessor } = makeOtelPlugin(endpoint, options?.serviceName);
+    config.workerOptions.plugins = [...(config.workerOptions.plugins ?? []), plugin];
+    config.shutdownHooks.push(async () => {
+        await spanProcessor.forceFlush();
+    });
+}
+// TODO: Spans don't automatically get parented to the lambda invocation span, and it's not clear
+// how we'd make that work, but is worth doing in the future if possible.
+/**
+ * Create the OpenTelemetry plugin for use with `Worker.create()` and
+ * `bundleWorkflowCode()`. When pre-bundling workflows, pass the returned plugin
+ * to `bundleWorkflowCode({ plugins: [plugin] })` so workflow interceptor modules
+ * are included in the bundle.
+ *
+ * @example
+ * ```ts
+ * import { bundleWorkflowCode } from '@temporalio/worker';
+ * import { makeOtelPlugin } from '@temporalio/lambda-worker/otel';
+ *
+ * const { plugin } = makeOtelPlugin();
+ * const bundle = await bundleWorkflowCode({
+ *   workflowsPath: require.resolve('./workflows'),
+ *   plugins: [plugin],
+ * });
+ * ```
+ */
+function makeOtelPlugin(endpoint, serviceName) {
+    const resolvedEndpoint = endpoint ?? process.env['OTEL_EXPORTER_OTLP_ENDPOINT'] ?? 'grpc://localhost:4317';
+    const resolvedServiceName = serviceName ??
+        process.env['OTEL_SERVICE_NAME'] ??
+        process.env['AWS_LAMBDA_FUNCTION_NAME'] ??
+        'temporal-lambda-worker';
+    const resource = new resources_1.Resource({ 'service.name': resolvedServiceName });
+    const traceExporter = new exporter_trace_otlp_grpc_1.OTLPTraceExporter({ url: resolvedEndpoint });
+    const spanProcessor = new sdk_trace_base_1.SimpleSpanProcessor(traceExporter);
+    return { plugin: new interceptors_opentelemetry_1.OpenTelemetryPlugin({ resource, spanProcessor }), spanProcessor };
+}
+//# sourceMappingURL=otel.js.map

package/lib/otel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel.js","sourceRoot":"","sources":["../src/otel.ts"],"names":[],"mappings":";;AAiEA,sCAuBC;AAsBD,wCAgBC;AA9HD,sFAA4E;AAC5E,wDAAoD;AACpD,kEAAoE;AACpE,uFAA6E;AAoB7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,SAAgB,aAAa,CAAC,MAA0B,EAAE,OAAqB;IAC7E,MAAM,QAAQ,GAAG,OAAO,EAAE,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,IAAI,uBAAuB,CAAC;IAE5G,yEAAyE;IACzE,uEAAuE;IACvE,iEAAiE;IACjE,MAAM,CAAC,cAAc,CAAC,gBAAgB,GAAG;QACvC,GAAG,MAAM,CAAC,cAAc,CAAC,gBAAgB;QACzC,OAAO,EAAE;YACP,IAAI,EAAE;gBACJ,GAAG,EAAE,QAAQ;aACd;SACF;KACF,CAAC;IAEF,iEAAiE;IACjE,mDAAmD;IACnD,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,GAAG,cAAc,CAAC,QAAQ,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;IACjF,MAAM,CAAC,aAAa,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;IAEjF,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;QACnC,MAAM,aAAa,CAAC,UAAU,EAAE,CAAC;IACnC,CAAC,CAAC,CAAC;AACL,CAAC;AAED,iGAAiG;AACjG,yEAAyE;AACzE;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,cAAc,CAC5B,QAAiB,EACjB,WAAoB;IAEpB,MAAM,gBAAgB,GAAG,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,IAAI,uBAAuB,CAAC;IAC3G,MAAM,mBAAmB,GACvB,WAAW;QACX,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;QAChC,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC;QACvC,wBAAwB,CAAC;IAE3B,MAAM,QAAQ,GAAG,IAAI,oBAAQ,CAAC,EAAE,cAAc,EAAE,mBAAmB,EAAE,CAAC,CAAC;IACvE,MAAM,aAAa,GAAG,IAAI,4CAAiB,CAAC,EAAE,GAAG,EAAE,gBAAgB,EAAE,CAAC,CAAC;IACvE,MAAM,aAAa,GAAG,IAAI,oCAAmB,CAAC,aAAa,CAAC,CAAC;IAE7D,OAAO,EAAE,MAAM,EAAE,IAAI,gDAAmB,CAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC;AACzF,CAAC"}

package/lib/types.d.ts

@@ -0,0 +1,70 @@
+import type { Context } from 'aws-lambda';
+import type { VersioningBehavior } from '@temporalio/common';
+import type { WorkerOptions, NativeConnectionOptions, RuntimeOptions } from '@temporalio/worker';
+/**
+ * A function called after the worker stops on each invocation.
+ * Errors are caught, logged, and do not prevent subsequent hooks from running.
+ */
+export type ShutdownHook = () => Promise<void> | void;
+/**
+ * Configuration object passed to the {@link runWorker} configure callback.
+ *
+ * Pre-populated with Lambda-tuned defaults. You should set `workerOptions.taskQueue`, register
+ * activities/workflows, and override any defaults as needed.
+ */
+export interface LambdaWorkerConfig {
+    /**
+     * Worker options, pre-populated with Lambda-appropriate defaults.
+     *
+     * You must set at least `taskQueue` (or set the `TEMPORAL_TASK_QUEUE` env var). Typically you'll
+     * also set `activities` and `workflowBundle` (prefer pre-bundled workflows over `workflowsPath`
+     * to avoid bundling overhead on Lambda cold starts).
+     *
+     * The following fields are managed by settings elsewhere and will be overridden per-invocation:
+     * `connection`, `namespace`, `identity`.
+     */
+    workerOptions: Partial<Omit<WorkerOptions, 'connection' | 'namespace' | 'identity' | 'workerDeploymentOptions'>> & {
+        /**
+         * `version` and `useWorkerVersioning` are managed by `runWorker` and cannot be set here.
+         *
+         * @default { defaultVersioningBehavior: 'PINNED' }
+         */
+        workerDeploymentOptions?: {
+            defaultVersioningBehavior?: VersioningBehavior;
+        };
+    };
+    /**
+     * Connection options overrides, merged on top of values loaded via envconfig.
+     */
+    connectionOptions?: Partial<NativeConnectionOptions>;
+    /**
+     * Namespace override. Falls back to the envconfig-loaded value, then `"default"`.
+     */
+    namespace?: string;
+    /**
+     * Time in milliseconds before the Lambda invocation deadline at which the worker
+     * begins its shutdown sequence (graceful drain + shutdown hooks).
+     *
+     * @default 7000 (5s graceful shutdown + 2s margin)
+     */
+    shutdownDeadlineBufferMs?: number;
+    /**
+     * Options for the Temporal {@link Runtime} singleton, installed automatically by `runWorker`.
+     *
+     * Pre-populated with a Powertools JSON logger (if `@aws-lambda-powertools/logger` is installed)
+     * and `shutdownSignals: []` (Lambda manages its own lifecycle).
+     *
+     * Override `runtimeOptions.logger` to use a custom logger, or modify `runtimeOptions.telemetryOptions`
+     * to configure Core-side telemetry.
+     */
+    runtimeOptions: RuntimeOptions;
+    /**
+     * Hooks executed in order after the worker stops on each invocation.
+     * Each hook's errors are caught and logged without preventing subsequent hooks.
+     */
+    shutdownHooks: ShutdownHook[];
+}
+/**
+ * The Lambda handler function returned by {@link runWorker}.
+ */
+export type LambdaHandler = (event: unknown, context: Context) => Promise<void>;

package/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@temporalio/lambda-worker",
+  "version": "1.17.0",
+  "description": "Temporal.io SDK AWS Lambda Worker",
+  "main": "lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./otel": {
+      "types": "./lib/otel.d.ts",
+      "default": "./lib/otel.js"
+    },
+    "./lib/*": {
+      "types": "./lib/*.d.ts",
+      "default": "./lib/*.js"
+    }
+  },
+  "keywords": [
+    "temporal",
+    "aws",
+    "lambda",
+    "worker"
+  ],
+  "author": "Temporal Technologies Inc. <sdk@temporal.io>",
+  "license": "MIT",
+  "dependencies": {
+    "@temporalio/common": "1.17.0",
+    "@temporalio/envconfig": "1.17.0",
+    "@temporalio/worker": "1.17.0"
+  },
+  "devDependencies": {
+    "@aws-lambda-powertools/logger": "^2.0.0",
+    "@types/aws-lambda": "^8.10.145"
+  },
+  "peerDependencies": {
+    "@aws-lambda-powertools/logger": "^2.0.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.52.0",
+    "@opentelemetry/resources": "^1.25.1",
+    "@opentelemetry/sdk-trace-base": "^1.25.1",
+    "@types/aws-lambda": "^8.10.145",
+    "@temporalio/interceptors-opentelemetry": "1.17.0"
+  },
+  "peerDependenciesMeta": {
+    "@aws-lambda-powertools/logger": {
+      "optional": true
+    },
+    "@temporalio/interceptors-opentelemetry": {
+      "optional": true
+    },
+    "@opentelemetry/exporter-trace-otlp-grpc": {
+      "optional": true
+    },
+    "@opentelemetry/resources": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-trace-base": {
+      "optional": true
+    },
+    "@types/aws-lambda": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">= 20.0.0"
+  },
+  "bugs": {
+    "url": "https://github.com/temporalio/sdk-typescript/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/temporalio/sdk-typescript.git",
+    "directory": "packages/lambda-worker"
+  },
+  "homepage": "https://github.com/temporalio/sdk-typescript/tree/main/packages/lambda-worker",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "lib"
+  ],
+  "scripts": {}
+}

package/src/config.ts

@@ -0,0 +1,53 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {
+  type ClientConnectConfig,
+  type LoadClientProfileOptions,
+  loadClientConnectConfig,
+} from '@temporalio/envconfig';
+
+/**
+ * Load client connection config with Lambda-aware config file resolution.
+ *
+ * Resolution order:
+ * 1. User-provided `configSource` in options (passthrough)
+ * 2. `TEMPORAL_CONFIG_FILE` env var (handled by envconfig)
+ * 3. `$LAMBDA_TASK_ROOT/temporal.toml`
+ * 4. `process.cwd()/temporal.toml`
+ * 5. Envconfig default (XDG paths / env-only)
+ */
+export function loadLambdaClientConnectConfig(options?: Partial<LoadClientProfileOptions>): ClientConnectConfig {
+  const resolvedOptions: LoadClientProfileOptions = { ...options };
+
+  // If the user provided a configSource or TEMPORAL_CONFIG_FILE is set, let envconfig handle it
+  if (!resolvedOptions.configSource && !process.env['TEMPORAL_CONFIG_FILE']) {
+    const lambdaConfigPath = findLambdaConfigFile();
+    if (lambdaConfigPath) {
+      resolvedOptions.configSource = { path: lambdaConfigPath };
+    }
+  }
+
+  return loadClientConnectConfig(resolvedOptions);
+}
+
+function findLambdaConfigFile(): string | undefined {
+  const candidates: string[] = [];
+
+  const lambdaTaskRoot = process.env['LAMBDA_TASK_ROOT'];
+  if (lambdaTaskRoot) {
+    candidates.push(path.join(lambdaTaskRoot, 'temporal.toml'));
+  }
+
+  candidates.push(path.join(process.cwd(), 'temporal.toml'));
+
+  for (const candidate of candidates) {
+    try {
+      fs.accessSync(candidate, fs.constants.R_OK);
+      return candidate;
+    } catch {
+      // File doesn't exist or isn't readable, try next
+    }
+  }
+
+  return undefined;
+}

package/src/defaults.ts

@@ -0,0 +1,30 @@
+import type { WorkerOptions } from '@temporalio/worker';
+
+/** Minimum work time in ms — error if less. */
+export const MINIMUM_WORK_TIME_MS = 1000;
+
+/** Low work time threshold in ms — warn if less. */
+export const WARN_WORK_TIME_MS = 5000;
+
+/**
+ * Default buffer in ms before the Lambda deadline to begin shutdown.
+ * Equals the default shutdownGraceTime (5s) + 2s margin.
+ */
+export const DEFAULT_SHUTDOWN_DEADLINE_BUFFER_MS = 7000;
+
+/**
+ * Lambda-tuned worker defaults. These are conservative values appropriate for
+ * Lambda's memory and CPU constraints. Users can override any of these via the
+ * configure callback.
+ */
+export const LAMBDA_WORKER_DEFAULTS: Partial<WorkerOptions> = {
+  maxConcurrentActivityTaskExecutions: 2,
+  maxConcurrentWorkflowTaskExecutions: 10,
+  maxConcurrentLocalActivityExecutions: 2,
+  maxConcurrentNexusTaskExecutions: 5,
+  shutdownGraceTime: '5s',
+  maxCachedWorkflows: 30,
+  workflowTaskPollerBehavior: { type: 'simple-maximum', maximum: 2 },
+  activityTaskPollerBehavior: { type: 'simple-maximum', maximum: 1 },
+  nexusTaskPollerBehavior: { type: 'simple-maximum', maximum: 1 },
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export { runWorker } from './lambda-worker';
+export { PowertoolsLoggerAdapter } from './json-logger';
+export type { LambdaWorkerConfig, LambdaHandler, ShutdownHook } from './types';

package/src/json-logger.ts

@@ -0,0 +1,69 @@
+import type { Logger as PowertoolsLogger } from '@aws-lambda-powertools/logger';
+import type { Context } from 'aws-lambda';
+import type { LogLevel, LogMetadata } from '@temporalio/common';
+import type { Logger } from '@temporalio/worker';
+
+/**
+ * Adapter that wraps an AWS Lambda Powertools Logger to implement the Temporal SDK Logger interface.
+ *
+ * This is used as the default logger for the Lambda worker, producing structured JSON output
+ * that CloudWatch Logs automatically parses.
+ *
+ * @example
+ * ```ts
+ * import { Logger } from '@aws-lambda-powertools/logger';
+ * import { PowertoolsLoggerAdapter } from '@temporalio/lambda-worker';
+ *
+ * const adapter = new PowertoolsLoggerAdapter(new Logger({ serviceName: 'my-worker' }));
+ * ```
+ */
+export class PowertoolsLoggerAdapter implements Logger {
+  constructor(private readonly ptLogger: PowertoolsLogger) {}
+
+  addContext(context: Context): void {
+    this.ptLogger.addContext(context);
+  }
+
+  log(level: LogLevel, message: string, meta?: LogMetadata): void {
+    switch (level) {
+      case 'TRACE':
+        this.ptLogger.debug(message, { ...meta, traceLevel: true });
+        break;
+      case 'DEBUG':
+        this.ptLogger.debug(message, meta as Record<string, unknown>);
+        break;
+      case 'INFO':
+        this.ptLogger.info(message, meta as Record<string, unknown>);
+        break;
+      case 'WARN':
+        this.ptLogger.warn(message, meta as Record<string, unknown>);
+        break;
+      case 'ERROR':
+        this.ptLogger.error(message, meta as Record<string, unknown>);
+        break;
+      default:
+        level satisfies never;
+        break;
+    }
+  }
+
+  trace(message: string, meta?: LogMetadata): void {
+    this.log('TRACE', message, meta);
+  }
+
+  debug(message: string, meta?: LogMetadata): void {
+    this.log('DEBUG', message, meta);
+  }
+
+  info(message: string, meta?: LogMetadata): void {
+    this.log('INFO', message, meta);
+  }
+
+  warn(message: string, meta?: LogMetadata): void {
+    this.log('WARN', message, meta);
+  }
+
+  error(message: string, meta?: LogMetadata): void {
+    this.log('ERROR', message, meta);
+  }
+}