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

package/dist/assets/mcp/python-lambda/handler.py

@@ -1,144 +0,0 @@
-"""
-Lambda handler for AgentCore Gateway tools.
-
-This template mirrors the FastMCP server tools but runs as a Lambda function
-behind an AgentCore Gateway.
-
-Tool routing uses bedrockAgentCoreToolName from client context:
-  Format: {target_name}___{tool_name}
-"""
-import json
-import logging
-import urllib.request
-import urllib.error
-from typing import Any, Dict, Optional
-
-logger = logging.getLogger()
-logger.setLevel(logging.INFO)
-
-HTTP_TIMEOUT = 10
-TOOLS = {}
-
-
-def tool(name: str):
-    """Decorator to register a tool handler."""
-    def decorator(func):
-        TOOLS[name] = func
-        return func
-    return decorator
-
-
-def lambda_handler(event: Dict[str, Any], context) -> Dict[str, Any]:
-    """Route incoming gateway requests to the appropriate tool."""
-    try:
-        extended_name = context.client_context.custom.get("bedrockAgentCoreToolName", "")
-        tool_name = None
-
-        if "___" in extended_name:
-            tool_name = extended_name.split("___", 1)[1]
-
-        if not tool_name:
-            return _response(400, {"error": "Missing tool name in bedrockAgentCoreToolName"})
-
-        handler = TOOLS.get(tool_name)
-        if not handler:
-            return _response(400, {"error": f"Unknown tool: {tool_name}"})
-
-        result = handler(event)
-        return _response(200, {"result": result})
-
-    except Exception as e:
-        logger.exception("Tool execution failed")
-        return _response(500, {"error": str(e)})
-
-
-def _response(status_code: int, body: Dict[str, Any]) -> Dict[str, Any]:
-    """Consistent JSON response wrapper."""
-    return {"statusCode": status_code, "body": json.dumps(body)}
-
-
-def _fetch_json(url: str) -> Optional[Dict[str, Any]]:
-    """Fetch JSON from URL with error handling."""
-    try:
-        req = urllib.request.Request(url, headers={"User-Agent": "AgentCore-Tool/1.0"})
-        with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT) as resp:
-            return json.loads(resp.read().decode())
-    except (urllib.error.URLError, json.JSONDecodeError) as e:
-        logger.warning(f"Failed to fetch {url}: {e}")
-        return None
-
-
-@tool("{{Name}}_lookup_ip")
-def lookup_ip(event: Dict[str, Any]) -> str:
-    """Look up geolocation and network info for an IP address.
-
-    Args:
-        ip_address: IPv4 or IPv6 address to look up
-    """
-    ip_address = event.get("ip_address", "")
-    if not ip_address:
-        return "Missing required parameter: ip_address"
-
-    data = _fetch_json(f"http://ip-api.com/json/{ip_address}")
-    if not data:
-        return f"Failed to look up IP: {ip_address}"
-
-    if data.get("status") == "fail":
-        return f"Lookup failed: {data.get('message', 'unknown error')}"
-
-    return (
-        f"IP: {data['query']}\n"
-        f"Location: {data['city']}, {data['regionName']}, {data['country']}\n"
-        f"ISP: {data['isp']}\n"
-        f"Organization: {data['org']}\n"
-        f"Timezone: {data['timezone']}"
-    )
-
-
-@tool("{{Name}}_get_random_user")
-def get_random_user(event: Dict[str, Any]) -> str:
-    """Generate a random user profile for testing or mock data."""
-    data = _fetch_json("https://randomuser.me/api/")
-    if not data or "results" not in data:
-        return "Failed to generate random user."
-
-    user = data["results"][0]
-    name = user["name"]
-    location = user["location"]
-
-    return (
-        f"Name: {name['first']} {name['last']}\n"
-        f"Email: {user['email']}\n"
-        f"Location: {location['city']}, {location['country']}\n"
-        f"Phone: {user['phone']}"
-    )
-
-
-@tool("{{Name}}_fetch_post")
-def fetch_post(event: Dict[str, Any]) -> str:
-    """Fetch a post by ID from JSONPlaceholder API.
-
-    Args:
-        post_id: The post ID (1-100)
-    """
-    post_id = event.get("post_id")
-    if post_id is None:
-        return "Missing required parameter: post_id"
-
-    try:
-        post_id = int(post_id)
-    except (TypeError, ValueError):
-        return "post_id must be an integer"
-
-    if not 1 <= post_id <= 100:
-        return "Post ID must be between 1 and 100."
-
-    data = _fetch_json(f"https://jsonplaceholder.typicode.com/posts/{post_id}")
-    if not data:
-        return f"Failed to fetch post {post_id}."
-
-    return (
-        f"Post #{data['id']}\n"
-        f"Title: {data['title']}\n\n"
-        f"{data['body']}"
-    )

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

