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

package/src/lib/errors.ts

@@ -0,0 +1,101 @@
+import { ServiceError, badRequestError } from '@lowerdeck/error';
+
+type ErrorResponse = {
+  status?: number;
+  statusText?: string;
+  data?: unknown;
+};
+
+let isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+let pushString = (messages: string[], value: unknown) => {
+  if (typeof value === 'string' && value.trim() && !messages.includes(value.trim())) {
+    messages.push(value.trim());
+  }
+};
+
+let extractLambdaMessage = (error: unknown) => {
+  let response = isRecord(error) ? (error.response as ErrorResponse | undefined) : undefined;
+  let data = response?.data;
+  let messages: string[] = [];
+
+  if (isRecord(data)) {
+    for (let key of [
+      'message',
+      'Message',
+      'error',
+      'Error',
+      'code',
+      'Code',
+      '__type',
+      'Type'
+    ]) {
+      pushString(messages, data[key]);
+    }
+  } else {
+    pushString(messages, data);
+  }
+
+  if (messages.length > 0) {
+    return [...new Set(messages)].join(' - ');
+  }
+
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+
+  return 'Unknown error';
+};
+
+let extractLambdaStatus = (error: unknown) => {
+  if (!isRecord(error)) return undefined;
+
+  let response = error.response as ErrorResponse | undefined;
+  let metadata = isRecord(error.$metadata) ? error.$metadata : undefined;
+  let status =
+    response?.status ?? metadata?.httpStatusCode ?? error.statusCode ?? error.status;
+  return typeof status === 'number' || typeof status === 'string' ? status : undefined;
+};
+
+let extractLambdaCode = (error: unknown) => {
+  if (!isRecord(error)) return undefined;
+
+  if (typeof error.Code === 'string') return error.Code;
+  if (typeof error.code === 'string' && !error.code.startsWith('upstream.')) {
+    return error.code;
+  }
+  if (typeof error.name === 'string' && error.name !== 'Error') return error.name;
+  return undefined;
+};
+
+export let lambdaServiceError = (message: string) =>
+  new ServiceError(badRequestError({ message }));
+
+export let lambdaApiError = (error: unknown, operation = 'request') => {
+  if (error instanceof ServiceError) {
+    return error;
+  }
+
+  let response = isRecord(error) ? (error.response as ErrorResponse | undefined) : undefined;
+  let status = extractLambdaStatus(error);
+  let code = extractLambdaCode(error);
+  let statusLabel =
+    status !== undefined
+      ? `HTTP ${status}${response?.statusText ? ` ${response.statusText}` : ''}: `
+      : '';
+  let codeLabel = code ? `${code} - ` : '';
+  let serviceError = lambdaServiceError(
+    `AWS Lambda API ${operation} failed: ${statusLabel}${codeLabel}${extractLambdaMessage(error)}`
+  );
+
+  serviceError.data.reason = 'aws_lambda_api_error';
+  serviceError.data.upstreamStatus = status;
+  serviceError.data.upstreamCode = code;
+
+  if (error instanceof Error) {
+    serviceError.setParent(error);
+  }
+
+  return serviceError;
+};

package/src/lib/helpers.ts

@@ -0,0 +1,15 @@
+import { LambdaClient } from './client';
+
+export let createClient = (
+  config: { region: string },
+  auth: { accessKeyId: string; secretAccessKey: string; sessionToken?: string }
+): LambdaClient => {
+  return new LambdaClient({
+    region: config.region,
+    credentials: {
+      accessKeyId: auth.accessKeyId,
+      secretAccessKey: auth.secretAccessKey,
+      sessionToken: auth.sessionToken
+    }
+  });
+};

package/src/spec.ts

@@ -0,0 +1,13 @@
+import { SlateSpecification } from 'slates';
+import { auth } from './auth';
+import { config } from './config';
+
+export let spec = SlateSpecification.create({
+  key: 'aws-lambda',
+  name: 'AWS Lambda',
+  description:
+    'Serverless compute service for running code in response to events without managing servers.',
+  metadata: {},
+  config,
+  auth
+});

package/src/tools/configure-async-invocation.ts

