@aws/agentcore 1.0.0-preview.9 → 1.0.0-rc.3

package/dist/assets/cdk/README.md

@@ -1,26 +1,52 @@
-# AgentCore CDK Project
+# AgentCore CDK app
 
-This CDK project is managed by the AgentCore CLI. It deploys your agent infrastructure into AWS using the `@aws/agentcore-cdk` L3 constructs.
+This CDK app is managed by the AgentCore CLI. It deploys everything declared in `agentcore/agentcore.json` into AWS
+through the `@aws/agentcore-cdk` constructs. It is two files:
 
-## Structure
+- `bin/cdk.ts` — the entry point. It reads the project once (`readAgentCoreProject`), creates one stack per deployment
+  target (`resolveTargetStacks`), and turns `agentcore.json` into the application's props (`transformAgentCoreJson`).
+  Everything about how `agentcore.json` is interpreted lives in the library, so it changes with the library version, not
+  with this file.
+- `lib/cdk-stack.ts` — `AgentCoreStack`, which instantiates one `AgentCoreApplication`. This is the file you edit.
 
-- `bin/cdk.ts` — Entry point. Reads project configuration from `agentcore/` and creates a stack per deployment target.
-- `lib/cdk-stack.ts` — Defines `AgentCoreStack`, which wraps the `AgentCoreApplication` L3 construct.
-- `test/cdk.test.ts` — Unit tests for stack synthesis.
+Harness settings are read from `harness.yaml`. Inline `systemPrompt` text overrides
+the conventional `system-prompt.md` file in the harness directory.
 
-## Useful commands
+## The CLI runs it for you
 
-- `npm run build` compile TypeScript to JavaScript
-- `npm run test` run unit tests
-- `npx cdk synth` emit the synthesized CloudFormation template
-- `npx cdk deploy` deploy this stack to your default AWS account/region
-- `npx cdk diff` compare deployed stack with current state
+You normally do not run this app directly:
 
-## Usage
+```bash
+agentcore project build    # synthesizes the CloudFormation templates into agentcore/cdk/cdk.out
+agentcore project deploy   # synthesizes, then deploys the stack for the selected target
+agentcore project status   # reports the resources agentcore.json declares
+```
 
-You typically don't need to interact with this directory directly. The AgentCore CLI handles synthesis and deployment:
+`npm run build` compiles the app, and `npx cdk synth` / `npx cdk diff` work from this directory too.
 
