import json

HANDLERS = {
"funding_liquidity": {
"signals": ["repo stress", "money-market spreads", "USD funding", "swap basis"],
"summary": "Check funding stress before treating yield movement as isolated sovereign repricing.",
},
"credit_spread_widening": {
"signals": ["IG spreads", "HY spreads", "CDS indices", "downgrade risk"],
"summary": "Credit spread widening can indicate default-risk repricing or liquidity-premium expansion.",
},
"sovereign_debt_risk_repricing": {
"signals": ["real yields", "fiscal credibility", "policy divergence", "capital flows"],
"summary": "Sovereign repricing should be decomposed into fiscal, policy, flow, and FX drivers.",
},
"currency_mismatch": {
"signals": ["external debt", "FX reserves", "basis swaps", "forward hedging cost"],
"summary": "Currency mismatch can amplify stress when external refinancing conditions tighten.",
},
}


def normalize_tool_name(tool_name):
if not tool_name:
return None
if "___" in tool_name:
tool_name = tool_name.split("___", 1)[1]
if "__" in tool_name and tool_name not in HANDLERS:
candidate = tool_name.split("__", 1)[1]
if candidate in HANDLERS:
tool_name = candidate
return tool_name


def lambda_handler(event, context):
tool_name = (
event.get("name")
or event.get("toolName")
or event.get("tool_name")
)
tool_name = normalize_tool_name(tool_name)

arguments = event.get("arguments") or event.get("input") or {}
query = arguments.get("query", "") if isinstance(arguments, dict) else ""

if tool_name not in HANDLERS:
return {
"statusCode": 400,
"body": json.dumps({
"error": "Unknown or missing tool",
"received_tool_name": tool_name,
"available_tools": sorted(HANDLERS.keys()),
}),
}

result = {
"tool": tool_name,
"query": query,
"signals": HANDLERS[tool_name]["signals"],
"summary": HANDLERS[tool_name]["summary"],
"limitations": [
"Educational engineering output",
"Not investment advice",
"No autonomous trading action",
],
"request_id": context.aws_request_id,
}
return {"statusCode": 200, "body": json.dumps(result)}

cat > tool_schema.json <<'EOF'
[
{
"name": "funding_liquidity",
"description": "Assess repo stress, money-market pressure, USD funding conditions, swap basis, and cash preference before interpreting market repricing.",
"inputSchema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Funding-liquidity analysis request."
}
},
"required": ["query"]
}
},
{
"name": "credit_spread_widening",
"description": "Assess investment-grade and high-yield spread widening, CDS pressure, downgrade risk, default repricing, and liquidity premium.",
"inputSchema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Credit-spread analysis request."
}
},
"required": ["query"]
}
},
{
"name": "sovereign_debt_risk_repricing",
"description": "Assess sovereign debt repricing through fiscal credibility, real yields, policy divergence, capital flows, and foreign-exchange pressure.",
"inputSchema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Sovereign-debt repricing request."
}
},
"required": ["query"]
}
},
{
"name": "currency_mismatch",
"description": "Assess foreign-exchange mismatch, external debt refinancing, reserve adequacy, cross-currency basis, and hedging cost context.",
"inputSchema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Currency-mismatch analysis request."
}
},
"required": ["query"]
}
}
]
EOF
python -m json.tool tool_schema.json > /dev/null && echo "Tool schema is valid JSON"

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "InvokeSovereignRiskToolLambda",
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-1:123456789012:function:sovereign-risk-tool-handler"
}
]
}

export COGNITO_DOMAIN='https://your-domain.auth.us-east-1.amazoncognito.com'
export COGNITO_CLIENT_ID='replace-me'
export COGNITO_CLIENT_SECRET='replace-me'
export COGNITO_SCOPE='replace-with-approved-scope'

export AGENTCORE_GATEWAY_JWT=$(curl -s \
-u "${COGNITO_CLIENT_ID}:${COGNITO_CLIENT_SECRET}" \
-H 'Content-Type: application/x-www-form-urlencoded' \
-d "grant_type=client_credentials&scope=${COGNITO_SCOPE}" \
"${COGNITO_DOMAIN}/oauth2/token" | python -c 'import json,sys; print(json.load(sys.stdin)["access_token"])')

