agentcore-cli 0.31.1__py3-none-any.whl

agentcore/operations/dev/web_ui/handlers/invocations.py

@@ -0,0 +1,327 @@
+"""POST /invocations (port of handlers/invocations.ts): proxy to local agents or invoke deployed ones."""
+
+import codecs
+import http.client
+import itertools
+import json
+import uuid
+from typing import Any
+
+from agentcore.operations.dev._http import fetch
+from agentcore.operations.dev._server import Request, Response, js_dumps
+from agentcore.operations.dev.invoke_a2a import extract_sse_event_text, extract_task_text, is_status_update_event
+from agentcore.operations.dev.sse_transform import pipe_sse_transformed
+from agentcore.operations.dev.web_ui.handlers._common import send_json
+from agentcore.operations.dev.web_ui.handlers._deployed import resolve_deployed
+from agentcore.operations.dev.web_ui.handlers.harness_invocation import handle_harness_invocation
+
+_a2a_request_ids = itertools.count(1)
+
+_SSE_HEADERS = {"Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive"}
+
+
+def _iter_response(resp: http.client.HTTPResponse):  # type: ignore[no-untyped-def]
+    while chunk := resp.read1(8192):
+        yield chunk
+
+
+def _proxy_post(
+    ctx: Any,
+    res: Response,
+    origin: str | None,
+    port: int,
+    headers: dict[str, str],
+    body: str,
+    session_id: str | None,
+    transform_sse: bool,
+    error_label: str,
+) -> None:
+    conn = http.client.HTTPConnection("127.0.0.1", port)
+    try:
+        try:
+            conn.request("POST", "/invocations", body=body.encode("utf-8"), headers=headers)
+            agent_res = conn.getresponse()
+        except OSError as err:
+            if not res.headers_sent:
+                send_json(ctx, res, origin, 502, {"success": False, "error": f"{error_label}: {err}"})
+            return
+        content_type = agent_res.getheader("content-type") or "text/plain"
+        ctx.set_cors_headers(res, origin)
+        response_headers = {"Content-Type": content_type}
+        if session_id:
+            response_headers["x-session-id"] = session_id
+        res.write_head(agent_res.status or 200, response_headers)
+        if transform_sse and "text/event-stream" in content_type:
+            pipe_sse_transformed(_iter_response(agent_res), res.write, res.end)
+        else:
+            for chunk in _iter_response(agent_res):
+                res.write(chunk)
+            res.end()
+    finally:
+        conn.close()
+
+
+def handle_invocations(ctx: Any, req: Request, res: Response, origin: str | None = None) -> None:
+    from agentcore.operations.dev.web_ui.web_server import parse_request_url
+
+    _, param = parse_request_url(req)
+    if param("target") == "deployed":
+        handle_deployed_invocation(ctx, req, res, origin)
+        return
+
+    body = ctx.read_body(req)
+    parsed: dict[str, Any] | None = None
+    try:
+        loaded = json.loads(body)
+        parsed = loaded if isinstance(loaded, dict) else None
+    except ValueError:
+        pass
+    if parsed and parsed.get("harnessName"):
+        handle_harness_invocation(ctx, parsed, res, origin)
+        return
+
+    agent_port = agent_protocol = agent_name = session_id = user_id = None
+    if parsed is not None:
+        agent_name = parsed.get("agentName")
+        session_id = parsed.get("sessionId") or str(uuid.uuid4())
+        user_id = parsed.get("userId")
+        if agent_name:
+            running = ctx.running_agents.get(agent_name)
+            if running:
+                agent_port, agent_protocol = running.port, running.protocol
+
+    if agent_name:
+        ctx.agent_errors.pop(agent_name, None)
+
+    if agent_port is None:  # fall back to the first running agent
+        first = next(iter(list(ctx.running_agents.values())), None)
+        if first:
+            agent_port, agent_protocol = first.port, first.protocol
+
+    if agent_port is None:
+        send_json(
+            ctx, res, origin, 409, {"success": False, "error": "No agent is running. Call POST /api/start first."}
+        )
+        return
+
+    if agent_protocol == "A2A":
+        _handle_a2a_invocation(ctx, res, body, agent_port, session_id, origin)
+        return
+    if agent_protocol == "AGUI":
+        _handle_agui_invocation(ctx, res, body, agent_port, session_id, user_id, origin)
+        return
+
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "text/event-stream, */*",
+        "x-amzn-bedrock-agentcore-runtime-session-id": session_id or str(uuid.uuid4()),
+    }
+    if user_id:
+        headers["x-amzn-bedrock-agentcore-runtime-user-id"] = user_id
+    _proxy_post(ctx, res, origin, agent_port, headers, body, session_id, True, "Agent server error")
+
+
+def _prompt_of(raw: str) -> str:
+    try:
+        parsed = json.loads(raw)
+        return (parsed.get("prompt") if isinstance(parsed, dict) else None) or ""
+    except ValueError:
+        return ""
+
+
+def _handle_a2a_invocation(
+    ctx: Any, res: Response, raw_body: str, agent_port: int, session_id: str | None, origin: str | None
+) -> None:
+    prompt = _prompt_of(raw_body)
+    if not prompt:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "prompt is required"})
+        return
+    message: dict[str, Any] = {
+        "messageId": str(uuid.uuid4()),
+        "role": "user",
+        "parts": [{"kind": "text", "text": prompt}],
+    }
+    if session_id:
+        message["contextId"] = session_id
+    a2a_body = {
+        "jsonrpc": "2.0",
+        "id": next(_a2a_request_ids),
+        "method": "message/stream",
+        "params": {"message": message},
+    }
+    try:
+        agent_res = fetch(
+            f"http://127.0.0.1:{agent_port}/",
+            method="POST",
+            headers={"Content-Type": "application/json", "Accept": "text/event-stream"},
+            body=json.dumps(a2a_body),
+        )
+    except Exception as err:  # noqa: BLE001
+        send_json(ctx, res, origin, 502, {"success": False, "error": f"A2A agent error: {err}"})
+        return
+    if not agent_res.ok:
+        agent_res.close()
+        send_json(ctx, res, origin, 502, {"success": False, "error": f"A2A agent returned {agent_res.status}"})
+        return
+
+    content_type = agent_res.header("content-type") or ""
+    ctx.set_cors_headers(res, origin)
+    if "text/event-stream" in content_type:
+        headers = dict(_SSE_HEADERS)
+        if session_id:
+            headers["x-session-id"] = session_id
+        res.write_head(200, headers)
+        decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
+        buffer = ""
+        streamed_from_status = False
+        for chunk in agent_res.iter_chunks():
+            buffer += decoder.decode(chunk)
+            lines = buffer.split("\n")
+            buffer = lines.pop()
+            for line in lines:
+                if not line.startswith("data: "):
+                    continue
+                data = line[6:].strip()
+                if not data:
+                    continue
+                try:
+                    event = json.loads(data)
+                    if not isinstance(event, dict):
+                        raise ValueError
+                    text = extract_sse_event_text(event, streamed_from_status)
+                except (ValueError, AttributeError, TypeError):
+                    res.write(f"data: {js_dumps(data)}\n\n")
+                    continue
+                if text:
+                    if is_status_update_event(event):
+                        streamed_from_status = True
+                    res.write(f"data: {js_dumps(text)}\n\n")
+        res.end()
+        return
+
+    response_text = agent_res.text()
+    try:
+        parsed = json.loads(response_text)
+        if not isinstance(parsed, dict):
+            raise ValueError
+    except ValueError:
+        res.write_head(200, {"Content-Type": "text/plain"})
+        res.end(response_text)
+        return
+    result = parsed.get("result")
+    if result:
+        text = (extract_task_text(result) if isinstance(result, dict) else None) or json.dumps(
+            result, indent=2, ensure_ascii=False
+        )
+    else:
+        text = response_text
+    res.write_head(200, {"Content-Type": "text/event-stream"})
+    res.write(f"data: {js_dumps(text)}\n\n")
+    res.end()
+
+
+def _handle_agui_invocation(
+    ctx: Any,
+    res: Response,
+    raw_body: str,
+    agent_port: int,
+    session_id: str | None,
+    user_id: str | None,
+    origin: str | None,
+) -> None:
+    from agentcore.aws.agui_types import build_agui_run_input
+
+    prompt = _prompt_of(raw_body)
+    if not prompt:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "prompt is required"})
+        return
+    agui_body = json.dumps(build_agui_run_input(prompt, session_id))
+    headers = {"Content-Type": "application/json", "Accept": "text/event-stream"}
+    if session_id:
+        headers["x-amzn-bedrock-agentcore-runtime-session-id"] = session_id
+    if user_id:
+        headers["x-amzn-bedrock-agentcore-runtime-user-id"] = user_id
+    _proxy_post(ctx, res, origin, agent_port, headers, agui_body, session_id, False, "AGUI agent error")
+
+
+def handle_deployed_invocation(ctx: Any, req: Request, res: Response, origin: str | None = None) -> None:
+    if not ctx.options.config_root:
+        send_json(ctx, res, origin, 404, {"success": False, "error": "No agentcore project found"})
+        return
+    raw = ctx.read_body(req)
+    try:
+        parsed = json.loads(raw)
+        if not isinstance(parsed, dict):
+            raise ValueError
+    except ValueError:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "Invalid JSON body"})
+        return
+    prompt = parsed.get("prompt")
+    if not prompt:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "prompt is required"})
+        return
+    session_id = parsed.get("sessionId")
+    user_id = parsed.get("userId")
+    resolved = resolve_deployed(ctx, res, origin, parsed.get("agentName"), parsed.get("targetName"), session_id)
+    if resolved is None:
+        return
+    session_id = session_id or resolved.session_id or str(uuid.uuid4())
+
+    from agentcore.aws import agentcore as aws_agentcore
+    from agentcore.aws.agui_types import build_agui_run_input
+
+    try:
+        protocol = getattr(resolved.agent_spec, "protocol", None) or "HTTP"
+        if protocol == "A2A":
+            result = aws_agentcore.invoke_a2a_runtime(
+                aws_agentcore.A2AInvokeOptions(
+                    region=resolved.region,
+                    runtime_arn=resolved.runtime_arn,
+                    user_id=user_id,
+                    session_id=session_id,
+                    bearer_token=resolved.bearer_token,
+                ),
+                prompt,
+            )
+            stream, result_session = result.stream, result.session_id
+        elif protocol == "AGUI":
+            result = aws_agentcore.invoke_agui_runtime(
+                aws_agentcore.AguiInvokeOptions(
+                    region=resolved.region,
+                    runtime_arn=resolved.runtime_arn,
+                    session_id=session_id,
+                    user_id=user_id,
+                    bearer_token=resolved.bearer_token,
+                ),
+                build_agui_run_input(prompt, session_id),
+            )
+            stream, result_session = result.text_stream, result.session_id
+        else:
+            result = aws_agentcore.invoke_agent_runtime_streaming(
+                aws_agentcore.InvokeAgentRuntimeOptions(
+                    region=resolved.region,
+                    runtime_arn=resolved.runtime_arn,
+                    payload=prompt,
+                    session_id=session_id,
+                    user_id=user_id,
+                    bearer_token=resolved.bearer_token,
+                    baggage=resolved.baggage,
+                )
+            )
+            stream, result_session = result.stream, result.session_id
+
+        ctx.set_cors_headers(res, origin)
+        headers = dict(_SSE_HEADERS)
+        if result_session:
+            headers["x-session-id"] = result_session
+        res.write_head(200, headers)
+        try:
+            for chunk in stream:
+                res.write(f"data: {js_dumps(chunk)}\n\n")
+        except Exception as err:  # noqa: BLE001
+            res.write(f"data: {js_dumps({'error': str(err)})}\n\n")
+        finally:
+            res.end()
+    except Exception as err:  # noqa: BLE001
+        if not res.headers_sent:
+            send_json(ctx, res, origin, 502, {"success": False, "error": f"Invoke failed: {err}"})

