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

package/dist/assets/{python/a2a/googleadk/base → templates/agent-python-langchain}/gitignore.template

@@ -38,4 +38,4 @@ env/
 
 # OS
 .DS_Store
-Thumbs.db
+Thumbs.db

package/dist/assets/templates/agent-python-langchain/main.py

@@ -0,0 +1,50 @@
+from langchain.agents import create_agent
+from langchain.tools import tool
+from langgraph.checkpoint.memory import InMemorySaver
+from bedrock_agentcore.runtime import BedrockAgentCoreApp
+from model.load import load_model
+
+app = BedrockAgentCoreApp()
+
+SYSTEM_PROMPT = "You are a helpful assistant. Use tools when appropriate."
+
+
+@tool
+def add_numbers(a: int, b: int) -> int:
+    """Return the sum of two numbers"""
+    return a + b
+
+
+tools = [add_numbers]
+
+agent = create_agent(
+    model=load_model(),
+    tools=tools,
+    system_prompt=SYSTEM_PROMPT,
+    checkpointer=InMemorySaver(),
+)
+
+
+@app.entrypoint
+async def invoke(payload, context):
+    prompt = payload.get("prompt") if isinstance(payload, dict) else None
+    if not isinstance(prompt, str) or not prompt:
+        yield {"error": "payload must be a JSON object with a non-empty string 'prompt'"}
+        return
+
+    session_id = context.session_id or "default-session"
+    config = {"configurable": {"thread_id": session_id}}
+
+    async with await agent.astream_events(
+        {"messages": [{"role": "user", "content": prompt}]},
+        config,
+        version="v3",
+    ) as stream:
+        async for message in stream.messages:
+            blocks = (await message.output).content_blocks
+            if blocks:
+                yield {"node": message.node, "content": blocks}
+
+
+if __name__ == "__main__":
+    app.run()

package/dist/assets/templates/agent-python-langchain/model/load.py

@@ -0,0 +1,9 @@
+from langchain.chat_models import init_chat_model
+from langchain_core.language_models import BaseChatModel
+
+MODEL_ID = "global.anthropic.claude-sonnet-4-5-20250929-v1:0"
+
+
+def load_model() -> BaseChatModel:
+    """Get a Bedrock chat model using IAM credentials."""
+    return init_chat_model(MODEL_ID, model_provider="bedrock_converse")

package/dist/assets/templates/agent-python-langchain/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["hatchling ~= 1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ name }}"
+version = "0.1.0"
+description = "AgentCore Runtime Application using LangChain"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "aws-opentelemetry-distro ~= 0.19.0",
+    "bedrock-agentcore ~= 1.22.0",
+    "langchain ~= 1.4.0",
+    "langchain-aws ~= 1.7.5",
+    "langgraph ~= 1.2.11",
+    "opentelemetry-instrumentation-langchain ~= 0.62.3",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]

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

@@ -0,0 +1,31 @@
+# agent-python-minimal
+
+A minimal AgentCore Runtime HTTP agent with no agent framework. Its
+`@app.entrypoint` returns a fixed `Hello, world!` message for every
+invocation — a starting point you own and grow into a real agent.
+
+## What's here
+
+- `main.py` — the agent. A `BedrockAgentCoreApp` wraps the entrypoint that
+  receives each invocation payload and returns the response.
+- `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
+```
+
+Environment variables for local development go in `agentcore/.env.local`
+(gitignored).
+
+## Deploy
+
+```bash
+agentcore project deploy
+agentcore project invoke runtime --payload '{"prompt":"Hello!"}'
+```

package/dist/assets/templates/agent-python-minimal/main.py

@@ -0,0 +1,13 @@
+from bedrock_agentcore.runtime import BedrockAgentCoreApp
+
+app = BedrockAgentCoreApp()
+
+
+@app.entrypoint
+def invoke(payload, context):
+    """Add agent logic here"""
+    return {"message": "Hello, world!"}
+
+
+if __name__ == "__main__":
+    app.run()

package/dist/assets/templates/agent-python-minimal/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agent-python-minimal"
+version = "0.1.0"
+description = "Minimal AgentCore Runtime HTTP agent"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "aws-opentelemetry-distro ~= 0.18.0",
+    "bedrock-agentcore ~= 1.9.1",
+    "botocore[crt] ~= 1.43.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]

package/dist/assets/{container/python/Dockerfile → templates/agent-python-strands/Dockerfile.template}

@@ -1,4 +1,6 @@
-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/templates/agent-python-strands/README.md

