Overview

AppTheory API Reference

This page is the canonical human-readable map of the AppTheory surface. Treat the generated snapshots as the release-gated source of truth, and use this document to understand which surface to reach for.

Source of truth

Use these files when reviewing or documenting external interfaces:

  • Go: api-snapshots/go.txt (exports from runtime/, pkg/, and testkit/)
  • TypeScript: api-snapshots/ts.txt (exports from ts/dist/index.d.ts)
  • Python: api-snapshots/py.txt (exports from py/src/apptheory/__init__.py and py/src/apptheory/limited/__init__.py)
  • CDK: cdk/.jsii, cdk/lib/index.ts, and cdk/lib/*.d.ts

Known CLI surface:

  • cmd/lift-migrate exists as a Go migration helper with -root and -apply flags
  • ./scripts/migrate-from-lift-go.sh is the repo wrapper for go run ./cmd/lift-migrate
  • UNKNOWN: no broader stable public CLI contract is documented for cmd/

Verification command surface:

  • make test-unit
  • ./scripts/verify-ts-tests.sh
  • ./scripts/verify-python-tests.sh
  • ./scripts/verify-contract-tests.sh
  • ./scripts/update-api-snapshots.sh
  • ./scripts/verify-api-snapshots.sh
  • ./scripts/verify-docs-standard.sh
  • make rubric

Security migration note:

  • For new closed-default HTTP, AppSync, and WebSocket applications, see SecureApp Closed-Default Routing.
  • For consolidated v1.0 fail-closed migration guidance across the surfaces documented here, see docs/migration/v1-security.md.

Core runtime entrypoints

Concern Go TypeScript Python
Secure app container apptheory.NewSecure(SecureOptions{...}) new SecureApp({...}) SecureApp(...)
Legacy app container apptheory.New(...) createApp() create_app()
Deterministic test env testkit.New() createTestEnv() create_test_env()
Universal Lambda dispatcher app.HandleLambda(ctx, event) app.handleLambda(event, ctx) app.handle_lambda(event, ctx)
AppSync resolver entrypoint app.ServeAppSync(ctx, event) app.serveAppSync(event, ctx) app.serve_appsync(event, ctx)
Strict route registration app.GetStrict(...), app.HandleStrict(...) app.handleStrict(...) app.handle_strict(...)
HTTP entrypoints ServeAPIGatewayV2, ServeLambdaFunctionURL, ServeAPIGatewayProxy serveAPIGatewayV2, serveLambdaFunctionURL, serveAPIGatewayProxy serve_apigw_v2, serve_lambda_function_url, serve_apigw_proxy
Streaming helpers SSEResponse, SSEStreamResponse htmlStream, sseEventStream, createLambdaFunctionURLStreamingHandler html_stream, sse_event_stream

Shared request model:

  • Request: method, path, headers, query, body, and normalized source provenance
  • Response: status, headers, cookies, body, and streaming fields where supported
  • Context: request-scoped accessors for headers, params, request ID, tenant, source provenance, clock, IDs, and middleware state

Common helper exports:

Concern Go TypeScript Python
App creation apptheory.New(...) createApp() create_app()
Deterministic HTTP builders testkit.APIGatewayV2Request, testkit.LambdaFunctionURLRequest buildAPIGatewayV2Request, buildLambdaFunctionURLRequest build_apigw_v2_request, build_lambda_function_url_request
Deterministic AppSync builders testkit.AppSyncEvent buildAppSyncEvent build_appsync_event
Basic response helpers Text, JSON, Binary text, json, html, binary, sse text, json, html, binary, sse

SecureApp semantic API map

Concern Go TypeScript Python
Closed options SecureOptions SecureOptions explicit SecureApp(...) keywords
Postures Public, Optional, Authenticated, AuthenticatedAnyOf, InternalOnly Public, Optional, Authenticated, AuthenticatedAnyOf, InternalOnly public, optional, authenticated, authenticated_any_of, internal_only
Principal SecurePrincipal, PrincipalKind SecurePrincipal, PrincipalKind SecurePrincipal, PrincipalKind
Resolver SecurePrincipalResolver SecurePrincipalResolver SecurePrincipalResolver
Context accessor ctx.SecurePrincipal() ctx.securePrincipal() ctx.secure_principal()
AppSync registration app.AppSyncField(...) app.appSyncField(...) app.appsync_field(...)
WebSocket registration app.WebSocket(...) app.webSocket(...) app.websocket(...)
Route inventory app.Routes() app.routes() app.routes()
Secure OpenAPI app.GenerateOpenAPI(...) app.generateOpenAPI(...) app.generate_openapi(...)

All secure HTTP, AppSync, and WebSocket registrations require one posture. The fixed gate runs before user middleware; unknown principal kinds fail with 401. Authenticated scopes are all-of; AuthenticatedAnyOf scopes are any-of and encode each scope alias as an OpenAPI security alternative. For example, Mastodon-compatible read:statuses OR read authorization belongs in AuthenticatedAnyOf("read:statuses", "read"), not in a route-local guard. The secure OpenAPI method exact-joins only HTTP route records and emits the secure-v1 contract marker. Legacy free OpenAPI functions cannot read secure posture and are unsupported for SecureApp adopters.

HTTP error compatibility:

  • Default HTTP error bodies remain nested under error.
  • In the default nested envelope, any error whose code string is EMPTY_BODY or INVALID_JSON is remapped to canonical app.bad_request fields; the opt-in flat legacy format preserves those Lift-era codes/messages.
  • Lift-compatible flat HTTP error bodies are opt-in:
    • Go: apptheory.WithHTTPErrorFormat(apptheory.HTTPErrorFormatFlatLegacy) or apptheory.WithLegacyHTTPErrorShape()
    • TypeScript: createApp({ httpErrorFormat: HTTP_ERROR_FORMAT_FLAT_LEGACY })
    • Python: create_app(http_error_format=HTTP_ERROR_FORMAT_FLAT_LEGACY)
  • This setting applies to HTTP serialization only. AppSync and WebSocket error payloads keep their existing shapes.

HTTP source provenance

SourceProvenance is the portable, structured source-IP contract for HTTP requests. It is available in every HTTP tier, including P0, and is derived only from AWS provider request context fields.

Concern Go TypeScript Python
Structured type SourceProvenance SourceProvenance SourceProvenance
Request field Request.SourceProvenance Request.sourceProvenance Request.source_provenance
Context accessor ctx.SourceProvenance() ctx.sourceProvenance() ctx.source_provenance()
Convenience IP accessor ctx.SourceIP() ctx.sourceIP() ctx.source_ip()
API Gateway v2 test builder option HTTPEventOptions.SourceIP sourceIp source_ip
Lambda Function URL test builder option HTTPEventOptions.SourceIP sourceIp source_ip

The structured value has four fields:

  • source_ip: canonical parsed source IP string, or "" when invalid/unknown
  • provider: apigw-v2, lambda-url, apigw-v1, or unknown
  • source: provider_request_context or unknown
  • valid: true only when the provider supplied a parseable source IP

Provider mapping:

  • API Gateway v2 HTTP API: requestContext.http.sourceIp -> provider = "apigw-v2"
  • Lambda Function URL: requestContext.http.sourceIp -> provider = "lambda-url"
  • API Gateway v1 REST proxy: requestContext.identity.sourceIp -> provider = "apigw-v1"
  • Missing, malformed, unsupported, or ALB source values -> provider = "unknown", source = "unknown", valid = false

Valid IPs are parsed and re-emitted in canonical form before they become public response or handler strings. For example, 2001:DB8::1 becomes 2001:db8::1 in all three runtimes.

AppTheory does not parse or trust Forwarded, X-Forwarded-For, or similar client-controlled forwarding headers for this contract. Those headers remain ordinary request headers if AWS forwards them, but they do not influence SourceProvenance or SourceIP.

Universal Lambda entrypoint

When one Lambda must accept multiple AWS trigger types, keep the handler thin and delegate dispatch to the runtime.

func handler(ctx context.Context, event json.RawMessage) (any, error) {
	return app.HandleLambda(ctx, event)
}

export const handler = async (event: unknown, ctx: unknown) =>
  app.handleLambda(event, ctx);

def handler(event, ctx):
    return app.handle_lambda(event, ctx)

Event shape to entrypoint mapping

Event shape Detection heuristic Entry point called
SQS Records[0].eventSource == "aws:sqs" ServeSQS / serveSQSEvent / serve_sqs
DynamoDB Streams Records[0].eventSource == "aws:dynamodb" ServeDynamoDBStream / serveDynamoDBStream / serve_dynamodb_stream
Kinesis Records[0].eventSource == "aws:kinesis" ServeKinesis / serveKinesisEvent / serve_kinesis
SNS Records[0].Sns or EventSource == "aws:sns" ServeSNS / serveSNSEvent / serve_sns
EventBridge detail-type or detailType ServeEventBridge / serveEventBridge / serve_eventbridge
AppSync resolver info.fieldName + info.parentTypeName + arguments ServeAppSync / serveAppSync / serve_appsync
WebSocket (APIGW v2) requestContext.connectionId ServeWebSocket / serveWebSocket / serve_websocket
API Gateway v2 (HTTP API) requestContext.http + routeKey ServeAPIGatewayV2 / serveAPIGatewayV2 / serve_apigw_v2
Lambda Function URL requestContext.http + no routeKey ServeLambdaFunctionURL / serveLambdaFunctionURL / serve_lambda_function_url
ALB Target Group requestContext.elb.targetGroupArn ServeALB / serveALB / serve_alb
API Gateway v1 (REST proxy) httpMethod ServeAPIGatewayProxy / serveAPIGatewayProxy / serve_apigw_proxy

Notes:

  • Unknown shapes fail closed
  • Exact field casing varies by AWS integration; prefer deterministic event builders from the test envs
  • Package-local runtime docs may add language-specific examples, but the canonical cross-language dispatch guidance lives here

Event workload contract notes:

  • EventBridge workload fixtures pin portable envelope/correlation behavior for future helpers.
  • metadata.correlation_id and top-level headers["x-correlation-id"] are AppTheory portable envelope conventions, not AWS-native EventBridge fields.
  • Scheduled workloads use EventBridge scheduled events and derive run IDs, idempotency keys, remaining-time/deadline fields, and structured result summaries.
  • DynamoDB Streams workloads keep the Lambda partial-batch response contract and derive only safe record summaries.
  • Kinesis workloads keep the Lambda partial-batch response contract, route by stream name, and fail closed for unregistered streams by returning every record ID as a failure.

Kinesis runtime and helpers

Kinesis uses the universal Lambda dispatcher. Register one stream handler through the AppTheory app and keep the Lambda handler on HandleLambda, handleLambda, or handle_lambda.

Concern Go TypeScript Python
Register stream handler app.Kinesis(streamName, handler) app.kinesis(streamName, handler) app.kinesis(stream_name, handler)
Direct Kinesis entrypoint app.ServeKinesis(ctx, event) app.serveKinesisEvent(event, ctx) app.serve_kinesis(event, ctx)
CloudWatch Logs decoder DecodeCloudWatchLogsSubscription(record) decodeCloudWatchLogsSubscription(record) decode_cloudwatch_logs_subscription(record)
JSON producer record helper NewKinesisJSONRecord(opts) createKinesisJsonRecord(opts) create_kinesis_json_record(...)
PutRecords failure reporter ReportKinesisPutRecordsFailures(records, results) reportKinesisPutRecordsFailures(records, results) report_kinesis_put_records_failures(records, results)

Kinesis handler failures are returned as Lambda partial-batch failures by record eventID; successful records are omitted. DecodeCloudWatchLogsSubscription and its TypeScript/Python equivalents decode the gzip CloudWatch Logs subscription envelope carried in Kinesis data and return a safe_summary that excludes raw log messages. The decoder bounds its work before it materializes the payload: the decompressed document is capped at 2 MiB, the decoded/compressed ratio is capped, the subscriptionFilters and logEvents arrays have cardinality limits, and any top-level field outside the documented envelope is rejected, so a small, highly compressed producer record cannot expand into a memory-exhausting object graph. The producer helpers create deterministic JSON record bytes and safe failure summaries without introducing a second per-service record or failure shape.

Testkit helpers:

Concern Go TypeScript Python
Build Kinesis event KinesisEvent buildKinesisEvent build_kinesis_event
Build CloudWatch Logs subscription record KinesisCloudWatchLogsSubscriptionRecord kinesisCloudWatchLogsSubscriptionRecord kinesis_cloudwatch_logs_subscription_record
Build CloudWatch Logs subscription data CloudWatchLogsSubscriptionData cloudWatchLogsSubscriptionData cloudwatch_logs_subscription_data

Guide: Event Workload Contracts Canonical CDK example: examples/cdk/kinesis-cloudwatch-logs

AppSync resolvers

AppTheory supports the standard AWS direct Lambda resolver event shape in all three runtimes.

  • Event models:
    • Go: AppSyncResolverEvent, AppSyncResolverInfo, AppSyncResolverRequest
    • TypeScript: AppSyncResolverEvent, AppSyncResolverInfo, AppSyncResolverRequest
    • Python: AppSyncResolverEvent, AppSyncResolverInfo, AppSyncResolverRequest
  • Core event fields:
    • arguments: top-level resolver arguments; adapted into the JSON request body
    • info.fieldName + info.parentTypeName: determine the AppTheory route and method
    • info.variables: preserved on the typed context and raw event
    • info.selectionSetList + info.selectionSetGraphQL: preserved on the exported event types and available on the raw event for selection-set-aware handlers
    • request.headers: forwarded to the synthesized request
    • identity, source, prev, and stash: preserved on the typed context and portable metadata keys
  • Typed context:
    • Go: ctx.AsAppSync()
    • TypeScript: ctx.asAppSync()
    • Python: ctx.as_appsync()
  • Portable context metadata keys:

| Key | Meaning | | — | — | | apptheory.trigger_type | Constant "appsync" | | apptheory.appsync.field_name | GraphQL field name | | apptheory.appsync.parent_type_name | GraphQL parent type | | apptheory.appsync.arguments | Top-level resolver arguments | | apptheory.appsync.identity | Resolver identity payload | | apptheory.appsync.source | Parent/source object | | apptheory.appsync.variables | GraphQL variables | | apptheory.appsync.prev | Previous resolver result | | apptheory.appsync.stash | Resolver stash map | | apptheory.appsync.request_headers | Forwarded AppSync request headers | | apptheory.appsync.raw_event | Full resolver event |

  • Request adaptation:
    • Mutation -> POST /fieldName
    • Query -> GET /fieldName
    • Subscription -> GET /fieldName
    • top-level arguments become the JSON request body
    • request.headers are forwarded and content-type: application/json is synthesized when absent
  • Response behavior:
    • JSON bodies project back to native resolver payloads
    • empty bodies project to null
    • any other non-empty body projects to a UTF-8 string
    • binary and streaming bodies fail closed with deterministic AppSync system errors
  • Error behavior:
    • handler failures return Lift-compatible AppSync error objects with pay_theory_error, error_message, error_type, error_data, and error_info
    • portable AppTheory/AppError payloads include error_data.status_code and may include request_id, trace_id, timestamp, plus error_info.code, trigger_type, method, path, and optional details
    • non-portable exceptions now mask to error_message: "internal error" instead of echoing raw exception text

Recipe:

Infrastructure note:

  • use aws-cdk-lib/aws-appsync for the GraphQL API, schema, auth, and Lambda data source wiring
  • AppTheory does not currently export an AppSync-specific CDK construct

Route registration

Invalid route patterns, duplicate method/pattern pairs, and nil/undefined/None handlers fail closed during registration across runtimes. Use the normal fluent registration path for new code:

  • Go: app.Get("/users/{id}", h) or app.Handle("GET", "/users/{id}", h)
  • TypeScript: app.get("/users/{id}", h) or app.handle("GET", "/users/{id}", h)
  • Python: app.get("/users/{id}", h) or app.handle("GET", "/users/{id}", h)

Strict helpers remain as deprecated compatibility wrappers for code that already depends on their error-returning or throwing shape. Python strict helpers now raise AppTheoryError rather than ValueError, and Go strict helpers return canonical AppTheoryError messaging where applicable. See UPGRADING.md for per-line deprecation notes.

Cross-language feature surfaces

These feature areas extend the core runtime and have dedicated guides when you need deeper operational detail.

Rate limiting

The limited feature set provides DynamoDB-backed cross-instance rate limiting.

  • Go: pkg/limited
  • TypeScript: exports in api-snapshots/ts.txt including DynamoRateLimiter, FixedWindowStrategy, SlidingWindowStrategy, and MultiWindowStrategy
  • Python: exports in api-snapshots/py.txt under apptheory.limited

Go runtime note:

  • runtime.RateLimitMiddleware(...) fingerprints default credential-derived identifiers before they reach limiter backends:
    • x-api-key → api_key:hmac-sha256:<hex>
    • Authorization: Bearer ... → bearer:hmac-sha256:<hex>
  • AuthIdentity, TenantID, and explicit ExtractIdentifier overrides are unchanged.
  • This avoids storing raw credentials in rate-limit tables, but it also changes observed key values and resets any existing credential-backed buckets on first deploy.
  • For operator migration guidance, see docs/migration/v1-security.md.

Sanitization

Safe logging helpers are exported in all three runtimes:

  • Go: pkg/sanitization
  • TypeScript: sanitizeLogString, sanitizeFieldValue, sanitizeJSON, sanitizeJSONValue, sanitizeXML
  • Python: sanitize_log_string, sanitize_field_value, sanitize_json, sanitize_json_value, sanitize_xml

Guide: Sanitization

Operational note:

  • Sanitization heuristics once again redact token-like unknown keys by default, including authorization_id. See docs/migration/v1-security.md if you have log-processing workflows that depended on those values remaining visible.

Jobs ledger

TableTheory-backed job ledger primitives exist for long-running workflows that need job state, record state, idempotency, and leases.

  • Go: pkg/jobs
  • TypeScript: exports in api-snapshots/ts.txt including DynamoJobLedger, CreateJobInput, JobMeta, and related status types
  • Python: exports in api-snapshots/py.txt including DynamoJobLedger, JobsConfig, and related helpers

Guide: Jobs Ledger Reference stack: examples/cdk/import-pipeline/

Object store helper

AppTheory includes a narrow bounded object-store helper for framework-owned byte payload storage. It is not a general storage SDK and does not expose list, multipart, copy, head, presigned GET, generic presign, public URL, or raw-client escape hatches.

  • Go: pkg/objectstore
  • TypeScript: ObjectStore, ObjectRef, createS3ObjectStore, and FakeObjectStore
  • Python: ObjectStore, ObjectRef, create_s3_object_store, and FakeObjectStore
  • Testkit/fakes: testkit/objectstore in Go plus package-local fake stores in TypeScript and Python
  • Object refs: strict s3://bucket/key parsing into bucket/key/version fields with no default bucket/key and no query or fragment support.
  • Store contract: Put, bounded Get with required MaxBytes, and Delete only.
  • Bounded upload grant: UploadGranter / ObjectStoreUploadGranter is the one authorized presigning exception and is deliberately a separate capability interface rather than a fourth store method. PresignPut / presignPut / presign_put mints a single-object PUT link that signs content-length, content-type, and x-amz-checksum-sha256 as request headers (never as unsigned query parameters), requires an exact unversioned reference and a caller-supplied MaxBytes, and refuses any expiry above MaxPresignPutExpiresIn (MAX_PRESIGN_PUT_EXPIRES_IN) of fifteen minutes. Every S3 implementation verifies the presigned URL after signing and fails closed with objectstore.invalid_store_config when the constraints are not signed headers.
  • Upload-grant validation: PresignPutInput.Validate / validatePresignPutInput / validate_presign_put_input fails closed with objectstore.invalid_ref for a versioned or malformed reference and with objectstore.invalid_presign_put for a missing or invalid content length, MaxBytes, content type, checksum, or expiry.
  • Still forbidden: presigned GET, presigning without a checksum, list, multipart, copy, head, public URLs, and raw clients. The objectstore contract fixtures assert both halves of that boundary.
  • S3 implementations: each runtime keeps the cloud client seam inside the framework surface and exposes only bounded put/get/delete operations plus the bounded upload grant. TypeScript intentionally carries @aws-sdk/client-s3 and @aws-sdk/s3-request-presigner as hard package dependencies because the S3 implementation imports them at module load; Python intentionally keeps boto3 optional/lazy and fails closed from create_s3_object_store if the dependency or required S3 methods are unavailable.
  • Encryption: bucket-default, S3-managed, and KMS modes fail closed on contradictory or missing KMS configuration.

Guide: Object Store Helper

AWS runtime hardening helpers (Go)

The Go-only runtime/aws package centralizes two platform-Lambda invariants without changing the portable runtime contract. AssumeFirst uses AssumeRoleAPI plus CallerIdentityFactory to establish assumed authority, delegates the identity proof to AssertAccount through CallerIdentityAPI, and returns AssumeFirstResult.Credentials only for an AccountAssertionVerified result. AccountAssertion, AccountAssertionState, and AssumeRoleRequest preserve the explicit not-configured, assume-failed, unavailable, mismatch, and verified outcomes.

VerifyVersionedArtifact accepts AppTheory’s existing objectstore.Store and a fully pinned VersionedArtifactRequest. It requires a non-null S3 VersionID, verifies GetOutput.Ref.VersionID, and derives the aggregate digest from a bounded regular-file tar whose member paths reject ambiguous or unsafe forms. VersionedArtifact, ArtifactEntry, and ArtifactVerificationState carry explicit evidence; verified bytes are exposed only through defensive-copy accessors. MaxVersionedArtifactBytes and MaxVersionedArtifactEntries are fixed ceilings. Stable errors distinguish invalid requests, missing versions, unavailable objects, version mismatches, invalid archives, and digest mismatches.

Guide: AWS Runtime Hardening Helpers

Semantic vector helpers

AppTheory includes a narrow semantic-recall helper surface for S3 Vectors and Bedrock Titan embeddings. It is a retrieval plane, not canonical persistence: store durable records and ledgers in TableTheory-backed or app-owned stores, then publish keyed embeddings and retrieval metadata through the AppTheory vectorstore contract.

  • Go: pkg/vectorstore exposes VectorRecord, PutInput, GetInput, DeleteInput, QueryInput, QueryHit, Store, Embedder, SemanticRecord, and SemanticIndex.
  • Fake/test helpers: NewFakeStore, FakeStore, NewFakeEmbedder, and FakeEmbedder.
  • S3 Vectors adapter: NewS3VectorStore, S3VectorStore, and S3VectorsAPI.
  • Bedrock Titan adapter: NewTitanEmbedder, TitanEmbedder, BedrockRuntimeAPI, DefaultTitanEmbedTextModelID, DefaultEmbeddingDimensions, EnvEmbeddingProvider, EnvEmbeddingModelID, EnvEmbeddingDimensions, and EnvEmbeddingNormalize.
  • S3 Vectors environment/config: EnvVectorBucketName, EnvVectorIndexName, EnvVectorIndexARN, EnvVectorDimension, DefaultQueryTopK, MaxQueryTopK, and MaxPutDeleteBatchSize.
  • Validation helpers: ValidateDimension, ValidateVector, ValidateKey, ValidateRequiredMetadata, NormalizeTopK, CloneVector, CloneMetadata, and EmbeddingErrorCode.
  • Fail-closed errors: ErrorCodeInvalidConfig, ErrorCodeInvalidInput, ErrorCodeInvalidVector, ErrorCodeDimensionMismatch, ErrorCodeEmbeddingFailed, ErrorCodeNotFound, ErrorCodeUnsupportedOperation, ErrInvalidConfig, ErrInvalidInput, ErrInvalidVector, ErrDimensionMismatch, ErrEmbeddingFailed, ErrNotFound, and ErrUnsupportedOperation.

Guides: S3 Vectors and Bedrock Embeddings and S3 Vector Index

AWS Lambda MicroVM support

The corrective M16 MicroVM surface is fixture-backed across Go, TypeScript, and Python. It is a constrained AppTheory primitive, not a raw AWS SDK escape hatch. The v1.14.0 / M15 foundation should not be cited as complete live MicroVM support; the canonical real operation vocabulary is run, get, list, suspend, resume, terminate, invoke, auth-token, and shell-auth-token.

  • Go: runtime/microvm exports lifecycle adapters, real controller routes, constrained provider adapters, safe session records, token-hidden workload invocation, TableTheory session registry helpers, and test fakes. Runtime logging is represented by ProviderLogging / ProviderCloudWatchLogging, configured with WithControllerLogging, and read from EnvLogging by deployed real controllers.
  • TypeScript: MicroVMLifecycleAdapter, MicroVMRealController, TableTheoryMicroVMSessionRegistry, createAWSLambdaMicroVMProvider, createRealMicroVMController, and related validators.
  • Python: MicroVMLifecycleAdapter, MicroVMRealController, TableTheoryMicroVMSessionRegistry, create_aws_lambda_microvm_provider, create_real_microvm_controller, and related validators.
  • CDK: AppTheoryMicrovmNetworkConnector, AppTheoryMicrovmImage, and AppTheoryMicrovmController wire typed connector references, endpoint-dispatched no-hook images, protected routes, IAM grants, token-hidden workload invoke, and the durable session table.
  • Conformance: examples/microvm-conformance is the AppTheory-owned harness for a consumer-provided EqualToAI/Host lab.

The golden path requires sanitized lifecycle events, protected controller routes, sanitized token metadata, token-hidden workload invocation through /microvms/{session_id}/invoke, and the TableTheory/DynamoDB-style session registry with pk, sk, and ttl. It does not provide EqualToAI/Host application proof, customer workload readiness, generalized account vending, unauthenticated controllers, raw SDK access, provider auth-token exposure, or raw lifecycle hook bypasses.

Guide: AWS Lambda MicroVM Golden Path CDK guide: Lambda MicroVM CDK Constructs

Migration and configuration notes

Confirmed migration surface:

  • Dry run: go run ./cmd/lift-migrate -root ./path/to/service
  • Apply rewrite: go run ./cmd/lift-migrate -root ./path/to/service -apply
  • Repo wrapper: ./scripts/migrate-from-lift-go.sh -root ./path/to/service [-apply]

Known configuration keys surfaced by canonical docs:

  • APPTHEORY_EVENTBUS_TABLE_NAME
  • ERROR_NOTIFICATION_SNS_TOPIC_ARN
  • APPTHEORY_JOBS_TABLE_NAME
  • UNKNOWN: a complete stable env-var/config-key catalog is not yet centralized in one canonical index

Internal streaming join (Go)

runtime/internal/streamjoin is internal to the module’s runtime/... tree and is not public API. It hands a producer goroutine’s output to a response body reader that joins the producer: the Body reader reports EOF only once its producer has returned, and closing it releases the producer and waits for it. Producer is the function it runs. Every response body the runtime produces incrementally (SSE responses, the MCP session listener, streamed tool events) is built on it, so an adapter that abandons a body cannot leave a producer running past the invocation that started it.

MCP and OAuth

AppTheory includes fixture-backed MCP and OAuth support across the runtime family, with the Go package paths listed here for operators who need implementation-level details:

  • runtime/mcp: Streamable HTTP POST/GET/DELETE /mcp, protocol negotiation, origin validation, sessions, resumable SSE, and the MCP request surface (initialize, ping, tools/*, resources/*, prompts/*, plus accepted notifications/initialized / notifications/cancelled)
  • Protocol-shape detection has both byte/request and already-parsed-message entrypoints: DetectProtocolVersion / DetectProtocolVersionForMessage, detectMcpProtocolVersion / detectMcpProtocolVersionForMessage, and detect_mcp_protocol_version / detect_mcp_protocol_version_for_message.
  • testkit/mcp: deterministic in-process MCP client helpers (NewClient, Initialize, ListTools, CallTool, ListResources, ReadResource, ListPrompts, GetPrompt, RawStream, ResumeStream, Stream.Response, Stream.Cancel, Stream.Next, Stream.ReadAll) plus JSON-RPC request builders and assertions
  • runtime/oauth: protected-resource metadata, challenges, DCR, PKCE, token-store helpers, and the namespace MCP bundle. MCPServerConfig, RegisterMCPServer, and NewMCPProtectedResourceDiscoveryHandler keep the MCP route authenticated while registering request-host-derived RFC 9728 discovery with public SecureApp posture. Canonical paths are exported as MCPPath, OAuthProtectedResourcePath, OAuthProtectedResourceMCPPath, and OAuthAuthorizationServerMCPPath. NormalizeRequestOrigin is the shared fail-closed request-origin normalizer.
  • runtime/mcproutes: the m17.mcp-route-algebra/v1 contract. EndpointPath, ParseMCPPath, the SupportedEndpointTemplates, SupportedOAuthFacadeTemplates, and SupportedOAuthDiscoveryTemplates enumerations, and pure protected-resource/authorization-server derivations define the namespace, partner-namespace, agent, and partner-agent golden path consumed by both AppTheoryMcpServer and runtime/mcpfacade. ParamClientNamespace, ParamPartnerID, and ParamAgentID pin the canonical router parameter names used by those templates.
  • runtime/mcpfacade: the Go composition helper over that contract. RegisterMCPFacade accepts FacadeConfig, registers the four MCP method families and both OAuth metadata documents, and returns a versioned RouteInventory. The URLMode values URLModePublicBaseURL and URLModeRequestHost select fixed front-door/CDN origins or derive each origin from the incoming request. DefaultCapabilities supplies the fixed defaults, while Capabilities, per-kind scope sets, and paired application-owned HandlerFactory authorize/token plug points remain explicit config. Optional RootDiscoveryConfig installs the static upstream authorization-server root document. Each installed Route records its methods and derived paths.
  • testkit/oauth: Claude-like end-to-end OAuth flow helpers for remote MCP tests (NewClaudePublicClient, AuthorizeOptions, Authorize)
  • TypeScript and Python expose matching MCP registries, server/test harnesses, in-memory/Dynamo stores, bearer-token validation, protected-resource metadata, DCR, and PKCE helpers through their package API snapshots.

Remote MCP auth hardening notes:

  • oauth.RequireBearerTokenMiddleware(...) is fail-closed in Go: you must provide a Validator, and metadata discovery for the WWW-Authenticate challenge comes from an explicit ResourceMetadataURL, a route-derived ResourceMetadataURLFunc, or a {param} ResourceMetadataURLTemplate (TypeScript resourceMetadataURLTemplate, Python resource_metadata_url_template) — never from an environment variable or request headers. Precedence is resolver > template > static URL. A placeholder the matched route does not supply, or a substituted value outside [a-z0-9._~-]{1,128} (excluding ./..), degrades the challenge to the bare Bearer form, and a malformed template fails at registration (panic / throw / raise). With none configured the challenge is the bare Bearer form.
  • Invalid-audience bearer tokens are intentionally fixture-pinned as authorization failures: AppTheory returns 403 app.forbidden without a WWW-Authenticate challenge, matching insufficient-scope denial so a token bound to another resource is not treated as a rediscovery prompt. Missing or expired bearers remain 401 challenge cases.
  • Namespace deployments use attach-first AppTheoryMcpServer with mcpfacade.RegisterMCPFacade. The construct derives every API Gateway route through AppTheoryMcpRouteAlgebra; issuer, JWKS, scopes, URL mode, and handlers stay in explicit FacadeConfig. Neither CDK nor the helper accepts a protected-resource origin as route configuration.

Related canonical integration guides:

CDK construct overview

Canonical CDK guidance lives under docs/cdk. The construct inventory exported by cdk/lib/index.ts includes:

  • AppTheoryHttpApi
  • AppTheoryRestApi
  • AppTheoryRestApiRouter
  • AppTheoryMcpServer
  • AppTheoryMcpRouteAlgebra
  • AppTheoryMcpPaths
  • AppTheoryRemoteMcpServer
  • AppTheoryMcpProtectedResource (deprecated URL-valued static-document props)
  • AppTheoryInstallParameters
  • AppTheoryJobsTable
  • AppTheoryS3Ingest
  • AppTheoryS3VersionedIngress
  • AppTheoryVectorIndex
  • AppTheoryCodeBuildJobRunner
  • AppTheoryKinesisStream
  • AppTheoryKinesisStreamMapping
  • AppTheoryCloudWatchLogsDestination
  • AppTheoryMicrovmNetworkConnector
  • AppTheoryMicrovmImage
  • AppTheoryMicrovmController

Start with:

Package-local docs remain available under ts/docs/, py/docs/, and cdk/docs/ for language-specific examples, but they should not be treated as the canonical external root.

Go snapshot coverage index

This index is maintained with scripts/verify-api-docs.sh so handwritten docs cannot drift from api-snapshots/go.txt.

1162 exported top-level symbols ```text AccountAssertion, AccountAssertionAssumeFailed, AccountAssertionMismatch, AccountAssertionNotConfigured, AccountAssertionState, AccountAssertionUnavailable, AccountAssertionVerified, AcquireLeaseInput, AcquireSemaphoreSlotInput, AgentMCPPattern, ALBTargetGroupRequest, AllowedFields, AllowOrigins, APIGatewayV2Request, App, AppError, AppSyncContext, AppSyncEvent, AppSyncEventOptions, AppSyncResolverEvent, AppSyncResolverInfo, AppSyncResolverRequest, AppTheoryError, AppTheoryErrorFromAppError, ArtifactEntry, ArtifactVerificationArchiveInvalid, ArtifactVerificationDigestMismatch, ArtifactVerificationInvalidRequest, ArtifactVerificationState, ArtifactVerificationUnavailable, ArtifactVerificationVerified, ArtifactVerificationVersionMismatch, ArtifactVerificationVersionRequired, AsAppTheoryError, AsProviderError, AssertAccount, AssertBearerTokenReachesHandler, AssertCredentialFreeDenied, AssertError, AssertHasTools, AssertInsufficientScopeRemediation, AssertToolResult, AssumeFirst, AssumeFirstResult, AssumeRoleAPI, AssumeRoleRequest, AtomicRateLimiter, AuthContext, Authenticated, AuthenticatedAnyOf, AutheoryProvider, AutheoryProviderOptions, AuthHook, AuthoritativeOriginURL, AuthorizationAuthorizePathForResourcePath, AuthorizationCodeRecord, AuthorizationCodeStore, AuthorizationCodeStoreOptions, AuthorizationRegisterPathForResourcePath, AuthorizationRequest, AuthorizationServerMetadata, AuthorizationServerMetadataHandler, AuthorizationServerMetadataOption, AuthorizationServerPathForResourcePath, AuthorizationServerPrefix, AuthorizationServerSuffixPathForResourcePath, AuthorizationTokenPathForResourcePath, AuthorizeOptions, AuthPosture, AuthPostureAuthenticated, AuthPostureAuthenticatedAnyOf, AuthPostureInternalOnly, AuthPostureKind, AuthPostureOptional, AuthPosturePublic, AuthPrincipal, AWSLambdaMicroVMProvider, AWSLambdaMicroVMProviderID, AWSLambdaMicroVMProviderOption, BaseName, BearerTokenClaims, BearerTokenClaimsFromContext, BearerTokenClaimsValidator, BearerTokenFromHeaders, BearerTokenRecord, BearerTokenValidationOptions, BearerTokenValidator, BedrockRuntimeAPI, Binary, BindConfig, Body, BodyStream, BootstrapOIDCDiscovery, BrokerStatusActive, BrokerStatusExpired, BrokerStatusIssued, BrokerStatusReauthRequired, BrokerStatusRefreshing, BrokerStatusRevoked, BuiltInLoggingProfileNames, CacheableResultConfig, CacheControlISR, CacheControlSSG, CacheControlSSR, CacheHint, CacheScope, CacheScopePrivate, CacheScopePublic, Call, CallbackPathForConfiguredPath, CallbackPatternKey, CallerIdentityAPI, CallerIdentityFactory, CallToolRequest, CanonicalizeIssuerURL, CanonicalResourceURL, Capabilities, CapabilityConfig, CaptureBodyStream, Claims, ClaudeDynamicClientRegistrationPolicy, ClaudePublicClient, Client, ClientIP, ClientRecord, ClientStore, ClientStoreOptions, Clock, CloneMetadata, CloneVector, CloudWatchLogsSubscription, CloudWatchLogsSubscriptionData, CloudWatchLogsSubscriptionLogEvent, CloudWatchLogsSubscriptionOptions, CloudWatchLogsSubscriptionSummary, CodeExchangeRequest, CodeHeaderMismatch, CodeInternalError, CodeInvalidParams, CodeInvalidRequest, CodeMethodNotFound, CodeMissingRequiredClientCapability, CodeParseError, CodeServerError, CodeUnsupportedProtocolVersion, Command, CommandAuthToken, CommandCreate, CommandGet, CommandInvoke, CommandLegacyShellToken, CommandList, CommandResume, CommandRun, CommandSession, CommandShellAuthToken, CommandShellToken, CommandStart, CommandStatus, CommandStop, CommandSuspend, CommandTerminate, CompleteIdempotencyRecordInput, Completion, CompletionArgument, CompletionContext, CompletionHook, CompletionRef, CompletionRequest, CompletionResult, Config, ConformanceCase, ConformanceEpoch, Connection, ContentBlock, Context, ContextKeyBearerClaims, ContextKeyBearerToken, ContractKind, ContractName, ContractVersion, ContractVersionM16, ContractVersionV1, Controller, ControllerAuthContract, ControllerAuthDefaultDeny, ControllerCommandContract, ControllerContract, ControllerDeploymentDefaults, ControllerEnvelopeContract, ControllerInvokeRequest, ControllerOption, ControllerRequest, ControllerResponse, CORSConfig, CreatedJSON, CreateIdempotencyRecordInput, CreateJobInput, CreateSessionInput, CreateTaskResult, DCRResult, DecodeCloudWatchLogsSubscription, DecodeLoggingProfileJSON, DecodeLoggingProfileYAML, DefaultAuthorizationCodeTTL, DefaultCallbackPath, DefaultCapabilities, DefaultCapabilityConfig, DefaultConfig, DefaultControllerContract, DefaultEmbeddingDimensions, DefaultEnvironmentErrorNotifications, DefaultEventBusConfig, DefaultLifecycleContract, DefaultLoggingProfile, DefaultOperationContract, DefaultProviderStateMappings, DefaultQueryTopK, DefaultRateLimitWindow, DefaultRealLifecycleContract, DefaultRouteRefreshBrokerTTL, DefaultRouteRefreshLockTTL, DefaultSessionProviderID, DefaultSessionRegistryContract, DefaultSessionRegistryTableName, DefaultTitanEmbedTextModelID, DefaultTransactionTTL, DeleteInput, DetectProtocolVersion, DetectProtocolVersionForMessage, DiscoverResult, Discovery, DynamicClientRegistrationPolicy, DynamicClientRegistrationRequest, DynamicClientRegistrationResponse, DynamoDBEventBus, DynamoDBStreamEvent, DynamoDBStreamEventOptions, DynamoDBStreamHandler, DynamoDBStreamRecordOptions, DynamoDBStreamRecordSummary, DynamoJobLedger, DynamoRateLimiter, DynamoSessionStore, DynamoStreamStore, DynamoStreamStoreOption, DynamoTaskStore, Embedder, EmbeddingErrorCode, EMFMetricSink, EMFMetricSinkOption, EncodeLoggingProfileEvent, EncodeLoggingProfileEventWithSanitizer, EndpointKind, EndpointKindAgent, EndpointKindNamespace, EndpointKindPartnerAgent, EndpointKindPartnerNamespace, EndpointPath, EndpointTemplate, Env, EnvEgressNetworkConnectorRefs, EnvEmbeddingDimensions, EnvEmbeddingModelID, EnvEmbeddingNormalize, EnvEmbeddingProvider, EnvExecutionRoleArn, EnvImageRef, EnvIngressNetworkConnectorRefs, EnvironmentErrorNotificationsOptions, EnvJobsTableName, EnvLogging, EnvNetworkConnectorRefs, EnvSessionRegistryTableName, EnvVectorBucketName, EnvVectorDimension, EnvVectorIndexARN, EnvVectorIndexName, ErrAccountMismatch, ErrArtifactArchiveInvalid, ErrArtifactDigestMismatch, ErrArtifactInvalidRequest, ErrArtifactUnavailable, ErrArtifactVersionMismatch, ErrArtifactVersionRequired, ErrAssumeRoleFailed, ErrAuthorizationCodeExpired, ErrAuthorizationCodeNotFound, ErrAuthorizationCodeReplayed, ErrBearerTokenExpired, ErrBearerTokenInsufficientScope, ErrBearerTokenInvalidAudience, ErrBrokerLocked, ErrBrokerNotFound, ErrBrokerNotSeedable, ErrBrokerRevoked, ErrBrokerVersionConflict, ErrCallerIdentityUnavailable, ErrClientNotFound, ErrClientVersionConflict, ErrDimensionMismatch, ErrEmbeddingFailed, ErrEventNotFound, ErrExpectedAccountNotConfigured, ErrInvalidAuthorizationHeader, ErrInvalidBearerToken, ErrInvalidConfig, ErrInvalidEncryptionConfig, ErrInvalidGetLimit, ErrInvalidInput, ErrInvalidObjectRef, ErrInvalidPresignPut, ErrInvalidStoreConfig, ErrInvalidURL, ErrInvalidVector, ErrMissingBearerToken, ErrNotFound, ErrObjectNotFound, ErrObjectTooLarge, Error, ErrorCodeControllerCommandFailed, ErrorCodeControllerIncomplete, ErrorCodeDimensionMismatch, ErrorCodeEmbeddingFailed, ErrorCodeForbiddenField, ErrorCodeInvalidConfig, ErrorCodeInvalidContract, ErrorCodeInvalidControllerRequest, ErrorCodeInvalidInput, ErrorCodeInvalidLifecycleEvent, ErrorCodeInvalidVector, ErrorCodeLifecycleBypass, ErrorCodeLifecycleHookFailed, ErrorCodeLifecycleIncomplete, ErrorCodeNotFound, ErrorCodeOperationContractIncomplete, ErrorCodeProviderOperationFailed, ErrorCodeProviderOperationUnsupported, ErrorCodeProviderRequestInvalid, ErrorCodeProviderStateMappingIncomplete, ErrorCodeRawSDKEscapeHatch, ErrorCodeRealLifecycleIncomplete, ErrorCodeRouteContractIncomplete, ErrorCodeSessionRegistryIncomplete, ErrorCodeTenantBindingViolation, ErrorCodeTokenSafetyViolation, ErrorCodeUnauthenticatedController, ErrorCodeUnsupportedOperation, ErrorEnvelope, ErrorEnvelopeFromError, ErrorNotifier, ErrorType, ErrorTypeConflict, ErrorTypeInternal, ErrorTypeInvalidInput, ErrorTypeNotFound, ErrorTypeRateLimit, ErrRecordKeyRequired, ErrRefreshTokenExpired, ErrRefreshTokenNotFound, ErrSessionNotFound, ErrStreamEventTooLarge, ErrStreamNotFound, ErrTaskNotFound, ErrTaskTerminal, ErrTransactionExpired, ErrTransactionNotFound, ErrUnsupportedOperation, EscapeHatches, ETag, Event, EventBridgeEvent, EventBridgeEventOptions, EventBridgeHandler, EventBridgePattern, EventBridgeRule, EventBridgeScheduledWorkloadResultSummary, EventBridgeScheduledWorkloadSummary, EventBridgeSelector, EventBridgeWorkloadEnvelope, EventBus, EventBusConfig, EventContext, EventHandler, EventMiddleware, EventQuery, FacadeConfig, Factory, FakeClient, FakeEmbedder, FakeProvider, FakeSNSClient, FakeStore, FakeStreamerClient, FixedWindowStrategy, FullyRedact, GenerateOpenAPI, GenerateOpenAPIJSON, GetDayWindow, GetFixedWindow, GetHourWindow, GetInput, GetMinuteWindow, GetOutput, GetPromptRequest, Handler, HandlerFactory, HashKey, HookFailure, HookPrepareImage, HookReadiness, HookReady, HookResume, HookRun, HooksFromEMFMetricSink, HooksFromLogger, HooksFromLoggerAndEMFMetricSink, HooksFromProfileLogger, HookStart, HookStop, HookSuspend, HookTeardown, HookTerminate, HookValidate, HTML, HTMLStream, HTTPErrorFormat, HTTPErrorFormatFlatLegacy, HTTPErrorFormatNested, HTTPEventOptions, Icon, IdempotencyCreateOutcome, IdempotencyOutcomeAlreadyCompleted, IdempotencyOutcomeAlreadyInProgress, IdempotencyOutcomeCreated, IdempotencyStatus, IdempotencyStatusCompleted, IdempotencyStatusInProgress, IdentifierKey, IDGenerator, IdGenerator, InitializeRequest, InitialSessionListenerBudgetOptions, InputRequest, InputRequiredResult, InspectSemaphoreInput, InsufficientScopeWWWAuthenticate, InternalOnly, IsLambda, IssuerMode, IssuerModeFamily, IssuerModeRoute, IsTerminalState, JobLedger, JobLock, JobLockSortKey, JobMeta, JobMetaSortKey, JobPartitionKey, JobRecord, JobRecordSortKey, JobRequest, JobRequestSortKey, JobStatus, JobStatusCanceled, JobStatusFailed, JobStatusPending, JobStatusRunning, JobStatusSucceeded, JSON, JWKSValidatorOptions, KindControllerSession, KindLifecycle, KinesisCloudWatchLogsSubscriptionRecord, KinesisCloudWatchLogsSubscriptionRecordOptions, KinesisEvent, KinesisEventOptions, KinesisHandler, KinesisJSONRecord, KinesisJSONRecordOptions, KinesisJSONRecordSummary, KinesisPutRecordsFailure, KinesisPutRecordsFailureReport, KinesisPutRecordsFailureReportSummary, KinesisPutRecordsResultRecord, KinesisRecordOptions, LambdaFunctionURLRequest, LifecycleAdapter, LifecycleContract, LifecycleEvent, LifecycleHandler, LifecycleHook, LifecycleHookSpec, LifecycleOption, LifecycleResult, LifecycleState, LifecycleTransition, Limit, LimitDecision, Limits, ListPromptsRequest, ListResourcesRequest, ListToolsRequest, LoadConformanceCases, LogEntry, Logger, LoggerConfig, LoggerFactory, LoggerStats, LoggingLevel, LoggingLevelAlert, LoggingLevelCritical, LoggingLevelDebug, LoggingLevelEmergency, LoggingLevelError, LoggingLevelHook, LoggingLevelInfo, LoggingLevelNotice, LoggingLevelRequest, LoggingLevelWarning, LoggingProfileAlertingHints, LoggingProfileCatalog, LoggingProfileCloudWatchJSON, LoggingProfileConfig, LoggingProfileEncoding, LoggingProfileEnrichment, LoggingProfileError, LoggingProfileErrorCapture, LoggingProfileEvent, LoggingProfileJobContext, LoggingProfileLegacy, LoggingProfileLocalDev, LoggingProfilePayTheoryAlertV1, LoggingProfileRequestContext, LoggingProfileSanitization, LoggingProfileSchemaVersion, LoggingProfileValidationError, LoggingProfileValidationErrors, LogRecord, ManualClock, ManualIDGenerator, MapProviderState, MarshalResponse, MaskCardNumber, MaskCompletelyFunc, MaskFirstLast, MaskFirstLast4, MaskTokenLastFour, MatchesIfNoneMatch, MaxPresignPutExpiresIn, MaxPutDeleteBatchSize, MaxQueryTopK, MaxVersionedArtifactBytes, MaxVersionedArtifactEntries, MCPPath, MCPServerConfig, MemoryAuthorizationCodeStore, MemoryClientStore, MemoryEventBus, MemoryRateLimitStore, MemoryRefreshTokenStore, MemoryRouteRefreshBrokerStore, MemorySessionRegistry, MemorySessionStore, MemorySessionStoreOption, MemoryStreamStore, MemoryStreamStoreOption, MemoryTaskStore, MemoryTransactionStore, MetricRecord, Middleware, MultiWindowStrategy, MustJSON, MustSSEResponse, NamespaceMCPPattern, New, NewAppTheoryError, NewAutheoryProvider, NewAuthorizationServerMetadata, NewAWSLambdaMicroVMProvider, NewClaudePublicClient, NewClient, NewController, NewDynamoDBEventBus, NewDynamoJobLedger, NewDynamoRateLimiter, NewDynamoSessionStore, NewDynamoStreamStore, NewDynamoTaskStore, NewEMFMetricSink, NewError, NewErrorEnvelope, NewErrorResponse, NewEvent, NewFakeClient, NewFakeClientWithTime, NewFakeEmbedder, NewFakeProvider, NewFakeProviderWithTime, NewFakeSNSClient, NewFakeStore, NewFakeStreamerClient, NewFixedWindowStrategy, NewHandler, NewJobLock, NewJobMeta, NewJobRecord, NewJobRequest, NewJWKSValidator, NewKinesisJSONRecord, NewLifecycleAdapter, NewManualClock, NewManualIDGenerator, NewMCPProtectedResourceDiscoveryHandler, NewMemoryAuthorizationCodeStore, NewMemoryBearerTokenValidator, NewMemoryClientStore, NewMemoryEventBus, NewMemoryRateLimitStore, NewMemoryRefreshTokenStore, NewMemoryRouteRefreshBrokerStore, NewMemorySessionRegistry, NewMemorySessionStore, NewMemoryStreamStore, NewMemoryTaskStore, NewMemoryTransactionStore, NewMultiWindowStrategy, NewNoOpLogger, NewOpaqueToken, NewPKCECodeVerifier, NewPolicySanitizer, NewProfileLogger, NewPromptRegistry, NewProtectedResourceMetadata, NewProviderError, NewRealController, NewReconstructingSessionRegistry, NewRegistryClient, NewResourceRegistry, NewResultResponse, NewS3Store, NewS3VectorStore, NewSecure, NewSemaphoreLease, NewServer, NewSlidingWindowStrategy, NewSNSNotifier, NewStore, NewTableTheorySessionRegistry, NewTestLogger, NewTitanEmbedder, NewToolRegistry, NewWithTime, NewZapLogger, NewZapLoggerFactory, NoContent, NormalizeCallbackPath, NormalizeDynamoDBStreamRecord, NormalizeEventBridgeScheduledWorkload, NormalizeEventBridgeWorkloadEnvelope, NormalizeRequestOrigin, NormalizeStage, NormalizeTopK, OAuthAuthorizationServerMCPPath, OAuthDiscoveryTemplate, OAuthFacadeTemplate, OAuthProtectedResourceMCPPath, OAuthProtectedResourcePath, ObjectRef, ObservabilityHooks, OpenAPIAuthSchemes, OpenAPIFieldSpec, OpenAPIRequestSpec, OpenAPIResponseSpec, OpenAPIRouteSpec, OpenAPISpec, OpenAPIValidationRule, Operation, OperationAuthToken, OperationContract, OperationDelete, OperationGet, OperationHTTPRouteContract, OperationInvoke, OperationLegacyShellToken, OperationList, OperationPresignPut, OperationPut, OperationResume, OperationRun, OperationShellAuthToken, OperationShellToken, OperationSuspend, OperationTerminate, Option, Optional, OptionalAuth, Options, OriginalHost, OriginalURI, OriginURL, OriginValidator, ParamAgentID, ParamClientNamespace, ParamPartnerID, ParseBatchRequest, ParseMCPPath, ParseObjectRef, ParseRequest, ParseResponse, PartialMask, PartnerAgentMCPPattern, PartnerNamespaceMCPPattern, PaymentXMLPatterns, PKCEChallengeS256, PKCEVerifyS256, Policy, PolicyAction, PolicyAllow, PolicyDecision, PolicyFromEnv, PolicyFromText, PolicyFullyRedact, PolicyHook, PolicyPartialMask, PolicyRule, PresignPutInput, PresignPutOutput, PrincipalAuthHook, PrincipalExternal, PrincipalInternal, PrincipalKind, Producer, ProfileLogger, ProfileLoggerOption, PromptArgument, PromptDef, PromptHandler, PromptMessage, PromptRegistry, PromptResult, ProtectedResourceMetadata, ProtectedResourceMetadataHandler, ProtectedResourceMetadataURLForRequest, ProtectedResourcePathForResourcePath, ProtectedResourcePathFromMCPPath, ProtectedResourcePrefix, ProtectedResourceWWWAuthenticate, ProtocolShape, ProtocolShape20251125, ProtocolShape20260728, ProtocolShapeUnknown, ProtocolVersion20260728, Provider, ProviderCall, ProviderCloudWatchLogging, ProviderError, ProviderErrorClass, ProviderIdlePolicy, ProviderInvalidGrant, ProviderInvalidRequest, ProviderInvokeInput, ProviderInvokeOutput, ProviderListInput, ProviderListOutput, ProviderLogging, ProviderMetadata, ProviderPortScope, ProviderReauthRequired, ProviderRunInput, ProviderSession, ProviderSessionBinding, ProviderSessionInput, ProviderStateMapping, ProviderTemporarilyUnavailable, ProviderToken, ProviderTokenInput, ProviderUpstreamError, Public, PutInput, QueryHit, QueryInput, RandomIDGenerator, RandomIdGenerator, RapidConnectXMLPatterns, RateLimitAllowed, RateLimitBucketKey, RateLimitConfig, RateLimitDecisionKey, RateLimitEntry, RateLimiter, RateLimitKey, RateLimitLimited, RateLimitMiddleware, RateLimitResult, RateLimitStore, RateLimitStoreOptions, RateLimitStrategy, RateLimitWindow, RawJSON, ReadResourceRequest, ReadSSEMessage, RealClock, ReconstructingSessionRegistry, ReconstructSessionRecord, RecordStatus, RecordStatusFailed, RecordStatusPending, RecordStatusProcessing, RecordStatusSkipped, RecordStatusSucceeded, RefreshLeaseInput, RefreshRequest, RefreshSemaphoreSlotInput, RefreshStage, RefreshTokenRecord, RefreshTokenStore, RegisterControllerRoutes, RegisterMCPFacade, RegisterMCPServer, RegisterMicroVMControllerRoutes, RegistryClient, RegistryClientOption, RelatedTaskMetadata, ReleaseLeaseInput, ReleaseSemaphoreSlotInput, ReportKinesisPutRecordsFailures, Request, RequireAnyScope, RequireAuth, RequireBearerTokenMiddleware, RequireBearerTokenOptions, RequiredForbiddenOperationFields, RequiredOperations, RequireEventBridgeWorkloadEnvelope, RequireScope, ResourceContent, ResourceDef, ResourceHandler, ResourceMetadataURLFromMcpEndpoint, ResourceName, ResourcePathFromProtectedResourcePath, ResourceRegistry, ResourceSubscription, ResourceSubscriptionHook, ResourceTemplateDef, Response, ResultType, ResultTypeComplete, ResultTypeInputRequired, RFC9728ResourceMetadataURL, RootDiscoveryConfig, Route, RouteInventory, RouteOption, RouteRefreshBrokerRecord, RouteRefreshBrokerSeeder, RouteRefreshBrokerStore, RouteRefreshBrokerStoreOptions, RPCError, RunConformance, S3EncryptionBucketDefault, S3EncryptionConfig, S3EncryptionKMS, S3EncryptionMode, S3EncryptionS3Managed, S3StoreConfig, S3VectorsAPI, S3VectorStore, SafeError, SafeJSONForHTML, SanitizationType, SanitizeFields, SanitizeFieldValue, SanitizeJSON, SanitizeJSONValue, SanitizeLogString, SanitizerFunc, SanitizeXML, ScrubFreeText, SecureApp, SecureOpenAPISpec, SecureOptions, SecurePrincipal, SecurePrincipalResolver, SecureRoute, SecureRouteAppSync, SecureRouteHTTP, SecureRouteSurface, SecureRouteWebSocket, SemanticIndex, SemanticRecord, SemaphoreInspection, SemaphoreLease, SemaphorePartitionKey, SemaphoreSlotSortKey, SensitiveFields, Server, ServerIdentity, ServerOption, Session, SessionCommandInput, SessionKey, SessionListInput, SessionQueryInput, SessionReconstructionHook, SessionReconstructionOption, SessionReconstructionRequest, SessionRecord, SessionRecordFromRegistryRecord, SessionRecordToRegistryRecord, SessionRegistry, SessionRegistryContract, SessionRegistryLister, SessionRegistryPartitionKey, SessionRegistryRecord, SessionRegistrySortKey, SessionRegistryTableName, SessionSpec, SessionStatus, SessionStore, SessionTokenMetadata, SessionTokenMetadataFromProviderToken, SetLogger, SlidingWindowStrategy, SNSEvent, SNSEventOptions, SNSHandler, SNSNotifierOptions, SNSPublishCall, SNSRecordOptions, SourceProvenance, SpanRecord, SQSEvent, SQSEventOptions, SQSHandler, SQSMessageOptions, SSEEvent, SSEMessage, SSEResponse, SSEStreamResponse, StageGlobalRoute, StateFailed, StateImagePrepared, StateImagePreparing, StateReadinessProbing, StateReady, StateRequested, StateResuming, StateRunning, StateStarted, StateStarting, StateStopped, StateStopping, StateSuspended, StateSuspending, StateTearingDown, StateTerminated, StateTerminating, StateValidated, StateValidating, StepFunctionsTaskToken, StepFunctionsTaskTokenEvent, StepFunctionsTaskTokenEventOptions, Store, Stores, Stream, StreamBytes, StreamChunk, StreamerCall, StreamError, StreamEvent, StreamingToolHandler, StreamResult, StreamStore, StructuredLogger, SupportedEndpointTemplates, SupportedIssuerModes, SupportedOAuthDiscoveryTemplates, SupportedOAuthFacadeTemplates, SupportedStageGlobalRoutes, TableTheorySessionRegistry, Task, TaskListRequest, TaskListResult, TaskLookup, TaskMetadata, TaskRecord, TaskRuntimeOptions, TaskStatus, TaskStatusCanceled, TaskStatusCompleted, TaskStatusFailed, TaskStatusInputRequired, TaskStatusWorking, TaskStore, TaskSupport, TaskSupportForbidden, TaskSupportOptional, TaskSupportRequired, TenantBindingRule, TestLogger, Text, Tier, TierP0, TierP1, TierP2, TimeoutConfig, TimeoutMiddleware, TimeWindow, TitanEmbedder, TokenClaims, TokenExpectations, TokenIssuanceContract, TokenResponse, TokenSet, ToolAnnotations, ToolContextHook, ToolDef, ToolExecution, ToolHandler, ToolInput, ToolInputFromContext, ToolLifecycleFinish, ToolLifecycleOptions, ToolLifecycleOutcome, ToolLifecycleOutcomeContextCanceled, ToolLifecycleOutcomeHandledError, ToolLifecycleOutcomeInvalidParams, ToolLifecycleOutcomePanic, ToolLifecycleOutcomeSuccess, ToolLifecycleOutcomeTimeout, ToolLifecycleOutcomeUnhandledError, ToolLifecycleStart, ToolLifecycleTelemetry, ToolRegistry, ToolResult, TransactionRecord, TransactionStore, TransactionStoreOptions, TransitionJobStatusInput, TransportPosture, TransportPostureIAM, TransportPostureJWT, TransportPostureNonePublic, TransportPostureRuntimeBearer, UploadGranter, UpsertRecordStatusInput, URLMode, URLModePublicBaseURL, URLModeRequestHost, UsageStats, UsageWindow, ValidateControllerContract, ValidateDimension, ValidateDynamicClientRegistrationRequest, ValidateEscapeHatches, ValidateKey, ValidateLifecycleContract, ValidateLoggingProfile, ValidateOperationContract, ValidatePKCECodeVerifier, ValidateProviderInvokeInput, ValidateProviderListInput, ValidateProviderRunInput, ValidateProviderSession, ValidateProviderSessionInput, ValidateProviderToken, ValidateProviderTokenInput, ValidateRealLifecycleContract, ValidateRequiredMetadata, ValidateSessionRecord, ValidateSessionRegistryContract, ValidateSessionRegistryRecord, ValidateSessionStatus, ValidateSessionTokenMetadata, ValidateVector, ValidationFieldError, ValidationRuleEnum, ValidationRuleMax, ValidationRuleMaxLength, ValidationRuleMin, ValidationRuleMinLength, ValidationRulePattern, ValidationRuleRequired, Vary, VectorRecord, VerifyVersionedArtifact, VersionedArtifact, VersionedArtifactRequest, WebSocketClientFactory, WebSocketContext, WebSocketEvent, WebSocketEventOptions, WebSocketHandler, WindowConfig, WindowLimit, WithAPI, WithAuthHook, WithAuthPrincipalHook, WithAWSConfig, WithAWSLambdaMicroVMClock, WithAWSLambdaMicroVMRegion, WithCacheableResultConfig, WithCapabilityConfig, WithClock, WithCompletionHooks, WithControllerClock, WithControllerDeploymentDefaults, WithControllerExecutionRoleArn, WithControllerID, WithControllerIDGenerator, WithControllerLogging, WithControllerProviderID, WithControllerSessionTTL, WithCORS, WithDeviceAuthorizationEndpoint, WithDynamoStreamSpillEncryption, WithEMFClock, WithEMFNamespace, WithEMFService, WithEMFWriter, WithEnvironmentErrorNotifications, WithErrorNotifier, WithExtensionCapabilities, WithHTTPErrorFormat, WithIdentifier, WithIDGenerator, WithInitialSessionListenerBudget, WithLegacyHTTPErrorShape, WithLifecycleContract, WithLifecycleHandler, WithLimits, WithLogger, WithLoggingLevelHook, WithObservability, WithOriginValidator, WithPolicyHook, WithProfileClock, WithProfileEnvironment, WithProfileSanitizer, WithProfileWriter, WithRegistryClientTTL, WithResourceSubscriptionHooks, WithRevocationEndpoint, WithSanitizer, WithServerIDGenerator, WithServerInfoMetadata, WithSessionReconstructionClock, WithSessionReconstructionStaleAfter, WithSessionStore, WithStreamIDGenerator, WithStreamStore, WithTaskRuntime, WithTenantClaim, WithTier, WithToolContextHook, WithWebSocketClientFactory, WithWebSocketSupport, WithZapLogger, WrapError, XMLSanitizationPattern ```