@aws/agentcore 1.0.0-preview.3 → 1.0.0-preview.31

package/dist/assets/__tests__/__snapshots__/dockerfile-render.test.ts.snap

@@ -1,7 +1,9 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`Dockerfile enableOtel rendering > renders opentelemetry-instrument CMD when enableOtel is true > Dockerfile-enableOtel-true 1`] = `
-"FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim
+"FROM public.ecr.aws/docker/library/python:3.12-slim-trixie
+
+RUN pip install --no-cache-dir uv
 
 ARG UV_DEFAULT_INDEX
 ARG UV_INDEX
@@ -39,7 +41,9 @@ CMD ["opentelemetry-instrument", "python", "-m", "main"]
 `;
 
 exports[`Dockerfile enableOtel rendering > renders plain python CMD when enableOtel is false > Dockerfile-enableOtel-false 1`] = `
-"FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim
+"FROM public.ecr.aws/docker/library/python:3.12-slim-trixie
+
+RUN pip install --no-cache-dir uv
 
 ARG UV_DEFAULT_INDEX
 ARG UV_INDEX

package/dist/assets/__tests__/assets.snapshot.test.ts

@@ -87,36 +87,22 @@ describe('Assets Directory Snapshots', () => {
     });
   });
 
-  describe('Static assets', () => {
+  describe.skipIf(assetFiles.filter(f => f.startsWith('static/')).length === 0)('Static assets', () => {
     const staticFiles = assetFiles.filter(f => f.startsWith('static/'));
 
-    if (staticFiles.length > 0) {
-      it.each(staticFiles)('static/%s should match snapshot', file => {
-        const content = readFileContent(path.join(ASSETS_DIR, file));
-        expect(content).toMatchSnapshot();
-      });
-    } else {
-      it('static directory is empty or does not exist', () => {
-        // Static assets may not exist
-        expect(true).toBe(true);
-      });
-    }
+    it.each(staticFiles)('static/%s should match snapshot', file => {
+      const content = readFileContent(path.join(ASSETS_DIR, file));
+      expect(content).toMatchSnapshot();
+    });
   });
 
-  describe('TypeScript assets', () => {
+  describe.skipIf(assetFiles.filter(f => f.startsWith('typescript/')).length === 0)('TypeScript assets', () => {
     const tsFiles = assetFiles.filter(f => f.startsWith('typescript/'));
 
-    if (tsFiles.length > 0) {
-      it.each(tsFiles)('typescript/%s should match snapshot', file => {
-        const content = readFileContent(path.join(ASSETS_DIR, file));
-        expect(content).toMatchSnapshot();
-      });
-    } else {
-      it('typescript directory is empty or contains only placeholder files', () => {
-        // TypeScript assets may not exist yet
-        expect(true).toBe(true);
-      });
-    }
+    it.each(tsFiles)('typescript/%s should match snapshot', file => {
+      const content = readFileContent(path.join(ASSETS_DIR, file));
+      expect(content).toMatchSnapshot();
+    });
   });
 
   describe('Root-level assets', () => {

package/dist/assets/__tests__/googleadk-observability.test.ts

@@ -0,0 +1,23 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { describe, expect, it } from 'vitest';
+
+const ASSETS_DIR = path.resolve(__dirname, '..', 'python');
+const EXPECTED_DEPENDENCIES = [
+  ['http', '"aws-opentelemetry-distro >= 0.17.0"'],
+  ['agui', '"aws-opentelemetry-distro >= 0.17.0"'],
+  ['a2a', '"aws-opentelemetry-distro"'],
+] as const;
+
+describe('Google ADK observability dependencies', () => {
+  it.each(EXPECTED_DEPENDENCIES)('%s uses the AWS OpenTelemetry distro', (protocol, expectedDependency) => {
+    const pyproject = fs.readFileSync(
+      path.join(ASSETS_DIR, protocol, 'googleadk', 'base', 'pyproject.toml'),
+      'utf-8'
+    );
+
+    expect(pyproject).toContain(expectedDependency);
+    expect(pyproject).not.toMatch(/^\s*"opentelemetry-distro",?$/m);
+    expect(pyproject).not.toMatch(/^\s*"opentelemetry-exporter-otlp",?$/m);
+  });
+});

package/dist/assets/__tests__/googleadk-session-eviction.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Regression test for the GoogleADK session-store LRU eviction (#808, #1639).
+ *
+ * The rendered template bounds InMemorySessionService to 128 sessions via an
+ * OrderedDict whose KEY is the composite (user_id, session_id) tuple. The
+ * eviction must unpack the key tuple from popitem() -- popitem() returns
+ * (key, value), so the value (always True) must be discarded. A previous
+ * bug unpacked `old_user_id, old_session_id = popitem(...)`, which assigned the
+ * tuple key to old_user_id and True to old_session_id, so delete_session() was
+ * called with garbage and the real session was never freed -- growing unbounded.
+ */
+import * as fs from 'fs';
+import Handlebars from 'handlebars';
+import * as path from 'path';
+import { describe, expect, it } from 'vitest';
+
+const MAIN_PATH = path.resolve(__dirname, '..', 'python', 'http', 'googleadk', 'base', 'main.py');
+
+const SESSION_LIMIT = 128;
+const SEP = '::';
+
+/**
+ * Mirror of the rendered template's `get_or_create_session` eviction loop so we
+ * can assert the observable behavior (store cap + correct delete ids) without a
+ * Python runtime. Returns the keys still tracked and the (user_id, session_id)
+ * pairs that delete_session was invoked with, in eviction order.
+ */
+function simulateEviction(sessions: Array<[string, string]>): {
+  tracked: Set<string>;
+  deleted: Array<[string, string]>;
+} {
+  const keys = new Map<string, true>();
+  const deleted: Array<[string, string]> = [];
+
+  for (const [userId, sessionId] of sessions) {
+    const key = `${userId}${SEP}${sessionId}`;
+    if (keys.has(key)) {
+      keys.delete(key);
+      keys.set(key, true);
+      continue;
+    }
+    while (keys.size >= SESSION_LIMIT) {
+      const oldest = keys.keys().next().value as string;
+      keys.delete(oldest);
+      const [oldUser, oldSession] = oldest.split(SEP);
+      deleted.push([oldUser, oldSession]);
+    }
+    keys.set(key, true);
+  }
+
+  return { tracked: new Set(keys.keys()), deleted };
+}
+
+describe('GoogleADK session store LRU eviction', () => {
+  const template = Handlebars.compile(fs.readFileSync(MAIN_PATH, 'utf-8'));
+  const rendered = template({ name: 'evictionagent', needsOs: false, hasGateway: false });
+
+  it('unpacks the composite key tuple from popitem (not key->user_id, value->session_id)', () => {
+    // The load-bearing fix: the key tuple must be destructured, value discarded.
+    expect(rendered).toContain('(old_user_id, old_session_id), _ = _session_keys.popitem(last=False)');
+    // Guard against the buggy form regressing back in.
+    expect(rendered).not.toMatch(/^\s*old_user_id, old_session_id = _session_keys\.popitem/m);
+  });
+
+  it('passes the unpacked ids straight to delete_session', () => {
+    expect(rendered).toContain('user_id=old_user_id, session_id=old_session_id');
+  });
+
+  it('caps the store at 128 and evicts the oldest sessions in order', () => {
+    const sessions: Array<[string, string]> = [];
+    for (let i = 0; i < 200; i++) {
+      sessions.push(['u', `s${i}`]);
+    }
+
+    const { tracked, deleted } = simulateEviction(sessions);
+
+    // Store stays bounded at the limit regardless of how many distinct sessions arrive.
+    expect(tracked.size).toBe(SESSION_LIMIT);
+    // 200 inserts - 128 retained = 72 evictions, oldest first.
+    expect(deleted.length).toBe(200 - SESSION_LIMIT);
+    expect(deleted[0]).toEqual(['u', 's0']);
+    expect(deleted[deleted.length - 1]).toEqual(['u', `s${200 - SESSION_LIMIT - 1}`]);
+    // The most recent session is retained; the first evicted one is gone.
+    expect(tracked.has(`u${SEP}s199`)).toBe(true);
+    expect(tracked.has(`u${SEP}s0`)).toBe(false);
+  });
+});

package/dist/assets/__tests__/input-validation.test.ts

@@ -0,0 +1,44 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const ASSETS_DIR = resolve(__dirname, '..');
+
+const PYTHON_HTTP_ENTRYPOINTS = [
+  'python/http/autogen/base/main.py',
+  'python/http/googleadk/base/main.py',
+  'python/http/langchain_langgraph/base/main.py',
+  'python/http/openaiagents/base/main.py',
+  'python/http/strands/base/main.py',
+];
+
+const TYPESCRIPT_HTTP_ENTRYPOINTS = [
+  'typescript/http/strands/base/main.ts',
+  'typescript/http/vercelai/base/main.ts',
+];
+
+describe('HTTP agent template input validation', () => {
+  it.each(PYTHON_HTTP_ENTRYPOINTS)('%s rejects non-string prompts', templatePath => {
+    const template = readFileSync(resolve(ASSETS_DIR, templatePath), 'utf8');
+
+    expect(template).toContain('if not isinstance(prompt, str):');
+    expect(template).toContain('raise ValueError("prompt must be a string")');
+  });
+
+  it.each(TYPESCRIPT_HTTP_ENTRYPOINTS)('%s validates prompts with Zod', templatePath => {
+    const template = readFileSync(resolve(ASSETS_DIR, templatePath), 'utf8');
+
+    expect(template).toContain("prompt: z.string().default('')");
+    expect(template).toContain('requestSchema,');
+  });
+
+  it('strips toolUse blocks from the Python Strands message-history tail', () => {
+    const template = readFileSync(resolve(ASSETS_DIR, 'python/http/strands/base/main.py'), 'utf8');
+
+    expect(template).toContain('def strip_trailing_tool_use(messages: Any) -> list[dict]:');
+    expect(template).toContain('while messages:');
+    expect(template).toContain('content = [block for block in original_content if "toolUse" not in block]');
+    expect(template).toContain('messages.pop()');
+    expect(template).toContain('return strip_trailing_tool_use(payload["messages"])');
+  });
+});

package/dist/assets/__tests__/summarization-namespace.test.ts

@@ -0,0 +1,43 @@
+/**
+ * Regression test for cross-session SUMMARIZATION recall (issue #665).
+ *
+ * The SUMMARIZATION retrieval namespace must be actor-scoped (`/summaries/{actor_id}`),
+ * not session-scoped. The SDK's namespace_path is a hierarchical prefix match, so a
+ * per-session prefix (`/summaries/{actor_id}/{session_id}`) only ever matches the current
+ * session's own summaries and never surfaces summaries written by prior sessions —
+ * silently breaking cross-session recall. This guards against another silent revert
+ * (see PR #1299, reverted by squash release #1547).
+ */
+import Handlebars from 'handlebars';
+import * as fs from 'fs';
+import * as path from 'path';
+import { describe, expect, it } from 'vitest';
+// Importing render registers the `includes` Handlebars helper used by the template.
+import '../../cli/templates/render.js';
+
+const FLAVORS = ['http', 'agui', 'a2a'] as const;
+
+function renderSessionTemplate(flavor: string): string {
+  const templatePath = path.resolve(
+    __dirname,
+    '..',
+    'python',
+    flavor,
+    'strands',
+    'capabilities',
+    'memory',
+    'session.py'
+  );
+  const content = fs.readFileSync(templatePath, 'utf-8');
+  return Handlebars.compile(content)({
+    memoryProviders: [{ envVarName: 'MEMORY_TEST_ID', strategies: ['SUMMARIZATION'] }],
+  });
+}
+
+describe('SUMMARIZATION retrieval namespace', () => {
+  it.each(FLAVORS)('%s session.py uses an actor-scoped summary namespace', flavor => {
+    const rendered = renderSessionTemplate(flavor);
+    expect(rendered).toContain('f"/summaries/{actor_id}": RetrievalConfig');
+    expect(rendered).not.toContain('/summaries/{actor_id}/{session_id}');
+  });
+});

package/dist/assets/agents/AGENTS.md

@@ -23,6 +23,8 @@ Tags defined in `agentcore.json` flow through to deployed CloudFormation resourc
    `agentcore validate` to check.
 4. **Resource Removal:** Use `agentcore remove` to remove resources. Run `agentcore deploy` after removal to tear down
    deployed infrastructure.
+5. **Invocation Input:** Validate runtime payloads and require text prompts to be strings. If a Strands app accepts a
+   caller-supplied message history, normalize the history tail with `strip_trailing_tool_use()` before invocation.
 
 ## Directory Structure
 
@@ -36,8 +38,7 @@ myProject/
 │   ├── .llm-context/       # TypeScript type definitions for AI assistants
 │   │   ├── README.md       # Guide to using schema files
 │   │   ├── agentcore.ts    # AgentCoreProjectSpec types
-│   │   ├── aws-targets.ts  # AWS deployment target types
-│   │   └── mcp.ts          # Gateway and MCP tool types
+│   │   └── aws-targets.ts  # AWS deployment target types
 │   └── cdk/                # AWS CDK project (@aws/agentcore-cdk L3 constructs)
 ├── app/                    # Agent application code
 └── evaluators/             # Custom evaluator code (if any)
@@ -51,18 +52,25 @@ file maps to a JSON config file and includes validation constraints as comments
 | JSON Config | Schema File | Root Type |
 | --- | --- | --- |
 | `agentcore/agentcore.json` | `agentcore/.llm-context/agentcore.ts` | `AgentCoreProjectSpec` |
-| `agentcore/agentcore.json` (gateways) | `agentcore/.llm-context/mcp.ts` | `AgentCoreMcpSpec` |
 | `agentcore/aws-targets.json` | `agentcore/.llm-context/aws-targets.ts` | `AwsDeploymentTarget[]` |
 
 ### Key Types
 
-- **AgentCoreProjectSpec**: Root config with `runtimes`, `memories`, `credentials`, `agentCoreGateways`, `evaluators`, `onlineEvalConfigs`, `policyEngines` arrays
+- **AgentCoreProjectSpec**: Root config with runtimes, memories, knowledge bases, credentials, evaluators, online evals and insights, gateways, policy engines, config bundles, A/B tests, harness registrations, datasets, payment managers, and capacity providers
 - **AgentEnvSpec**: Agent configuration (build type, entrypoint, code location, runtime version, network mode)
 - **Memory**: Memory resource with strategies (SEMANTIC, SUMMARIZATION, USER_PREFERENCE, EPISODIC) and expiry
 - **Credential**: API key or OAuth credential provider
-- **AgentCoreGateway**: MCP gateway with targets (Lambda, MCP server, OpenAPI, Smithy, API Gateway)
+- **AgentCoreGateway**: MCP gateway with targets (Lambda, MCP server, OpenAPI, Smithy, API Gateway, web-search, knowledge-base)
 - **Evaluator**: LLM-as-a-Judge or code-based evaluator
 - **OnlineEvalConfig**: Continuous evaluation pipeline bound to an agent
+- **OnlineInsightsConfig** _[preview]_: Continuous failure-pattern analysis bound to an agent
+- **KnowledgeBase**: Managed Bedrock Knowledge Base auto-wired to a gateway
+- **Harness**: Declarative agent — runtime + tools + skills + memory + observability without writing agent code
+- **PolicyEngine** + **Policy**: Cedar policy engine with form-based guardrails (Bedrock content filters, prompt-attack, sensitive-info) or raw Cedar policies
+- **PaymentManager** + **PaymentConnector**: x402-protocol payment orchestration with provider credentials (CoinbaseCDP, StripePrivy)
+- **ConfigBundle**: Versioned runtime configuration as a separately-deployable resource
+- **Dataset**: Curated session dataset for batch evaluation and recommendation runs
+- **RuntimeEndpoint**: Named endpoint (e.g. `PROMPT_V1`) targeting a specific runtime version
 
 ### Common Enum Values
 
@@ -70,8 +78,11 @@ file maps to a JSON config file and includes validation constraints as comments
 - **NetworkMode**: `'PUBLIC'` | `'VPC'`
 - **RuntimeVersion**: `'PYTHON_3_10'` | `'PYTHON_3_11'` | `'PYTHON_3_12'` | `'PYTHON_3_13'` | `'PYTHON_3_14'` | `'NODE_18'` | `'NODE_20'` | `'NODE_22'`
 - **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'` | `'EPISODIC'`