@@ -1,15 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "{{ name }}"
-version = "0.1.0"
-description = "Lambda tools for AgentCore Gateway"
-readme = "README.md"
-requires-python = ">=3.10"
-# No external dependencies - uses stdlib only
-dependencies = []
-
-[tool.hatch.build.targets.wheel]
-packages = ["."]

package/dist/assets/python/a2a/googleadk/base/README.md

@@ -1,22 +0,0 @@
-# {{ name }}
-
-An A2A (Agent-to-Agent) agent deployed on Amazon Bedrock AgentCore using Google ADK.
-
-## Overview
-
-This agent implements the A2A protocol using Google's Agent Development Kit, enabling agent-to-agent communication.
-
-## Local Development
-
-```bash
-uv sync
-uv run python main.py
-```
-
-The agent starts on port 9000.
-
-## Deploy
-
-```bash
-agentcore deploy
-```

package/dist/assets/python/a2a/googleadk/base/main.py

@@ -1,110 +0,0 @@
-import os
-from google.adk.agents import Agent
-from google.adk.a2a.executor.a2a_agent_executor import A2aAgentExecutor
-from google.adk.runners import Runner
-from google.adk.sessions import InMemorySessionService
-from a2a.types import AgentCapabilities, AgentCard, AgentSkill
-from bedrock_agentcore.runtime import serve_a2a
-from model.load import load_model
-
-load_model()  # Sets GOOGLE_API_KEY env var (returns None)
-
-
-def add_numbers(a: int, b: int) -> int:
-    """Return the sum of two numbers."""
-    return a + b
-
-
-tools = [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
-
-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}"
-
-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}"
-
-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}}
-
-AGENT_INSTRUCTION = """
-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}}
-"""
-
-agent = Agent(
-    model="gemini-2.5-flash",
-    name="{{ name }}",
-    description="A helpful assistant that can use tools.",
-    instruction=AGENT_INSTRUCTION,
-    tools=tools,
-)
-
-runner = Runner(
-    app_name=agent.name,
-    agent=agent,
-    session_service=InMemorySessionService(),
-)
-
-card = AgentCard(
-    name=agent.name,
-    description=agent.description,
-    url="http://localhost:9000/",
-    version="0.1.0",
-    capabilities=AgentCapabilities(streaming=True),
-    skills=[
-        AgentSkill(
-            id="tools",
-            name="tools",
-            description="Use tools to help answer questions",
-            tags=["tools"],
-        )
-    ],
-    default_input_modes=["text"],
-    default_output_modes=["text"],
-)
-
-if __name__ == "__main__":
-    serve_a2a(A2aAgentExecutor(runner=runner), card)

package/dist/assets/python/a2a/googleadk/base/model/load.py

@@ -1,41 +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 Gemini API key authentication.
-    Uses AgentCore Identity for API key management in deployed environments,
-    and falls back to .env file for local development.
-    Sets the GOOGLE_API_KEY environment variable for the Google ADK.
-    """
-    api_key = _get_api_key()
-    # Use Google AI Studios API Key Authentication.
-    # https://google.github.io/adk-docs/agents/models/#google-ai-studio
-    os.environ["GOOGLE_API_KEY"] = api_key
-    # Set to TRUE is using Google Vertex AI, Set to FALSE for Google AI Studio
-    os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "FALSE"

package/dist/assets/python/a2a/googleadk/base/pyproject.toml

@@ -1,20 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "{{ name }}"
-version = "0.1.0"
-description = "AgentCore A2A Agent using Google ADK"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    "a2a-sdk >= 0.2.0",
-    "aws-opentelemetry-distro",
-    "bedrock-agentcore[a2a] >= 1.0.3",
-    "google-adk >= 1.0.0",
-    "google-genai >= 1.0.0",
-]
-
-[tool.hatch.build.targets.wheel]
-packages = ["."]

package/dist/assets/python/a2a/langchain_langgraph/base/README.md

@@ -1,22 +0,0 @@
-# {{ name }}
-
-An A2A (Agent-to-Agent) agent deployed on Amazon Bedrock AgentCore using LangChain + LangGraph.
-
-## Overview
-
-This agent implements the A2A protocol using LangGraph, enabling agent-to-agent communication.
-
-## Local Development
-
-```bash
-uv sync
-uv run python main.py
-```
-
-The agent starts on port 9000.
-
-## Deploy
-
-```bash
-agentcore deploy
-```

package/dist/assets/python/a2a/langchain_langgraph/base/main.py

@@ -1,130 +0,0 @@
-import os
-from langchain_core.tools import tool
-from langgraph.prebuilt import create_react_agent
-from opentelemetry.instrumentation.langchain import LangchainInstrumentor
-from a2a.server.agent_execution import AgentExecutor, RequestContext
-from a2a.server.events import EventQueue
-from a2a.server.tasks import TaskUpdater
-from a2a.types import AgentCapabilities, AgentCard, AgentSkill, Part, TextPart
-from a2a.utils import new_task
-from bedrock_agentcore.runtime import serve_a2a
-from model.load import load_model
-
-LangchainInstrumentor().instrument()
-
-
-@tool
-def add_numbers(a: int, b: int) -> int:
-    """Return the sum of two numbers."""
-    return a + b
-
-
-tools = [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}}
-
-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}}
-"""
-
-model = load_model()
-graph = create_react_agent(model, tools=tools, prompt=SYSTEM_PROMPT)
-
-
-class LangGraphA2AExecutor(AgentExecutor):
-    """Wraps a LangGraph CompiledGraph as an a2a-sdk AgentExecutor."""
-
-    def __init__(self, graph):
-        self.graph = graph
-
-    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
-        task = context.current_task or new_task(context.message)
-        if not context.current_task:
-            await event_queue.enqueue_event(task)
-        updater = TaskUpdater(event_queue, task.id, task.context_id)
-
-        user_text = context.get_user_input()
-        result = await self.graph.ainvoke({"messages": [("user", user_text)]})
-        response = result["messages"][-1].content
-
-        await updater.add_artifact([Part(root=TextPart(text=response))])
-        await updater.complete()
-
-    async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
-        pass
-
-
-card = AgentCard(
-    name="{{ name }}",
-    description="A LangGraph agent on Bedrock AgentCore",
-    url="http://localhost:9000/",
-    version="0.1.0",
-    capabilities=AgentCapabilities(streaming=True),
-    skills=[
-        AgentSkill(
-            id="tools",
-            name="tools",
-            description="Use tools to help answer questions",
-            tags=["tools"],
-        )
-    ],
-    default_input_modes=["text"],
-    default_output_modes=["text"],
-)
-
-if __name__ == "__main__":
-    serve_a2a(LangGraphA2AExecutor(graph), card)