@@ -0,0 +1,60 @@
+This is a project generated by the AgentCore CLI!
+
+# Layout
+
+The generated application code lives at the agent root directory. At the root, there is a `.gitignore` file, an
+`agentcore/` folder which represents the configurations and state associated with this project. Other `agentcore`
+commands like `deploy`, `dev`, and `invoke` rely on the configuration stored here.
+
+## Agent Root
+
+The main entrypoint to your app is defined in `main.py`. Using the AgentCore SDK `@app.entrypoint` decorator, this
+file defines a Starlette ASGI app with the Strands Agent SDK running within.
+
+`model/load.py` instantiates the chosen model provider.
+
+## Input Validation
+
+Validate invocation input before forwarding it to Strands. Keep plain prompts typed as strings. If the app accepts a
+caller-supplied message history, retain `_strip_trailing_tool_use()` in `parse.py`, which normalizes the history tail
+before invoking the agent.
+
+## Payload
+
+The Runtime accepts a JSON object. `parse_payload()` reads:
+
+- `prompt` (string) — a single user message. Used when `messages` is absent; defaults to `""`.
+- `messages` (array) — a full conversation history (`[{"role": ..., "content": [...]}]`). Takes precedence over `prompt`; trailing `toolUse` blocks are stripped before the agent runs.
+- `actorId` (string, optional) — identifies the end user for Memory scoping (e.g. `/users/{actorId}/facts`). Defaults to `"default"`.
+
+Provide either `prompt` or `messages`. The `session_id` is not in the body — it comes from the `X-Amzn-Bedrock-AgentCore-Runtime-Session-Id` header (`context.session_id`); reuse it to continue a conversation.
+
+```json
+{ "prompt": "What's the weather?", "actorId": "user-123" }
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+| --- | --- | --- |
+{{#if identityProviders.[0]}}| `{{identityProviders.[0].envVarName}}` | Yes | {{modelProvider}} API key (local) or Identity provider name (deployed) |
+{{/if}}| `LOCAL_DEV` | No | Set to `1` to use `.env.local` instead of AgentCore Identity |
+
+# Developing locally
+
+If installation was successful, a virtual environment is already created with dependencies installed.
+
+Activate the environment with `source .venv/bin/activate` on macOS/Linux, `.venv\Scripts\activate.bat` in Windows
+Command Prompt, or `.\.venv\Scripts\activate.ps1` in Windows PowerShell.
+
+`agentcore project dev` will start a local server on 0.0.0.0:8080.
+
+# Deployment
+
+After providing credentials, `agentcore project deploy` will deploy your project into Amazon Bedrock AgentCore.
+
+Invoke the deployed Runtime with its native payload:
+
+```bash
+agentcore project invoke runtime --payload '{"prompt":"Hello!"}'
+```

package/dist/assets/{python/a2a/langchain_langgraph/base → templates/agent-python-strands}/gitignore.template

@@ -38,4 +38,4 @@ env/
 
 # OS
 .DS_Store
-Thumbs.db
+Thumbs.db

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

@@ -0,0 +1,65 @@
+from functools import lru_cache
+
+from strands import Agent, tool
+from strands.agent.conversation_manager.null_conversation_manager import NullConversationManager
+from bedrock_agentcore.runtime import BedrockAgentCoreApp
+from model.load import load_model
+from parse import parse_payload
+from memory.session import get_memory_session_manager
+
+DEFAULT_SYSTEM_PROMPT = "You are a helpful assistant. Use tools when appropriate."
+
+# Define a collection of tools used by the model
+tools = []
+
+# Define a simple function tool
+@tool
+def add_numbers(a: int, b: int) -> int:
+    """Return the sum of two numbers"""
+    return a + b
+
+tools.append(add_numbers)
+
+def _make_conversation_manager():
+    return NullConversationManager()
+
+@lru_cache(maxsize=128)
+def _get_agent(session_id: str, actor_id: str) -> Agent:
+    """Given a session_id and actor_id, return or construct the corresponding Strands agent.
+    Note: caching helps avoid repeated identity fetches on non-bedrock model loads
+    and supports in-memory session management for local dev."""
+    return Agent(
+        model=load_model(),
+        session_manager=get_memory_session_manager(session_id, actor_id),
+        conversation_manager=_make_conversation_manager(),
+        system_prompt=DEFAULT_SYSTEM_PROMPT,
+        tools=tools,
+    )
+
+def create_app():
+    app = BedrockAgentCoreApp()
+    log = app.logger
+
+    @app.entrypoint
+    async def invoke(payload, context):
+        log.info("Invoking Agent.....")
+
+        session_id = getattr(context, "session_id", None) or "default-session"
+        prompt, actor_id = parse_payload(payload)
+
+        log.info(f"Invoking with session_id={session_id} and actor_id={actor_id}")
+        agent = _get_agent(session_id, actor_id)
+
+        async for event in agent.stream_async(prompt):
+            if not isinstance(event, dict) or "event" not in event:
+                continue
+            cbs = event["event"].get("contentBlockStart")
+            if cbs is not None and not cbs.get("start"):
+                continue
+            yield event
+
+    return app
+
+app = create_app()
+if __name__ == "__main__":
+    app.run()

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

@@ -0,0 +1,31 @@
+import os
+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: str, actor_id: str,
+) -> Optional[AgentCoreMemorySessionManager]:
+    if not MEMORY_ID:
+        return None
+
+    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/{python/http/strands/base → templates/agent-python-strands}/model/load.py

@@ -12,7 +12,7 @@ import os
 from strands.models.anthropic import AnthropicModel
 from bedrock_agentcore.identity.auth import requires_api_key
 
-IDENTITY_PROVIDER_NAME = "{{identityProviders.[0].name}}"
+IDENTITY_PROVIDER_NAME = os.environ.get("{{identityProviders.[0].envVarName}}_NAME", "{{identityProviders.[0].name}}")
 IDENTITY_ENV_VAR = "{{identityProviders.[0].envVarName}}"
 
 
@@ -51,7 +51,7 @@ import os
 from strands.models.openai import OpenAIModel
 from bedrock_agentcore.identity.auth import requires_api_key
 
-IDENTITY_PROVIDER_NAME = "{{identityProviders.[0].name}}"
+IDENTITY_PROVIDER_NAME = os.environ.get("{{identityProviders.[0].envVarName}}_NAME", "{{identityProviders.[0].name}}")
 IDENTITY_ENV_VAR = "{{identityProviders.[0].envVarName}}"
 
 
@@ -89,7 +89,7 @@ import os
 from strands.models.gemini import GeminiModel
 from bedrock_agentcore.identity.auth import requires_api_key
 
-IDENTITY_PROVIDER_NAME = "{{identityProviders.[0].name}}"
+IDENTITY_PROVIDER_NAME = os.environ.get("{{identityProviders.[0].envVarName}}_NAME", "{{identityProviders.[0].name}}")
 IDENTITY_ENV_VAR = "{{identityProviders.[0].envVarName}}"
 
 
@@ -121,3 +121,49 @@ def load_model() -> GeminiModel:
         model_id="gemini-2.5-flash",
     )
 {{/if}}
+{{#if (eq modelProvider "LiteLLM")}}
+{{#if identityProviders.[0].name}}
+import os
+
+{{/if}}
+from strands.models.litellm import LiteLLMModel
+{{#if identityProviders.[0].name}}
+from bedrock_agentcore.identity.auth import requires_api_key
+
+IDENTITY_PROVIDER_NAME = os.environ.get("{{identityProviders.[0].envVarName}}_NAME", "{{identityProviders.[0].name}}")
+IDENTITY_ENV_VAR = "{{identityProviders.[0].envVarName}}"
+
+
+@requires_api_key(provider_name=IDENTITY_PROVIDER_NAME)
+def _agentcore_identity_api_key_provider(api_key: str) -> str:
+    """Fetch API key from AgentCore Identity."""
+    return api_key
+
+
+def _get_api_key() -> str:
+    """
+    Uses AgentCore Identity for API key management in deployed environments.
+    For local development, run via 'agentcore dev' which loads agentcore/.env.
+    """
+    if os.getenv("LOCAL_DEV") == "1":
+        api_key = os.getenv(IDENTITY_ENV_VAR)
+        if not api_key:
+            raise RuntimeError(
+                f"{IDENTITY_ENV_VAR} not found. Add {IDENTITY_ENV_VAR}=your-key to .env.local"
+            )
+        return api_key
+    return _agentcore_identity_api_key_provider()
+{{/if}}
+
+
+def load_model() -> LiteLLMModel:
+    """Get a LiteLLM model client (proxies to the provider encoded in model_id)."""
+    client_args = {}
+    {{#if identityProviders.[0].name}}
+    client_args["api_key"] = _get_api_key()
+    {{/if}}
+    return LiteLLMModel(
+        client_args=client_args,
+        model_id="bedrock/us.anthropic.claude-sonnet-4-5-20250514-v1:0",
+    )
+{{/if}}

package/dist/assets/templates/agent-python-strands/parse.py

@@ -0,0 +1,41 @@
+from typing import Any
+
+def _strip_trailing_tool_use(messages: Any) -> list[dict]:
+    """Strip toolUse blocks from the tail until the last message has none."""
+    if not isinstance(messages, list):
+        raise ValueError("messages must be a list")
+
+    messages = list(messages)
+    while messages:
+        last = messages[-1]
+        if not isinstance(last, dict):
+            raise ValueError("each message must be an object")
+        original_content = last.get("content", [])
+        if not isinstance(original_content, list) or not all(isinstance(block, dict) for block in original_content):
+            raise ValueError("each message content value must be a list of content blocks")
+
+        content = [block for block in original_content if "toolUse" not in block]
+        if len(content) == len(original_content):
+            break
+        if content:
+            messages[-1] = {**last, "content": content}
+            break
+        messages.pop()
+
+    return messages
+
+def parse_payload(payload: dict):
+    """Accept a caller-supplied message history or a plain prompt string."""
+    if not isinstance(payload, dict):
+        raise ValueError("payload must be a JSON object")
+    actor_id = payload.get("actorId", "default")
+    if not isinstance(actor_id, str):
+        raise ValueError("actorId must be a string")
+    if not actor_id:
+        actor_id = "default"
+    if "messages" in payload:
+        return _strip_trailing_tool_use(payload["messages"]), actor_id
+    prompt = payload.get("prompt", "")
+    if not isinstance(prompt, str):
+        raise ValueError("prompt must be a string")
+    return prompt, actor_id

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

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling ~= 1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ name }}"
+version = "0.1.0"
+description = "AgentCore Runtime Application using Strands SDK"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "aws-opentelemetry-distro ~= 0.18.0",
+    "bedrock-agentcore ~= 1.9.1",
+    "botocore[crt] ~= 1.43.0",
+    {{#if (eq modelProvider "Anthropic")}}"strands-agents[anthropic] ~= 1.15.0",
+    {{else}}{{#if (eq modelProvider "OpenAI")}}"strands-agents[openai] ~= 1.15.0",
+    {{else}}{{#if (eq modelProvider "Gemini")}}"strands-agents[gemini] ~= 1.15.0",
+    {{else}}{{#if (eq modelProvider "LiteLLM")}}"strands-agents[litellm] ~= 1.15.0",
+    {{else}}"strands-agents ~= 1.15.0",
+    {{/if}}{{/if}}{{/if}}{{/if}}
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]

package/dist/assets/templates/agent-typescript-strands/README.md

@@ -0,0 +1,50 @@
+This is a project generated by the AgentCore CLI!
+
+# Layout
+
+The generated application code lives at the agent root directory. At the root, there is a `.gitignore` file, an
+`agentcore/` folder which represents the configurations and state associated with this project. Other `agentcore`
+commands like `deploy`, `dev`, and `invoke` rely on the configuration stored here.
+
+## Agent Root
+
+The main entrypoint to your app is defined in `main.ts`. Using the AgentCore SDK `BedrockAgentCoreApp`, this file
+defines an HTTP server that streams tokens from your chosen Agent framework SDK.
+
+`model/load.ts` instantiates your chosen model provider.
+
+## Input Validation
+
+The generated Zod request schema keeps the prompt and actor ID typed as strings before forwarding them to Strands.
+Retain this validation when extending the request shape, and pass only prompt text to the agent.
+
+## Payload
+
+The Runtime accepts a JSON object with:
+
+- `prompt` (string) — a single user message; defaults to `""`.
+- `actorId` (string, optional) — identifies the end user for Memory scoping (for example,
+  `/users/{actorId}/facts`); defaults to `"default"`.
+
+The `sessionId` is not in the body. It comes from the
+`X-Amzn-Bedrock-AgentCore-Runtime-Session-Id` header (`context.sessionId`); reuse it to continue a conversation.
+
+```json
+{ "prompt": "What's the weather?", "actorId": "user-123" }
+```
+
+# Developing locally
+
+If installation was successful, `node_modules/` is already populated with dependencies.
+
+`agentcore project dev` will start a local server using `tsx watch main.ts` for hot reload on 0.0.0.0:8080.
+
+# Deployment
+
+After providing credentials, `agentcore project deploy` will deploy your project into Amazon Bedrock AgentCore.
+
+Invoke the deployed Runtime with its native payload:
+
+```bash
+agentcore project invoke runtime --payload '{"prompt":"Hello!","actorId":"user-123"}'
+```

package/dist/assets/templates/agent-typescript-strands/gitignore.template

@@ -0,0 +1,22 @@
+# Environment variables
+.env
+.env.*
+
+# Node
+node_modules/
+dist/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db

package/dist/assets/templates/agent-typescript-strands/main.ts

@@ -0,0 +1,77 @@
+import { BedrockAgentCoreApp } from 'bedrock-agentcore/runtime';
+import { Agent, tool, type ToolList } from '@strands-agents/sdk';
+import { z } from 'zod';
+import { loadModel } from './model/load.js';
+import { getOrCreateMemoryManager } from './memory/memory.js';
+
+// Define a collection of tools used by the model
+const tools: ToolList = [];
+
+// Define a simple function tool — the Zod schema gives us type inference and runtime validation for free
+const addNumbers = tool({
+  name: 'add_numbers',
+  description: 'Return the sum of two numbers',
+  inputSchema: z.object({
+    a: z.number(),
+    b: z.number(),
+  }),
+  callback: async ({ a, b }) => a + b,
+});
+tools.push(addNumbers);
+
+const SYSTEM_PROMPT = `
+You are a helpful assistant. Use tools when appropriate.
+`;
+
+const requestSchema = z.object({
+  prompt: z.string().default(''),
+  actorId: z.string().default('default').transform((actorId) => actorId || 'default'),
+});
+
+const agentCache = new Map<string, Agent>();
+
+async function getOrCreateAgent(sessionId: string, actorId: string): Promise<Agent> {
+  const key = `${actorId}:${sessionId}`;
+  let agent = agentCache.get(key);
+  if (agent) return agent;
+
+  const model = await loadModel();
+  agent = new Agent({
+    model,
+    systemPrompt: SYSTEM_PROMPT,
+    tools,
+    memoryManager: getOrCreateMemoryManager(sessionId, actorId) ?? undefined,
+  });
+  agentCache.set(key, agent);
+  return agent;
+}
+
+const app = new BedrockAgentCoreApp({
+  invocationHandler: {
+    requestSchema,
+    async *process(payload, context) {
+      const sessionId = context?.sessionId ?? 'default-session';
+      const actorId = payload.actorId;
+      const agent = await getOrCreateAgent(sessionId, actorId);
+
+      try {
+        for await (const event of agent.stream(payload.prompt)) {
+          if (
+            event.type === 'modelStreamUpdateEvent' &&
+            event.event?.type === 'modelContentBlockDeltaEvent' &&
+            event.event.delta?.type === 'textDelta'
+          ) {
+            yield { data: event.event.delta.text };
+          }
+        }
+      } finally {
+        // Drain in-flight createEvent calls before the runtime can reclaim
+        // the session microVM. flush() is the durability mechanism — without
+        // it, an idle reclamation can lose the tail of the conversation.
+        await agent.memoryManager?.flush();
+      }
+    },
+  },
+});
+
+app.run({ port: parseInt(process.env.PORT ?? '8080') });

package/dist/assets/templates/agent-typescript-strands/memory/memory.ts

@@ -0,0 +1,33 @@
+import { MemoryManager } from '@strands-agents/sdk';
+import { createAgentCoreMemoryStores } from 'bedrock-agentcore/experimental/memory/strands';
+
+const MEMORY_ID = process.env.{{memoryEnvVarName}};
+
+const memoryManagerCache = new Map<string, MemoryManager>();
+
+export function getOrCreateMemoryManager(sessionId: string, actorId: string): MemoryManager | null {
+  if (!MEMORY_ID) return null;
+
+  const key = `${actorId}:${sessionId}`;
+  let manager = memoryManagerCache.get(key);
+  if (manager) return manager;
+
+  const stores = createAgentCoreMemoryStores({
+    memoryId: MEMORY_ID,
+    actorId,
+    sessionId,
+    namespaces: [
+      { namespace: '/users/{actorId}/facts' },
+      { namespace: '/users/{actorId}/preferences' },
+      { namespace: '/episodes/{actorId}/{sessionId}' },
+      { namespace: '/summaries/{actorId}' },
+    ],
+    // readMode defaults to 'per-namespace' (one retrieve call per namespace).
+    // Switch to 'subtree' to consolidate to a single hierarchical recall call.
+    extraction: true,
+  });
+
+  manager = new MemoryManager({ stores });
+  memoryManagerCache.set(key, manager);
+  return manager;
+}

package/dist/assets/templates/agent-typescript-strands/model/load.ts

@@ -0,0 +1,5 @@
+import { BedrockModel } from '@strands-agents/sdk/models/bedrock';
+
+export function loadModel(): BedrockModel {
+  return new BedrockModel({ modelId: 'global.anthropic.claude-sonnet-4-5-20250929-v1:0' });
+}