-- **GatewayTargetType**: `'lambda'` | `'mcpServer'` | `'openApiSchema'` | `'smithyModel'` | `'apiGateway'` | `'lambdaFunctionArn'`
+- **GatewayTargetType**: `'lambda'` | `'mcpServer'` | `'openApiSchema'` | `'smithyModel'` | `'apiGateway'` | `'lambdaFunctionArn'` | `'connector'` (web-search, bedrock-knowledge-bases)
 - **ModelProvider**: `'Bedrock'` | `'Gemini'` | `'OpenAI'` | `'Anthropic'`
+- **PaymentProvider**: `'CoinbaseCDP'` | `'StripePrivy'`
+- **PolicyEnforcementMode**: `'ACTIVE'` | `'PASSIVE'`
+- **GuardrailContentFilter**: `'VIOLENCE'` | `'HATE'` | `'SEXUAL'` | `'MISCONDUCT'` | `'INSULTS'`
 
 ### Build Types
 
@@ -122,20 +133,86 @@ When modifying JSON config files:
 4. Use CloudFormation-safe names (alphanumeric, start with letter)
 5. Run `agentcore validate` to verify changes
 
+## Harness Export
+
+`agentcore export harness` converts a harness configuration into a deployable Strands Python agent under `app/<agentName>/`.
+
+**After every export, you MUST read `app/<agentName>/EXPORT_NOTES.md` before proceeding.**
+
+This file lists any manual follow-up items required before the agent will deploy or run correctly — missing files to create, IAM policies to add, or configuration steps the exporter could not automate. A clean export produces "No manual steps required." Complete every item in the file before running `agentcore deploy`.
+
+```bash
+agentcore export harness --name <harnessName>   # generates app/<agentName>/EXPORT_NOTES.md
+cat app/<agentName>/EXPORT_NOTES.md             # read this before touching anything else
+```
+
 ## CLI Commands
 