agentcore/operations/dev/web_ui/handlers/mcp_proxy.py

@@ -0,0 +1,119 @@
+"""POST /api/mcp (port of handlers/mcp-proxy.ts)."""
+
+import json
+from typing import Any
+
+from agentcore.operations.dev._http import fetch
+from agentcore.operations.dev._server import Request, Response, js_dumps
+from agentcore.operations.dev.web_ui.handlers._common import send_json
+from agentcore.operations.dev.web_ui.handlers._deployed import resolve_deployed
+
+
+def handle_mcp_proxy(ctx: Any, req: Request, res: Response, origin: str | None = None) -> None:
+    from agentcore.operations.dev.web_ui.web_server import parse_request_url
+
+    _, param = parse_request_url(req)
+    if param("target") == "deployed":
+        _handle_deployed_mcp_proxy(ctx, req, res, origin)
+        return
+
+    ctx.set_cors_headers(res, origin)
+    try:
+        parsed = json.loads(ctx.read_body(req))
+        if not isinstance(parsed, dict):
+            raise ValueError
+    except ValueError:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "Invalid JSON"}, False)
+        return
+    agent_name, body, session_id = parsed.get("agentName"), parsed.get("body"), parsed.get("sessionId")
+    if not agent_name:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "agentName is required"}, False)
+        return
+    if not body:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "body is required"}, False)
+        return
+    running = ctx.running_agents.get(agent_name)
+    if not running:
+        send_json(ctx, res, origin, 400, {"success": False, "error": f'Agent "{agent_name}" is not running'}, False)
+        return
+    headers = {"Content-Type": "application/json", "Accept": "application/json, text/event-stream"}
+    if session_id:
+        headers["mcp-session-id"] = session_id
+    try:
+        mcp_res = fetch(f"http://localhost:{running.port}/mcp", method="POST", headers=headers, body=json.dumps(body))
+    except Exception as err:  # noqa: BLE001
+        error = f"Failed to connect to MCP agent: {err}"
+        send_json(ctx, res, origin, 502, {"success": False, "error": error}, False)
+        return
+    if not mcp_res.ok:
+        mcp_res.close()
+        error = f"MCP server returned status {mcp_res.status}"
+        send_json(ctx, res, origin, 502, {"success": False, "error": error}, False)
+        return
+    text = mcp_res.text()
+    response_session = mcp_res.header("mcp-session-id") or None
+    try:
+        result: Any = json.loads(text)
+    except ValueError:
+        result = text
+    send_json(ctx, res, origin, 200, {"success": True, "result": result, "sessionId": response_session}, False)
+
+
+def _handle_deployed_mcp_proxy(ctx: Any, req: Request, res: Response, origin: str | None) -> None:
+    if not ctx.options.config_root:
+        send_json(ctx, res, origin, 404, {"success": False, "error": "No agentcore project found"})
+        return
+    try:
+        parsed = json.loads(ctx.read_body(req))
+        if not isinstance(parsed, dict):
+            raise ValueError
+    except ValueError:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "Invalid JSON"})
+        return
+    body, session_id = parsed.get("body"), parsed.get("sessionId")
+    if not body:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "body is required"})
+        return
+    resolved = resolve_deployed(ctx, res, origin, parsed.get("agentName"), parsed.get("targetName"), session_id)
+    if resolved is None:
+        return
+
+    from agentcore.aws import agentcore as aws_agentcore
+
+    opts = aws_agentcore.McpInvokeOptions(
+        region=resolved.region,
+        runtime_arn=resolved.runtime_arn,
+        bearer_token=resolved.bearer_token,
+        mcp_session_id=session_id,
+    )
+    method = body.get("method") if isinstance(body, dict) else None
+    try:
+        if method == "initialize":
+            mcp_session = aws_agentcore.mcp_init_session(opts)
+            send_json(
+                ctx,
+                res,
+                origin,
+                200,
+                {"success": True, "result": {"jsonrpc": "2.0", "result": {}}, "sessionId": mcp_session},
+            )
+        elif method == "tools/list":
+            tools = aws_agentcore.mcp_list_tools(opts).tools
+            send_json(
+                ctx, res, origin, 200, {"success": True, "result": {"jsonrpc": "2.0", "result": {"tools": tools}}}
+            )
+        elif method == "tools/call":
+            params = body.get("params") or {}
+            if not params.get("name"):
+                send_json(ctx, res, origin, 400, {"success": False, "error": "tools/call requires params.name"})
+                return
+            text = aws_agentcore.mcp_call_tool(opts, params["name"], params.get("arguments") or {})
+            result = {"jsonrpc": "2.0", "result": {"content": [{"type": "text", "text": text}]}}
+            send_json(ctx, res, origin, 200, {"success": True, "result": result})
+        else:
+            send_json(ctx, res, origin, 400, {"success": False, "error": f"Unsupported MCP method: {method}"})
+    except Exception as err:  # noqa: BLE001
+        ctx.set_cors_headers(res, origin)
+        if not res.headers_sent:
+            res.write_head(502, {"Content-Type": "application/json"})
+        res.end(js_dumps({"success": False, "error": f"MCP invoke failed: {err}"}))

