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

package/dist/assets/python/http/openaiagents/base/mcp_client/client.py

@@ -1,74 +0,0 @@
-import os
-import logging
-from agents.mcp import MCPServerStreamableHttp
-
-logger = logging.getLogger(__name__)
-
-{{#if hasGateway}}
-{{#if (includes gatewayAuthTypes "AWS_IAM")}}
-import httpx
-from mcp_proxy_for_aws.sigv4_helper import SigV4HTTPXAuth, create_aws_session
-{{/if}}
-{{#if (includes gatewayAuthTypes "CUSTOM_JWT")}}
-from bedrock_agentcore.identity import requires_access_token
-{{/if}}
-
-{{#each gatewayProviders}}
-{{#if (eq authType "CUSTOM_JWT")}}
-@requires_access_token(
-    provider_name="{{credentialProviderName}}",
-    scopes=[{{#if scopes}}"{{scopes}}"{{/if}}],
-    auth_flow="M2M",
-)
-def _get_bearer_token_{{snakeCase name}}(*, access_token: str):
-    """Obtain OAuth access token via AgentCore Identity for {{name}}."""
-    return access_token
-
-{{/if}}
-{{/each}}
-
-def get_all_gateway_mcp_servers() -> list[MCPServerStreamableHttp]:
-    """Returns MCP servers for all configured gateways."""
-    servers = []
-    {{#each gatewayProviders}}
-    url = os.environ.get("{{envVarName}}")
-    if url:
-        {{#if (eq authType "AWS_IAM")}}
-        session = create_aws_session()
-        auth = SigV4HTTPXAuth(session.get_credentials(), "bedrock-agentcore", session.region_name)
-        servers.append(MCPServerStreamableHttp(
-            name="{{name}}",
-            params={"url": url, "httpx_client_factory": lambda **kwargs: httpx.AsyncClient(auth=auth, **kwargs)}
-        ))
-        {{else if (eq authType "CUSTOM_JWT")}}
-        token = _get_bearer_token_{{snakeCase name}}()
-        headers = {"Authorization": f"Bearer {token}"} if token else {}
-        servers.append(MCPServerStreamableHttp(name="{{name}}", params={"url": url, "headers": headers}))
-        {{else}}
-        servers.append(MCPServerStreamableHttp(name="{{name}}", params={"url": url}))
-        {{/if}}
-    else:
-        logger.warning("{{envVarName}} not set — {{name}} gateway tools unavailable")
-    {{/each}}
-    return servers
-{{else}}
-{{#if isVpc}}
-# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
-# Add an AgentCore Gateway with `agentcore add gateway`, or configure your own endpoint below.
-
-def get_streamable_http_mcp_client() -> MCPServerStreamableHttp | None:
-    """No MCP server configured. Add a gateway with `agentcore add gateway`."""
-    return None
-{{else}}
-# ExaAI provides information about code through web searches, crawling and code context searches through their platform. Requires no authentication
-EXAMPLE_MCP_ENDPOINT = "https://mcp.exa.ai/mcp"
-
-
-def get_streamable_http_mcp_client() -> MCPServerStreamableHttp:
-    """Returns an MCP Client compatible with OpenAI Agents SDK."""
-    # to use an MCP server that supports bearer authentication, add headers={"Authorization": f"Bearer {access_token}"}
-    return MCPServerStreamableHttp(
-        name="AgentCore Gateway MCP", params={"url": EXAMPLE_MCP_ENDPOINT}
-    )
-{{/if}}
-{{/if}}

package/dist/assets/python/http/openaiagents/base/model/__init__.py

@@ -1 +0,0 @@
-# Package marker

package/dist/assets/python/http/openaiagents/base/model/load.py

@@ -1,37 +0,0 @@
-import os
-from bedrock_agentcore.identity.auth import requires_api_key
-
-IDENTITY_PROVIDER_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()
-
-
-def load_model() -> None:
-    """
-    Set up OpenAI API key authentication.
-    Uses AgentCore Identity for API key management in deployed environments,
-    and falls back to .env file for local development.
-    Sets the OPENAI_API_KEY environment variable for the OpenAI Agents SDK.
-    """
-    api_key = _get_api_key()
-    os.environ["OPENAI_API_KEY"] = api_key if api_key else ""

package/dist/assets/python/http/openaiagents/base/pyproject.toml

@@ -1,21 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "{{ name }}"
-version = "0.1.0"
-description = "AgentCore Runtime Application using OpenAI Agents SDK"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    "aws-opentelemetry-distro",
-    "openai-agents >= 0.4.2",
-    "bedrock-agentcore >= 1.0.3",
-    "botocore[crt] >= 1.35.0",
-    {{#if hasGateway}}{{#if (includes gatewayAuthTypes "AWS_IAM")}}"mcp-proxy-for-aws >= 1.1.0",
-    {{/if}}{{/if}}
-]
-
-[tool.hatch.build.targets.wheel]
-packages = ["."]

package/dist/assets/python/http/strands/base/main.py

@@ -1,217 +0,0 @@
-from typing import Any
-
-from strands import Agent, tool
-{{#if hasConfigBundle}}
-from strands.hooks import HookProvider, HookRegistry, BeforeInvocationEvent, BeforeToolCallEvent
-from bedrock_agentcore.runtime.context import BedrockAgentCoreContext
-{{/if}}
-from bedrock_agentcore.runtime import BedrockAgentCoreApp
-from model.load import load_model
-{{#if hasGateway}}
-from mcp_client.client import get_all_gateway_mcp_clients
-{{else}}
-from mcp_client.client import get_streamable_http_mcp_client
-{{/if}}
-{{#if hasMemory}}
-from memory.session import get_memory_session_manager
-{{/if}}
-{{#if sessionStorageMountPath}}
-import os
-{{/if}}
-
-app = BedrockAgentCoreApp()
-log = app.logger
-
-# Define a Streamable HTTP MCP Client
-{{#if hasGateway}}
-mcp_clients = get_all_gateway_mcp_clients()
-{{else}}
-mcp_clients = [get_streamable_http_mcp_client()]
-{{/if}}
-
-DEFAULT_SYSTEM_PROMPT = """
-You are a helpful assistant. Use tools when appropriate.
-{{#if sessionStorageMountPath}}
-You have persistent storage at {{sessionStorageMountPath}}. Use file tools to read and write files. Data persists across sessions.
-{{/if}}
-"""
-
-{{#if hasConfigBundle}}
-DEFAULT_TOOL_DESC = "Return the sum of two numbers"
-{{/if}}
-
-# Define a collection of tools used by the model
-tools = []
-
-# Define a simple function tool
-{{#if hasConfigBundle}}
-@tool(description=DEFAULT_TOOL_DESC)
-{{else}}
-@tool
-{{/if}}
-def add_numbers(a: int, b: int) -> int:
-    """Return the sum of two numbers"""
-    return a+b
-tools.append(add_numbers)
-
-{{#if sessionStorageMountPath}}
-SESSION_STORAGE_PATH = "{{sessionStorageMountPath}}"
-
-def _safe_resolve(path: str) -> str:
-    """Resolve path safely within the storage boundary."""
-    resolved = os.path.realpath(os.path.join(SESSION_STORAGE_PATH, path.lstrip("/")))
-    if not resolved.startswith(os.path.realpath(SESSION_STORAGE_PATH)):
-        raise ValueError(f"Path '{path}' is outside the storage boundary")
-    return resolved
-
-@tool
-def file_read(path: str) -> str:
-    """Read a file from persistent storage. The path is relative to the storage root."""
-    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 content to a file in persistent storage. The path is relative to the storage root."""
-    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(directory: str = "") -> str:
-    """List files in persistent storage. The directory is relative to the storage root."""
-    try:
-        target = _safe_resolve(directory)
-        entries = os.listdir(target)
-        return "\n".join(entries) if entries else "(empty directory)"
-    except ValueError as e:
-        return str(e)
-    except OSError as e:
-        return f"Error listing '{directory}': {e.strerror}"
-
-tools.extend([file_read, file_write, list_files])
-{{/if}}
-
-# Add MCP client to tools if available
-for mcp_client in mcp_clients:
-    if mcp_client:
-        tools.append(mcp_client)
-
-{{#if hasConfigBundle}}
-
-class ConfigBundleHook(HookProvider):
-    """Injects config bundle values (system prompt, tool descriptions) before each invocation.
-
-    BedrockAgentCoreContext.get_config_bundle() fetches the component configuration
-    for the current runtime ARN from the config bundle service. The SDK caches the
-    result and refreshes on bundle version changes.
-    """
-
-    def register_hooks(self, registry: HookRegistry, **kwargs: Any) -> None:
-        registry.add_callback(BeforeInvocationEvent, self._inject_system_prompt)
-        registry.add_callback(BeforeToolCallEvent, self._override_tool_desc)
-
-    def _inject_system_prompt(self, event: BeforeInvocationEvent) -> None:
-        config = BedrockAgentCoreContext.get_config_bundle()
-        prompt = config.get("systemPrompt", DEFAULT_SYSTEM_PROMPT)
-
-        if prompt != event.agent.system_prompt:
-            event.agent.system_prompt = prompt
-
-    def _override_tool_desc(self, event: BeforeToolCallEvent) -> None:
-        config = BedrockAgentCoreContext.get_config_bundle()
-        tool_descs = config.get("toolDescriptions", {})
-
-        tool_name = event.tool_use["name"]
-        override = tool_descs.get(tool_name)
-        if override and event.selected_tool:
-            spec = event.selected_tool.tool_spec
-            if spec and "description" in spec:
-                spec["description"] = override
-
-{{/if}}
-
-{{#if hasMemory}}
-def agent_factory():
-    cache = {}
-    def get_or_create_agent(session_id, user_id):
-        key = f"{session_id}/{user_id}"
-        if key not in cache:
-            # Create an agent for the given session_id and user_id
-            cache[key] = Agent(
-                model=load_model(),
-                session_manager=get_memory_session_manager(session_id, user_id),
-                system_prompt=DEFAULT_SYSTEM_PROMPT,
-                tools=tools{{#if hasConfigBundle}},
-                hooks=[ConfigBundleHook()]{{/if}}
-            )
-        return cache[key]
-    return get_or_create_agent
-get_or_create_agent = agent_factory()
-{{else}}
-{{#if hasConfigBundle}}
-def create_agent():
-    return Agent(
-        model=load_model(),
-        system_prompt=DEFAULT_SYSTEM_PROMPT,
-        tools=tools,
-        hooks=[ConfigBundleHook()],
-    )
-{{else}}
-_agent = None
-
-def get_or_create_agent():
-    global _agent
-    if _agent is None:
-        _agent = Agent(
-            model=load_model(),
-            system_prompt=DEFAULT_SYSTEM_PROMPT,
-            tools=tools
-        )
-    return _agent
-{{/if}}
-{{/if}}
-
-
-@app.entrypoint
-async def invoke(payload, context):
-    log.info("Invoking Agent.....")
-
-{{#if hasMemory}}
-    session_id = getattr(context, 'session_id', 'default-session')
-    user_id = getattr(context, 'user_id', 'default-user')
-    agent = get_or_create_agent(session_id, user_id)
-{{else}}
-{{#if hasConfigBundle}}
-    agent = create_agent()
-{{else}}
-    agent = get_or_create_agent()
-{{/if}}
-{{/if}}
-
-    # Execute and format response
-    stream = agent.stream_async(payload.get("prompt"))
-
-    async for event in stream:
-        # Handle Text parts of the response
-        if "data" in event and isinstance(event["data"], str):
-            yield event["data"]
-
-
-if __name__ == "__main__":
-    app.run()

package/dist/assets/python/http/strands/base/mcp_client/__init__.py

@@ -1 +0,0 @@
-# Package marker

package/dist/assets/python/http/strands/base/mcp_client/client.py

@@ -1,73 +0,0 @@
-import os
-import logging
-from mcp.client.streamable_http import streamablehttp_client
-from strands.tools.mcp.mcp_client import MCPClient
-
-logger = logging.getLogger(__name__)
-
-{{#if hasGateway}}
-{{#if (includes gatewayAuthTypes "AWS_IAM")}}
-from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client
-{{/if}}
-{{#if (includes gatewayAuthTypes "CUSTOM_JWT")}}
-from bedrock_agentcore.identity import requires_access_token
-{{/if}}
-
-{{#each gatewayProviders}}
-{{#if (eq authType "CUSTOM_JWT")}}
-@requires_access_token(
-    provider_name="{{credentialProviderName}}",
-    scopes=[{{#if scopes}}"{{scopes}}"{{/if}}],
-    auth_flow="M2M",
-)
-def _get_bearer_token_{{snakeCase name}}(*, access_token: str):
-    """Obtain OAuth access token via AgentCore Identity for {{name}}."""
-    return access_token
-
-{{/if}}
-{{/each}}
-{{#each gatewayProviders}}
-def get_{{snakeCase name}}_mcp_client() -> MCPClient | None:
-    """Returns an MCP Client connected to the {{name}} gateway."""
-    url = os.environ.get("{{envVarName}}")
-    if not url:
-        logger.warning("{{envVarName}} not set — {{name}} gateway tools unavailable")
-        return None
-    {{#if (eq authType "AWS_IAM")}}
-    return MCPClient(lambda: aws_iam_streamablehttp_client(url, aws_service="bedrock-agentcore", aws_region=os.environ.get("AWS_REGION", os.environ.get("AWS_DEFAULT_REGION"))))
-    {{else if (eq authType "CUSTOM_JWT")}}
-    token = _get_bearer_token_{{snakeCase name}}()
-    headers = {"Authorization": f"Bearer {token}"} if token else {}
-    return MCPClient(lambda: streamablehttp_client(url, headers=headers))
-    {{else}}
-    return MCPClient(lambda: streamablehttp_client(url))
-    {{/if}}
-
-{{/each}}
-def get_all_gateway_mcp_clients() -> list[MCPClient]:
-    """Returns MCP clients for all configured gateways."""
-    clients = []
-    {{#each gatewayProviders}}
-    client = get_{{snakeCase name}}_mcp_client()
-    if client:
-        clients.append(client)
-    {{/each}}
-    return clients
-{{else}}
-{{#if isVpc}}
-# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
-# Add an AgentCore Gateway with `agentcore add gateway`, or configure your own endpoint below.
-
-def get_streamable_http_mcp_client() -> MCPClient | None:
-    """No MCP server configured. Add a gateway with `agentcore add gateway`."""
-    return None
-{{else}}
-# ExaAI provides information about code through web searches, crawling and code context searches through their platform. Requires no authentication
-EXAMPLE_MCP_ENDPOINT = "https://mcp.exa.ai/mcp"
-
-def get_streamable_http_mcp_client() -> MCPClient:
-    """Returns an MCP Client compatible with Strands"""
-    # to use an MCP server that supports bearer authentication, add headers={"Authorization": f"Bearer {access_token}"}
-    return MCPClient(lambda: streamablehttp_client(EXAMPLE_MCP_ENDPOINT))
-{{/if}}
-{{/if}}

package/dist/assets/python/http/strands/base/model/__init__.py

@@ -1 +0,0 @@
-# Package marker

package/dist/assets/python/http/strands/base/pyproject.toml

@@ -1,25 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-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 = [
-    {{#if (eq modelProvider "Anthropic")}}"anthropic >= 0.30.0",
-    {{/if}}"aws-opentelemetry-distro",
-    "bedrock-agentcore >= 1.0.3",
-    "botocore[crt] >= 1.35.0",
-    {{#if (eq modelProvider "Gemini")}}"google-genai >= 1.0.0",
-    {{/if}}"mcp >= 1.19.0",
-    {{#if (eq modelProvider "OpenAI")}}"openai >= 1.0.0",
-    {{/if}}"strands-agents >= 1.13.0",
-    {{#if hasGateway}}{{#if (includes gatewayAuthTypes "AWS_IAM")}}"mcp-proxy-for-aws >= 1.1.0",
-    {{/if}}{{/if}}
-]
-
-[tool.hatch.build.targets.wheel]
-packages = ["."]

package/dist/assets/python/http/strands/capabilities/memory/__init__.py

@@ -1 +0,0 @@
-# Package marker

package/dist/assets/python/http/strands/capabilities/memory/session.py

@@ -1,44 +0,0 @@
-import os
-import uuid
-from typing import Optional
-
-from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig{{#if memoryProviders.[0].strategies.length}}, RetrievalConfig{{/if}}
-from bedrock_agentcore.memory.integrations.strands.session_manager import AgentCoreMemorySessionManager
-
-MEMORY_ID = os.getenv("{{memoryProviders.[0].envVarName}}")
-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
-
-    # AgentCoreMemoryConfig rejects None; OAuth/CUSTOM_JWT callers can reach us
-    # without a runtime session header, so synthesize one when absent.
-    session_id = session_id or uuid.uuid4().hex
-
-{{#if memoryProviders.[0].strategies.length}}
-    retrieval_config = {
-{{#if (includes memoryProviders.[0].strategies "SEMANTIC")}}
-        f"/users/{actor_id}/facts": RetrievalConfig(top_k=3, relevance_score=0.5),
-{{/if}}
-{{#if (includes memoryProviders.[0].strategies "USER_PREFERENCE")}}
-        f"/users/{actor_id}/preferences": RetrievalConfig(top_k=3, relevance_score=0.5),
-{{/if}}
-{{#if (includes memoryProviders.[0].strategies "SUMMARIZATION")}}
-        f"/summaries/{actor_id}/{session_id}": RetrievalConfig(top_k=3, relevance_score=0.5),
-{{/if}}
-    }
-{{/if}}
-
-    return AgentCoreMemorySessionManager(
-        AgentCoreMemoryConfig(
-            memory_id=MEMORY_ID,
-            session_id=session_id,
-            actor_id=actor_id,
-{{#if memoryProviders.[0].strategies.length}}
-            retrieval_config=retrieval_config,
-{{/if}}
-        ),
-        REGION
-    )
-

package/dist/assets/python/mcp/standalone/base/README.md

@@ -1,36 +0,0 @@
-# {{ name }}
-
-An MCP (Model Context Protocol) server deployed on Amazon Bedrock AgentCore.
-
-## Overview
-
-This project implements an MCP server using FastMCP. MCP servers expose tools that can be consumed by MCP clients (other agents or applications).
-
-## Local Development
-
-```bash
-# Install dependencies
-uv sync
-
-# Run the MCP server locally
-uv run python main.py
-```
-
-The server starts on port 8000 with Streamable HTTP transport.
-
-## Adding Tools
-
-Define tools using the `@mcp.tool()` decorator in `main.py`:
-
-```python
-@mcp.tool()
-def my_tool(param: str) -> str:
-    """Description of what the tool does."""
-    return f"Result: {param}"
-```
-
-## Deploy
-
-```bash
-agentcore deploy
-```

package/dist/assets/python/mcp/standalone/base/gitignore.template

@@ -1,41 +0,0 @@
-# Environment variables
-.env
-
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-
-# Virtual environments
-.venv/
-venv/
-ENV/
-env/
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-
-# OS
-.DS_Store
-Thumbs.db

package/dist/assets/python/mcp/standalone/base/main.py

@@ -1,25 +0,0 @@
-from mcp.server.fastmcp import FastMCP
-
-mcp = FastMCP("{{ name }}", host="0.0.0.0", stateless_http=True)
-
-
-@mcp.tool()
-def add_numbers(a: int, b: int) -> int:
-    """Add two numbers together"""
-    return a + b
-
-
-@mcp.tool()
-def multiply_numbers(a: int, b: int) -> int:
-    """Multiply two numbers together"""
-    return a * b
-
-
-@mcp.tool()
-def greet_user(name: str) -> str:
-    """Greet a user by name"""
-    return f"Hello, {name}! Nice to meet you."
-
-
-if __name__ == "__main__":
-    mcp.run(transport="streamable-http")