refactor(gateway): simplify tools to accept direct inputs and switch agent models to Nova

Tools now accept explicit position/player data instead of full game_state.
Agent models updated: DEF/FWD2 → nova-lite, FWD1/GK → nova-micro, MID → nova-pro.
BedrockModel now uses defaults instead of fixed temperature/max_tokens.

Author: William Garcia

agentic-football-sample-agents/ai-team-strands-gateway/ai-def/src/main.py

@@ -48,7 +48,7 @@
 fallback_commands = build_fallback(DEF_CONFIG)
 
 agent, mcp_client = create_gateway_agent(
-    SYSTEM_PROMPT, MY_PLAYER_ID, POSITION_LABEL, model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0"
+    SYSTEM_PROMPT, MY_PLAYER_ID, POSITION_LABEL, model_id="us.amazon.nova-lite-v1:0"
 )
 create_gateway_invoke_handler(
     app, agent, mcp_client, MY_PLAYER_ID, POSITION_LABEL, fallback_commands,

agentic-football-sample-agents/ai-team-strands-gateway/ai-fwd1/src/main.py

@@ -49,7 +49,7 @@
 fallback_commands = build_fallback(FWD1_CONFIG)
 
 agent, mcp_client = create_gateway_agent(
-    SYSTEM_PROMPT, MY_PLAYER_ID, POSITION_LABEL, model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0"
+    SYSTEM_PROMPT, MY_PLAYER_ID, POSITION_LABEL, model_id="us.amazon.nova-micro-v1:0"
 )
 create_gateway_invoke_handler(
     app, agent, mcp_client, MY_PLAYER_ID, POSITION_LABEL, fallback_commands,

agentic-football-sample-agents/ai-team-strands-gateway/ai-fwd2/src/main.py

@@ -49,7 +49,7 @@
 fallback_commands = build_fallback(FWD2_CONFIG)
 
 agent, mcp_client = create_gateway_agent(
-    SYSTEM_PROMPT, MY_PLAYER_ID, POSITION_LABEL, model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0"
+    SYSTEM_PROMPT, MY_PLAYER_ID, POSITION_LABEL, model_id="us.amazon.nova-lite-v1:0"
 )
 create_gateway_invoke_handler(
     app, agent, mcp_client, MY_PLAYER_ID, POSITION_LABEL, fallback_commands,

agentic-football-sample-agents/ai-team-strands-gateway/ai-gk/src/main.py

@@ -47,7 +47,7 @@
 fallback_commands = build_fallback(GK_CONFIG)
 
 agent, mcp_client = create_gateway_agent(
-    SYSTEM_PROMPT, MY_PLAYER_ID, POSITION_LABEL, model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0"
+    SYSTEM_PROMPT, MY_PLAYER_ID, POSITION_LABEL, model_id="us.amazon.nova-micro-v1:0"
 )
 create_gateway_invoke_handler(
     app, agent, mcp_client, MY_PLAYER_ID, POSITION_LABEL, fallback_commands,

agentic-football-sample-agents/ai-team-strands-gateway/ai-mid/src/main.py

@@ -49,7 +49,7 @@
 fallback_commands = build_fallback(MID_CONFIG)
 
 agent, mcp_client = create_gateway_agent(
-    SYSTEM_PROMPT, MY_PLAYER_ID, POSITION_LABEL, model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0"
+    SYSTEM_PROMPT, MY_PLAYER_ID, POSITION_LABEL, model_id="us.amazon.nova-pro-v1:0"
 )
 create_gateway_invoke_handler(
     app, agent, mcp_client, MY_PLAYER_ID, POSITION_LABEL, fallback_commands,

agentic-football-sample-agents/ai-team-strands-gateway/gateway_agent_base.py

@@ -49,11 +49,7 @@ def create_gateway_agent(
       when invoking the agent so tools remain available.
     """
     mcp_client = MCPClient(_create_gateway_transport)
-    model = BedrockModel(
-        model_id=model_id,
-        temperature=0,
-        max_tokens=5000,
-    )
+    model = BedrockModel(model_id=model_id)
 
     # Fetch tool definitions inside the context so the connection is active.
     with mcp_client:

agentic-football-sample-agents/ai-team-strands-gateway/gateway_tools/calculate_pass_options.py

@@ -1,74 +1,58 @@
 """Gateway Tool: calculate_pass_options
 
-Accepts game_state + team_id + player_id from the MCP schema,
-extracts the relevant data, and calculates pass success probability
-for each teammate based on distance and interception risk.
+Given a player's position, teammates, and opponents, calculates pass
+success probability for each teammate based on distance and interception risk.
+
+Deployed as a Lambda behind AgentCore Gateway.
 """
 
 import json
 import math
 
 
-def _distance(p1, p2):
+def _distance(p1: dict, p2: dict) -> float:
     return math.sqrt((p1["x"] - p2["x"]) ** 2 + (p1["y"] - p2["y"]) ** 2)
 
 
-def _player_idx(p):
-    if "agentId" in p:
-        try:
-            return int(p["agentId"].rsplit("_", 1)[-1])
-        except (ValueError, IndexError):
-            return 0
-    return p.get("playerId", 0)
-
-
-def _is_team(p, team_id):
-    if "teamCode" in p:
-        return p["teamCode"] == ("home" if team_id == 0 else "away")
-    return p.get("teamId") == team_id
-
-
-def _interception_risk(passer, receiver, opponents):
+def _interception_risk(passer: dict, receiver: dict, opponents: list[dict]) -> float:
+    """Estimate interception probability (0-1) based on opponents near the pass lane."""
     pass_dist = _distance(passer, receiver)
     if pass_dist < 1:
         return 0.0
+
     dx = receiver["x"] - passer["x"]
     dy = receiver["y"] - passer["y"]
     risk = 0.0
+
     for opp in opponents:
+        # Project opponent onto pass vector
         ox = opp["x"] - passer["x"]
         oy = opp["y"] - passer["y"]
         t = max(0, min(1, (ox * dx + oy * dy) / (pass_dist ** 2)))
-        cx = passer["x"] + t * dx
-        cy = passer["y"] + t * dy
-        d = math.sqrt((opp["x"] - cx) ** 2 + (opp["y"] - cy) ** 2)
-        if d < 8:
-            risk = max(risk, 1.0 - (d / 8.0))
+        closest_x = passer["x"] + t * dx
+        closest_y = passer["y"] + t * dy
+        dist_to_lane = math.sqrt((opp["x"] - closest_x) ** 2 + (opp["y"] - closest_y) ** 2)
+
+        if dist_to_lane < 8:
+            risk = max(risk, 1.0 - (dist_to_lane / 8.0))
+
     return min(risk, 0.95)
 
 
 def lambda_handler(event, context):
+    """Lambda handler — input: passer position, teammates, opponents."""
     body = json.loads(event.get("body", "{}")) if isinstance(event.get("body"), str) else event
 
-    game_state = body.get("game_state", body)
-    team_id = body.get("team_id", 0)
-    player_id = body.get("player_id", 0)
-
-    players = game_state.get("players", [])
-    me = next((p for p in players if _player_idx(p) == player_id and _is_team(p, team_id)), None)
-    passer_pos = me["position"] if me else {"x": 0, "y": 0}
-
-    teammates = [
-        {"player_id": _player_idx(p), "position": p["position"]}
-        for p in players if _is_team(p, team_id) and _player_idx(p) != player_id
-    ]
-    opp_positions = [p["position"] for p in players if not _is_team(p, team_id)]
+    passer_pos = body["passer_position"]
+    teammates = body["teammates"]
+    opponents = body["opponents"]
 
     options = []
     for tm in teammates:
         dist = round(_distance(passer_pos, tm["position"]), 1)
-        risk = _interception_risk(passer_pos, tm["position"], opp_positions)
+        risk = _interception_risk(passer_pos, tm["position"], [o["position"] for o in opponents])
         success = round(max(0.05, 1.0 - risk - (dist / 120.0)), 2)
+
         options.append({
             "player_id": tm["player_id"],
             "distance": dist,
@@ -78,4 +62,8 @@ def lambda_handler(event, context):
         })
 
     options.sort(key=lambda x: x["success_probability"], reverse=True)
-    return {"statusCode": 200, "body": json.dumps({"pass_options": options})}
+
+    return {
+        "statusCode": 200,
+        "body": json.dumps({"pass_options": options}),
+    }

agentic-football-sample-agents/ai-team-strands-gateway/gateway_tools/evaluate_shot.py

@@ -1,89 +1,85 @@
 """Gateway Tool: evaluate_shot
 
-Accepts game_state + team_id + player_id from the MCP schema,
-extracts shooter/GK positions, and evaluates shot success probability.
+Evaluates shot success probability from a given position,
+considering distance to goal, angle, and goalkeeper position.
+
+Deployed as a Lambda behind AgentCore Gateway.
 """
 
 import json
 import math
 
-GOAL_HOME = {"x": -55, "y": 0}
-GOAL_AWAY = {"x": 55, "y": 0}
-GOAL_HALF_WIDTH = 5.0
+# Goal center positions
+GOAL_HOME = {"x": -55, "y": 0}  # HOME team's goal
+GOAL_AWAY = {"x": 55, "y": 0}   # AWAY team's goal
+GOAL_HALF_WIDTH = 5.0  # approximate half-width of goal
 
 
-def _distance(p1, p2):
+def _distance(p1: dict, p2: dict) -> float:
     return math.sqrt((p1["x"] - p2["x"]) ** 2 + (p1["y"] - p2["y"]) ** 2)
 
 
-def _player_idx(p):
-    if "agentId" in p:
-        try:
-            return int(p["agentId"].rsplit("_", 1)[-1])
-        except (ValueError, IndexError):
-            return 0
-    return p.get("playerId", 0)
-
-
-def _is_team(p, team_id):
-    if "teamCode" in p:
-        return p["teamCode"] == ("home" if team_id == 0 else "away")
-    return p.get("teamId") == team_id
-
-
 def lambda_handler(event, context):
+    """Lambda handler — input: shooter position, GK position, team side."""
     body = json.loads(event.get("body", "{}")) if isinstance(event.get("body"), str) else event
 
-    game_state = body.get("game_state", body)
-    team_id = body.get("team_id", 0)
-    player_id = body.get("player_id", 0)
-
-    players = game_state.get("players", [])
-    me = next((p for p in players if _player_idx(p) == player_id and _is_team(p, team_id)), None)
-    shooter = me["position"] if me else {"x": 0, "y": 0}
+    shooter = body["shooter_position"]
+    gk_pos = body["goalkeeper_position"]
+    team_side = body.get("team_side", "HOME")
+    blockers = body.get("blocker_positions", [])
 
-    # Opponent GK is player index 0 on the other team
-    opp_gk = next((p for p in players if _player_idx(p) == 0 and not _is_team(p, team_id)), None)
-    gk_pos = opp_gk["position"] if opp_gk else {"x": 50, "y": 0}
-
-    team_side = "HOME" if team_id == 0 else "AWAY"
+    # Target goal (opponent's goal)
     goal = GOAL_AWAY if team_side == "HOME" else GOAL_HOME
 
-    # Blockers: opponents near the shooting lane (excluding GK)
-    blockers = [p["position"] for p in players if not _is_team(p, team_id) and _player_idx(p) != 0]
-
     dist_to_goal = _distance(shooter, goal)
     dist_gk_to_goal = _distance(gk_pos, goal)
 
+    # Angle factor: wider angle = better chance
+    dy = abs(shooter["y"])
     angle_to_goal = math.atan2(GOAL_HALF_WIDTH, dist_to_goal)
     angle_factor = min(1.0, angle_to_goal / 0.15)
+
+    # Distance factor: closer = better
     distance_factor = max(0.0, 1.0 - (dist_to_goal / 55.0))
+
+    # GK positioning factor: GK off-center = better chance
     gk_offset = abs(gk_pos["y"])
     gk_factor = min(1.0, gk_offset / 8.0) * 0.3
+
+    # GK distance factor: GK far from goal = better
     gk_dist_factor = min(1.0, dist_gk_to_goal / 15.0) * 0.2
 
+    # Blocker penalty
     blocker_penalty = 0.0
     for b in blockers:
         b_dist = _distance(shooter, b)
         if b_dist < 10:
             blocker_penalty += (10 - b_dist) / 10.0 * 0.15
     blocker_penalty = min(blocker_penalty, 0.4)
 
-    probability = round(max(0.02, min(0.95,
-        (distance_factor * 0.45) + (angle_factor * 0.25) + gk_factor + gk_dist_factor - blocker_penalty
-    )), 2)
+    probability = round(
+        max(0.02, min(0.95,
+            (distance_factor * 0.45) + (angle_factor * 0.25) + gk_factor + gk_dist_factor - blocker_penalty
+        )), 2
+    )
 
+    # Recommend aim location based on GK position
     if gk_pos["y"] > 1:
         aim = "BL" if shooter["y"] > 0 else "BR"
     elif gk_pos["y"] < -1:
         aim = "TL" if shooter["y"] > 0 else "TR"
     else:
         aim = "TR" if shooter["y"] <= 0 else "TL"
 
-    return {"statusCode": 200, "body": json.dumps({
-        "success_probability": probability,
-        "distance_to_goal": round(dist_to_goal, 1),
-        "recommended_aim": aim,
-        "recommended_power": round(min(1.0, 0.6 + (dist_to_goal / 80.0)), 2),
-        "should_shoot": probability > 0.25,
-    })}
+    recommended_power = round(min(1.0, 0.6 + (dist_to_goal / 80.0)), 2)
+
+    return {
+        "statusCode": 200,
+        "body": json.dumps({
+            "success_probability": probability,
+            "distance_to_goal": round(dist_to_goal, 1),
+            "recommended_aim": aim,
+            "recommended_power": recommended_power,
+            "should_shoot": probability > 0.25,
+        }),
+    }