+Run `agentcore --help` or `agentcore <command> --help` for full flags. Commonly used:
+
+**Project lifecycle**
+
 | Command | Description |
 | --- | --- |
 | `agentcore create` | Create a new project |
-| `agentcore add <resource>` | Add agent, memory, credential, gateway, evaluator, policy |
-| `agentcore remove <resource>` | Remove a resource |
 | `agentcore dev` | Run agent locally with hot-reload |
 | `agentcore deploy` | Deploy to AWS |
-| `agentcore status` | Show deployment status |
 | `agentcore invoke` | Invoke agent (local or deployed) |
-| `agentcore logs` | View agent logs |
-| `agentcore traces` | View agent traces |
-| `agentcore eval` | Run evaluations against an agent |
-| `agentcore package` | Package agent artifacts |
+| `agentcore capacity-provider delete-session` | Delete (deprovision) a live capacity provider session |
+| `agentcore status` | Show deployment status |
 | `agentcore validate` | Validate configuration |
-| `agentcore pause` / `resume` | Pause or resume a deployed agent |
+| `agentcore package` | Package agent artifacts |
+| `agentcore import` | Import resources from a Bedrock AgentCore Starter Toolkit project |
+
+**Resources**
+
+| Command | Description |
+| --- | --- |
+| `agentcore add <resource>` | Add agent, memory, credential, gateway, gateway-target, evaluator, online-eval, online-insights, knowledge-base, harness, policy-engine, policy, payment-manager, payment-connector, capacity-provider, config-bundle, dataset, runtime-endpoint |
+| `agentcore remove <resource>` | Remove any resource |
+| `agentcore export harness` | Export a harness to a Strands runtime agent under `app/<agentName>/` |
+
+**Jobs (run, view, archive, lifecycle)**
+
+| Command | Description |
+| --- | --- |
+| `agentcore run eval` | Run on-demand evaluation against agent traces |
+| `agentcore run batch-evaluation` | Run evaluators across all sessions at scale |
+| `agentcore run recommendation` | Optimize prompts or tool descriptions from real traces |
+| `agentcore run insights` _[preview]_ | Run failure-pattern analysis across sessions |
+| `agentcore run ab-test` | Start an A/B test (config-bundle or target-based) |
+| `agentcore run ingest` | Start a fresh ingestion job for every data source on a deployed knowledge base |
+| `agentcore view <type>` | List or view jobs (recommendation, batch-evaluation, ab-test, insights) |
+| `agentcore archive <type>` | Delete a job on the service + clear local history |
+| `agentcore stop <type>` | Stop a running batch-evaluation or ab-test |
+| `agentcore promote ab-test` | Apply the winning variant to `agentcore.json` |
+| `agentcore pause <type>` / `agentcore resume <type>` | Pause/resume a deployed online-eval, online-insights, or ab-test |
+
+**Config bundles & datasets**
+
+| Command | Description |
+| --- | --- |
+| `agentcore config-bundle versions` (alias `cb versions`) | List version history for a bundle |
+| `agentcore config-bundle diff` | Diff two versions of a bundle |
+| `agentcore config-bundle create-branch` | Create a new branch on an existing bundle |
+| `agentcore dataset download` | Download a dataset version locally |
+| `agentcore dataset publish-version` | Publish a new dataset version |
+| `agentcore dataset remove-version` | Remove a dataset version |
+
+**Observability & history**
+
+| Command | Description |
+| --- | --- |
+| `agentcore logs` | Stream/search agent runtime logs |
+| `agentcore logs evals` | Stream/search online-eval logs |
+| `agentcore traces list` / `agentcore traces get` | List recent traces or download one to JSON |
+| `agentcore evals history` | View past on-demand eval results |
+
+**Utilities**
+
+| Command | Description |
+| --- | --- |
+| `agentcore fetch access` | Fetch access info for deployed gateway or agent |
+| `agentcore feedback` | Send feedback (with optional screenshot) to the AgentCore team |
+| `agentcore update` | Check for and install CLI updates |
+| `agentcore telemetry` | View or change telemetry preferences |

