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

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

@@ -1,176 +0,0 @@
-import os
-from typing import Any
-
-from langchain_core.messages import HumanMessage{{#if hasConfigBundle}}, SystemMessage{{/if}}
-from langgraph.prebuilt import create_react_agent
-from langchain.tools import tool
-{{#if hasConfigBundle}}
-from langchain_core.callbacks import BaseCallbackHandler
-from bedrock_agentcore.runtime.context import BedrockAgentCoreContext
-{{/if}}
-from opentelemetry.instrumentation.langchain import LangchainInstrumentor
-from bedrock_agentcore.runtime import BedrockAgentCoreApp
-from model.load import load_model
-{{#if hasGateway}}
-from mcp_client.client import get_all_gateway_mcp_client
-{{else}}
-from mcp_client.client import get_streamable_http_mcp_client
-{{/if}}
-
-LangchainInstrumentor().instrument()
-
-app = BedrockAgentCoreApp()
-log = app.logger
-
-_llm = None
-
-def get_or_create_model():
-    global _llm
-    if _llm is None:
-        _llm = load_model()
-    return _llm
-
-
-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}}
-"""
-
-
-# Define a simple function tool
-@tool
-def add_numbers(a: int, b: int) -> int:
-    """Return the sum of two numbers"""
-    return a + b
-
-
-# Define a collection of tools used by the model
-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}}
-
-{{#if hasConfigBundle}}
-
-class ConfigBundleCallback(BaseCallbackHandler):
-    """Injects config bundle values into LangGraph agent at runtime.
-
-    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 on_chain_start(self, serialized: dict, inputs: dict, **kwargs: Any) -> None:
-        config = BedrockAgentCoreContext.get_config_bundle()
-        prompt = config.get("systemPrompt", DEFAULT_SYSTEM_PROMPT)
-
-        messages = inputs.get("messages", [])
-        if messages and isinstance(messages[0], SystemMessage):
-            messages[0] = SystemMessage(content=prompt)
-        else:
-            messages.insert(0, SystemMessage(content=prompt))
-        inputs["messages"] = messages
-
-{{/if}}
-
-@app.entrypoint
-async def invoke(payload, context):
-    log.info("Invoking Agent.....")
-
-    # Get MCP Client
-    {{#if hasGateway}}
-    mcp_client = get_all_gateway_mcp_client()
-    {{else}}
-    mcp_client = get_streamable_http_mcp_client()
-    {{/if}}
-
-    # Load MCP Tools
-    mcp_tools = []
-    if mcp_client:
-        mcp_tools = await mcp_client.get_tools()
-
-    # Define the agent using create_react_agent
-{{#if hasConfigBundle}}
-    graph = create_react_agent(get_or_create_model(), tools=mcp_tools + tools, prompt=DEFAULT_SYSTEM_PROMPT)
-    callback = ConfigBundleCallback()
-
-    # Process the user prompt
-    prompt = payload.get("prompt", "What can you help me with?")
-    log.info(f"Agent input: {prompt}")
-
-    # Run the agent with config bundle callback
-    result = await graph.ainvoke(
-        {"messages": [HumanMessage(content=prompt)]},
-        config={"callbacks": [callback]},
-    )
-{{else}}
-    graph = create_react_agent(get_or_create_model(), tools=mcp_tools + tools, prompt=DEFAULT_SYSTEM_PROMPT)
-
-    # Process the user prompt
-    prompt = payload.get("prompt", "What can you help me with?")
-    log.info(f"Agent input: {prompt}")
-
-    # Run the agent
-    result = await graph.ainvoke({"messages": [HumanMessage(content=prompt)]})
-{{/if}}
-
-    # Return result
-    output = result["messages"][-1].content
-    log.info(f"Agent output: {output}")
-    return {"result": output}
-
-
-if __name__ == "__main__":
-    app.run()

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

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

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

@@ -1,77 +0,0 @@
-import os
-import logging
-from langchain_mcp_adapters.client import MultiServerMCPClient
-
-logger = logging.getLogger(__name__)
-
-{{#if hasGateway}}
-{{#if (includes gatewayAuthTypes "AWS_IAM")}}
-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_client() -> MultiServerMCPClient | None:
-    """Returns an MCP Client connected to 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["{{name}}"] = {"transport": "streamable_http", "url": url, "auth": auth}
-        {{else if (eq authType "CUSTOM_JWT")}}
-        token = _get_bearer_token_{{snakeCase name}}()
-        headers = {"Authorization": f"Bearer {token}"} if token else None
-        servers["{{name}}"] = {"transport": "streamable_http", "url": url, "headers": headers}
-        {{else}}
-        servers["{{name}}"] = {"transport": "streamable_http", "url": url}
-        {{/if}}
-    else:
-        logger.warning("{{envVarName}} not set — {{name}} gateway tools unavailable")
-    {{/each}}
-    if not servers:
-        return None
-    return MultiServerMCPClient(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() -> MultiServerMCPClient | 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() -> MultiServerMCPClient:
-    """Returns an MCP Client compatible with LangChain/LangGraph."""
-    # to use an MCP server that supports bearer authentication, add headers={"Authorization": f"Bearer {access_token}"}
-    return MultiServerMCPClient(
-        {
-            "agentcore_gateway": {
-                "transport": "streamable_http",
-                "url": EXAMPLE_MCP_ENDPOINT,
-            }
-        }
-    )
-{{/if}}
-{{/if}}

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

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

package/dist/assets/python/http/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/http/langchain_langgraph/base/pyproject.toml

@@ -1,37 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "{{ name }}"
-version = "0.1.0"
-description = "AgentCore Runtime Application using LangChain/LangGraph"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    "aws-opentelemetry-distro",
-    "opentelemetry-instrumentation-langchain >= 0.59.0",
-    "langgraph >= 1.0.2",
-    "mcp >= 1.19.0",
-    "langchain-mcp-adapters >= 0.1.11",
-    "langchain >= 1.0.3",
-    "bedrock-agentcore >= 1.0.3",
-    "botocore[crt] >= 1.35.0",
-{{#if (eq modelProvider "Bedrock")}}
-    "langchain-aws >= 1.0.0",
-{{/if}}
-{{#if (eq modelProvider "Anthropic")}}
-    "langchain-anthropic >= 1.1.0",
-{{/if}}
-{{#if (eq modelProvider "OpenAI")}}
-    "langchain-openai >= 1.0.3",
-{{/if}}
-{{#if (eq modelProvider "Gemini")}}
-    "langchain-google-genai >= 3.0.3",
-{{/if}}
-    {{#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/openaiagents/base/README.md

@@ -1,39 +0,0 @@
-This is a project generated by the agentcore create CLI tool!
-
-# 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 OpenAI Agents SDK framework running within.
-
-`model/load.py` instantiates your chosen model provider (OpenAI).
-
-## Environment Variables
-
-| Variable | Required | Description |
-| --- | --- | --- |
-{{#if hasIdentity}}| `{{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.
-
-Run `source .venv/bin/activate` before developing.
-
-`agentcore dev` will start a local server on 0.0.0.0:8080.
-
-In a new terminal, you can invoke that server with:
-
-`agentcore invoke --dev "What can you do"`
-
-# Deployment
-
-After providing credentials, `agentcore deploy` will deploy your project into Amazon Bedrock AgentCore.
-
-Use `agentcore invoke` to invoke your deployed agent.

package/dist/assets/python/http/openaiagents/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/http/openaiagents/base/main.py

@@ -1,169 +0,0 @@
-import os
-from agents import Agent, Runner, function_tool
-from bedrock_agentcore.runtime import BedrockAgentCoreApp
-from model.load import load_model
-{{#if hasGateway}}
-from mcp_client.client import get_all_gateway_mcp_servers
-{{else}}
-from mcp_client.client import get_streamable_http_mcp_client
-{{/if}}
-
-app = BedrockAgentCoreApp()
-log = app.logger
-
-# Get MCP Server
-{{#if hasGateway}}
-mcp_servers = get_all_gateway_mcp_servers()
-{{else}}
-mcp_server = get_streamable_http_mcp_client()
-mcp_servers = [mcp_server] if mcp_server else []
-{{/if}}
-
-_credentials_loaded = False
-
-def ensure_credentials_loaded():
-    global _credentials_loaded
-    if not _credentials_loaded:
-        load_model()
-        _credentials_loaded = True
-
-
-# Define a simple function tool
-@function_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
-
-@function_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}"
-
-@function_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}"
-
-@function_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}}
-
-INSTRUCTIONS = """
-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}}
-"""
-
-# Define the agent execution
-async def main(query):
-    ensure_credentials_loaded()
-    try:
-        {{#if hasGateway}}
-        if mcp_servers:
-            agent = Agent(
-                name="{{ name }}",
-                model="gpt-4.1",
-                instructions=INSTRUCTIONS,
-                mcp_servers=mcp_servers,
-                tools=tools
-            )
-            result = await Runner.run(agent, query)
-            return result
-        else:
-            agent = Agent(
-                name="{{ name }}",
-                model="gpt-4.1",
-                instructions=INSTRUCTIONS,
-                mcp_servers=[],
-                tools=tools
-            )
-            result = await Runner.run(agent, query)
-            return result
-        {{else}}
-        if mcp_servers:
-            async with mcp_servers[0] as server:
-                active_servers = [server]
-                agent = Agent(
-                    name="{{ name }}",
-                    model="gpt-4.1",
-                    instructions=INSTRUCTIONS,
-                    mcp_servers=active_servers,
-                    tools=tools
-                )
-                result = await Runner.run(agent, query)
-                return result
-        else:
-            agent = Agent(
-                name="{{ name }}",
-                model="gpt-4.1",
-                instructions=INSTRUCTIONS,
-                mcp_servers=[],
-                tools=tools
-            )
-            result = await Runner.run(agent, query)
-            return result
-        {{/if}}
-    except Exception as e:
-        log.error(f"Error during agent execution: {e}", exc_info=True)
-        raise e
-
-
-@app.entrypoint
-async def invoke(payload, context):
-    log.info("Invoking Agent.....")
-
-    # Process the user prompt
-    prompt = payload.get("prompt", "What can you help me with?")
-
-    # Run the agent
-    result = await main(prompt)
-
-    # Return result
-    return {"result": result.final_output}
-
-
-if __name__ == "__main__":
-    app.run()

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

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