package/dist/assets/python/a2a/langchain_langgraph/base/model/load.py

@@ -1,123 +0,0 @@
-{{#if (eq modelProvider "Bedrock")}}
-from langchain_aws import ChatBedrock
-
-# Uses global inference profile for Claude Sonnet 4.5
-# https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html
-MODEL_ID = "global.anthropic.claude-sonnet-4-5-20250929-v1:0"
-
-
-def load_model() -> ChatBedrock:
-    """Get Bedrock model client using IAM credentials."""
-    return ChatBedrock(model_id=MODEL_ID)
-{{/if}}
-{{#if (eq modelProvider "Anthropic")}}
-import os
-from langchain_anthropic import ChatAnthropic
-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() -> ChatAnthropic:
-    """Get authenticated Anthropic model client."""
-    return ChatAnthropic(
-        model="claude-sonnet-4-5-20250929",
-        api_key=_get_api_key()
-    )
-{{/if}}
-{{#if (eq modelProvider "OpenAI")}}
-import os
-from langchain_openai import ChatOpenAI
-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() -> ChatOpenAI:
-    """Get authenticated OpenAI model client."""
-    return ChatOpenAI(
-        model="gpt-4.1",
-        api_key=_get_api_key()
-    )
-{{/if}}
-{{#if (eq modelProvider "Gemini")}}
-import os
-from langchain_google_genai import ChatGoogleGenerativeAI
-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() -> ChatGoogleGenerativeAI:
-    """Get authenticated Gemini model client."""
-    return ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
-        api_key=_get_api_key()
-    )
-{{/if}}

package/dist/assets/python/a2a/langchain_langgraph/base/pyproject.toml

@@ -1,25 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "{{ name }}"
-version = "0.1.0"
-description = "AgentCore A2A Agent using LangChain + LangGraph"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    "a2a-sdk >= 0.2.0",
-    {{#if (eq modelProvider "Anthropic")}}"langchain-anthropic >= 0.3.0",
-    {{/if}}{{#if (eq modelProvider "Bedrock")}}"langchain-aws >= 0.2.0",
-    {{/if}}{{#if (eq modelProvider "Gemini")}}"langchain-google-genai >= 2.0.0",
-    {{/if}}{{#if (eq modelProvider "OpenAI")}}"langchain-openai >= 0.2.0",
-    {{/if}}"aws-opentelemetry-distro",
-    "opentelemetry-instrumentation-langchain >= 0.59.0",
-    "bedrock-agentcore[a2a] >= 1.0.3",
-    "botocore[crt] >= 1.35.0",
-    "langgraph >= 0.2.0",
-]
-
-[tool.hatch.build.targets.wheel]
-packages = ["."]

package/dist/assets/python/a2a/strands/base/README.md

@@ -1,22 +0,0 @@
-# {{ name }}
-
-An A2A (Agent-to-Agent) agent deployed on Amazon Bedrock AgentCore using Strands SDK.
-
-## Overview
-
-This agent implements the A2A protocol, enabling agent-to-agent communication. Other agents can discover and interact with this agent via the `/.well-known/agent-card.json` endpoint.
-
-## Local Development
-
-```bash
-uv sync
-uv run python main.py
-```
-
-The agent starts on port 9000.
-
-## Deploy
-
-```bash
-agentcore deploy
-```