@@ -0,0 +1,134 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let configureAsyncInvocation = SlateTool.create(spec, {
+  name: 'Configure Async Invocation',
+  key: 'configure_async_invocation',
+  description: `List, get, set, update, or remove the asynchronous invocation configuration for a Lambda function. Controls retry behavior, maximum event age, and destination routing for successful or failed invocations (to SQS, SNS, Lambda, S3, or EventBridge).`,
+  instructions: [
+    'Use **action** "set" to replace the full config, "update" to patch only supplied fields, "get" to view one qualifier, "list" to view all configs, or "delete" to remove.',
+    'Destinations route invocation results to other AWS services for further processing.'
+  ]
+})
+  .input(
+    z.object({
+      action: z
+        .enum(['list', 'get', 'set', 'update', 'delete'])
+        .describe('Operation to perform'),
+      functionName: z.string().describe('Function name or ARN'),
+      qualifier: z.string().optional().describe('Version or alias'),
+      marker: z.string().optional().describe('Pagination token for list'),
+      maxItems: z.number().optional().describe('Maximum configs to return for list (1-50)'),
+      maximumRetryAttempts: z.number().optional().describe('Max retry attempts (0-2)'),
+      maximumEventAgeInSeconds: z
+        .number()
+        .optional()
+        .describe('Max event age before discard (60-21600)'),
+      onSuccessDestinationArn: z
+        .string()
+        .optional()
+        .describe('Destination ARN for successful invocations'),
+      onFailureDestinationArn: z
+        .string()
+        .optional()
+        .describe('Destination ARN for failed invocations')
+    })
+  )
+  .output(
+    z.object({
+      functionArn: z.string().optional().describe('Function ARN'),
+      maximumRetryAttempts: z.number().optional().describe('Max retry attempts'),
+      maximumEventAgeInSeconds: z.number().optional().describe('Max event age in seconds'),
+      onSuccessDestination: z.string().optional().describe('Success destination ARN'),
+      onFailureDestination: z.string().optional().describe('Failure destination ARN'),
+      lastModified: z.string().optional().describe('Last modified timestamp'),
+      configs: z
+        .array(
+          z.object({
+            functionArn: z.string().optional(),
+            maximumRetryAttempts: z.number().optional(),
+            maximumEventAgeInSeconds: z.number().optional(),
+            onSuccessDestination: z.string().optional(),
+            onFailureDestination: z.string().optional(),
+            lastModified: z.string().optional()
+          })
+        )
+        .optional()
+        .describe('Async invocation configs returned by list'),
+      nextMarker: z.string().optional().describe('Pagination token for the next page'),
+      deleted: z.boolean().optional()
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action, functionName, qualifier } = ctx.input;
+
+    let mapConfig = (result: any) => ({
+      functionArn: result.FunctionArn,
+      maximumRetryAttempts: result.MaximumRetryAttempts,
+      maximumEventAgeInSeconds: result.MaximumEventAgeInSeconds,
+      onSuccessDestination: result.DestinationConfig?.OnSuccess?.Destination,
+      onFailureDestination: result.DestinationConfig?.OnFailure?.Destination,
+      lastModified: result.LastModified ? String(result.LastModified) : undefined
+    });
+
+    if (action === 'list') {
+      let result = await client.listFunctionEventInvokeConfigs(
+        functionName,
+        ctx.input.marker,
+        ctx.input.maxItems
+      );
+      let configs = (result.FunctionEventInvokeConfigs || []).map(mapConfig);
+      return {
+        output: {
+          configs,
+          nextMarker: result.NextMarker
+        },
+        message: `Found **${configs.length}** async invocation config(s) for **${functionName}**.`
+      };
+    }
+
+    if (action === 'get') {
+      let result = await client.getFunctionEventInvokeConfig(functionName, qualifier);
+      return {
+        output: mapConfig(result),
+        message: `Async config for **${functionName}**: retries=${result.MaximumRetryAttempts}, maxAge=${result.MaximumEventAgeInSeconds}s.`
+      };
+    }
+
+    if (action === 'delete') {
+      await client.deleteFunctionEventInvokeConfig(functionName, qualifier);
+      return {
+        output: { deleted: true },
+        message: `Removed async invocation config from **${functionName}**.`
+      };
+    }
+
+    let params: Record<string, any> = {};
+    if (ctx.input.maximumRetryAttempts !== undefined)
+      params['MaximumRetryAttempts'] = ctx.input.maximumRetryAttempts;
+    if (ctx.input.maximumEventAgeInSeconds !== undefined)
+      params['MaximumEventAgeInSeconds'] = ctx.input.maximumEventAgeInSeconds;
+
+    let destConfig: Record<string, any> = {};
+    if (ctx.input.onSuccessDestinationArn)
+      destConfig['OnSuccess'] = { Destination: ctx.input.onSuccessDestinationArn };
+    if (ctx.input.onFailureDestinationArn)
+      destConfig['OnFailure'] = { Destination: ctx.input.onFailureDestinationArn };
+    if (Object.keys(destConfig).length > 0) params['DestinationConfig'] = destConfig;
+
+    let result =
+      action === 'update'
+        ? await client.updateFunctionEventInvokeConfig(functionName, params, qualifier)
+        : await client.putFunctionEventInvokeConfig(functionName, params, qualifier);
+    return {
+      output: mapConfig(result),
+      message:
+        action === 'update'
+          ? `Patched async invocation config for **${functionName}**.`
+          : `Updated async invocation config for **${functionName}**.`
+    };
+  })
+  .build();

