@anthusai/papyrus 5.43.0 → 5.45.0

package/infra/chat-stack.js

@@ -0,0 +1,222 @@
+import { Annotations, Arn, ArnFormat, Aws, CfnOutput, CfnParameter, Duration, Fn, RemovalPolicy, Stack } from "aws-cdk-lib";
+import * as dynamodb from "aws-cdk-lib/aws-dynamodb";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import * as eventSources from "aws-cdk-lib/aws-lambda-event-sources";
+import * as logs from "aws-cdk-lib/aws-logs";
+import * as s3 from "aws-cdk-lib/aws-s3";
+import * as sqs from "aws-cdk-lib/aws-sqs";
+import { CHAT_PRIVATE_ASSISTANT_ID, CHAT_PRIVATE_ASSISTANT_NAME, chatExportName, resolveChatLogGroupPrefix, resolveChatStackName, } from "./site-config.js";
+/**
+ * The private newsroom chat data plane of one publication: two DynamoDB tables, a private versioned S3 bucket, run
+ * and probe queues with DLQs, and the two worker Lambdas with their event source mappings. The CMS compute role
+ * receives the scoped gateway policy through the `GatewayRoleArn` parameter (the app shell's `CmsComputeRoleArn`
+ * output), and the app shell reads the resource names back through this stack's exports.
+ *
+ * The resource definitions are the ones the first activated stack `PapyrusChatDataCandidate` was activated from
+ * (infra/shared-chat-runtime/cdk/synth.cjs); logical ids and construct order are kept so that stack is adopted by an
+ * in-place update (scripts/test-infra-chat.ts compares the two templates).
+ */
+export class PapyrusChatStack extends Stack {
+    constructor(scope, props) {
+        const { config, lambdaAssetDirectory, ...stackProps } = props;
+        const chat = config.chat;
+        const stackName = resolveChatStackName(config);
+        if (!chat || !stackName)
+            throw new Error(`site ${config.siteId} does not enable chat`);
+        // The construct id is the stack name: the SQS event source mapping logical ids derive from it.
+        super(scope, stackName, { ...stackProps, stackName });
+        const modelKeyParameter = chat.modelKeyParameter;
+        const logGroupPrefix = resolveChatLogGroupPrefix(config);
+        const gatewayRoleArn = new CfnParameter(this, "GatewayRoleArn", {
+            type: "String",
+            description: "The site's CMS compute role ARN (CmsComputeRoleArn output of the app-shell stack); receives the scoped gateway policy.",
+            allowedPattern: "^arn:aws:iam::[0-9]{12}:role/.+$",
+        });
+        const privateBotId = new CfnParameter(this, "PrivateAssistantBotId", {
+            type: "String",
+            default: CHAT_PRIVATE_ASSISTANT_ID,
+            description: "Stable Papyrus-owned assistant ID; stored per derived account tenant on first private-channel open.",
+            allowedPattern: "^[A-Za-z0-9][A-Za-z0-9_-]{1,63}$",
+        });
+        const privateBotName = new CfnParameter(this, "PrivateAssistantBotName", {
+            type: "String",
+            default: CHAT_PRIVATE_ASSISTANT_NAME,
+            description: "Visible name for the private Papyrus assistant.",
+            allowedPattern: "^[A-Za-z0-9][A-Za-z0-9 ._-]{1,63}$",
+        });
+        const messaging = new dynamodb.Table(this, "PrivateMessaging", {
+            partitionKey: { name: "pk", type: dynamodb.AttributeType.STRING },
+            sortKey: { name: "sk", type: dynamodb.AttributeType.STRING },
+            billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+            timeToLiveAttribute: "expires_at",
+            pointInTimeRecoverySpecification: { pointInTimeRecoveryEnabled: true },
+            deletionProtection: true,
+            removalPolicy: RemovalPolicy.RETAIN,
+        });
+        const conversations = new dynamodb.Table(this, "PrivateConversationIndex", {
+            partitionKey: { name: "pk", type: dynamodb.AttributeType.STRING },
+            sortKey: { name: "sk", type: dynamodb.AttributeType.STRING },
+            billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+            pointInTimeRecoverySpecification: { pointInTimeRecoveryEnabled: true },
+            deletionProtection: true,
+            removalPolicy: RemovalPolicy.RETAIN,
+        });
+        for (const name of ["l1", "l2", "l3"]) {
+            conversations.addLocalSecondaryIndex({
+                indexName: `${name}-index`,
+                sortKey: { name, type: dynamodb.AttributeType.STRING },
+                projectionType: dynamodb.ProjectionType.ALL,
+            });
+        }
+        const objects = new s3.Bucket(this, "PrivateSessionObjects", {
+            blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
+            encryption: s3.BucketEncryption.S3_MANAGED,
+            enforceSSL: true,
+            versioned: true,
+            removalPolicy: RemovalPolicy.RETAIN,
+            objectOwnership: s3.ObjectOwnership.BUCKET_OWNER_ENFORCED,
+        });
+        const queue = (id, extra = {}) => new sqs.Queue(this, id, { encryption: sqs.QueueEncryption.SQS_MANAGED, enforceSSL: true, ...extra });
+        const runDlq = queue("TurnRunDlq", { retentionPeriod: Duration.days(14) });
+        const probeDlq = queue("TurnProbeDlq", { retentionPeriod: Duration.days(14) });
+        const runs = queue("TurnRuns", {
+            visibilityTimeout: Duration.seconds(1800),
+            retentionPeriod: Duration.days(4),
+            deadLetterQueue: { queue: runDlq, maxReceiveCount: 5 },
+        });
+        const probes = queue("TurnProbes", {
+            visibilityTimeout: Duration.minutes(2),
+            retentionPeriod: Duration.days(4),
+            deadLetterQueue: { queue: probeDlq, maxReceiveCount: 5 },
+        });
+        const gateway = iam.Role.fromRoleArn(this, "PapyrusChatGatewayRole", gatewayRoleArn.valueAsString, { mutable: true });
+        gateway.addToPrincipalPolicy(new iam.PolicyStatement({
+            actions: ["dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:UpdateItem", "dynamodb:TransactWriteItems", "dynamodb:Query", "dynamodb:BatchGetItem"],
+            resources: [messaging.tableArn],
+        }));
+        gateway.addToPrincipalPolicy(new iam.PolicyStatement({
+            actions: ["dynamodb:GetItem", "dynamodb:Query", "dynamodb:BatchGetItem"],
+            resources: [conversations.tableArn, `${conversations.tableArn}/index/*`],
+        }));
+        gateway.addToPrincipalPolicy(new iam.PolicyStatement({ actions: ["s3:GetObject"], resources: [objects.arnForObjects("conversations/*")] }));
+        gateway.addToPrincipalPolicy(new iam.PolicyStatement({ actions: ["sqs:SendMessage"], resources: [runs.queueArn, probes.queueArn] }));
+        // Appended last, as in the activated stack's policy (the transaction-check correction was added to it afterwards).
+        gateway.addToPrincipalPolicy(new iam.PolicyStatement({ actions: ["dynamodb:ConditionCheckItem"], resources: [messaging.tableArn] }));
+        const hostedEnvironment = {
+            PAPYRUS_CHAT_MESSAGING_TABLE: messaging.tableName,
+            PAPYRUS_CHAT_CONVERSATIONS_TABLE: conversations.tableName,
+            PAPYRUS_CHAT_SESSION_BUCKET: objects.bucketName,
+            PAPYRUS_CHAT_TURN_RUNS_QUEUE_URL: runs.queueUrl,
+            PAPYRUS_CHAT_TURN_PROBES_QUEUE_URL: probes.queueUrl,
+            PAPYRUS_CHAT_PRIVATE_BOT_ID: privateBotId.valueAsString,
+            PAPYRUS_CHAT_PRIVATE_BOT_NAME: privateBotName.valueAsString,
+        };
+        const runLogGroup = new logs.LogGroup(this, "RunWorkerLogs", {
+            logGroupName: `${logGroupPrefix}-run-worker`,
+            retention: logs.RetentionDays.ONE_MONTH,
+            removalPolicy: RemovalPolicy.RETAIN,
+        });
+        const probeLogGroup = new logs.LogGroup(this, "ProbeWorkerLogs", {
+            logGroupName: `${logGroupPrefix}-probe-worker`,
+            retention: logs.RetentionDays.ONE_MONTH,
+            removalPolicy: RemovalPolicy.RETAIN,
+        });
+        const runWorker = new iam.Role(this, "RunWorkerRole", {
+            assumedBy: new iam.ServicePrincipal("lambda.amazonaws.com"),
+            description: "Private Papyrus computerless chat run worker.",
+        });
+        runWorker.addToPolicy(new iam.PolicyStatement({
+            actions: ["dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:UpdateItem", "dynamodb:DeleteItem", "dynamodb:Query", "dynamodb:BatchGetItem", "dynamodb:TransactWriteItems"],
+            resources: [messaging.tableArn, conversations.tableArn, `${conversations.tableArn}/index/*`],
+        }));
+        runWorker.addToPolicy(new iam.PolicyStatement({
+            actions: ["ssm:GetParameter"],
+            // Pseudo parameters, not the literal account: the template stays environment-agnostic like the activated stack.
+            resources: [Arn.format({ partition: Aws.PARTITION, region: Aws.REGION, account: Aws.ACCOUNT_ID, service: "ssm", resource: "parameter", resourceName: modelKeyParameter.slice(1), arnFormat: ArnFormat.SLASH_RESOURCE_NAME })],
+        }));
+        runWorker.addToPolicy(new iam.PolicyStatement({ actions: ["logs:CreateLogStream", "logs:PutLogEvents"], resources: [`${runLogGroup.logGroupArn}:*`] }));
+        runWorker.addToPolicy(new iam.PolicyStatement({
+            actions: ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
+            resources: [objects.arnForObjects("conversations/*")],
+        }));
+        runWorker.addToPolicy(new iam.PolicyStatement({ actions: ["sqs:ChangeMessageVisibility", "sqs:SendMessage"], resources: [runs.queueArn, probes.queueArn] }));
+        const probeWorker = new iam.Role(this, "ProbeWorkerRole", {
+            assumedBy: new iam.ServicePrincipal("lambda.amazonaws.com"),
+            description: "Private Papyrus chat deadline/recovery worker.",
+        });
+        probeWorker.addToPolicy(new iam.PolicyStatement({
+            actions: ["dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:UpdateItem", "dynamodb:DeleteItem", "dynamodb:Query", "dynamodb:TransactWriteItems", "dynamodb:BatchGetItem"],
+            resources: [messaging.tableArn],
+        }));
+        probeWorker.addToPolicy(new iam.PolicyStatement({
+            actions: ["dynamodb:GetItem", "dynamodb:Query", "dynamodb:BatchGetItem"],
+            resources: [conversations.tableArn, `${conversations.tableArn}/index/*`],
+        }));
+        probeWorker.addToPolicy(new iam.PolicyStatement({ actions: ["s3:GetObject"], resources: [objects.arnForObjects("conversations/*")] }));
+        probeWorker.addToPolicy(new iam.PolicyStatement({ actions: ["sqs:SendMessage"], resources: [runs.queueArn, probes.queueArn] }));
+        probeWorker.addToPolicy(new iam.PolicyStatement({ actions: ["logs:CreateLogStream", "logs:PutLogEvents"], resources: [`${probeLogGroup.logGroupArn}:*`] }));
+        let code;
+        if (chat.workerCodeS3Key) {
+            // Already uploaded and verified bytes: the template names the object, nothing is bundled or uploaded.
+            const assets = s3.Bucket.fromBucketName(this, "WorkerCodeAssets", Fn.sub("cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}"));
+            code = lambda.Code.fromBucket(assets, chat.workerCodeS3Key);
+            Annotations.of(assets).acknowledgeWarning("@aws-cdk/aws-lambda:codeFromBucketObjectVersionNotSpecified", "the key is a content hash; it is never overwritten");
+        }
+        else {
+            if (!lambdaAssetDirectory)
+                throw new Error(`site ${config.siteId}: bundle the chat workers first (scripts/bundle-chat-lambdas.mjs) and pass -c chatLambdas=<dir>, or pin chat.workerCodeS3Key`);
+            code = lambda.Code.fromAsset(lambdaAssetDirectory);
+        }
+        const runWorkerFunction = new lambda.Function(this, "RunWorker", {
+            runtime: lambda.Runtime.NODEJS_22_X,
+            handler: "run-worker.handler",
+            code,
+            role: runWorker,
+            memorySize: 1024,
+            timeout: Duration.seconds(900),
+            logGroup: runLogGroup,
+            environment: { ...hostedEnvironment, OPENAI_API_KEY_PARAMETER: modelKeyParameter },
+            description: "Runs Papyrus private chat turns with the computerless Chatticus execution profile.",
+        });
+        const probeWorkerFunction = new lambda.Function(this, "ProbeWorker", {
+            runtime: lambda.Runtime.NODEJS_22_X,
+            handler: "probe-worker.handler",
+            code,
+            role: probeWorker,
+            memorySize: 512,
+            timeout: Duration.seconds(60),
+            logGroup: probeLogGroup,
+            environment: hostedEnvironment,
+            description: "Recovers and finalizes Papyrus private chat turns.",
+        });
+        // The model key parameter exists for every configured site, so the workers run from the first deploy.
+        runWorkerFunction.addEventSource(new eventSources.SqsEventSource(runs, { enabled: true, batchSize: 1 }));
+        probeWorkerFunction.addEventSource(new eventSources.SqsEventSource(probes, { enabled: true, batchSize: 1 }));
+        // Last, as in the activated stack (the storage-owner fence was added after the event source grants).
+        runWorker.addToPolicy(new iam.PolicyStatement({ actions: ["dynamodb:ConditionCheckItem"], resources: [conversations.tableArn] }));
+        const exported = (id, value, exportKey) => new CfnOutput(this, id, { value, ...(exportKey ? { exportName: chatExportName(stackName, exportKey) } : {}) });
+        exported("MessagingTableName", messaging.tableName, "MessagingTableName");
+        exported("ConversationIndexTableName", conversations.tableName, "ConversationIndexTableName");
+        exported("SessionBucketName", objects.bucketName, "SessionBucketName");
+        exported("TurnRunsQueueUrl", runs.queueUrl, "TurnRunsQueueUrl");
+        exported("TurnProbesQueueUrl", probes.queueUrl, "TurnProbesQueueUrl");
+        exported("FeatureDefault", "enabled per site by the chat block of its site.json (PAPYRUS_PRIVATE_CHAT_ENABLED on the CMS production branch)");
+        exported("SyntheticAdapterTestOnly", "false");
+        exported("GatewayMessagingTableEnvironmentName", "PAPYRUS_CHAT_MESSAGING_TABLE");
+        exported("GatewayMessagingTableName", messaging.tableName);
+        exported("GatewayConversationTableEnvironmentName", "PAPYRUS_CHAT_CONVERSATIONS_TABLE");
+        exported("GatewayConversationTableName", conversations.tableName);
+        exported("GatewaySessionBucketEnvironmentName", "PAPYRUS_CHAT_SESSION_BUCKET");
+        exported("GatewaySessionBucketName", objects.bucketName);
+        exported("GatewayRunQueueEnvironmentName", "PAPYRUS_CHAT_TURN_RUNS_QUEUE_URL");
+        exported("GatewayProbeQueueEnvironmentName", "PAPYRUS_CHAT_TURN_PROBES_QUEUE_URL");
+        exported("GatewayPrivateBotIdEnvironmentName", "PAPYRUS_CHAT_PRIVATE_BOT_ID");
+        exported("PrivateAssistantBotIdValue", privateBotId.valueAsString);
+        exported("GatewayPrivateBotNameEnvironmentName", "PAPYRUS_CHAT_PRIVATE_BOT_NAME");
+        exported("PrivateAssistantBotNameValue", privateBotName.valueAsString);
+        exported("WorkerModelKeyParameterName", modelKeyParameter);
+        exported("RunWorkerFunctionName", runWorkerFunction.functionName);
+        exported("ProbeWorkerFunctionName", probeWorkerFunction.functionName);
+    }
+}