-```bash
-agentcore deploy    # synthesizes and deploys via CDK
-agentcore status    # checks deployment status
+## Extending the stack
+
+Add your own AWS resources in `lib/cdk-stack.ts` after the application and wire them to a runtime or harness through the
+application's accessors. Runtimes and harnesses implement `iam.IGrantable`, so any AWS L2 grant accepts them, and they
+expose `grantRead` / `grantWrite` / `grantReadWrite` for DynamoDB tables, S3 buckets and Secrets Manager secrets plus
+`addEnvironmentVariable`:
+
+```ts
+import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
+
+const orders = new dynamodb.Table(this, 'Orders', {
+  partitionKey: { name: 'pk', type: dynamodb.AttributeType.STRING },
+});
+const checkout = this.application.runtime('checkout'); // or this.application.harness('support')
+checkout.grantReadWrite(orders); // updates the runtime's execution role
+checkout.addEnvironmentVariable('ORDERS_TABLE', orders.tableName);
+orders.grantReadData(this.application.harness('support')); // any AWS L2 grant works too
 ```
+
+Then run `agentcore project deploy` again. An unknown name fails at synth and lists the names that exist.
+
+If a runtime or harness is configured with an `executionRoleArn`, CDK cannot modify that imported role: every grant
+emits a synth-time warning listing the permissions that were not attached, and the role must already carry them.
+
+`agentcore project status` reports only the resources `agentcore.json` declares; resources you add here are visible
+through CloudFormation (`aws cloudformation describe-stack-resources`).

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

@@ -1,131 +1,30 @@
 #!/usr/bin/env node
+import { App } from 'aws-cdk-lib';
+import { readAgentCoreProject, resolveTargetStacks, transformAgentCoreJson } from '@aws/agentcore-cdk';
 import { AgentCoreStack } from '../lib/cdk-stack';
-import { ConfigIO, type AwsDeploymentTarget } from '@aws/agentcore-cdk';
-import { App, type Environment } from 'aws-cdk-lib';
-import * as path from 'path';
-import * as fs from 'fs';
-
-function toEnvironment(target: AwsDeploymentTarget): Environment {
-  return {
-    account: target.account,
-    region: target.region,
-  };
-}
-
-function sanitize(name: string): string {
-  return name.replace(/_/g, '-');
-}
-
-function toStackName(projectName: string, targetName: string): string {
-  return `AgentCore-${sanitize(projectName)}-${sanitize(targetName)}`;
-}
-
-async function main() {
-  // Config root is parent of cdk/ directory. The CLI sets process.cwd() to agentcore/cdk/.
-  const configRoot = path.resolve(process.cwd(), '..');
-  const configIO = new ConfigIO({ baseDir: configRoot });
-
-  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.
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const specAny = spec as any;
-  const mcpSpec = specAny.agentCoreGateways?.length
-    ? {
-        agentCoreGateways: specAny.agentCoreGateways,
-        mcpRuntimeTools: specAny.mcpRuntimeTools,
-        unassignedTargets: specAny.unassignedTargets,
-      }
-    : undefined;
-
-  // Read deployed state for credential ARNs (populated by pre-deploy identity setup)
-  let deployedState: Record<string, unknown> | undefined;
-  try {
-    deployedState = JSON.parse(fs.readFileSync(path.join(configRoot, '.cli', 'deployed-state.json'), 'utf8'));
-  } catch {
-    // Deployed state may not exist on first deploy
-  }
-
-  if (targets.length === 0) {
-    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/).
-  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;
-  }[] = [];
-  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'));
-      harnessConfigs.push({
-        name: entry.name,
-        executionRoleArn: harnessSpec.executionRoleArn,
-        memoryName: harnessSpec.memory?.name,
-        containerUri: harnessSpec.containerUri,
-        hasDockerfile: !!harnessSpec.dockerfile,
-        dockerfile: harnessSpec.dockerfile,
-        codeLocation: harnessSpec.dockerfile ? harnessDir : undefined,
-        tools: harnessSpec.tools,
-        apiKeyArn: harnessSpec.model?.apiKeyArn,
-      });
-    } catch (err) {
-      throw new Error(
-        `Could not read harness.json for "${entry.name}" at ${harnessPath}: ${err instanceof Error ? err.message : err}`
-      );
-    }
-  }
 
+try {
+  // The AgentCore CLI runs this app from agentcore/cdk/; readAgentCoreProject walks up to agentcore/.
+  const project = readAgentCoreProject();
   const app = new App();
-
-  for (const target of targets) {
-    const env = toEnvironment(target);
-    const stackName = toStackName(spec.name, target.name);
-
-    // Extract credentials from deployed state for this target
-    const targetState = (deployedState as Record<string, unknown>)?.targets as
-      | Record<string, Record<string, unknown>>
-      | undefined;
-    const targetResources = targetState?.[target.name]?.resources as Record<string, unknown> | undefined;
-    const credentials = targetResources?.credentials as
-      | Record<string, { credentialProviderArn: string; clientSecretArn?: string }>
-      | undefined;
-
-    new AgentCoreStack(app, stackName, {
-      spec,
-      mcpSpec,
-      credentials,
-      harnesses: harnessConfigs.length > 0 ? harnessConfigs : undefined,
-      env,
-      description: `AgentCore stack for ${spec.name} deployed to ${target.name} (${target.region})`,
-      tags: {
-        'agentcore:project-name': spec.name,
-        'agentcore:target-name': target.name,
-      },
+  for (const stack of resolveTargetStacks({
+    projectName: project.projectName,
+    targets: project.targets,
+    deployedState: project.deployedState,
+  })) {
+    new AgentCoreStack(app, stack.stackName, {
+      env: stack.env,
+      tags: stack.tags,
+      description: stack.description,
+      application: transformAgentCoreJson(project.agentCoreJson, {
+        projectRoot: project.projectRoot,
+        credentials: stack.credentials,
+        target: stack.target,
+      }),
     });
   }
-
   app.synth();
-}
-
-main().catch((error: unknown) => {
+} catch (error) {
   console.error('AgentCore CDK synthesis failed:', error instanceof Error ? error.message : error);
-  process.exitCode = 1;
-});
+  process.exit(1);
+}

package/dist/assets/cdk/lib/cdk-stack.ts

@@ -1,83 +1,32 @@
-import {
-  AgentCoreApplication,
-  AgentCoreMcp,
-  type AgentCoreProjectSpec,
-  type AgentCoreMcpSpec,
-} from '@aws/agentcore-cdk';
-import { CfnOutput, Stack, type StackProps } from 'aws-cdk-lib';
+import { AgentCoreApplication, type AgentCoreApplicationProps } from '@aws/agentcore-cdk';
+import { Stack, type StackProps } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 
-export interface HarnessConfig {
-  name: string;
-  executionRoleArn?: string;
-  memoryName?: string;
-  containerUri?: string;
-  hasDockerfile?: boolean;
-  dockerfile?: string;
-  codeLocation?: string;
-  tools?: { type: string; name: string }[];
-  apiKeyArn?: string;
-}
-
 export interface AgentCoreStackProps extends StackProps {
-  /**
-   * The AgentCore project specification containing agents, memories, and credentials.
-   */
-  spec: AgentCoreProjectSpec;
-  /**
-   * The MCP specification containing gateways and servers.
-   */
-  mcpSpec?: AgentCoreMcpSpec;
-  /**
-   * Credential provider ARNs from deployed state, keyed by credential name.
-   */
-  credentials?: Record<string, { credentialProviderArn: string; clientSecretArn?: string }>;
-  /**
-   * Harness role configurations. Each entry creates an IAM execution role for a harness.
-   *
-   * When `hasDockerfile` is true and `codeLocation` is provided (without an explicit
-   * `containerUri`), the L3 construct builds and pushes a container image via CodeBuild
-   * and emits its URI as a stack output for the post-CDK harness deployer.
-   */
-  harnesses?: HarnessConfig[];
+  /** Props for the AgentCore application, produced by transformAgentCoreJson from agentcore/agentcore.json. */
+  application: AgentCoreApplicationProps;
 }
 
 /**
- * CDK Stack that deploys AgentCore infrastructure.
- *
- * This is a thin wrapper that instantiates L3 constructs.
- * All resource logic and outputs are contained within the L3 constructs.
+ * The stack the AgentCore CLI deploys. Everything declared in agentcore/agentcore.json is
+ * created by the AgentCoreApplication construct. Add your own resources below it and wire
+ * them to your runtimes and harnesses through the application's accessors.
  */
 export class AgentCoreStack extends Stack {
-  /** The AgentCore application containing all agent environments */
   public readonly application: AgentCoreApplication;
 
   constructor(scope: Construct, id: string, props: AgentCoreStackProps) {
     super(scope, id, props);
-
-    const { spec, mcpSpec, credentials, harnesses } = props;
-
-    // Create AgentCoreApplication with all agents and harness roles
-    this.application = new AgentCoreApplication(this, 'Application', {
-      spec,
-      harnesses: harnesses?.length ? harnesses : undefined,
-    });
-
-    // Create AgentCoreMcp if there are gateways configured
-    if (mcpSpec?.agentCoreGateways && mcpSpec.agentCoreGateways.length > 0) {
-      new AgentCoreMcp(this, 'Mcp', {
-        projectName: spec.name,
-        mcpSpec,
-        agentCoreApplication: this.application,
-        credentials,
-        projectTags: spec.tags,
-      });
-    }
-
-    // Stack-level output
-    new CfnOutput(this, 'StackNameOutput', {
-      description: 'Name of the CloudFormation Stack',
-      value: this.stackName,
-    });
+    this.application = new AgentCoreApplication(this, 'Application', props.application);
+
+    // Example: give a runtime a DynamoDB table.
+    //
+    // import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
+    // const orders = new dynamodb.Table(this, 'Orders', {
+    //   partitionKey: { name: 'pk', type: dynamodb.AttributeType.STRING },
+    // });
+    // const checkout = this.application.runtime('checkout'); // or .harness('support')
+    // checkout.grantReadWrite(orders);
+    // checkout.addEnvironmentVariable('ORDERS_TABLE', orders.tableName);
   }
 }

package/dist/assets/cdk/package.json

@@ -7,24 +7,17 @@
   "scripts": {
     "build": "tsc",
     "watch": "tsc -w",
-    "test": "jest",
     "cdk": "npm run build && cdk",
-    "clean": "rm -rf dist",
-    "format": "prettier --write .",
-    "format:check": "prettier --check ."
+    "clean": "rm -rf dist"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.14",
-    "@types/node": "^24.10.1",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.2.5",
-    "aws-cdk": "2.1100.1",
-    "prettier": "^3.4.2",
+    "@types/node": "~24.13.3",
+    "aws-cdk": "~2.1126.0",
     "typescript": "~5.9.3"
   },
   "dependencies": {
-    "@aws/agentcore-cdk": "^0.1.0-alpha.19",
-    "aws-cdk-lib": "^2.248.0",
-    "constructs": "^10.0.0"
+    "@aws/agentcore-cdk": "1.0.0-rc.1",
+    "aws-cdk-lib": "~2.269.0",
+    "constructs": "~10.7.0"
   }
 }

package/dist/assets/cdk/tsconfig.json

@@ -23,6 +23,6 @@
     "rootDir": ".",
     "outDir": "dist"
   },
-  "include": ["bin/**/*", "lib/**/*", "test/**/*"],
+  "include": ["bin/**/*", "lib/**/*"],
   "exclude": ["node_modules", "cdk.out", "dist"]
 }

package/dist/assets/evaluators/python-lambda/README.md

@@ -0,0 +1,32 @@
+# {{ Name }}
+
+An AgentCore **code-based evaluator** — a Lambda that scores an agent session
+with your own logic.
+
+## What's here
+
+- `lambda_function.py` — the evaluator. The `@custom_code_based_evaluator()`
+  handler receives an `EvaluatorInput` (the session / trace / tool-call to
+  grade) and returns an `EvaluatorOutput` (`value` + `label`, or an error). It
+  ships as a stub that returns `Pass` for everything — replace the `TODO` with
+  your scoring logic.
+- `pyproject.toml` — Python dependencies, managed with
+  [uv](https://docs.astral.sh/uv/).
+- `execution-role-policy.json` — extra IAM the evaluator Lambda gets at runtime.
+  Add statements here for anything your logic calls (Bedrock, DynamoDB, S3, …).
+
+Third-party evaluation libraries are ordinary application dependencies. Add
+them to `pyproject.toml`, configure them in `lambda_function.py`, and grant any
+required permissions in `execution-role-policy.json`.
+
+## Write your evaluator
+
+```python
+@custom_code_based_evaluator()
+def handler(input: EvaluatorInput, context) -> EvaluatorOutput:
+    # inspect input.session_spans / input.target_trace_id / input.target_span_id
+    return EvaluatorOutput(value=1.0, label="Pass", explanation="…")
+```
+
+Then `agentcore project deploy` packages this directory into the evaluator
+Lambda and registers the evaluator.

package/dist/assets/evaluators/python-lambda/pyproject.toml

@@ -8,7 +8,7 @@ version = "0.1.0"
 description = "AgentCore Code-Based Evaluator"
 requires-python = ">=3.10"
 dependencies = [
-    "bedrock-agentcore>=1.6.0",
+    "bedrock-agentcore>=1.6.0,<2.0.0",
 ]
 
 [tool.hatch.build.targets.wheel]

package/dist/assets/templates/a2a-python-strands/README.md

@@ -0,0 +1,31 @@
+# {{ name }}
+
+An A2A (Agent-to-Agent) agent deployed on Amazon Bedrock AgentCore using the Strands SDK.
+
+## Overview
+
+This agent speaks the A2A protocol. Other agents discover it via its agent card at
+`/.well-known/agent-card.json` and invoke it with JSON-RPC (`message/send`, `message/stream`)
+at the server root, matching the AgentCore Runtime A2A service contract.
+
+## Adding Tools
+
+Define tools with the `@tool` decorator in `main.py` and add them to the `tools` list:
+
+```python
+@tool
+def my_tool(param: str) -> str:
+    """Description of what the tool does."""
+    return f"Result: {param}"
+```
+
+## Developing locally
+
+`agentcore project dev` starts the agent locally on `0.0.0.0:9000`. Fetch its agent card at
+`http://127.0.0.1:9000/.well-known/agent-card.json` and send it messages by posting A2A
+JSON-RPC to `http://127.0.0.1:9000/`.
+
+## Deployment
+
+`agentcore project deploy` deploys the agent into Amazon Bedrock AgentCore. Invoke it with the
+AWS CLI (`bedrock-agentcore invoke-agent-runtime`) using an A2A JSON-RPC payload.