package/dist/assets/cdk/bin/cdk.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { AgentCoreStack } from '../lib/cdk-stack';
-import { ConfigIO, type AwsDeploymentTarget } from '@aws/agentcore-cdk';
+import { AgentCoreStack, type HarnessConfig } from '../lib/cdk-stack';
+import { ConfigIO, HarnessSpecSchema, type AwsDeploymentTarget } from '@aws/agentcore-cdk';
 import { App, type Environment } from 'aws-cdk-lib';
 import * as path from 'path';
 import * as fs from 'fs';
@@ -28,12 +28,14 @@ async function main() {
   const spec = await configIO.readProjectSpec();
   const targets = await configIO.readAWSDeploymentTargets();
 
-  // Extract MCP configuration from project spec.
-  // Gateway fields are stored in agentcore.json but may not yet be on the
-  // AgentCoreProjectSpec type from @aws/agentcore-cdk, so we read them
-  // dynamically and cast the resulting object.
+  // The vended CDK project compiles against the published @aws/agentcore-cdk
+  // schema type, which may lag the CLI's own AgentCoreProjectSpec (e.g. payments,
+  // harnesses, gateway fields). Cast once so those fields are reachable.
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const specAny = spec as any;
+
+  // Extract MCP configuration from project spec.
+  // Gateway fields are stored in agentcore.json but may not yet be on the
   const mcpSpec = specAny.agentCoreGateways?.length
     ? {
         agentCoreGateways: specAny.agentCoreGateways,
@@ -54,37 +56,55 @@ async function main() {
     throw new Error('No deployment targets configured. Please define targets in agentcore/aws-targets.json');
   }
 
-  // Read harness configs for role creation.
-  // Harness fields may not yet be on the AgentCoreProjectSpec type from @aws/agentcore-cdk,
-  // so we read them dynamically via specAny (same pattern as gateways above).
-  // Harness paths in agentcore.json are relative to the project root (parent of agentcore/).
+  // Read harness configs: the full validated spec drives the CFN resource; the
+  // role-scoped fields drive the IAM role + container build.
   const projectRoot = path.resolve(configRoot, '..');
-  const harnessConfigs: {
-    name: string;
-    executionRoleArn?: string;
-    memoryName?: string;
-    containerUri?: string;
-    hasDockerfile?: boolean;
-    dockerfile?: string;
-    codeLocation?: string;
-    tools?: { type: string; name: string }[];
-    apiKeyArn?: string;
-  }[] = [];
+
+  // Read non-S3 KB connector-config files and pass their parsed contents to the
+  // L3 verbatim. The L3 does not read files; it expects the parsed
+  // connectorParameters keyed by the data source's connectorConfigFile path.
+  const connectorParametersByFile: Record<string, Record<string, unknown>> = {};
+  for (const kb of specAny.knowledgeBases ?? []) {
+    for (const ds of kb.dataSources ?? []) {
+      if (ds.type !== 'S3' && ds.connectorConfigFile) {
+        const abs = path.resolve(projectRoot, ds.connectorConfigFile);
+        try {
+          connectorParametersByFile[ds.connectorConfigFile] = JSON.parse(fs.readFileSync(abs, 'utf-8'));
+        } catch (err) {
+          throw new Error(
+            `Could not read connector config '${ds.connectorConfigFile}' for knowledge base '${kb.name}' at ${abs}: ${err instanceof Error ? err.message : err}`
+          );
+        }
+      }
+    }
+  }
+
+  // Synthesize an AWS::BedrockAgentCore::Harness resource for each harness entry in the spec.
+  const harnessConfigs: HarnessConfig[] = [];
   for (const entry of specAny.harnesses ?? []) {
     const harnessDir = path.resolve(projectRoot, entry.path);
     const harnessPath = path.resolve(harnessDir, 'harness.json');
     try {
-      const harnessSpec = JSON.parse(fs.readFileSync(harnessPath, 'utf-8'));
+      const harnessSpec = HarnessSpecSchema.parse(JSON.parse(fs.readFileSync(harnessPath, 'utf-8')));
       harnessConfigs.push({
         name: entry.name,
         executionRoleArn: harnessSpec.executionRoleArn,
-        memoryName: harnessSpec.memory?.name,
+        // Only an `existing` memory ref carries a name to wire IAM against; managed memory is
+        // owned by the harness (no sibling) and disabled has none — both resolve to undefined.
+        memoryName: harnessSpec.memory?.mode === 'existing' ? harnessSpec.memory.name : undefined,
         containerUri: harnessSpec.containerUri,
         hasDockerfile: !!harnessSpec.dockerfile,
         dockerfile: harnessSpec.dockerfile,
         codeLocation: harnessSpec.dockerfile ? harnessDir : undefined,
         tools: harnessSpec.tools,
+        skills: harnessSpec.skills,
         apiKeyArn: harnessSpec.model?.apiKeyArn,
+        efsAccessPoints: harnessSpec.efsAccessPoints,
+        s3AccessPoints: harnessSpec.s3AccessPoints,
+        apiFormat: harnessSpec.model?.apiFormat,
+        // Full spec + dir drive the AWS::BedrockAgentCore::Harness CFN resource.
+        spec: harnessSpec,
+        harnessDir,
       });
     } catch (err) {
       throw new Error(
@@ -108,11 +128,76 @@ async function main() {
       | Record<string, { credentialProviderArn: string; clientSecretArn?: string }>
       | undefined;
 
+    // Payment credential provider ARNs live in the same credentials map as identity credentials
+    const paymentCredentials = credentials;
+
+    const paymentSpec = specAny.payments?.length
+      ? specAny.payments.map(
+          (p: {
+            name: string;
+            description?: string;
+            authorizerType: 'AWS_IAM' | 'CUSTOM_JWT';
+            authorizerConfiguration?: unknown;
+            autoPayment?: boolean;
+            paymentToolAllowlist?: string[];
+            networkPreferences?: string[];
+            connectors: {
+              name: string;
+              provider?: string;
+              provisionMode?: 'MANUAL' | 'QUICK_CREATE';
+              credentialName?: string;
+            }[];
+          }) => ({
+            name: p.name,
+            description: p.description,
+            authorizerType: p.authorizerType,
+            authorizerConfiguration: p.authorizerConfiguration,
+            autoPayment: p.autoPayment,
+            paymentToolAllowlist: p.paymentToolAllowlist,
+            networkPreferences: p.networkPreferences,
+            connectors: p.connectors.map(c => {
+              if (c.provisionMode === 'QUICK_CREATE') {
+                return {
+                  name: c.name,
+                  provider: 'CoinbaseCDP' as const,
+                  provisionMode: 'QUICK_CREATE' as const,
+                };
+              }
+
+              if (!c.credentialName) {
+                throw new Error(
+                  `Manual payment connector "${c.name}" on manager "${p.name}" is missing its credential name.`
+                );
+              }
+              const credentialProviderArn = paymentCredentials?.[c.credentialName]?.credentialProviderArn;
+              if (!credentialProviderArn) {
+                // Fail fast with an actionable message rather than passing an empty
+                // ARN that fails opaquely server-side at CreatePaymentConnector.
+                throw new Error(
+                  `Payment connector "${c.name}" on manager "${p.name}" references credential ` +
+                    `"${c.credentialName}", but no deployed credential provider was found for it. ` +
+                    `Run \`agentcore deploy\` so the credential provider is created first.`
+                );
+              }
+              return {
+                name: c.name,
+                provider: c.provider,
+                ...(c.provisionMode && { provisionMode: c.provisionMode }),
+                credentialName: c.credentialName,
+                credentialProviderArn,
+              };
+            }),
+          })
+        )
+      : undefined;
+
     new AgentCoreStack(app, stackName, {
       spec,
       mcpSpec,
       credentials,
+      connectorParametersByFile,
       harnesses: harnessConfigs.length > 0 ? harnessConfigs : undefined,
+      paymentSpec,
       env,
       description: `AgentCore stack for ${spec.name} deployed to ${target.name} (${target.region})`,
       tags: {
@@ -127,5 +212,5 @@ async function main() {
 
 main().catch((error: unknown) => {
   console.error('AgentCore CDK synthesis failed:', error instanceof Error ? error.message : error);
-  process.exitCode = 1;
+  process.exit(1);
 });