package/infra/chat-stack.ts

@@ -0,0 +1,250 @@
+import { Construct } from "constructs";
+import { Annotations, Arn, ArnFormat, Aws, CfnOutput, CfnParameter, Duration, Fn, RemovalPolicy, Stack, StackProps } from "aws-cdk-lib";
+import * as dynamodb from "aws-cdk-lib/aws-dynamodb";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import * as eventSources from "aws-cdk-lib/aws-lambda-event-sources";
+import * as logs from "aws-cdk-lib/aws-logs";
+import * as s3 from "aws-cdk-lib/aws-s3";
+import * as sqs from "aws-cdk-lib/aws-sqs";
+import {
+  AmplifyAppShellSiteConfig,
+  CHAT_PRIVATE_ASSISTANT_ID,
+  CHAT_PRIVATE_ASSISTANT_NAME,
+  chatExportName,
+  resolveChatLogGroupPrefix,
+  resolveChatStackName,
+} from "./site-config";
+
+export type PapyrusChatStackProps = StackProps & {
+  config: AmplifyAppShellSiteConfig;
+  /** Directory holding the bundled `run-worker.js` and `probe-worker.js`. Not needed when `chat.workerCodeS3Key` pins the code. */
+  lambdaAssetDirectory?: string;
+};
+
+/**
+ * The private newsroom chat data plane of one publication: two DynamoDB tables, a private versioned S3 bucket, run
+ * and probe queues with DLQs, and the two worker Lambdas with their event source mappings. The CMS compute role
+ * receives the scoped gateway policy through the `GatewayRoleArn` parameter (the app shell's `CmsComputeRoleArn`
+ * output), and the app shell reads the resource names back through this stack's exports.
+ *
+ * The resource definitions are the ones the first activated stack `PapyrusChatDataCandidate` was activated from
+ * (infra/shared-chat-runtime/cdk/synth.cjs); logical ids and construct order are kept so that stack is adopted by an
+ * in-place update (scripts/test-infra-chat.ts compares the two templates).
+ */
+export class PapyrusChatStack extends Stack {
+  constructor(scope: Construct, props: PapyrusChatStackProps) {
+    const { config, lambdaAssetDirectory, ...stackProps } = props;
+    const chat = config.chat;
+    const stackName = resolveChatStackName(config);
+    if (!chat || !stackName) throw new Error(`site ${config.siteId} does not enable chat`);
+    // The construct id is the stack name: the SQS event source mapping logical ids derive from it.
+    super(scope, stackName, { ...stackProps, stackName });
+
+    const modelKeyParameter = chat.modelKeyParameter;
+    const logGroupPrefix = resolveChatLogGroupPrefix(config);
+
+    const gatewayRoleArn = new CfnParameter(this, "GatewayRoleArn", {
+      type: "String",
+      description: "The site's CMS compute role ARN (CmsComputeRoleArn output of the app-shell stack); receives the scoped gateway policy.",
+      allowedPattern: "^arn:aws:iam::[0-9]{12}:role/.+$",
+    });
+    const privateBotId = new CfnParameter(this, "PrivateAssistantBotId", {
+      type: "String",
+      default: CHAT_PRIVATE_ASSISTANT_ID,
+      description: "Stable Papyrus-owned assistant ID; stored per derived account tenant on first private-channel open.",
+      allowedPattern: "^[A-Za-z0-9][A-Za-z0-9_-]{1,63}$",
+    });
+    const privateBotName = new CfnParameter(this, "PrivateAssistantBotName", {
+      type: "String",
+      default: CHAT_PRIVATE_ASSISTANT_NAME,
+      description: "Visible name for the private Papyrus assistant.",
+      allowedPattern: "^[A-Za-z0-9][A-Za-z0-9 ._-]{1,63}$",
+    });
+
+    const messaging = new dynamodb.Table(this, "PrivateMessaging", {
+      partitionKey: { name: "pk", type: dynamodb.AttributeType.STRING },
+      sortKey: { name: "sk", type: dynamodb.AttributeType.STRING },
+      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+      timeToLiveAttribute: "expires_at",
+      pointInTimeRecoverySpecification: { pointInTimeRecoveryEnabled: true },
+      deletionProtection: true,
+      removalPolicy: RemovalPolicy.RETAIN,
+    });
+
+    const conversations = new dynamodb.Table(this, "PrivateConversationIndex", {
+      partitionKey: { name: "pk", type: dynamodb.AttributeType.STRING },
+      sortKey: { name: "sk", type: dynamodb.AttributeType.STRING },
+      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+      pointInTimeRecoverySpecification: { pointInTimeRecoveryEnabled: true },
+      deletionProtection: true,
+      removalPolicy: RemovalPolicy.RETAIN,
+    });
+    for (const name of ["l1", "l2", "l3"]) {
+      conversations.addLocalSecondaryIndex({
+        indexName: `${name}-index`,
+        sortKey: { name, type: dynamodb.AttributeType.STRING },
+        projectionType: dynamodb.ProjectionType.ALL,
+      });
+    }
+
+    const objects = new s3.Bucket(this, "PrivateSessionObjects", {
+      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
+      encryption: s3.BucketEncryption.S3_MANAGED,
+      enforceSSL: true,
+      versioned: true,
+      removalPolicy: RemovalPolicy.RETAIN,
+      objectOwnership: s3.ObjectOwnership.BUCKET_OWNER_ENFORCED,
+    });
+
+    const queue = (id: string, extra: Partial<sqs.QueueProps> = {}) =>
+      new sqs.Queue(this, id, { encryption: sqs.QueueEncryption.SQS_MANAGED, enforceSSL: true, ...extra });
+    const runDlq = queue("TurnRunDlq", { retentionPeriod: Duration.days(14) });
+    const probeDlq = queue("TurnProbeDlq", { retentionPeriod: Duration.days(14) });
+    const runs = queue("TurnRuns", {
+      visibilityTimeout: Duration.seconds(1800),
+      retentionPeriod: Duration.days(4),
+      deadLetterQueue: { queue: runDlq, maxReceiveCount: 5 },
+    });
+    const probes = queue("TurnProbes", {
+      visibilityTimeout: Duration.minutes(2),
+      retentionPeriod: Duration.days(4),
+      deadLetterQueue: { queue: probeDlq, maxReceiveCount: 5 },
+    });
+
+    const gateway = iam.Role.fromRoleArn(this, "PapyrusChatGatewayRole", gatewayRoleArn.valueAsString, { mutable: true });
+    gateway.addToPrincipalPolicy(new iam.PolicyStatement({
+      actions: ["dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:UpdateItem", "dynamodb:TransactWriteItems", "dynamodb:Query", "dynamodb:BatchGetItem"],
+      resources: [messaging.tableArn],
+    }));
+    gateway.addToPrincipalPolicy(new iam.PolicyStatement({
+      actions: ["dynamodb:GetItem", "dynamodb:Query", "dynamodb:BatchGetItem"],
+      resources: [conversations.tableArn, `${conversations.tableArn}/index/*`],
+    }));
+    gateway.addToPrincipalPolicy(new iam.PolicyStatement({ actions: ["s3:GetObject"], resources: [objects.arnForObjects("conversations/*")] }));
+    gateway.addToPrincipalPolicy(new iam.PolicyStatement({ actions: ["sqs:SendMessage"], resources: [runs.queueArn, probes.queueArn] }));
+    // Appended last, as in the activated stack's policy (the transaction-check correction was added to it afterwards).
+    gateway.addToPrincipalPolicy(new iam.PolicyStatement({ actions: ["dynamodb:ConditionCheckItem"], resources: [messaging.tableArn] }));
+
+    const hostedEnvironment = {
+      PAPYRUS_CHAT_MESSAGING_TABLE: messaging.tableName,
+      PAPYRUS_CHAT_CONVERSATIONS_TABLE: conversations.tableName,
+      PAPYRUS_CHAT_SESSION_BUCKET: objects.bucketName,
+      PAPYRUS_CHAT_TURN_RUNS_QUEUE_URL: runs.queueUrl,
+      PAPYRUS_CHAT_TURN_PROBES_QUEUE_URL: probes.queueUrl,
+      PAPYRUS_CHAT_PRIVATE_BOT_ID: privateBotId.valueAsString,
+      PAPYRUS_CHAT_PRIVATE_BOT_NAME: privateBotName.valueAsString,
+    };
+
+    const runLogGroup = new logs.LogGroup(this, "RunWorkerLogs", {
+      logGroupName: `${logGroupPrefix}-run-worker`,
+      retention: logs.RetentionDays.ONE_MONTH,
+      removalPolicy: RemovalPolicy.RETAIN,
+    });
+    const probeLogGroup = new logs.LogGroup(this, "ProbeWorkerLogs", {
+      logGroupName: `${logGroupPrefix}-probe-worker`,
+      retention: logs.RetentionDays.ONE_MONTH,
+      removalPolicy: RemovalPolicy.RETAIN,
+    });
+
+    const runWorker = new iam.Role(this, "RunWorkerRole", {
+      assumedBy: new iam.ServicePrincipal("lambda.amazonaws.com"),
+      description: "Private Papyrus computerless chat run worker.",
+    });
+    runWorker.addToPolicy(new iam.PolicyStatement({
+      actions: ["dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:UpdateItem", "dynamodb:DeleteItem", "dynamodb:Query", "dynamodb:BatchGetItem", "dynamodb:TransactWriteItems"],
+      resources: [messaging.tableArn, conversations.tableArn, `${conversations.tableArn}/index/*`],
+    }));
+    runWorker.addToPolicy(new iam.PolicyStatement({
+      actions: ["ssm:GetParameter"],
+      // Pseudo parameters, not the literal account: the template stays environment-agnostic like the activated stack.
+      resources: [Arn.format({ partition: Aws.PARTITION, region: Aws.REGION, account: Aws.ACCOUNT_ID, service: "ssm", resource: "parameter", resourceName: modelKeyParameter.slice(1), arnFormat: ArnFormat.SLASH_RESOURCE_NAME })],
+    }));
+    runWorker.addToPolicy(new iam.PolicyStatement({ actions: ["logs:CreateLogStream", "logs:PutLogEvents"], resources: [`${runLogGroup.logGroupArn}:*`] }));
+    runWorker.addToPolicy(new iam.PolicyStatement({
+      actions: ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
+      resources: [objects.arnForObjects("conversations/*")],
+    }));
+    runWorker.addToPolicy(new iam.PolicyStatement({ actions: ["sqs:ChangeMessageVisibility", "sqs:SendMessage"], resources: [runs.queueArn, probes.queueArn] }));
+
+    const probeWorker = new iam.Role(this, "ProbeWorkerRole", {
+      assumedBy: new iam.ServicePrincipal("lambda.amazonaws.com"),
+      description: "Private Papyrus chat deadline/recovery worker.",
+    });
+    probeWorker.addToPolicy(new iam.PolicyStatement({
+      actions: ["dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:UpdateItem", "dynamodb:DeleteItem", "dynamodb:Query", "dynamodb:TransactWriteItems", "dynamodb:BatchGetItem"],
+      resources: [messaging.tableArn],
+    }));
+    probeWorker.addToPolicy(new iam.PolicyStatement({
+      actions: ["dynamodb:GetItem", "dynamodb:Query", "dynamodb:BatchGetItem"],
+      resources: [conversations.tableArn, `${conversations.tableArn}/index/*`],
+    }));
+    probeWorker.addToPolicy(new iam.PolicyStatement({ actions: ["s3:GetObject"], resources: [objects.arnForObjects("conversations/*")] }));
+    probeWorker.addToPolicy(new iam.PolicyStatement({ actions: ["sqs:SendMessage"], resources: [runs.queueArn, probes.queueArn] }));
+    probeWorker.addToPolicy(new iam.PolicyStatement({ actions: ["logs:CreateLogStream", "logs:PutLogEvents"], resources: [`${probeLogGroup.logGroupArn}:*`] }));
+
+    let code: lambda.Code;
+    if (chat.workerCodeS3Key) {
+      // Already uploaded and verified bytes: the template names the object, nothing is bundled or uploaded.
+      const assets = s3.Bucket.fromBucketName(this, "WorkerCodeAssets", Fn.sub("cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}"));
+      code = lambda.Code.fromBucket(assets, chat.workerCodeS3Key);
+      Annotations.of(assets).acknowledgeWarning("@aws-cdk/aws-lambda:codeFromBucketObjectVersionNotSpecified", "the key is a content hash; it is never overwritten");
+    } else {
+      if (!lambdaAssetDirectory) throw new Error(`site ${config.siteId}: bundle the chat workers first (scripts/bundle-chat-lambdas.mjs) and pass -c chatLambdas=<dir>, or pin chat.workerCodeS3Key`);
+      code = lambda.Code.fromAsset(lambdaAssetDirectory);
+    }
+
+    const runWorkerFunction = new lambda.Function(this, "RunWorker", {
+      runtime: lambda.Runtime.NODEJS_22_X,
+      handler: "run-worker.handler",
+      code,
+      role: runWorker,
+      memorySize: 1024,
+      timeout: Duration.seconds(900),
+      logGroup: runLogGroup,
+      environment: { ...hostedEnvironment, OPENAI_API_KEY_PARAMETER: modelKeyParameter },
+      description: "Runs Papyrus private chat turns with the computerless Chatticus execution profile.",
+    });
+    const probeWorkerFunction = new lambda.Function(this, "ProbeWorker", {
+      runtime: lambda.Runtime.NODEJS_22_X,
+      handler: "probe-worker.handler",
+      code,
+      role: probeWorker,
+      memorySize: 512,
+      timeout: Duration.seconds(60),
+      logGroup: probeLogGroup,
+      environment: hostedEnvironment,
+      description: "Recovers and finalizes Papyrus private chat turns.",
+    });
+    // The model key parameter exists for every configured site, so the workers run from the first deploy.
+    runWorkerFunction.addEventSource(new eventSources.SqsEventSource(runs, { enabled: true, batchSize: 1 }));
+    probeWorkerFunction.addEventSource(new eventSources.SqsEventSource(probes, { enabled: true, batchSize: 1 }));
+    // Last, as in the activated stack (the storage-owner fence was added after the event source grants).
+    runWorker.addToPolicy(new iam.PolicyStatement({ actions: ["dynamodb:ConditionCheckItem"], resources: [conversations.tableArn] }));
+
+    const exported = (id: string, value: string, exportKey?: Parameters<typeof chatExportName>[1]) =>
+      new CfnOutput(this, id, { value, ...(exportKey ? { exportName: chatExportName(stackName, exportKey) } : {}) });
+    exported("MessagingTableName", messaging.tableName, "MessagingTableName");
+    exported("ConversationIndexTableName", conversations.tableName, "ConversationIndexTableName");
+    exported("SessionBucketName", objects.bucketName, "SessionBucketName");
+    exported("TurnRunsQueueUrl", runs.queueUrl, "TurnRunsQueueUrl");
+    exported("TurnProbesQueueUrl", probes.queueUrl, "TurnProbesQueueUrl");
+    exported("FeatureDefault", "enabled per site by the chat block of its site.json (PAPYRUS_PRIVATE_CHAT_ENABLED on the CMS production branch)");
+    exported("SyntheticAdapterTestOnly", "false");
+    exported("GatewayMessagingTableEnvironmentName", "PAPYRUS_CHAT_MESSAGING_TABLE");
+    exported("GatewayMessagingTableName", messaging.tableName);
+    exported("GatewayConversationTableEnvironmentName", "PAPYRUS_CHAT_CONVERSATIONS_TABLE");
+    exported("GatewayConversationTableName", conversations.tableName);
+    exported("GatewaySessionBucketEnvironmentName", "PAPYRUS_CHAT_SESSION_BUCKET");
+    exported("GatewaySessionBucketName", objects.bucketName);
+    exported("GatewayRunQueueEnvironmentName", "PAPYRUS_CHAT_TURN_RUNS_QUEUE_URL");
+    exported("GatewayProbeQueueEnvironmentName", "PAPYRUS_CHAT_TURN_PROBES_QUEUE_URL");
+    exported("GatewayPrivateBotIdEnvironmentName", "PAPYRUS_CHAT_PRIVATE_BOT_ID");
+    exported("PrivateAssistantBotIdValue", privateBotId.valueAsString);
+    exported("GatewayPrivateBotNameEnvironmentName", "PAPYRUS_CHAT_PRIVATE_BOT_NAME");
+    exported("PrivateAssistantBotNameValue", privateBotName.valueAsString);
+    exported("WorkerModelKeyParameterName", modelKeyParameter);
+    exported("RunWorkerFunctionName", runWorkerFunction.functionName);
+    exported("ProbeWorkerFunctionName", probeWorkerFunction.functionName);
+  }
+}