agentcore/operations/dev/web_ui/handlers/memory.py

@@ -0,0 +1,84 @@
+"""GET /api/memory and POST /api/memory/search (port of handlers/memory.ts)."""
+
+import json
+from typing import Any
+
+from agentcore.operations.dev._server import Request, Response
+from agentcore.operations.dev.web_ui.handlers._common import send_json
+
+
+def _ns_args(namespace: str | None, namespace_path: str | None) -> dict[str, str]:
+    return {"namespace": namespace} if namespace else {"namespacePath": namespace_path or ""}
+
+
+def handle_list_memory_records(ctx: Any, req: Request, res: Response, origin: str | None = None) -> None:
+    from agentcore.operations.dev.web_ui.web_server import parse_request_url
+
+    handler = ctx.options.on_list_memory_records
+    if not handler:
+        send_json(ctx, res, origin, 404, {"success": False, "error": "Memory browsing is not available"})
+        return
+    _, param = parse_request_url(req)
+    memory_name, namespace = param("memoryName"), param("namespace")
+    namespace_path, strategy_id = param("namespacePath"), param("strategyId")
+    if not memory_name:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "memoryName query parameter is required"})
+        return
+    if namespace and namespace_path:
+        error = "'namespace' and 'namespacePath' query parameters are mutually exclusive"
+        send_json(ctx, res, origin, 400, {"success": False, "error": error})
+        return
+    if not namespace and not namespace_path:
+        error = "either 'namespace' or 'namespacePath' query parameter is required"
+        send_json(ctx, res, origin, 400, {"success": False, "error": error})
+        return
+    try:
+        result = handler({"memoryName": memory_name, "strategyId": strategy_id, **_ns_args(namespace, namespace_path)})
+        send_json(ctx, res, origin, 200 if result.get("success") else 500, result)
+    except Exception as err:  # noqa: BLE001
+        ctx.log("error", f"List memory records error: {err}")
+        send_json(ctx, res, origin, 500, {"success": False, "error": "Failed to list memory records"})
+
+
+def handle_retrieve_memory_records(ctx: Any, req: Request, res: Response, origin: str | None = None) -> None:
+    handler = ctx.options.on_retrieve_memory_records
+    if not handler:
+        send_json(ctx, res, origin, 404, {"success": False, "error": "Memory search is not available"})
+        return
+    body = ctx.read_body(req)
+    parsed: dict[str, Any] = {}
+    try:
+        loaded = json.loads(body)
+        parsed = loaded if isinstance(loaded, dict) else {}
+    except ValueError:
+        pass
+    memory_name, namespace = parsed.get("memoryName"), parsed.get("namespace")
+    namespace_path, search_query = parsed.get("namespacePath"), parsed.get("searchQuery")
+    strategy_id = parsed.get("strategyId")
+    if not memory_name:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "memoryName is required"})
+        return
+    if namespace and namespace_path:
+        error = "'namespace' and 'namespacePath' request fields are mutually exclusive"
+        send_json(ctx, res, origin, 400, {"success": False, "error": error})
+        return
+    if not namespace and not namespace_path:
+        error = "either 'namespace' or 'namespacePath' request field is required"
+        send_json(ctx, res, origin, 400, {"success": False, "error": error})
+        return
+    if not search_query:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "searchQuery is required"})
+        return
+    try:
+        result = handler(
+            {
+                "memoryName": memory_name,
+                "searchQuery": search_query,
+                "strategyId": strategy_id,
+                **_ns_args(namespace, namespace_path),
+            }
+        )
+        send_json(ctx, res, origin, 200 if result.get("success") else 500, result)
+    except Exception as err:  # noqa: BLE001
+        ctx.log("error", f"Retrieve memory records error: {err}")
+        send_json(ctx, res, origin, 500, {"success": False, "error": "Failed to search memory records"})