test -n "$AGENTCORE_GATEWAY_JWT" && echo "JWT obtained"

curl -sS "$AGENTCORE_GATEWAY_URL" \
-H "Authorization: Bearer $AGENTCORE_GATEWAY_JWT" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-H "MCP-Protocol-Version: $MCP_PROTOCOL_VERSION" \
-d '{
"jsonrpc": "2.0",
"id": "list-001",
"method": "tools/list",
"params": {}
}'

curl -sS "$AGENTCORE_GATEWAY_URL" \
-H "Authorization: Bearer $AGENTCORE_GATEWAY_JWT" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-H "MCP-Protocol-Version: $MCP_PROTOCOL_VERSION" \
-d '{
"jsonrpc": "2.0",
"id": "search-001",
"method": "tools/call",
"params": {
"name": "x_amz_bedrock_agentcore_search",
"arguments": {
"query": "RMB pressure, external dollar debt, reserve adequacy, and sovereign repricing"
}
}
}'

export SOVEREIGN_TOOL_NAME='replace-with-listed-sovereign-tool-name'

curl -sS "$AGENTCORE_GATEWAY_URL" \
-H "Authorization: Bearer $AGENTCORE_GATEWAY_JWT" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-H "MCP-Protocol-Version: $MCP_PROTOCOL_VERSION" \
-d "{
\"jsonrpc\": \"2.0\",
\"id\": \"call-001\",
\"method\": \"tools/call\",
\"params\": {
\"name\": \"${SOVEREIGN_TOOL_NAME}\",
\"arguments\": {
\"query\": \"US-China yield spread widening, RMB pressure, and capital-flow stress\"
}
}
}"

import os
from strands import Agent
from strands.models import BedrockModel
from strands.tools.mcp import MCPClient
from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client

REGION = os.getenv("AWS_REGION", "us-east-1")
GATEWAY_URL = os.environ["AGENTCORE_GATEWAY_URL"]
MODEL_ID = os.environ["BEDROCK_MODEL_ID"]

mcp_client = MCPClient(
lambda: aws_iam_streamablehttp_client(
endpoint=GATEWAY_URL,
aws_region=REGION,
aws_service="bedrock-agentcore",
)
)

with mcp_client:
tools = mcp_client.list_tools_sync()
print("Loaded tools:")
for tool in tools:
print("-", tool.tool_name)

agent = Agent(
model=BedrockModel(model_id=MODEL_ID, temperature=0.2),
tools=tools,
system_prompt=(
"You are an evidence-first sovereign-risk engineering assistant. "
"Use the smallest sufficient set of Gateway tools. "
"Separate observations, interpretations, confirmation signals, "
"limitations, and invalidation triggers. Do not provide investment "
"advice or autonomous trading instructions."
),
)

result = agent(
"Analyze how wider US-China yield spreads could interact with RMB pressure, "
"sovereign debt repricing, dollar funding, and credit-spread widening."
)
print(result)

import os
from strands import Agent
from strands.models import BedrockModel
from strands.tools.mcp import MCPClient
from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client
from bedrock_agentcore.gateway.integrations.strands.plugins import AgentCoreToolSearchPlugin

REGION = os.getenv("AWS_REGION", "us-east-1")

mcp_client = MCPClient(
lambda: aws_iam_streamablehttp_client(
endpoint=os.environ["AGENTCORE_GATEWAY_URL"],
aws_region=REGION,
aws_service="bedrock-agentcore",
)
)

with mcp_client:
agent = Agent(
model=BedrockModel(
model_id=os.environ["BEDROCK_MODEL_ID"],
temperature=0.2,
),
plugins=[AgentCoreToolSearchPlugin(mcp_client=mcp_client)],
system_prompt=(
"Use semantic discovery to load only evidence tools relevant to the request. "
"Never select execution or trading tools. Clearly state limitations."
),
)
print(agent("Assess RMB pressure and external dollar refinancing risk."))