package/dist/assets/templates/a2a-python-strands/main.py

@@ -0,0 +1,100 @@
+from strands import Agent, tool
+from strands.multiagent.a2a.executor import StrandsA2AExecutor
+from bedrock_agentcore.runtime import serve_a2a
+from model.load import load_model
+from memory.session import get_memory_session_manager
+{{#if needsOs}}
+import os
+{{/if}}
+
+
+@tool
+def add_numbers(a: int, b: int) -> int:
+    """Return the sum of two numbers."""
+    return a + b
+
+
+tools = [add_numbers]
+
+{{#if needsOs}}
+_MOUNT_PATHS = [
+    {{#if sessionStorageMountPath}}"{{sessionStorageMountPath}}",{{/if}}
+    {{#each efsMounts}}"{{mountPath}}",{{/each}}
+    {{#each s3Mounts}}"{{mountPath}}",{{/each}}
+]
+
+def _safe_resolve(path: str) -> str:
+    resolved = os.path.realpath(path)
+    if not any(resolved == os.path.realpath(m) or resolved.startswith(os.path.realpath(m) + os.sep) for m in _MOUNT_PATHS):
+        raise ValueError(f"Path '{path}' is not within any configured mount ({', '.join(_MOUNT_PATHS)})")
+    return resolved
+
+@tool
+def file_read(path: str) -> str:
+    """Read a file from a mounted filesystem. Use the absolute path (e.g. /mnt/tools/data.txt)."""
+    try:
+        full_path = _safe_resolve(path)
+        with open(full_path) as f:
+            return f.read()
+    except ValueError as e:
+        return str(e)
+    except OSError as e:
+        return f"Error reading '{path}': {e.strerror}"
+
+@tool
+def file_write(path: str, content: str) -> str:
+    """Write a file to a mounted filesystem. Use the absolute path (e.g. /mnt/tools/data.txt)."""
+    try:
+        full_path = _safe_resolve(path)
+        parent = os.path.dirname(full_path)
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+        with open(full_path, "w") as f:
+            f.write(content)
+        return f"Written to {path}"
+    except ValueError as e:
+        return str(e)
+    except OSError as e:
+        return f"Error writing '{path}': {e.strerror}"
+
+@tool
+def list_files(path: str) -> str:
+    """List files in a mounted filesystem directory. Use the absolute path (e.g. /mnt/tools)."""
+    try:
+        full_path = _safe_resolve(path)
+        entries = os.listdir(full_path)
+        return "\n".join(entries) if entries else "(empty directory)"
+    except ValueError as e:
+        return str(e)
+    except OSError as e:
+        return f"Error listing '{path}': {e.strerror}"
+
+tools.extend([file_read, file_write, list_files])
+{{/if}}
+
+SYSTEM_PROMPT = """
+You are a helpful assistant. Use tools when appropriate.
+{{#if needsOs}}
+You have access to the following mounted filesystems. Use file_read, file_write, and list_files with full absolute paths:
+{{#if sessionStorageMountPath}}- {{sessionStorageMountPath}}: ephemeral session storage (lost when session ends)
+{{/if}}{{#each efsMounts}}- {{mountPath}}: EFS persistent storage (persists across sessions and agent restarts)
+{{/each}}{{#each s3Mounts}}- {{mountPath}}: S3 Files persistent storage (durable, backed by S3)
+{{/each}}{{/if}}
+"""
+
+# serve_a2a serves one agent instance, so it is bound to a fixed session and
+# actor; get_memory_session_manager returns None (in-process history only) until
+# the deployed MEMORY_ID env var is set by the CDK.
+agent = Agent(
+    name="{{ name }}",
+    model=load_model(),
+    session_manager=get_memory_session_manager("default-session", "default-user"),
+    system_prompt=SYSTEM_PROMPT,
+    tools=tools,
+)
+
+# serve_a2a binds 0.0.0.0:9000 in the container (the AgentCore A2A service
+# contract) and publishes the agent card at /.well-known/agent-card.json. The
+# card is derived by introspecting the executor's agent.
+if __name__ == "__main__":
+    serve_a2a(StrandsA2AExecutor(agent))

package/dist/assets/templates/a2a-python-strands/memory/session.py

@@ -0,0 +1,35 @@
+import os
+import uuid
+from typing import Optional
+
+from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig, RetrievalConfig
+from bedrock_agentcore.memory.integrations.strands.session_manager import AgentCoreMemorySessionManager
+
+MEMORY_ID = os.getenv("{{memoryEnvVarName}}")
+REGION = os.getenv("AWS_REGION")
+
+
+def get_memory_session_manager(
+    session_id: Optional[str], actor_id: str
+) -> Optional[AgentCoreMemorySessionManager]:
+    if not MEMORY_ID:
+        return None
+
+    session_id = session_id or uuid.uuid4().hex
+
+    retrieval_config = {
+        f"/users/{actor_id}/facts": RetrievalConfig(top_k=3, relevance_score=0.5),
+        f"/users/{actor_id}/preferences": RetrievalConfig(top_k=3, relevance_score=0.5),
+        f"/episodes/{actor_id}/{session_id}": RetrievalConfig(top_k=5, relevance_score=0.5),
+        f"/summaries/{actor_id}": RetrievalConfig(top_k=3, relevance_score=0.5),
+    }
+
+    return AgentCoreMemorySessionManager(
+        AgentCoreMemoryConfig(
+            memory_id=MEMORY_ID,
+            session_id=session_id,
+            actor_id=actor_id,
+            retrieval_config=retrieval_config,
+        ),
+        REGION,
+    )

package/dist/assets/templates/a2a-python-strands/model/load.py

@@ -0,0 +1,6 @@
+from strands.models.bedrock import BedrockModel
+
+
+def load_model() -> BedrockModel:
+    """Get Bedrock model client using IAM credentials."""
+    return BedrockModel(model_id="global.anthropic.claude-sonnet-4-5-20250929-v1:0")

package/dist/assets/templates/a2a-python-strands/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling ~= 1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ name }}"
+version = "0.1.0"
+description = "AgentCore A2A Agent using Strands SDK"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "a2a-sdk[all] ~= 0.3.0",
+    "aws-opentelemetry-distro ~= 0.18.0",
+    "bedrock-agentcore[a2a] ~= 1.9.1",
+    "botocore[crt] ~= 1.43.0",
+    "strands-agents ~= 1.15.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]

package/dist/assets/templates/agent-python-langchain/README.md

@@ -0,0 +1,56 @@
+# agent-python-langchain
+
+A LangChain agent on AgentCore Runtime, calling Claude through Amazon Bedrock.
+The agent is built with `create_agent`, keeps conversation history per Runtime
+session, and streams its response.
+
+## What's here
+
+- `main.py`: the agent. A `BedrockAgentCoreApp` wraps an async entrypoint
+  that reads `prompt` from the payload, runs the agent, and streams each
+  completed model message back as a JSON event of content blocks. An
+  `InMemorySaver` checkpointer keyed on the Runtime session id carries history
+  between turns.
+- `model/load.py`: creates the Bedrock chat model with `init_chat_model`.
+- `pyproject.toml`: Python dependencies, managed with
+  [uv](https://docs.astral.sh/uv/). `agentcore project create` has already run
+  `uv sync` for you (unless you passed `--skip-install`), so `.venv/` is ready.
+
+## Develop
+
+Run the agent locally from the project root:
+
+```bash
+agentcore project dev
+agentcore project invoke runtime --local --payload '{"prompt":"What is 2 plus 3?"}'
+```
+
+Environment variables for local development go in `agentcore/.env.local`
+(gitignored).
+
+## Deploy
+
+```bash
+agentcore project deploy
+agentcore project invoke runtime --payload '{"prompt":"Hello!"}'
+```
+
+Traces are collected automatically: AgentCore Runtime starts the agent under
+`opentelemetry-instrument`, which picks up `opentelemetry-instrumentation-langchain`
+from the dependencies.
+
+## Extending
+
+Everything hangs off the `create_agent` call in `main.py`.
+
+- **Tools.** Add a function decorated with `@tool` and append it to `tools`.
+- **Middleware.** Hook the agent loop with `langchain.agents.middleware`, for
+  example a `@before_model` function passed as `middleware=[...]`.
+- **Durable memory.** Replace `InMemorySaver()` with `AgentCoreMemorySaver`
+  from `langgraph-checkpoint-aws` and add `actor_id` next to `thread_id` in the
+  `configurable` config to persist history in AgentCore Memory.
+- **Structured output.** Pass a Pydantic model as `response_format=` and read
+  `structured_response` from the final state.
+
+See the [LangChain agents documentation](https://docs.langchain.com/oss/python/langchain/agents)
+for the full `create_agent` surface.