agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/invoke/interactive.py

@@ -0,0 +1,604 @@
+"""Prompt-based replacement for the invoke TUI (tui/screens/invoke/InvokeScreen.tsx + useInvokeFlow.ts).
+
+Flow: load deployed agents/harnesses -> pick one (when several) -> resolve a CUSTOM_JWT bearer token
+(auto-fetch, else ask) -> chat loop. In the chat loop:
+
+* plain text is sent to the agent and the reply streams token by token;
+* ``!<command>`` runs a shell command in the runtime container;
+* ``/new`` starts a new session (Ctrl+N upstream), ``/shell`` opens an interactive shell (``s``
+  upstream), ``/exit`` (or Ctrl-C / Esc on the prompt) leaves the chat (back to the picker when
+  there are several agents, as Esc does upstream).
+
+For MCP agents the input is ``tool_name {"arg": "value"}``; ``list`` refreshes the tool list.
+"""
+
+import json
+import sys
+from dataclasses import dataclass, field
+from typing import Any
+
+import typer
+
+from agentcore.aws import (
+    DEFAULT_RUNTIME_USER_ID,
+    AguiInvokeOptions,
+    ExecuteBashOptions,
+    InvokeAgentRuntimeOptions,
+    McpInvokeOptions,
+    build_agui_run_input,
+    execute_bash_command,
+    get_or_create_payment_session,
+    invoke_a2a_runtime,
+    invoke_agent_runtime_streaming,
+    invoke_agui_runtime,
+    mcp_call_tool,
+    mcp_list_tools,
+)
+from agentcore.aws.agentcore import A2AInvokeOptions
+from agentcore.aws.agentcore_harness import invoke_harness
+from agentcore.cli import interactive
+from agentcore.cli.commands.invoke import _deps
+from agentcore.cli.commands.invoke.constants import ANSI
+from agentcore.cli.commands.invoke.resolve import build_config_bundle_baggage
+from agentcore.cli.errors import get_error_message
+from agentcore.lib.errors.types import ResourceNotFoundError
+from agentcore.lib.schemas.io.config_io import ConfigIO
+from agentcore.logging import InvokeLogger
+from agentcore.operations.session import generate_session_id
+
+
+@dataclass
+class InvokableRuntime:
+    name: str
+    state: Any
+    network_mode: str | None = None
+    protocol: str | None = None
+    authorizer_type: str | None = None
+    baggage: str | None = None
+
+
+@dataclass
+class InvokableHarness:
+    name: str
+    state: Any
+    authorizer_type: str | None = None
+
+
+@dataclass
+class InvokeConfig:
+    runtimes: list[InvokableRuntime]
+    harnesses: list[InvokableHarness]
+    target: Any
+    target_name: str
+    project_name: str
+
+
+@dataclass
+class _Session:
+    config: InvokeConfig
+    selected: int
+    session_id: str
+    user_id: str
+    headers: dict[str, str] | None
+    bearer_token: str
+    payment_instrument_id: str | None
+    payment_session_id: str | None
+    payment_user_id: str | None
+    logger: InvokeLogger | None = None
+    mcp_session_id: str | None = None
+    mcp_tools: list[Any] = field(default_factory=list)
+
+    @property
+    def is_harness(self) -> bool:
+        return self.selected >= len(self.config.runtimes)
+
+    @property
+    def runtime(self) -> InvokableRuntime | None:
+        return None if self.is_harness else self.config.runtimes[self.selected]
+
+    @property
+    def harness(self) -> InvokableHarness | None:
+        return self.config.harnesses[self.selected - len(self.config.runtimes)] if self.is_harness else None
+
+    @property
+    def name(self) -> str:
+        return (self.runtime or self.harness).name  # type: ignore[union-attr]
+
+    @property
+    def arn(self) -> str:
+        return self.runtime.state.runtime_arn if self.runtime else self.harness.state.harness_arn  # type: ignore[union-attr]
+
+    @property
+    def region(self) -> str:
+        return self.config.target.region
+
+    def get_logger(self) -> InvokeLogger:
+        if self.logger is None:
+            self.logger = InvokeLogger(
+                agent_name=self.name, runtime_arn=self.arn, region=self.region, session_id=self.session_id
+            )
+        return self.logger
+
+
+def _write(text: str) -> None:
+    sys.stdout.write(text)
+    sys.stdout.flush()
+
+
+def load_invoke_tui_config(config_io: ConfigIO | None = None) -> InvokeConfig:
+    """Load deployed runtimes/harnesses for the first target (useInvokeFlow ``load``)."""
+    config_io = config_io or ConfigIO()
+    try:
+        project = config_io.read_project_spec()
+    except Exception:  # noqa: BLE001
+        raise ResourceNotFoundError("No agentcore project found.") from None
+    deployed_state = config_io.read_deployed_state()
+    aws_targets = config_io.read_aws_deployment_targets()
+
+    target_names = list(deployed_state.targets or {})
+    if not target_names:
+        raise ResourceNotFoundError("No deployed targets found. Run `agentcore deploy` first.")
+    target_name = target_names[0]
+    target_state = deployed_state.targets[target_name]
+    target_config = next((t for t in aws_targets if t.name == target_name), None)
+    if target_config is None:
+        raise ResourceNotFoundError(f"Target config '{target_name}' not found")
+
+    resources = target_state.resources if target_state else None
+    runtimes: list[InvokableRuntime] = []
+    for agent in project.runtimes or []:
+        state = ((resources.runtimes if resources else None) or {}).get(agent.name)
+        if not state:
+            continue
+        runtimes.append(
+            InvokableRuntime(
+                name=agent.name,
+                state=state,
+                network_mode=agent.network_mode,
+                protocol=agent.protocol,
+                authorizer_type=agent.authorizer_type,
+                baggage=build_config_bundle_baggage(project, target_state, agent.name),
+            )
+        )
+    harnesses: list[InvokableHarness] = []
+    for harness in project.harnesses or []:
+        state = ((resources.harnesses if resources else None) or {}).get(harness.name)
+        if not state:
+            continue
+        authorizer_type = None
+        try:
+            authorizer_type = config_io.read_harness_spec(harness.name).authorizer_type
+        except Exception:  # noqa: BLE001, S110 - best-effort
+            pass
+        harnesses.append(InvokableHarness(name=harness.name, state=state, authorizer_type=authorizer_type))
+
+    if not runtimes and not harnesses:
+        raise ResourceNotFoundError("No deployed agents or harnesses found. Run `agentcore deploy` first.")
+    return InvokeConfig(runtimes, harnesses, target_config, target_name, project.name)
+
+
+def _auto_session(config_io: ConfigIO, config: InvokeConfig, payment_user_id: str | None) -> str:
+    project = config_io.read_project_spec()
+    deployed_state = config_io.read_deployed_state()
+    target_state = deployed_state.targets.get(config.target_name)
+    payments = target_state.resources.payments if target_state and target_state.resources else None
+    first_manager = next(iter(payments.values()), None) if payments else None
+    if not first_manager or not first_manager.manager_arn:
+        raise ResourceNotFoundError("--auto-session requires a deployed payment manager. Run `agentcore deploy` first.")
+    first_name = next(iter(payments))
+    spec = next((p for p in (project.payments or []) if p.name == first_name), None)
+    kwargs: dict[str, Any] = {}
+    if spec is not None and spec.default_spend_limit is not None:
+        kwargs["default_spend_limit"] = spec.default_spend_limit
+    try:
+        return get_or_create_payment_session(
+            region=config.target.region,
+            user_id=payment_user_id or DEFAULT_RUNTIME_USER_ID,
+            manager_arn=first_manager.manager_arn,
+            **kwargs,
+        )
+    except Exception as exc:
+        raise RuntimeError(f"--auto-session failed to create payment session: {exc}") from exc
+
+
+def _resolve_token(session: _Session) -> None:
+    """Token screen: auto-fetch the CUSTOM_JWT bearer token, else ask for one (Enter skips)."""
+    auth = session.runtime.authorizer_type if session.runtime else session.harness.authorizer_type  # type: ignore[union-attr]
+    if auth != "CUSTOM_JWT" or session.bearer_token:
+        return
+    try:
+        can_fetch = (
+            _deps.can_fetch_harness_token(session.name)
+            if session.is_harness
+            else _deps.can_fetch_runtime_token(session.name)
+        )
+    except Exception:  # noqa: BLE001
+        can_fetch = False
+    if can_fetch:
+        typer.echo("Fetching token...")
+        try:
+            fetched = (
+                _deps.fetch_harness_token(session.name, deploy_target=session.config.target_name)
+                if session.is_harness
+                else _deps.fetch_runtime_token(session.name, deploy_target=session.config.target_name)
+            )
+            session.bearer_token = _deps.token_of(fetched) or ""
+            return
+        except Exception as exc:  # noqa: BLE001
+            typer.echo(f"{ANSI.red}{get_error_message(exc)}{ANSI.reset}")
+    else:
+        typer.echo(
+            f"{ANSI.yellow}No OAuth credentials configured for auto-fetch. Enter a bearer token manually, or re-add "
+            f"with --client-id and --client-secret.{ANSI.reset}"
+        )
+    try:
+        session.bearer_token = interactive.text("Bearer token (Enter to skip):", secret=True).strip()
+    except typer.Exit:
+        session.bearer_token = ""
+
+
+def _print_header(session: _Session) -> None:
+    protocol = None if session.is_harness else (session.runtime.protocol or "HTTP")  # type: ignore[union-attr]
+    typer.echo(f"Project: {session.config.project_name}")
+    typer.echo(f"{'Harness' if session.is_harness else 'Agent'}: {session.name}")
+    if protocol:
+        typer.echo(f"Protocol: {protocol}")
+    typer.echo(f"Target: {session.region}")
+    typer.echo(f"Session: {session.session_id}")
+    typer.echo(f"User: {session.user_id}")
+    if session.payment_instrument_id or session.payment_session_id or session.payment_user_id:
+        typer.echo(f"Payments: active (wallet owner: {session.payment_user_id or 'default-user'})")
+    auth = session.runtime.authorizer_type if session.runtime else session.harness.authorizer_type  # type: ignore[union-attr]
+    if auth == "CUSTOM_JWT":
+        typer.echo(f"Auth: {'bearer token' if session.bearer_token else 'no token'}")
+    if session.runtime and session.runtime.network_mode == "VPC":
+        typer.echo(
+            f"{ANSI.yellow}Warning: This agent uses VPC network mode. Ensure your VPC endpoints are configured for "
+            f"invocation.{ANSI.reset}"
+        )
+    hint = "!<cmd> runs a shell command, /new starts a new session, /shell opens a shell, /exit leaves"
+    typer.echo(f"{ANSI.dim}{hint}{ANSI.reset}")
+
+
+def _mcp_opts(session: _Session) -> McpInvokeOptions:
+    return McpInvokeOptions(
+        region=session.region,
+        runtime_arn=session.arn,
+        user_id=session.user_id,
+        mcp_session_id=session.mcp_session_id,
+        headers=session.headers,
+        bearer_token=session.bearer_token or None,
+    )
+
+
+def _fetch_mcp_tools(session: _Session) -> None:
+    try:
+        listed = mcp_list_tools(_mcp_opts(session))
+        session.mcp_tools = list(listed.tools)
+        session.mcp_session_id = listed.mcp_session_id
+        if listed.tools:
+            typer.echo(_deps.format_mcp_tool_list(listed.tools))
+    except Exception as exc:  # noqa: BLE001
+        typer.echo(f"Failed to list tools: {get_error_message(exc)}")
+        session.mcp_tools = []
+
+
+def _invoke_harness(session: _Session, prompt: str, logger: InvokeLogger) -> str:
+    content = ""
+    pending_name: str | None = None
+    pending_input = ""
+    last_metadata: dict[str, Any] | None = None
+
+    def emit(text: str) -> None:
+        nonlocal content
+        content += text
+        _write(text)
+
+    for event in invoke_harness(
+        region=session.region,
+        harness_arn=session.arn,
+        runtime_session_id=session.session_id or generate_session_id(),
+        messages=[{"role": "user", "content": [{"text": prompt}]}],
+        bearer_token=session.bearer_token or None,
+    ):
+        kind = event.get("type")
+        if kind == "contentBlockDelta":
+            delta = event.get("delta") or {}
+            if delta.get("type") == "text":
+                emit(delta.get("text") or "")
+            elif delta.get("type") == "toolUse":
+                pending_input += delta.get("input") or ""
+        elif kind == "contentBlockStart":
+            start = event.get("start") or {}
+            if start.get("type") == "toolUse":
+                tool_use = start.get("toolUse") or {}
+                pending_name = tool_use.get("name")
+                pending_input = ""
+                server = tool_use.get("serverName")
+                label = f"{server}/{pending_name}" if server else pending_name
+                logger.log_info(f"Tool call: {pending_name} (id: {tool_use.get('toolUseId')})")
+                emit(f"\n{ANSI.dim}{label}")
+            elif start.get("type") == "toolResult":
+                status = (start.get("toolResult") or {}).get("status")
+                icon = f" {ANSI.red}[error]{ANSI.reset}" if status == "error" else f" [ok]{ANSI.reset}"
+                logger.log_info(f"Tool result ({pending_name}): status={status or 'success'}")
+                emit(f"{icon}\n")
+        elif kind == "messageStop":
+            if event.get("stopReason") == "tool_use" and pending_name:
+                try:
+                    parsed = json.loads(pending_input)
+                except ValueError:
+                    parsed = {}
+                logger.log_info(f"Tool input ({pending_name}): {json.dumps(parsed, separators=(',', ':'))}")
+        elif kind == "metadata":
+            usage = event.get("usage") or {}
+            latency = (event.get("metrics") or {}).get("latencyMs", 0)
+            logger.log_info(
+                f"Tokens: {usage.get('inputTokens')} in, {usage.get('outputTokens')} out | Latency: {latency}ms"
+            )
+            last_metadata = {"in": usage.get("inputTokens"), "out": usage.get("outputTokens"), "latency": latency}
+        elif kind == "error":
+            emit(f"\nError: {event.get('message')}")
+    if last_metadata:
+        emit(
+            f"\n{ANSI.dim}{last_metadata['in']} in / {last_metadata['out']} out / "
+            f"{last_metadata['latency'] / 1000:.1f}s{ANSI.reset}"
+        )
+    return content
+
+
+def _invoke_agui(session: _Session, prompt: str, logger: InvokeLogger) -> str:
+    content = ""
+    agui = invoke_agui_runtime(
+        AguiInvokeOptions(
+            region=session.region,
+            runtime_arn=session.arn,
+            user_id=session.user_id,
+            logger=logger,
+            headers=session.headers,
+            bearer_token=session.bearer_token or None,
+        ),
+        build_agui_run_input(prompt, session.session_id),
+    )
+    if agui.session_id:
+        session.session_id = agui.session_id
+        logger.update_session_id(agui.session_id)
+    tool_names: dict[str, str] = {}
+    for event in agui.stream:
+        kind = event.get("type")
+        if kind == "TEXT_MESSAGE_CONTENT":
+            content += event.get("delta", "")
+            _write(event.get("delta", ""))
+        elif kind == "TOOL_CALL_START":
+            tool_names[event.get("toolCallId", "")] = event.get("toolCallName", "")
+            _write(f"\n{ANSI.dim}{event.get('toolCallName', '')}{ANSI.reset}")
+        elif kind == "TOOL_CALL_RESULT":
+            raw = event.get("content")
+            text = raw if isinstance(raw, str) else json.dumps(raw, separators=(",", ":"))
+            _write(f"{ANSI.dim} -> {text}{ANSI.reset}\n")
+        elif kind == "REASONING_MESSAGE_CONTENT":
+            _write(f"{ANSI.dim}{event.get('delta', '')}{ANSI.reset}")
+        elif kind == "RUN_ERROR":
+            content += f"\nError: {event.get('message')}"
+            _write(f"\n{ANSI.red}Error: {event.get('message')}{ANSI.reset}")
+    return content
+
+
+def _invoke_turn(session: _Session, prompt: str) -> None:
+    logger = session.get_logger()
+    runtime = session.runtime
+
+    if runtime is not None and runtime.protocol == "MCP":
+        if prompt.strip().lower() == "list":
+            _fetch_mcp_tools(session)
+            return
+        parts = prompt.strip().split(None, 1)
+        if not parts:
+            return
+        tool_name, args_str = parts[0], (parts[1].strip() if len(parts) > 1 else "")
+        logger.log_prompt(f"MCP tools/call: {tool_name}({args_str})", session.session_id, session.user_id)
+        try:
+            args = json.loads(args_str) if args_str else {}
+            response = mcp_call_tool(_mcp_opts(session), tool_name, args)
+            typer.echo(f"Result: {response}")
+            logger.log_response(response)
+        except Exception as exc:  # noqa: BLE001
+            logger.log_error(exc, "MCP call failed")
+            typer.echo(f"Error: {get_error_message(exc)}")
+        return
+
+    logger.log_prompt(prompt, session.session_id, session.user_id)
+    try:
+        if session.is_harness:
+            content = _invoke_harness(session, prompt, logger)
+        elif runtime is not None and runtime.protocol == "AGUI":
+            content = _invoke_agui(session, prompt, logger)
+        else:
+            if runtime is not None and runtime.protocol == "A2A":
+                streamed = invoke_a2a_runtime(
+                    A2AInvokeOptions(
+                        region=session.region,
+                        runtime_arn=session.arn,
+                        user_id=session.user_id,
+                        session_id=session.session_id,
+                        logger=logger,
+                        headers=session.headers,
+                        bearer_token=session.bearer_token or None,
+                    ),
+                    prompt,
+                )
+            else:
+                streamed = invoke_agent_runtime_streaming(
+                    InvokeAgentRuntimeOptions(
+                        region=session.region,
+                        runtime_arn=session.arn,
+                        payload=prompt,
+                        session_id=session.session_id,
+                        user_id=session.user_id,
+                        logger=logger,
+                        headers=session.headers,
+                        bearer_token=session.bearer_token or None,
+                        baggage=runtime.baggage if runtime else None,
+                        payment_instrument_id=session.payment_instrument_id,
+                        payment_session_id=session.payment_session_id,
+                        payment_user_id=session.payment_user_id,
+                    )
+                )
+            if streamed.session_id:
+                session.session_id = streamed.session_id
+                logger.update_session_id(streamed.session_id)
+            content = ""
+            for chunk in streamed.stream:
+                content += chunk
+                _write(chunk)
+        _write("\n")
+        logger.log_response(content)
+    except Exception as exc:  # noqa: BLE001
+        context = (
+            "AGUI invoke failed" if runtime is not None and runtime.protocol == "AGUI" else "invoke streaming failed"
+        )
+        if not session.is_harness:
+            logger.log_error(exc, context)
+        _write("\n")
+        typer.echo(f"Error: {get_error_message(exc)}")
+
+
+def _exec_turn(session: _Session, command: str) -> None:
+    logger = session.get_logger()
+    logger.log_prompt(f"exec: {command}", session.session_id, session.user_id)
+    content = ""
+    try:
+        executed = execute_bash_command(
+            ExecuteBashOptions(
+                region=session.region,
+                runtime_arn=session.arn,
+                command=command,
+                session_id=session.session_id,
+                headers=session.headers,
+                bearer_token=session.bearer_token or None,
+            )
+        )
+        for event in executed.stream:
+            kind = event.get("type")
+            if kind in ("stdout", "stderr") and event.get("data"):
+                content += event["data"]
+                _write(event["data"])
+            elif kind == "stop":
+                code = event.get("exitCode")
+                if code is not None and code != 0:
+                    suffix = " (timed out)" if event.get("status") == "TIMED_OUT" else ""
+                    note = f"\n[exit code: {code}{suffix}]"
+                    content += note
+                    _write(note)
+        if content and not content.endswith("\n"):
+            _write("\n")
+        logger.log_response(content)
+    except Exception as exc:  # noqa: BLE001
+        logger.log_error(exc, "exec command failed")
+        typer.echo(f"Error: {get_error_message(exc)}")
+
+
+def _open_shell(session: _Session) -> None:
+    from agentcore.cli.commands.exec.action import ExecContext, handle_shell_session
+    from agentcore.cli.commands.exec.types import ExecOptions
+
+    if session.runtime is None:
+        return
+    handle_shell_session(
+        ExecContext(region=session.region, runtime_arn=session.arn),
+        ExecOptions(runtime_arn=session.arn, session_id=session.session_id, interactive=True),
+    )
+    typer.echo("[session resumed]")
+
+
+def _chat(session: _Session) -> bool:
+    """Chat loop. Returns True to go back to the agent picker, False to exit."""
+    _resolve_token(session)
+    _print_header(session)
+    if session.runtime is not None and session.runtime.protocol == "MCP":
+        _fetch_mcp_tools(session)
+
+    while True:
+        try:
+            line = interactive.text(">")
+        except typer.Exit:
+            return True
+        stripped = line.strip()
+        if not stripped:
+            continue
+        if stripped in ("/exit", "/quit"):
+            return True
+        if stripped == "/new":
+            session.session_id = generate_session_id()
+            session.mcp_session_id = None
+            session.mcp_tools = []
+            typer.echo(f"New session: {session.session_id}")
+            continue
+        if stripped == "/shell":
+            _open_shell(session)
+            continue
+        if stripped.startswith("!"):
+            command = stripped[1:].strip()
+            if command:
+                _exec_turn(session, command)
+            continue
+        _invoke_turn(session, line)
+
+
+def run_invoke_interactive(
+    *,
+    session_id: str | None = None,
+    user_id: str | None = None,
+    headers: dict[str, str] | None = None,
+    bearer_token: str | None = None,
+    payment_instrument_id: str | None = None,
+    payment_session_id: str | None = None,
+    auto_session: bool = False,
+    payment_user_id: str | None = None,
+    harness_name: str | None = None,
+) -> None:
+    config_io = ConfigIO()
+    try:
+        config = load_invoke_tui_config(config_io)
+        if auto_session and not payment_session_id:
+            payment_session_id = _auto_session(config_io, config, payment_user_id)
+    except Exception as exc:  # noqa: BLE001 - shown as the TUI error screen upstream
+        typer.echo(f"{ANSI.red}{get_error_message(exc)}{ANSI.reset}")
+        raise typer.Exit(1) from None
+
+    total = len(config.runtimes) + len(config.harnesses)
+    selected = 0
+    if harness_name:
+        idx = next((i for i, h in enumerate(config.harnesses) if h.name == harness_name), -1)
+        if idx >= 0:
+            selected = len(config.runtimes) + idx
+
+    session = _Session(
+        config=config,
+        selected=selected,
+        session_id=session_id or generate_session_id(),
+        user_id=user_id or DEFAULT_RUNTIME_USER_ID,
+        headers=headers,
+        bearer_token=bearer_token or "",
+        payment_instrument_id=payment_instrument_id,
+        payment_session_id=payment_session_id,
+        payment_user_id=payment_user_id,
+    )
+
+    while True:
+        if total > 1 and not harness_name:
+            choices = [interactive.Choice(r.name, i, r.protocol or "HTTP") for i, r in enumerate(config.runtimes)]
+            choices += [
+                interactive.Choice(h.name, len(config.runtimes) + i, "harness") for i, h in enumerate(config.harnesses)
+            ]
+            try:
+                session.selected = interactive.select("Select an agent to invoke", choices, default=None)
+            except typer.Exit:
+                break
+        harness_name = None
+        back = _chat(session)
+        if not back or total <= 1:
+            break
+
+    if session.logger is not None:
+        typer.echo(f"Log: {session.logger.get_relative_log_path()}", err=True)