package/infra/chat.test.js

@@ -0,0 +1,142 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { App } from "aws-cdk-lib";
+import { AmplifyAppShellStack } from "./amplify-app-shell.js";
+import { PapyrusChatStack } from "./chat-stack.js";
+import { parseSiteConfig, resolveChatLogGroupPrefix, resolveChatStackName, resolveStackName } from "./site-config.js";
+// Executes infra/amplify-app-shell/features/per-site-private-chat.feature (run through scripts/test-infra-chat.ts).
+const examples = path.resolve(__dirname, "../examples");
+const example = (name, change = () => { }) => {
+    const config = JSON.parse(fs.readFileSync(path.join(examples, `${name}.site.json`), "utf8"));
+    change(config);
+    return config;
+};
+const siteNames = fs.readdirSync(examples).filter((name) => name.endsWith(".site.json")).map((name) => name.replace(/\.site\.json$/, ""));
+const lambdaDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "papyrus-chat-test-"));
+for (const file of ["run-worker.js", "probe-worker.js"])
+    fs.writeFileSync(path.join(lambdaDirectory, file), "exports.handler = async () => ({});\n");
+const resourcesOf = (template, type) => Object.values(template.Resources).filter((resource) => resource.Type === type);
+function shellTemplate(raw) {
+    const config = parseSiteConfig(raw);
+    const stack = new AmplifyAppShellStack(new App(), "Shell", config, { env: { account: "712236451410", region: "us-east-1" }, stackName: resolveStackName(config) });
+    return JSON.parse(JSON.stringify(App.of(stack).synth().getStackByName(stack.stackName).template));
+}
+function chatTemplate(raw) {
+    const config = parseSiteConfig(raw);
+    const app = new App();
+    const stack = new PapyrusChatStack(app, { config, env: { account: "712236451410", region: "us-east-1" }, lambdaAssetDirectory: lambdaDirectory });
+    return JSON.parse(JSON.stringify(app.synth().getStackByName(stack.stackName).template));
+}
+const branchEnvironment = (template, branchName) => {
+    const branch = resourcesOf(template, "AWS::Amplify::Branch").find((resource) => resource.Properties.BranchName === branchName);
+    return Object.fromEntries(branch.Properties.EnvironmentVariables.map((variable) => [variable.Name, variable.Value]));
+};
+const CHAT_NAMES = ["PAPYRUS_CHAT_MESSAGING_TABLE", "PAPYRUS_CHAT_CONVERSATIONS_TABLE", "PAPYRUS_CHAT_SESSION_BUCKET", "PAPYRUS_CHAT_TURN_RUNS_QUEUE_URL", "PAPYRUS_CHAT_TURN_PROBES_QUEUE_URL", "PAPYRUS_CHAT_PRIVATE_BOT_ID", "PAPYRUS_CHAT_PRIVATE_BOT_NAME"];
+// Scenario: a site with chat enabled gets the chat environment and a data stack
+{
+    const raw = example("anth-us");
+    assert.equal(raw.chat.modelKeyParameter, "/papyrus/shipped/openai-api-key");
+    const config = parseSiteConfig(raw);
+    assert.equal(resolveChatStackName(config), "papyrus-chat-anth-us");
+    const production = branchEnvironment(shellTemplate(raw), "main");
+    assert.equal(production.PAPYRUS_PRIVATE_CHAT_ENABLED, "true");
+    assert.deepEqual(production.PAPYRUS_CHAT_MESSAGING_TABLE, { "Fn::ImportValue": "papyrus-chat-anth-us:MessagingTableName" });
+    assert.deepEqual(production.PAPYRUS_CHAT_SESSION_BUCKET, { "Fn::ImportValue": "papyrus-chat-anth-us:SessionBucketName" });
+    assert.deepEqual(production.PAPYRUS_CHAT_TURN_RUNS_QUEUE_URL, { "Fn::ImportValue": "papyrus-chat-anth-us:TurnRunsQueueUrl" });
+    assert.equal(production.PAPYRUS_CHAT_PRIVATE_BOT_ID, "papyrus-private-assistant");
+    const chat = chatTemplate(raw);
+    assert.equal(resourcesOf(chat, "AWS::DynamoDB::Table").length, 2);
+    const [bucket] = resourcesOf(chat, "AWS::S3::Bucket");
+    assert.equal(bucket.Properties.VersioningConfiguration.Status, "Enabled");
+    assert.equal(bucket.Properties.PublicAccessBlockConfiguration.BlockPublicPolicy, true);
+    assert.equal(resourcesOf(chat, "AWS::SQS::Queue").length, 4);
+    assert.equal(resourcesOf(chat, "AWS::Lambda::Function").length, 2);
+    const mappings = resourcesOf(chat, "AWS::Lambda::EventSourceMapping");
+    assert.equal(mappings.length, 2);
+    assert.ok(mappings.every((mapping) => mapping.Properties.Enabled === true));
+    for (const key of ["MessagingTableName", "ConversationIndexTableName", "SessionBucketName", "TurnRunsQueueUrl", "TurnProbesQueueUrl"]) {
+        assert.equal(chat.Outputs[key].Export.Name, `papyrus-chat-anth-us:${key}`);
+    }
+    assert.deepEqual(Object.keys(chat.Parameters).filter((name) => name !== "BootstrapVersion").sort(), ["GatewayRoleArn", "PrivateAssistantBotId", "PrivateAssistantBotName"]);
+    // Only the run worker may read the model key parameter; the gateway policy never names it.
+    const parameterGrants = resourcesOf(chat, "AWS::IAM::Policy").filter((policy) => JSON.stringify(policy.Properties.PolicyDocument).includes("openai-api-key"));
+    assert.equal(parameterGrants.length, 1);
+    assert.ok(parameterGrants[0].Properties.Roles.some((role) => JSON.stringify(role).includes("RunWorkerRole")));
+    assert.equal(JSON.stringify(chat).split("/papyrus/shipped/openai-api-key").length - 1, 3, "the parameter appears in the run worker grant, the run worker environment and one output only");
+    const gateway = resourcesOf(chat, "AWS::IAM::Policy").find((policy) => policy.Properties.Roles.some((role) => JSON.stringify(role).includes("GatewayRoleArn")));
+    assert.ok(gateway, "the gateway policy attaches to the role named by GatewayRoleArn");
+    const gatewayActions = gateway.Properties.PolicyDocument.Statement.flatMap((statement) => [statement.Action].flat());
+    assert.ok(!gatewayActions.some((action) => action.startsWith("ssm:") || action.endsWith("*")), "the gateway has no SSM access and no wildcard action");
+}
+// Scenario: the staging branch never gets private chat
+{
+    const staging = branchEnvironment(shellTemplate(example("p-apyr-us")), "staging");
+    assert.equal(staging.PAPYRUS_PRIVATE_CHAT_ENABLED, "false");
+    assert.deepEqual(CHAT_NAMES.filter((name) => name in staging), []);
+}
+// Scenario: a site without chat gets neither
+{
+    const withoutBlock = example("anth-us", (config) => delete config.chat);
+    const disabled = example("anth-us", (config) => (config.chat.enabled = false));
+    for (const raw of [withoutBlock, disabled]) {
+        const production = branchEnvironment(shellTemplate(raw), "main");
+        assert.equal(production.PAPYRUS_PRIVATE_CHAT_ENABLED, "false");
+        assert.deepEqual(CHAT_NAMES.filter((name) => name in production), []);
+        assert.equal(resolveChatStackName(parseSiteConfig(raw)), undefined);
+        assert.throws(() => chatTemplate(raw), /does not enable chat/);
+    }
+}
+// Scenario: the chat block cannot be contradicted by hand-set variables
+assert.throws(() => parseSiteConfig(example("anth-us", (config) => (config.cms.environment.PAPYRUS_PRIVATE_CHAT_ENABLED = "false"))), /cms\.environment\.PAPYRUS_PRIVATE_CHAT_ENABLED/);
+assert.throws(() => parseSiteConfig(example("anth-us", (config) => (config.cms.environment.PAPYRUS_CHAT_SESSION_BUCKET = "x"))), /cms\.environment\.PAPYRUS_CHAT_SESSION_BUCKET/);
+// Without chat, the existing hand-managed flag keeps working.
+assert.equal(branchEnvironment(shellTemplate(example("anth-us", (config) => { delete config.chat; config.cms.environment.PAPYRUS_PRIVATE_CHAT_ENABLED = "true"; })), "main").PAPYRUS_PRIVATE_CHAT_ENABLED, "true");
+// Scenario: chat needs a CMS and a model key parameter
+assert.throws(() => parseSiteConfig(example("anth-us", (config) => delete config.chat.modelKeyParameter)), /chat\.modelKeyParameter/);
+assert.throws(() => parseSiteConfig(example("anth-us", (config) => (config.chat.modelKeyParameter = "not-a-path"))), /chat\.modelKeyParameter/);
+assert.throws(() => parseSiteConfig(example("anth-us", (config) => (config.chat.enabled = "yes"))), /chat\.enabled/);
+assert.throws(() => parseSiteConfig(example("anth-us", (config) => (config.chat.extra = 1))), /chat\.extra/);
+assert.throws(() => parseSiteConfig(example("anth-us", (config) => (config.chat.workerCodeS3Key = "abc"))), /chat\.workerCodeS3Key/);
+assert.throws(() => parseSiteConfig({ siteId: "reader-only", repository: "https://github.com/example/x", brand: "x", frontend: "markus-static", papyrusVersion: "5.42.1", hostedZoneId: "Z10285921B1G7MVRV06W9", reader: { domainName: "x.example.test", buildCommand: "npm run build", baseDirectory: "out" }, chat: { enabled: true, modelKeyParameter: "/papyrus/x/openai-api-key" } }), /chat\.enabled.*requires cms/);
+assert.throws(() => new PapyrusChatStack(new App(), { config: parseSiteConfig(example("p-apyr-us", (config) => delete config.chat.workerCodeS3Key)), env: { account: "712236451410", region: "us-east-1" } }), /bundle the chat workers first/);
+// Scenario: two sites in one account do not share chat storage or log groups
+{
+    const enabled = siteNames.map((name) => parseSiteConfig(example(name))).filter((config) => config.chat?.enabled);
+    assert.deepEqual(enabled.map((config) => config.siteId).sort(), ["anth-us", "dataparade", "distinctive", "p-apyr-us", "pilobol-us", "shipped", "threat-intelligence"], "every Papyrus site example enables chat");
+    const names = enabled.map((config) => resolveChatStackName(config));
+    const prefixes = enabled.map((config) => resolveChatLogGroupPrefix(config));
+    assert.equal(new Set(names).size, names.length, "stack names are unique");
+    assert.equal(new Set(prefixes).size, prefixes.length, "worker log group prefixes are unique");
+    for (const config of enabled) {
+        assert.ok(/^\/(papyrus\/[a-z0-9-]+\/openai-api-key|amplify\/shared\/[a-z0-9]+\/OPENAI_API_KEY)$/.test(config.chat.modelKeyParameter), `${config.siteId} reuses an existing model key parameter`);
+    }
+}
+// Scenario: the activated p.apyr.us stack is adopted without replacing anything
+{
+    const activated = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../../shared-chat-runtime/cdk/PapyrusChatDataCandidate.template.json"), "utf8"));
+    const generated = chatTemplate(example("p-apyr-us"));
+    assert.equal(resolveChatStackName(parseSiteConfig(example("p-apyr-us"))), "PapyrusChatDataCandidate");
+    const normalize = (resource) => {
+        const copy = JSON.parse(JSON.stringify(resource));
+        delete copy.Metadata;
+        const statements = copy.Properties?.PolicyDocument?.Statement;
+        if (statements)
+            copy.Properties.PolicyDocument.Statement = [...statements].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+        return copy;
+    };
+    assert.deepEqual(Object.keys(generated.Resources).sort(), Object.keys(activated.Resources).sort(), "no resource is added, removed or renamed (a changed logical id would replace it)");
+    for (const [logicalId, resource] of Object.entries(activated.Resources)) {
+        const expected = normalize(resource);
+        // The activated template is the reviewed candidate; the queue mappings were enabled live afterwards.
+        if (resource.Type === "AWS::Lambda::EventSourceMapping")
+            expected.Properties.Enabled = true;
+        assert.deepEqual(normalize(generated.Resources[logicalId]), expected, `${logicalId} is unchanged`);
+    }
+    for (const key of Object.keys(activated.Outputs)) {
+        assert.deepEqual({ ...generated.Outputs[key], Export: undefined }, { ...activated.Outputs[key], Export: undefined, ...(key === "FeatureDefault" ? { Value: generated.Outputs[key].Value } : {}) }, `output ${key} keeps its value`);
+    }
+    assert.deepEqual(Object.keys(generated.Outputs).sort(), Object.keys(activated.Outputs).sort());
+}
+console.log("per-site private chat infra tests passed");