package/src/tools/create-function.ts

@@ -0,0 +1,127 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let createFunction = SlateTool.create(spec, {
+  name: 'Create Function',
+  key: 'create_function',
+  description: `Create a new Lambda function. Provide the function code via an S3 location, container image URI, or base64-encoded ZIP file. Requires a function name and an IAM execution role ARN at minimum.`,
+  instructions: [
+    'For ZIP deployments, specify runtime and handler. For container images, set packageType to "Image".',
+    'The role must be an IAM role ARN that Lambda can assume (e.g., arn:aws:iam::123456789012:role/my-role).'
+  ]
+})
+  .input(
+    z.object({
+      functionName: z.string().describe('Name for the function (1-64 characters)'),
+      role: z.string().describe('IAM execution role ARN'),
+      code: z
+        .object({
+          s3Bucket: z.string().optional().describe('S3 bucket containing the code package'),
+          s3Key: z.string().optional().describe('S3 object key for the code package'),
+          s3ObjectVersion: z.string().optional().describe('S3 object version'),
+          imageUri: z.string().optional().describe('Container image URI from ECR'),
+          zipFile: z.string().optional().describe('Base64-encoded ZIP file content')
+        })
+        .describe('Function code source'),
+      runtime: z
+        .string()
+        .optional()
+        .describe('Runtime (e.g., nodejs22.x, python3.13, java21)'),
+      handler: z.string().optional().describe('Handler function (e.g., index.handler)'),
+      description: z.string().optional().describe('Function description'),
+      timeout: z
+        .number()
+        .optional()
+        .describe('Execution timeout in seconds (1-900, default 3)'),
+      memorySize: z.number().optional().describe('Memory in MB (128-10240, default 128)'),
+      packageType: z.enum(['Zip', 'Image']).optional().describe('Deployment package type'),
+      architectures: z
+        .array(z.enum(['x86_64', 'arm64']))
+        .optional()
+        .describe('Instruction set architecture'),
+      environment: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Environment variables as key-value pairs'),
+      layers: z.array(z.string()).optional().describe('Layer ARNs to attach (up to 5)'),
+      publish: z.boolean().optional().describe('Publish a version after creation'),
+      ephemeralStorageSize: z
+        .number()
+        .optional()
+        .describe('Ephemeral /tmp storage in MB (512-10240)'),
+      tags: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Resource tags as key-value pairs'),
+      tracingMode: z.enum(['Active', 'PassThrough']).optional().describe('X-Ray tracing mode'),
+      vpcSubnetIds: z.array(z.string()).optional().describe('VPC subnet IDs'),
+      vpcSecurityGroupIds: z.array(z.string()).optional().describe('VPC security group IDs')
+    })
+  )
+  .output(
+    z.object({
+      functionName: z.string().describe('Name of the created function'),
+      functionArn: z.string().describe('ARN of the created function'),
+      runtime: z.string().optional().describe('Runtime environment'),
+      state: z.string().optional().describe('Current state'),
+      version: z.string().optional().describe('Published version'),
+      codeSize: z.number().optional().describe('Code package size in bytes'),
+      lastModified: z.string().optional().describe('Last modified timestamp')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+
+    let codeObj: Record<string, any> = {};
+    if (ctx.input.code.s3Bucket) codeObj['S3Bucket'] = ctx.input.code.s3Bucket;
+    if (ctx.input.code.s3Key) codeObj['S3Key'] = ctx.input.code.s3Key;
+    if (ctx.input.code.s3ObjectVersion)
+      codeObj['S3ObjectVersion'] = ctx.input.code.s3ObjectVersion;
+    if (ctx.input.code.imageUri) codeObj['ImageUri'] = ctx.input.code.imageUri;
+    if (ctx.input.code.zipFile) codeObj['ZipFile'] = ctx.input.code.zipFile;
+
+    let params: Record<string, any> = {
+      FunctionName: ctx.input.functionName,
+      Role: ctx.input.role,
+      Code: codeObj
+    };
+
+    if (ctx.input.runtime) params['Runtime'] = ctx.input.runtime;
+    if (ctx.input.handler) params['Handler'] = ctx.input.handler;
+    if (ctx.input.description) params['Description'] = ctx.input.description;
+    if (ctx.input.timeout) params['Timeout'] = ctx.input.timeout;
+    if (ctx.input.memorySize) params['MemorySize'] = ctx.input.memorySize;
+    if (ctx.input.packageType) params['PackageType'] = ctx.input.packageType;
+    if (ctx.input.architectures) params['Architectures'] = ctx.input.architectures;
+    if (ctx.input.environment) params['Environment'] = { Variables: ctx.input.environment };
+    if (ctx.input.layers) params['Layers'] = ctx.input.layers;
+    if (ctx.input.publish !== undefined) params['Publish'] = ctx.input.publish;
+    if (ctx.input.ephemeralStorageSize)
+      params['EphemeralStorage'] = { Size: ctx.input.ephemeralStorageSize };
+    if (ctx.input.tags) params['Tags'] = ctx.input.tags;
+    if (ctx.input.tracingMode) params['TracingConfig'] = { Mode: ctx.input.tracingMode };
+    if (ctx.input.vpcSubnetIds || ctx.input.vpcSecurityGroupIds) {
+      params['VpcConfig'] = {
+        SubnetIds: ctx.input.vpcSubnetIds || [],
+        SecurityGroupIds: ctx.input.vpcSecurityGroupIds || []
+      };
+    }
+
+    let result = await client.createFunction(params);
+
+    return {
+      output: {
+        functionName: result.FunctionName,
+        functionArn: result.FunctionArn,
+        runtime: result.Runtime,
+        state: result.State,
+        version: result.Version,
+        codeSize: result.CodeSize,
+        lastModified: result.LastModified
+      },
+      message: `Created function **${result.FunctionName}** (${result.FunctionArn}).`
+    };
+  })
+  .build();

package/src/tools/delete-function.ts

@@ -0,0 +1,41 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let deleteFunction = SlateTool.create(spec, {
+  name: 'Delete Function',
+  key: 'delete_function',
+  description: `Delete a Lambda function. Optionally specify a **qualifier** to delete only a specific version (not \`$LATEST\`). Without a qualifier, the entire function including all versions and aliases is deleted.`,
+  tags: {
+    destructive: true
+  }
+})
+  .input(
+    z.object({
+      functionName: z.string().describe('Function name or ARN'),
+      qualifier: z
+        .string()
+        .optional()
+        .describe('Version number to delete (cannot delete $LATEST)')
+    })
+  )
+  .output(
+    z.object({
+      deleted: z.boolean().describe('Whether the deletion was successful')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    await client.deleteFunction(ctx.input.functionName, ctx.input.qualifier);
+
+    let msg = ctx.input.qualifier
+      ? `Deleted version **${ctx.input.qualifier}** of function **${ctx.input.functionName}**.`
+      : `Deleted function **${ctx.input.functionName}** and all its versions/aliases.`;
+
+    return {
+      output: { deleted: true },
+      message: msg
+    };
+  })
+  .build();

package/src/tools/get-account-settings.ts

@@ -0,0 +1,45 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let getAccountSettings = SlateTool.create(spec, {
+  name: 'Get Account Settings',
+  key: 'get_account_settings',
+  description: `Retrieve Lambda account-level settings and limits for the configured region, including concurrent execution limits, code storage usage, and total code size.`,
+  tags: {
+    readOnly: true
+  }
+})
+  .input(z.object({}))
+  .output(
+    z.object({
+      totalCodeSize: z.number().optional().describe('Total code storage used in bytes'),
+      codeSizeUnzipped: z.number().optional().describe('Maximum unzipped deployment size'),
+      codeSizeZipped: z.number().optional().describe('Maximum zipped deployment size'),
+      concurrentExecutions: z.number().optional().describe('Concurrent execution limit'),
+      unreservedConcurrentExecutions: z
+        .number()
+        .optional()
+        .describe('Unreserved concurrent executions available')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let result = await client.getAccountSettings();
+
+    let usage = result.AccountUsage || {};
+    let limits = result.AccountLimit || {};
+
+    return {
+      output: {
+        totalCodeSize: usage.TotalCodeSize,
+        codeSizeUnzipped: limits.CodeSizeUnzipped,
+        codeSizeZipped: limits.CodeSizeZipped,
+        concurrentExecutions: limits.ConcurrentExecutions,
+        unreservedConcurrentExecutions: limits.UnreservedConcurrentExecutions
+      },
+      message: `Account limits: **${limits.ConcurrentExecutions}** concurrent executions, **${limits.UnreservedConcurrentExecutions}** unreserved. Code storage: **${(usage.TotalCodeSize / (1024 * 1024 * 1024)).toFixed(2)} GB** used.`
+    };
+  })
+  .build();

package/src/tools/get-function.ts

@@ -0,0 +1,104 @@
+import { SlateTool } from 'slates';
+import { createClient } from '../lib/helpers';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let getFunction = SlateTool.create(spec, {
+  name: 'Get Function',
+  key: 'get_function',
+  description: `Retrieve detailed information about a Lambda function including its configuration, code location, concurrency settings, and tags. Supports fetching a specific version or alias using the **qualifier** parameter.`,
+  tags: {
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      functionName: z.string().describe('Function name, ARN, or partial ARN'),
+      qualifier: z.string().optional().describe('Version number or alias name')
+    })
+  )
+  .output(
+    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'),
+      role: z.string().optional().describe('Execution role ARN'),
+      handler: z.string().optional().describe('Function handler'),
+      codeSize: z.number().optional().describe('Size of the deployment package in bytes'),
+      codeSha256: z.string().optional().describe('SHA256 hash of the deployment package'),
+      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'),
+      stateReason: z.string().optional().describe('Reason for current state'),
+      lastUpdateStatus: z.string().optional().describe('Status of the last update'),
+      lastUpdateStatusReason: z
+        .string()
+        .optional()
+        .describe('Reason for the last update status'),
+      packageType: z.string().optional().describe('Package type (Zip or Image)'),
+      architectures: z.array(z.string()).optional().describe('Instruction set architectures'),
+      environment: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Environment variables'),
+      layers: z
+        .array(
+          z.object({
+            arn: z.string().optional(),
+            codeSize: z.number().optional()
+          })
+        )
+        .optional()
+        .describe('Attached layers'),
+      codeLocation: z.string().optional().describe('Pre-signed URL to download the code'),
+      reservedConcurrency: z.number().optional().describe('Reserved concurrent executions'),
+      tags: z.record(z.string(), z.string()).optional().describe('Resource tags'),
+      ephemeralStorageSize: z.number().optional().describe('Ephemeral storage size in MB'),
+      loggingFormat: z.string().optional().describe('Log format (Text or JSON)')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let result = await client.getFunction(ctx.input.functionName, ctx.input.qualifier);
+
+    let config = result.Configuration || {};
+    let layers = (config.Layers || []).map((l: any) => ({
+      arn: l.Arn,
+      codeSize: l.CodeSize
+    }));
+
+    return {
+      output: {
+        functionName: config.FunctionName,
+        functionArn: config.FunctionArn,
+        runtime: config.Runtime,
+        role: config.Role,
+        handler: config.Handler,
+        codeSize: config.CodeSize,
+        codeSha256: config.CodeSha256,
+        description: config.Description,
+        timeout: config.Timeout,
+        memorySize: config.MemorySize,
+        lastModified: config.LastModified,
+        version: config.Version,
+        state: config.State,
+        stateReason: config.StateReason,
+        lastUpdateStatus: config.LastUpdateStatus,
+        lastUpdateStatusReason: config.LastUpdateStatusReason,
+        packageType: config.PackageType,
+        architectures: config.Architectures,
+        environment: config.Environment?.Variables,
+        layers,
+        codeLocation: result.Code?.Location,
+        reservedConcurrency: result.Concurrency?.ReservedConcurrentExecutions,
+        tags: result.Tags,
+        ephemeralStorageSize: config.EphemeralStorage?.Size,
+        loggingFormat: config.LoggingConfig?.LogFormat
+      },
+      message: `Retrieved function **${config.FunctionName}** (${config.Runtime || config.PackageType}, ${config.State || 'Active'}).`
+    };
+  })
+  .build();

package/src/tools/index.ts

@@ -0,0 +1,19 @@
+export { listFunctions } from './list-functions';
+export { getFunction } from './get-function';
+export { createFunction } from './create-function';
+export { updateFunction } from './update-function';
+export { deleteFunction } from './delete-function';
+export { invokeFunction } from './invoke-function';
+export { publishVersion } from './publish-version';
+export { manageAlias } from './manage-alias';
+export { manageLayer } from './manage-layer';
+export { manageEventSourceMapping } from './manage-event-source-mapping';
+export { manageFunctionUrl } from './manage-function-url';
+export { manageConcurrency } from './manage-concurrency';
+export { managePermission } from './manage-permission';
+export { manageTags } from './manage-tags';
+export { configureAsyncInvocation } from './configure-async-invocation';
+export { manageDurableExecution } from './manage-durable-execution';
+export { getAccountSettings } from './get-account-settings';
+export { manageRuntimeManagement } from './manage-runtime-management';
+export { manageRecursionConfig } from './manage-recursion-config';