@slates-integrations/aws-lambda 0.2.0-rc.6

package/src/tools/invoke-function.ts

@@ -0,0 +1,94 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let invokeFunction = SlateTool.create(spec, {
+  name: 'Invoke Function',
+  key: 'invoke_function',
+  description: `Invoke a Lambda function synchronously or asynchronously. **Synchronous** (RequestResponse) returns the function's output. **Asynchronous** (Event) queues the event and returns immediately. Use **DryRun** to validate permissions without executing.`,
+  instructions: [
+    'Synchronous invocations have a 6MB payload limit and return the function result.',
+    'Asynchronous invocations have a 1MB payload limit and return a 202 status immediately.',
+    'Set logType to "Tail" to get the last 4KB of execution logs in the response.'
+  ]
+})
+  .input(
+    z.object({
+      functionName: z.string().describe('Function name, ARN, or partial ARN'),
+      payload: z.any().optional().describe('JSON payload to send to the function'),
+      invocationType: z
+        .enum(['RequestResponse', 'Event', 'DryRun'])
+        .optional()
+        .describe('Invocation type (default: RequestResponse)'),
+      qualifier: z.string().optional().describe('Version or alias to invoke'),
+      logType: z
+        .enum(['None', 'Tail'])
+        .optional()
+        .describe('Set to "Tail" to include execution logs'),
+      clientContext: z
+        .string()
+        .optional()
+        .describe('Base64-encoded client context for synchronous invocations'),
+      durableExecutionName: z
+        .string()
+        .optional()
+        .describe('Optional durable execution name for durable functions'),
+      tenantId: z.string().optional().describe('Tenant identifier for multi-tenant functions')
+    })
+  )
+  .output(
+    z.object({
+      statusCode: z
+        .number()
+        .optional()
+        .describe('HTTP status code (200=sync, 202=async, 204=dry run)'),
+      response: z.any().optional().describe('Function response payload (synchronous only)'),
+      functionError: z
+        .string()
+        .optional()
+        .describe('Error type if the function returned an error'),
+      executedVersion: z.string().optional().describe('Version that was executed'),
+      logResult: z
+        .string()
+        .optional()
+        .describe('Last 4KB of execution log (when logType is Tail)'),
+      durableExecutionArn: z
+        .string()
+        .optional()
+        .describe('Durable execution ARN returned by durable function invocations')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+
+    let result = await client.invokeFunction(ctx.input.functionName, ctx.input.payload, {
+      invocationType: ctx.input.invocationType,
+      logType: ctx.input.logType,
+      qualifier: ctx.input.qualifier,
+      clientContext: ctx.input.clientContext,
+      durableExecutionName: ctx.input.durableExecutionName,
+      tenantId: ctx.input.tenantId
+    });
+
+    let invType = ctx.input.invocationType || 'RequestResponse';
+    let msg =
+      invType === 'Event'
+        ? `Function **${ctx.input.functionName}** invoked asynchronously.`
+        : invType === 'DryRun'
+          ? `Dry run completed for **${ctx.input.functionName}** — permissions validated.`
+          : `Function **${ctx.input.functionName}** invoked successfully.`;
+
+    return {
+      output: {
+        statusCode: result?.StatusCode,
+        response: result?.Payload,
+        functionError: result?.FunctionError,
+        executedVersion: result?.ExecutedVersion,
+        logResult: result?.LogResult,
+        durableExecutionArn: result?.DurableExecutionArn
+      },
+      message: msg
+    };
+  })
+  .build();

package/src/tools/list-functions.ts

@@ -0,0 +1,88 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let functionConfigSchema = z.object({
+  functionName: z.string().optional().describe('Name of the function'),
+  functionArn: z.string().optional().describe('ARN of the function'),
+  runtime: z
+    .string()
+    .optional()
+    .describe('Runtime environment (e.g., nodejs22.x, python3.13)'),
+  role: z.string().optional().describe('Execution role ARN'),
+  handler: z.string().optional().describe('Function handler (e.g., index.handler)'),
+  codeSize: z.number().optional().describe('Size of the deployment package in bytes'),
+  description: z.string().optional().describe('Function description'),
+  timeout: z.number().optional().describe('Execution timeout in seconds'),
+  memorySize: z.number().optional().describe('Memory allocated in MB'),
+  lastModified: z.string().optional().describe('Last modified timestamp'),
+  version: z.string().optional().describe('Function version'),
+  state: z.string().optional().describe('Current state of the function'),
+  packageType: z.string().optional().describe('Deployment package type (Zip or Image)'),
+  architectures: z.array(z.string()).optional().describe('Instruction set architectures')
+});
+
+export let listFunctions = SlateTool.create(spec, {
+  name: 'List Functions',
+  key: 'list_functions',
+  description: `List Lambda functions in the configured AWS region. Returns function names, ARNs, runtimes, and key configuration. Use **maxItems** to control page size and **marker** for pagination.`,
+  tags: {
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      maxItems: z
+        .number()
+        .optional()
+        .describe('Maximum number of functions to return (1-10000)'),
+      marker: z.string().optional().describe('Pagination token from previous response'),
+      includeAllVersions: z
+        .boolean()
+        .optional()
+        .describe('Set to true to include all published versions')
+    })
+  )
+  .output(
+    z.object({
+      functions: z.array(functionConfigSchema).describe('List of Lambda functions'),
+      nextMarker: z.string().optional().describe('Pagination token for the next page')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+
+    let functionVersion = ctx.input.includeAllVersions ? 'ALL' : undefined;
+    let result = await client.listFunctions(
+      ctx.input.marker,
+      ctx.input.maxItems,
+      functionVersion
+    );
+
+    let functions = (result.Functions || []).map((f: any) => ({
+      functionName: f.FunctionName,
+      functionArn: f.FunctionArn,
+      runtime: f.Runtime,
+      role: f.Role,
+      handler: f.Handler,
+      codeSize: f.CodeSize,
+      description: f.Description,
+      timeout: f.Timeout,
+      memorySize: f.MemorySize,
+      lastModified: f.LastModified,
+      version: f.Version,
+      state: f.State,
+      packageType: f.PackageType,
+      architectures: f.Architectures
+    }));
+
+    return {
+      output: {
+        functions,
+        nextMarker: result.NextMarker
+      },
+      message: `Found **${functions.length}** Lambda function(s)${result.NextMarker ? ' (more available)' : ''}.`
+    };
+  })
+  .build();

package/src/tools/manage-alias.ts

@@ -0,0 +1,159 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { lambdaServiceError } from '../lib/errors';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let routingConfigSchema = z
+  .object({
+    additionalVersionWeights: z
+      .record(z.string(), z.number())
+      .optional()
+      .describe(
+        'Version-to-weight mapping for traffic shifting (e.g., {"2": 0.1} routes 10% to version 2)'
+      )
+  })
+  .optional();
+
+export let manageAlias = SlateTool.create(spec, {
+  name: 'Manage Alias',
+  key: 'manage_alias',
+  description: `Create, update, get, delete, or list aliases for a Lambda function. Aliases are named pointers to function versions, enabling canary and blue/green deployments via weighted traffic shifting.`,
+  instructions: [
+    'Use **action** to specify the operation: "create", "update", "get", "delete", or "list".',
+    'For traffic shifting, use routingConfig to split traffic between the primary version and one additional version.'
+  ]
+})
+  .input(
+    z.object({
+      action: z
+        .enum(['create', 'update', 'get', 'delete', 'list'])
+        .describe('Operation to perform'),
+      functionName: z.string().describe('Function name or ARN'),
+      aliasName: z
+        .string()
+        .optional()
+        .describe('Alias name (required for create/update/get/delete)'),
+      functionVersion: z
+        .string()
+        .optional()
+        .describe(
+          'Function version the alias points to (required for create, optional for update)'
+        ),
+      description: z.string().optional().describe('Alias description'),
+      routingConfig: routingConfigSchema.describe(
+        'Traffic routing configuration for weighted aliases'
+      )
+    })
+  )
+  .output(
+    z.object({
+      aliasArn: z.string().optional().describe('Alias ARN'),
+      aliasName: z.string().optional().describe('Alias name'),
+      functionVersion: z.string().optional().describe('Version the alias points to'),
+      description: z.string().optional().describe('Alias description'),
+      routingConfig: z.any().optional().describe('Traffic routing configuration'),
+      aliases: z
+        .array(
+          z.object({
+            aliasArn: z.string().optional(),
+            aliasName: z.string().optional(),
+            functionVersion: z.string().optional(),
+            description: z.string().optional()
+          })
+        )
+        .optional()
+        .describe('List of aliases (for list action)'),
+      deleted: z.boolean().optional().describe('Whether the alias was deleted')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action, functionName, aliasName } = ctx.input;
+
+    if (action === 'list') {
+      let result = await client.listAliases(functionName);
+      let aliases = (result.Aliases || []).map((a: any) => ({
+        aliasArn: a.AliasArn,
+        aliasName: a.Name,
+        functionVersion: a.FunctionVersion,
+        description: a.Description
+      }));
+      return {
+        output: { aliases },
+        message: `Found **${aliases.length}** alias(es) for **${functionName}**.`
+      };
+    }
+
+    if (!aliasName) throw lambdaServiceError('aliasName is required for this action');
+
+    if (action === 'get') {
+      let result = await client.getAlias(functionName, aliasName);
+      return {
+        output: {
+          aliasArn: result.AliasArn,
+          aliasName: result.Name,
+          functionVersion: result.FunctionVersion,
+          description: result.Description,
+          routingConfig: result.RoutingConfig
+        },
+        message: `Alias **${aliasName}** points to version **${result.FunctionVersion}**.`
+      };
+    }
+
+    if (action === 'delete') {
+      await client.deleteAlias(functionName, aliasName);
+      return {
+        output: { deleted: true },
+        message: `Deleted alias **${aliasName}** from function **${functionName}**.`
+      };
+    }
+
+    if (action === 'create') {
+      if (!ctx.input.functionVersion)
+        throw lambdaServiceError('functionVersion is required for creating an alias');
+      let params: Record<string, any> = {
+        Name: aliasName,
+        FunctionVersion: ctx.input.functionVersion
+      };
+      if (ctx.input.description) params['Description'] = ctx.input.description;
+      if (ctx.input.routingConfig?.additionalVersionWeights) {
+        params['RoutingConfig'] = {
+          AdditionalVersionWeights: ctx.input.routingConfig.additionalVersionWeights
+        };
+      }
+      let result = await client.createAlias(functionName, params);
+      return {
+        output: {
+          aliasArn: result.AliasArn,
+          aliasName: result.Name,
+          functionVersion: result.FunctionVersion,
+          description: result.Description,
+          routingConfig: result.RoutingConfig
+        },
+        message: `Created alias **${result.Name}** → version **${result.FunctionVersion}**.`
+      };
+    }
+
+    // update
+    let params: Record<string, any> = {};
+    if (ctx.input.functionVersion) params['FunctionVersion'] = ctx.input.functionVersion;
+    if (ctx.input.description !== undefined) params['Description'] = ctx.input.description;
+    if (ctx.input.routingConfig?.additionalVersionWeights) {
+      params['RoutingConfig'] = {
+        AdditionalVersionWeights: ctx.input.routingConfig.additionalVersionWeights
+      };
+    }
+    let result = await client.updateAlias(functionName, aliasName, params);
+    return {
+      output: {
+        aliasArn: result.AliasArn,
+        aliasName: result.Name,
+        functionVersion: result.FunctionVersion,
+        description: result.Description,
+        routingConfig: result.RoutingConfig
+      },
+      message: `Updated alias **${result.Name}** → version **${result.FunctionVersion}**.`
+    };
+  })
+  .build();

package/src/tools/manage-concurrency.ts

@@ -0,0 +1,141 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { lambdaServiceError } from '../lib/errors';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let manageConcurrency = SlateTool.create(spec, {
+  name: 'Manage Concurrency',
+  key: 'manage_concurrency',
+  description: `Configure reserved and provisioned concurrency for a Lambda function. **Reserved concurrency** guarantees a set amount of concurrent executions. **Provisioned concurrency** keeps execution environments warm to eliminate cold starts.`,
+  instructions: [
+    'Use concurrencyType "reserved" to manage reserved concurrency, or "provisioned" for provisioned concurrency.',
+    'For provisioned concurrency, a qualifier (version number or alias) is required.',
+    'Use action "get" to check current settings, "set" to configure, or "delete" to remove.'
+  ]
+})
+  .input(
+    z.object({
+      action: z.enum(['get', 'set', 'delete']).describe('Operation to perform'),
+      functionName: z.string().describe('Function name or ARN'),
+      concurrencyType: z
+        .enum(['reserved', 'provisioned'])
+        .describe('Type of concurrency to manage'),
+      concurrentExecutions: z
+        .number()
+        .optional()
+        .describe('Number of concurrent executions to reserve/provision'),
+      qualifier: z
+        .string()
+        .optional()
+        .describe('Version or alias (required for provisioned concurrency)')
+    })
+  )
+  .output(
+    z.object({
+      reservedConcurrentExecutions: z
+        .number()
+        .optional()
+        .describe('Reserved concurrent executions'),
+      provisionedConcurrentExecutions: z
+        .number()
+        .optional()
+        .describe('Provisioned concurrent executions'),
+      allocatedProvisionedConcurrency: z
+        .number()
+        .optional()
+        .describe('Actually allocated provisioned concurrency'),
+      availableProvisionedConcurrency: z
+        .number()
+        .optional()
+        .describe('Available provisioned concurrency'),
+      status: z.string().optional().describe('Provisioned concurrency status'),
+      deleted: z.boolean().optional()
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action, functionName, concurrencyType } = ctx.input;
+
+    if (concurrencyType === 'reserved') {
+      if (action === 'get') {
+        let result = await client.getFunctionConcurrency(functionName);
+        return {
+          output: { reservedConcurrentExecutions: result.ReservedConcurrentExecutions },
+          message:
+            result.ReservedConcurrentExecutions !== undefined
+              ? `Reserved concurrency for **${functionName}**: **${result.ReservedConcurrentExecutions}**.`
+              : `No reserved concurrency configured for **${functionName}**.`
+        };
+      }
+      if (action === 'delete') {
+        await client.deleteFunctionConcurrency(functionName);
+        return {
+          output: { deleted: true },
+          message: `Removed reserved concurrency from **${functionName}**.`
+        };
+      }
+      if (!ctx.input.concurrentExecutions && ctx.input.concurrentExecutions !== 0) {
+        throw lambdaServiceError(
+          'concurrentExecutions is required to set reserved concurrency'
+        );
+      }
+      let result = await client.putFunctionConcurrency(
+        functionName,
+        ctx.input.concurrentExecutions
+      );
+      return {
+        output: { reservedConcurrentExecutions: result.ReservedConcurrentExecutions },
+        message: `Set reserved concurrency for **${functionName}** to **${result.ReservedConcurrentExecutions}**.`
+      };
+    }
+
+    // provisioned
+    if (!ctx.input.qualifier)
+      throw lambdaServiceError('qualifier is required for provisioned concurrency');
+
+    if (action === 'get') {
+      let result = await client.getProvisionedConcurrencyConfig(
+        functionName,
+        ctx.input.qualifier
+      );
+      return {
+        output: {
+          provisionedConcurrentExecutions: result.RequestedProvisionedConcurrentExecutions,
+          allocatedProvisionedConcurrency: result.AllocatedProvisionedConcurrentExecutions,
+          availableProvisionedConcurrency: result.AvailableProvisionedConcurrentExecutions,
+          status: result.Status
+        },
+        message: `Provisioned concurrency for **${functionName}:${ctx.input.qualifier}**: requested=${result.RequestedProvisionedConcurrentExecutions}, status=${result.Status}.`
+      };
+    }
+
+    if (action === 'delete') {
+      await client.deleteProvisionedConcurrencyConfig(functionName, ctx.input.qualifier);
+      return {
+        output: { deleted: true },
+        message: `Removed provisioned concurrency from **${functionName}:${ctx.input.qualifier}**.`
+      };
+    }
+
+    if (!ctx.input.concurrentExecutions) {
+      throw lambdaServiceError(
+        'concurrentExecutions is required to set provisioned concurrency'
+      );
+    }
+    let result = await client.putProvisionedConcurrencyConfig(
+      functionName,
+      ctx.input.qualifier,
+      ctx.input.concurrentExecutions
+    );
+    return {
+      output: {
+        provisionedConcurrentExecutions: result.RequestedProvisionedConcurrentExecutions,
+        allocatedProvisionedConcurrency: result.AllocatedProvisionedConcurrentExecutions,
+        availableProvisionedConcurrency: result.AvailableProvisionedConcurrentExecutions,
+        status: result.Status
+      },
+      message: `Set provisioned concurrency for **${functionName}:${ctx.input.qualifier}** to **${ctx.input.concurrentExecutions}** (status: ${result.Status}).`
+    };
+  })
+  .build();

package/src/tools/manage-durable-execution.ts

@@ -0,0 +1,209 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { lambdaServiceError } from '../lib/errors';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let manageDurableExecution = SlateTool.create(spec, {
+  name: 'Manage Durable Execution',
+  key: 'manage_durable_execution',
+  description: `Inspect, list, stop, or send callbacks for Lambda durable executions. Durable executions are long-running, stateful workflows that can be checkpointed and resumed. Supports viewing execution history, state, and sending callback signals for human-in-the-loop patterns.`,
+  instructions: [
+    'Use **action** to specify: "get", "get_history", "get_state", "list", "stop", "callback_success", "callback_failure", or "callback_heartbeat".',
+    'For "list", provide a functionName. For most other actions, provide a durableExecutionArn.',
+    'For "get_state", provide checkpointToken.',
+    'For callback actions, provide a callbackId.'
+  ]
+})
+  .input(
+    z.object({
+      action: z
+        .enum([
+          'get',
+          'get_history',
+          'get_state',
+          'list',
+          'stop',
+          'callback_success',
+          'callback_failure',
+          'callback_heartbeat'
+        ])
+        .describe('Operation to perform'),
+      durableExecutionArn: z
+        .string()
+        .optional()
+        .describe('Durable execution ARN (for get/get_history/get_state/stop)'),
+      functionName: z.string().optional().describe('Function name (required for list)'),
+      callbackId: z
+        .string()
+        .optional()
+        .describe('Callback ID (required for callback actions)'),
+      checkpointToken: z
+        .string()
+        .optional()
+        .describe('Checkpoint token required when retrieving durable execution state'),
+      callbackResult: z.any().optional().describe('Result payload for callback_success'),
+      stopErrorMessage: z
+        .string()
+        .optional()
+        .describe('Error message when stopping execution'),
+      stopErrorType: z.string().optional().describe('Error type when stopping execution'),
+      statusFilter: z
+        .enum(['RUNNING', 'SUCCEEDED', 'FAILED', 'TIMED_OUT', 'STOPPED'])
+        .optional()
+        .describe('Filter by status (for list)'),
+      maxItems: z
+        .number()
+        .optional()
+        .describe('Maximum items to return (for list/get_history)')
+    })
+  )
+  .output(
+    z.object({
+      durableExecutionArn: z.string().optional().describe('Durable execution ARN'),
+      durableExecutionName: z.string().optional().describe('Durable execution name'),
+      status: z.string().optional().describe('Execution status'),
+      startTimestamp: z.string().optional().describe('Start timestamp'),
+      endTimestamp: z.string().optional().describe('End timestamp'),
+      inputPayload: z.any().optional().describe('Input payload'),
+      result: z.any().optional().describe('Execution result'),
+      error: z.any().optional().describe('Execution error'),
+      functionArn: z.string().optional().describe('Associated function ARN'),
+      history: z.any().optional().describe('Execution history events'),
+      state: z.any().optional().describe('Current execution state'),
+      executions: z
+        .array(
+          z.object({
+            durableExecutionArn: z.string().optional(),
+            durableExecutionName: z.string().optional(),
+            status: z.string().optional(),
+            startTimestamp: z.string().optional()
+          })
+        )
+        .optional()
+        .describe('List of executions'),
+      stopTimestamp: z.string().optional().describe('Stop timestamp'),
+      callbackSent: z.boolean().optional()
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action } = ctx.input;
+
+    if (action === 'list') {
+      if (!ctx.input.functionName)
+        throw lambdaServiceError('functionName is required for list');
+      let result = await client.listDurableExecutionsByFunction(
+        ctx.input.functionName,
+        ctx.input.statusFilter,
+        undefined,
+        ctx.input.maxItems
+      );
+      let executions = (result.DurableExecutions || []).map((e: any) => ({
+        durableExecutionArn: e.DurableExecutionArn,
+        durableExecutionName: e.DurableExecutionName,
+        status: e.Status,
+        startTimestamp: e.StartTimestamp ? String(e.StartTimestamp) : undefined
+      }));
+      return {
+        output: { executions },
+        message: `Found **${executions.length}** durable execution(s) for **${ctx.input.functionName}**.`
+      };
+    }
+
+    if (action === 'get') {
+      if (!ctx.input.durableExecutionArn)
+        throw lambdaServiceError('durableExecutionArn is required');
+      let result = await client.getDurableExecution(ctx.input.durableExecutionArn);
+      return {
+        output: {
+          durableExecutionArn: result.DurableExecutionArn,
+          durableExecutionName: result.DurableExecutionName,
+          status: result.Status,
+          startTimestamp: result.StartTimestamp ? String(result.StartTimestamp) : undefined,
+          endTimestamp: result.EndTimestamp ? String(result.EndTimestamp) : undefined,
+          inputPayload: result.InputPayload,
+          result: result.Result,
+          error: result.Error,
+          functionArn: result.FunctionArn
+        },
+        message: `Durable execution **${result.DurableExecutionName || result.DurableExecutionArn}** is **${result.Status}**.`
+      };
+    }
+
+    if (action === 'get_history') {
+      if (!ctx.input.durableExecutionArn)
+        throw lambdaServiceError('durableExecutionArn is required');
+      let result = await client.getDurableExecutionHistory(
+        ctx.input.durableExecutionArn,
+        undefined,
+        ctx.input.maxItems
+      );
+      return {
+        output: { history: result },
+        message: `Retrieved history for durable execution.`
+      };
+    }
+
+    if (action === 'get_state') {
+      if (!ctx.input.durableExecutionArn)
+        throw lambdaServiceError('durableExecutionArn is required');
+      if (!ctx.input.checkpointToken)
+        throw lambdaServiceError('checkpointToken is required for get_state');
+      let result = await client.getDurableExecutionState(
+        ctx.input.durableExecutionArn,
+        ctx.input.checkpointToken,
+        undefined,
+        ctx.input.maxItems
+      );
+      return {
+        output: { state: result },
+        message: `Retrieved state for durable execution.`
+      };
+    }
+
+    if (action === 'stop') {
+      if (!ctx.input.durableExecutionArn)
+        throw lambdaServiceError('durableExecutionArn is required');
+      let params: Record<string, any> = {};
+      if (ctx.input.stopErrorMessage) params['ErrorMessage'] = ctx.input.stopErrorMessage;
+      if (ctx.input.stopErrorType) params['ErrorType'] = ctx.input.stopErrorType;
+      let result = await client.stopDurableExecution(ctx.input.durableExecutionArn, params);
+      return {
+        output: {
+          stopTimestamp: result.StopTimestamp ? String(result.StopTimestamp) : undefined
+        },
+        message: `Stopped durable execution.`
+      };
+    }
+
+    if (action === 'callback_success') {
+      if (!ctx.input.callbackId) throw lambdaServiceError('callbackId is required');
+      await client.sendDurableExecutionCallbackSuccess(
+        ctx.input.callbackId,
+        ctx.input.callbackResult
+      );
+      return {
+        output: { callbackSent: true },
+        message: `Sent success callback for **${ctx.input.callbackId}**.`
+      };
+    }
+
+    if (action === 'callback_failure') {
+      if (!ctx.input.callbackId) throw lambdaServiceError('callbackId is required');
+      await client.sendDurableExecutionCallbackFailure(ctx.input.callbackId);
+      return {
+        output: { callbackSent: true },
+        message: `Sent failure callback for **${ctx.input.callbackId}**.`
+      };
+    }
+
+    // callback_heartbeat
+    if (!ctx.input.callbackId) throw lambdaServiceError('callbackId is required');
+    await client.sendDurableExecutionCallbackHeartbeat(ctx.input.callbackId);
+    return {
+      output: { callbackSent: true },
+      message: `Sent heartbeat for callback **${ctx.input.callbackId}**.`
+    };
+  })
+  .build();