agentcore-cli 0.31.1__py3-none-any.whl

agentcore/assets/evaluators/autoevals-lambda/lambda_function.py

@@ -0,0 +1,37 @@
+{{#if ModelProviderBedrock}}
+import os
+
+# litellm's Bedrock provider reads AWS_REGION_NAME; Lambda only sets AWS_REGION/AWS_DEFAULT_REGION.
+os.environ.setdefault("AWS_REGION_NAME", os.environ.get("AWS_REGION", "us-west-2"))
+
+from autoevals import {{ EvaluatorClass }}, init
+from autoevals.litellm import LiteLLMClient
+
+from bedrock_agentcore.evaluation.custom_code_based_evaluators import (
+    EvaluatorInput,
+    EvaluatorOutput,
+    custom_code_based_evaluator,
+)
+from bedrock_agentcore.evaluation.custom_code_based_evaluators.third_party.autoevals import AutoEvalsAdapter
+
+client = LiteLLMClient()
+init(client=client, default_model="{{ Model }}")
+
+adapter = AutoEvalsAdapter(metric={{ EvaluatorClass }}(client=client, model="{{ Model }}"){{#if EvaluatorParams}}, {{{ EvaluatorParams }}}{{/if}})
+{{else}}
+from autoevals import {{ EvaluatorClass }}
+
+from bedrock_agentcore.evaluation.custom_code_based_evaluators import (
+    EvaluatorInput,
+    EvaluatorOutput,
+    custom_code_based_evaluator,
+)
+from bedrock_agentcore.evaluation.custom_code_based_evaluators.third_party.autoevals import AutoEvalsAdapter
+
+adapter = AutoEvalsAdapter(metric={{ EvaluatorClass }}({{#if Model}}model="{{ Model }}"{{/if}}){{#if EvaluatorParams}}, {{{ EvaluatorParams }}}{{/if}})
+{{/if}}
+
+
+@custom_code_based_evaluator()
+def handler(evaluator_input: EvaluatorInput, context) -> EvaluatorOutput:
+    return adapter(evaluator_input, context)

agentcore/assets/evaluators/autoevals-lambda/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ Name }}"
+version = "0.1.0"
+description = "AgentCore Code-Based Evaluator (Autoevals)"
+requires-python = ">=3.10"
+dependencies = [
+    "bedrock-agentcore[autoevals]",
+    "autoevals>=0.0.80,<1.0.0",
+{{#if ModelProviderBedrock}}
+    # autoevals grades via LiteLLMClient -> Bedrock (Converse); litellm replaces the openai judge
+    "litellm>=1.60,<1.85",
+{{else}}
+    "openai>=1.0.0",
+{{/if}}
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]

agentcore/assets/evaluators/deepeval-lambda/execution-role-policy.json

@@ -0,0 +1,15 @@
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"],
+      "Resource": "arn:*:logs:*:*:log-group:/aws/lambda/*"
+    },
+    {
+      "Effect": "Allow",
+      "Action": ["bedrock:InvokeModel"],
+      "Resource": "*"
+    }
+  ]
+}

agentcore/assets/evaluators/deepeval-lambda/lambda_function.py

@@ -0,0 +1,29 @@
+import os
+
+os.environ.setdefault("DEEPEVAL_RESULTS_FOLDER", "/tmp/.deepeval")
+os.environ.setdefault("DEEPEVAL_TELEMETRY_OPT_OUT", "YES")
+os.chdir("/tmp")
+
+{{#if ModelProviderBedrock}}
+from deepeval.models import AmazonBedrockModel
+{{/if}}
+from deepeval.metrics import {{ EvaluatorClass }}
+
+from bedrock_agentcore.evaluation.custom_code_based_evaluators import (
+    EvaluatorInput,
+    EvaluatorOutput,
+    custom_code_based_evaluator,
+)
+from bedrock_agentcore.evaluation.custom_code_based_evaluators.third_party.deepeval import DeepEvalAdapter
+
+{{#if ModelProviderBedrock}}
+model = AmazonBedrockModel(model="{{ Model }}", region=os.environ.get("AWS_REGION", "us-west-2"))
+adapter = DeepEvalAdapter(metric={{ EvaluatorClass }}(model=model{{#if EvaluatorParams}}, {{{ EvaluatorParams }}}{{/if}}))
+{{else}}
+adapter = DeepEvalAdapter(metric={{ EvaluatorClass }}({{{ EvaluatorParams }}}))
+{{/if}}
+
+
+@custom_code_based_evaluator()
+def handler(evaluator_input: EvaluatorInput, context) -> EvaluatorOutput:
+    return adapter(evaluator_input, context)

agentcore/assets/evaluators/deepeval-lambda/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ Name }}"
+version = "0.1.0"
+description = "AgentCore Code-Based Evaluator (DeepEval)"
+requires-python = ">=3.10"
+dependencies = [
+    "bedrock-agentcore[deepeval]",
+    "deepeval>=2.0.0,<3.0.0",
+{{#if ModelProviderBedrock}}
+    "aiobotocore>=2.13.0",
+{{/if}}
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]

agentcore/assets/evaluators/python-lambda/execution-role-policy.json

@@ -0,0 +1,10 @@
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"],
+      "Resource": "arn:*:logs:*:*:log-group:/aws/lambda/*"
+    }
+  ]
+}

agentcore/assets/evaluators/python-lambda/lambda_function.py

@@ -0,0 +1,19 @@
+from bedrock_agentcore.evaluation.custom_code_based_evaluators import (
+    custom_code_based_evaluator,
+    EvaluatorInput,
+    EvaluatorOutput,
+)
+
+
+@custom_code_based_evaluator()
+def handler(input: EvaluatorInput, context) -> EvaluatorOutput:
+    """Evaluate agent behavior with custom logic.
+
+    Args:
+        input: Contains evaluation_level, session_spans, target_trace_id, target_span_id
+
+    Returns:
+        EvaluatorOutput with value/label for success, or errorCode/errorMessage for failure.
+    """
+    # TODO: Replace with your evaluation logic
+    return EvaluatorOutput(value=1.0, label="Pass", explanation="Evaluation passed")

agentcore/assets/evaluators/python-lambda/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ Name }}"
+version = "0.1.0"
+description = "AgentCore Code-Based Evaluator"
+requires-python = ">=3.10"
+dependencies = [
+    "bedrock-agentcore>=1.6.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]

agentcore/assets/harness/invoke.py.template

@@ -0,0 +1,74 @@
+"""
+Standalone invoke script for AgentCore Harness.
+Generated by: agentcore create --with-invoke-script
+
+Usage:
+  pip install boto3
+  export HARNESS_ARN="arn:aws:bedrock-agentcore:<region>:<account>:harness/<harness-id>"
+  python invoke.py "Hello, what can you do?"
+  python invoke.py --raw-events "Hello"
+"""
+
+import argparse
+import json
+import os
+import sys
+import uuid
+
+import boto3
+
+# --- Configuration ---
+HARNESS_ARN = os.environ.get("HARNESS_ARN", "{{HARNESS_ARN}}")
+REGION = os.environ.get("AWS_REGION", "{{REGION}}")
+SESSION_ID = os.environ.get("SESSION_ID", str(uuid.uuid4()))
+
+parser = argparse.ArgumentParser(description="Invoke an AgentCore Harness")
+parser.add_argument("prompt", nargs="?", default="Hello!", help="Prompt to send to the agent")
+parser.add_argument("--raw-events", action="store_true", help="Print raw streaming events as JSON")
+parser.add_argument("--session-id", default=SESSION_ID, help="Session ID for conversation continuity")
+args = parser.parse_args()
+
+client = boto3.client("bedrock-agentcore", region_name=REGION)
+
+response = client.invoke_harness(
+    harnessArn=HARNESS_ARN,
+    runtimeSessionId=args.session_id,
+    messages=[
+        {
+            "role": "user",
+            "content": [{"text": args.prompt}],
+        }
+    ],
+)
+
+for event in response["stream"]:
+    if args.raw_events:
+        print(json.dumps(event, default=str))
+    else:
+        if "contentBlockStart" in event:
+            start = event["contentBlockStart"].get("start", {})
+            if "toolUse" in start:
+                tool = start["toolUse"]
+                print(f"\n🔧 Tool: {tool.get('name', 'unknown')}", flush=True)
+        elif "contentBlockDelta" in event:
+            delta = event["contentBlockDelta"].get("delta", {})
+            if "text" in delta:
+                print(delta["text"], end="", flush=True)
+        elif "messageStop" in event:
+            stop_reason = event["messageStop"].get("stopReason", "")
+            if stop_reason == "end_turn":
+                print()
+        elif "metadata" in event:
+            usage = event["metadata"].get("usage", {})
+            metrics = event["metadata"].get("metrics", {})
+            latency = metrics.get("latencyMs", 0) / 1000
+            print(
+                f"\n⚡ {usage.get('inputTokens', 0)} in · "
+                f"{usage.get('outputTokens', 0)} out · "
+                f"{latency:.1f}s",
+                file=sys.stderr,
+            )
+        elif "internalServerException" in event:
+            print(f"\nError: {event['internalServerException']}", file=sys.stderr)
+
+print(f"\n🔗 Session: {args.session_id}", file=sys.stderr)

agentcore/assets/mcp/python/README.md

@@ -0,0 +1,27 @@
+# {{ name }}
+
+This is a template MCP server generated by the AgentCore CLI.
+
+Demonstrates HTTP tool patterns with proper error handling and retry logic.
+
+## Quick Start
+
+```bash
+# Create and activate virtual environment
+uv venv
+source .venv/bin/activate  # or .venv\Scripts\activate on Windows
+
+# Install dependencies
+uv sync
+
+# Run the server
+uv run server.py
+```
+
+## Available Tools
+
+| Tool              | Description                                            |
+| ----------------- | ------------------------------------------------------ |
+| `lookup_ip`       | Look up geolocation and network info for an IP address |
+| `get_random_user` | Generate a random user profile for testing             |
+| `fetch_post`      | Fetch a post by ID from JSONPlaceholder API            |

agentcore/assets/mcp/python/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ name }}"
+version = "0.1.0"
+description = "MCP Server demonstrating HTTP tool patterns"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp[cli] >= 1.28.1, < 2.0.0",
+    "httpx >= 0.27.0",
+    "opentelemetry-distro",
+    "opentelemetry-exporter-otlp",
+]
+
+[project.scripts]
+server = "server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]

agentcore/assets/mcp/python/server.py

@@ -0,0 +1,117 @@
+"""
+MCP Server demonstrating HTTP tool patterns.
+
+This template shows:
+- Async HTTP boundaries with proper error handling
+- Retry logic and partial failure
+- Response parsing and validation
+
+Run with: uv run server.py
+"""
+
+import logging
+from typing import Any
+
+import httpx
+from mcp.server.fastmcp import FastMCP
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+mcp = FastMCP("tools")
+
+HTTP_TIMEOUT = 10.0
+MAX_RETRIES = 2
+
+
+async def fetch_json(url: str, headers: dict[str, str] | None = None) -> dict[str, Any] | None:
+    """Make an HTTP GET request with retry logic."""
+    async with httpx.AsyncClient() as client:
+        for attempt in range(MAX_RETRIES):
+            try:
+                response = await client.get(url, headers=headers, timeout=HTTP_TIMEOUT)
+                response.raise_for_status()
+                return response.json()
+            except httpx.TimeoutException:
+                logger.warning(f"Timeout on attempt {attempt + 1} for {url}")
+            except httpx.HTTPStatusError as e:
+                logger.error(f"HTTP {e.response.status_code} for {url}")
+                return None
+            except httpx.RequestError as e:
+                logger.error(f"Request failed: {e}")
+                return None
+    return None
+
+
+@mcp.tool()
+async def lookup_ip(ip_address: str) -> str:
+    """Look up geolocation and network info for an IP address.
+
+    Args:
+        ip_address: IPv4 or IPv6 address to look up
+    """
+    data = await 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']}"
+    )
+
+
+@mcp.tool()
+async def get_random_user() -> str:
+    """Generate a random user profile for testing or mock data."""
+    data = await 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']}"
+    )
+
+
+@mcp.tool()
+async def fetch_post(post_id: int) -> str:
+    """Fetch a post by ID from JSONPlaceholder API.
+
+    Args:
+        post_id: The post ID (1-100)
+    """
+    if not 1 <= post_id <= 100:
+        return "Post ID must be between 1 and 100."
+
+    data = await 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']}"
+    )
+
+
+def main():
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

agentcore/assets/mcp/python-lambda/README.md

@@ -0,0 +1,22 @@
+# {{ Name }}
+
+Lambda-based tools for AgentCore Gateway.
+
+## Tools
+
+- `lookup_ip` - Look up geolocation for an IP address
+- `get_random_user` - Generate random user profile
+- `fetch_post` - Fetch a post by ID
+
+## Gateway Integration
+
+Tools are invoked via AgentCore Gateway. The tool name is passed in:
+`context.client_context.custom["bedrockAgentCoreToolName"]`
+
+Format: `{target_name}___{tool_name}`
+
+## Adding New Tools
+
+1. Define the tool function with the `@tool("tool_name")` decorator
+2. Add the tool definition to `mcp-defs.json` in your agentcore project
+3. The tool will be automatically routed by the handler

agentcore/assets/mcp/python-lambda/handler.py

@@ -0,0 +1,144 @@
+"""
+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']}"
+    )

agentcore/assets/mcp/python-lambda/pyproject.toml

@@ -0,0 +1,15 @@
+[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 = ["."]

agentcore/assets/python/a2a/googleadk/base/README.md

@@ -0,0 +1,22 @@
+# {{ 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
+```

agentcore/assets/python/a2a/googleadk/base/gitignore.template

@@ -0,0 +1,41 @@
+# 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