agentcore-cli 0.31.1__py3-none-any.whl

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

@@ -0,0 +1,351 @@
+"""GET /api/resources (port of handlers/resources.ts): the project resource graph + deployment status."""
+
+from typing import Any
+from urllib.parse import quote
+
+from agentcore.aws.partition import service_endpoint
+from agentcore.lib.schemas.io.config_io import ConfigIO
+from agentcore.operations.dev._server import Response
+from agentcore.operations.dev.web_ui.handlers._common import send_json
+
+
+def build_runtime_invocation_url(region: str, runtime_arn: str) -> str:
+    """Port of commands/status/constants.ts buildRuntimeInvocationUrl (encodeURIComponent)."""
+    encoded = quote(runtime_arn, safe="-_.!~*'()")
+    return f"https://{service_endpoint('bedrock-agentcore', region)}/runtimes/{encoded}/invocations"
+
+
+def _compute_resource_statuses(project: Any, resources: Any) -> list[Any]:
+    """Delegates to the status command's computeResourceStatuses (owned by the deploy/status port)."""
+    try:
+        from agentcore.cli.commands.status.action import compute_resource_statuses
+    except ImportError:
+        try:
+            from agentcore.cli.commands.status import compute_resource_statuses  # type: ignore[no-redef]
+        except ImportError:
+            return []
+    # The status port takes the deployed-state resources as camelCase JSON.
+    as_json = resources.to_json_dict() if hasattr(resources, "to_json_dict") else resources
+    return list(compute_resource_statuses(project, as_json))
+
+
+def _entry(entry: Any, key: str) -> Any:
+    if isinstance(entry, dict):
+        return entry.get(key)
+    snake = "".join(f"_{c.lower()}" if c.isupper() else c for c in key)
+    return getattr(entry, snake, getattr(entry, key, None))
+
+
+def _dump(model: Any) -> Any:
+    if model is None:
+        return None
+    return model.to_json_dict() if hasattr(model, "to_json_dict") else model
+
+
+def _get(mapping: Any, name: str) -> Any:
+    return (mapping or {}).get(name)
+
+
+def handle_resources(ctx: Any, res: Response, origin: str | None = None) -> None:
+    config_root = ctx.options.config_root
+    if not config_root:
+        send_json(ctx, res, origin, 404, {"success": False, "error": "No agentcore project found"})
+        return
+    try:
+        send_json(ctx, res, origin, 200, _build(ctx, config_root))
+    except Exception as err:  # noqa: BLE001
+        ctx.log("error", f"Failed to read resources: {err}")
+        send_json(ctx, res, origin, 500, {"success": False, "error": "Failed to read project configuration"})
+
+
+def _build(ctx: Any, config_root: str) -> dict[str, Any]:
+    config_io = ConfigIO(base_dir=config_root)
+    project = config_io.read_project_spec()
+
+    targets: dict[str, Any] = {}
+    if config_io.config_exists("state"):
+        try:
+            targets = dict(config_io.read_deployed_state().targets or {})
+        except Exception:  # noqa: BLE001
+            ctx.log("warn", "Failed to read deployed state")
+    first_key = next(iter(targets), None)
+    tr = targets[first_key].resources if first_key and targets[first_key] else None
+
+    target_region: str | None = None
+    deployment_targets: list[dict[str, Any]] = []
+    try:
+        aws_targets = config_io.read_aws_deployment_targets()
+        first = next((t for t in aws_targets if t.name == first_key), None) if first_key else (aws_targets or [None])[0]
+        target_region = first.region if first else None
+        deployment_targets = [
+            {"name": t.name, "region": t.region, **({"description": t.description} if t.description else {})}
+            for t in aws_targets
+        ]
+    except Exception:  # noqa: BLE001 - aws-targets.json may not exist yet
+        pass
+
+    status_by: dict[str, Any] = {}
+    for entry in _compute_resource_statuses(project, tr):
+        status_by[f"{_entry(entry, 'resourceType')}:{_entry(entry, 'name')}"] = _entry(entry, "deploymentState")
+
+    def inv_url(deployed: Any) -> str | None:
+        arn = getattr(deployed, "runtime_arn", None) if deployed else None
+        return build_runtime_invocation_url(target_region, arn) if arn and target_region else None
+
+    runtimes = (tr.runtimes if tr else None) or {}
+    agents = []
+    for a in project.runtimes:
+        deployed = runtimes.get(a.name)
+        agents.append(
+            {
+                "name": a.name,
+                "build": a.build,
+                "entrypoint": a.entrypoint,
+                "codeLocation": a.code_location,
+                "runtimeVersion": a.runtime_version or "",
+                "networkMode": a.network_mode or "PUBLIC",
+                "protocol": a.protocol or "HTTP",
+                "envVars": [e.name for e in a.env_vars or []],
+                "deploymentStatus": status_by.get(f"agent:{a.name}"),
+                "deployed": _dump(deployed),
+                "invocationUrl": inv_url(deployed),
+            }
+        )
+    local = {a.name for a in project.runtimes}
+    for name, deployed in runtimes.items():
+        if name not in local:
+            agents.append(
+                {
+                    "name": name,
+                    "build": "",
+                    "entrypoint": "",
+                    "codeLocation": "",
+                    "runtimeVersion": "",
+                    "networkMode": "",
+                    "protocol": "",
+                    "envVars": [],
+                    "deploymentStatus": "pending-removal",
+                    "deployed": _dump(deployed),
+                    "invocationUrl": inv_url(deployed),
+                }
+            )
+
+    deployed_harnesses = (tr.harnesses if tr else None) or {}
+    credentials_state = (tr.credentials if tr else None) or {}
+    harnesses = []
+    for h in project.harnesses or []:
+        model, model_config, tools, skills = "", None, [], None
+        try:
+            spec = config_io.read_harness_spec(h.name)
+            model = f"{spec.model.provider}/{spec.model.model_id}"
+            model_config = _dump(spec.model)
+            tools = [t.name for t in spec.tools]
+            if spec.skills:
+                skills = []
+                for s in spec.skills:
+                    if getattr(s, "s3_uri", None):
+                        skills.append({"s3": {"uri": s.s3_uri}})
+                    elif getattr(s, "git_url", None):
+                        git: dict[str, Any] = {"url": s.git_url}
+                        if s.path:
+                            git["path"] = s.path
+                        if s.auth:
+                            cred = credentials_state.get(s.auth.credential_name)
+                            git["auth"] = {
+                                "credentialName": s.auth.credential_name,
+                                "credentialArn": cred.credential_provider_arn if cred else None,
+                                "username": s.auth.username,
+                            }
+                        skills.append({"git": git})
+                    elif getattr(s, "aws_skills", None) is not None:
+                        paths = s.aws_skills.paths
+                        skills.append({"awsSkills": {"paths": paths} if paths else {}})
+                    else:
+                        skills.append({"path": s.path})
+        except Exception:  # noqa: BLE001 - show what we can
+            pass
+        deployed = deployed_harnesses.get(h.name)
+        harnesses.append(
+            {
+                "name": h.name,
+                "model": model,
+                "modelConfig": model_config,
+                "tools": tools,
+                "skills": skills,
+                "deploymentStatus": status_by.get(f"harness:{h.name}"),
+                "deployed": {"harnessId": deployed.harness_id, "harnessArn": deployed.harness_arn}
+                if deployed
+                else None,
+            }
+        )
+    local = {h.name for h in project.harnesses or []}
+    for name, deployed in deployed_harnesses.items():
+        if name not in local:
+            harnesses.append(
+                {
+                    "name": name,
+                    "model": "",
+                    "tools": [],
+                    "deploymentStatus": "pending-removal",
+                    "deployed": {"harnessId": deployed.harness_id, "harnessArn": deployed.harness_arn},
+                }
+            )
+
+    def pending(state_map: Any, local_names: set[str], make: Any) -> list[dict[str, Any]]:
+        return [make(n, d) for n, d in (state_map or {}).items() if n not in local_names]
+
+    mem_state = (tr.memories if tr else None) or {}
+    memories = [
+        {
+            "name": m.name,
+            "strategies": [
+                {
+                    "type": s.type,
+                    "namespaceTemplates": s.namespace_templates
+                    if s.namespace_templates is not None
+                    else (s.namespaces if s.namespaces is not None else []),
+                }
+                for s in m.strategies
+            ],
+            "expiryDays": m.event_expiry_duration,
+            "deploymentStatus": status_by.get(f"memory:{m.name}"),
+            "deployed": _dump(mem_state.get(m.name)),
+        }
+        for m in project.memories
+    ] + pending(
+        mem_state,
+        {m.name for m in project.memories},
+        lambda n, d: {"name": n, "strategies": [], "deploymentStatus": "pending-removal", "deployed": _dump(d)},
+    )
+
+    cred_state = credentials_state
+    credentials = [
+        {
+            "name": c.name,
+            "type": c.authorizer_type,
+            "deploymentStatus": status_by.get(f"credential:{c.name}"),
+            "deployed": _dump(cred_state.get(c.name)),
+        }
+        for c in project.credentials
+    ] + pending(
+        cred_state,
+        {c.name for c in project.credentials},
+        lambda n, d: {"name": n, "type": "", "deploymentStatus": "pending-removal", "deployed": _dump(d)},
+    )
+
+    mcp = tr.mcp if tr else None
+    gw_state = (mcp.gateways if mcp else None) or {}
+    gateways = [
+        {
+            "name": g.name,
+            "targets": [
+                {
+                    "name": t.tool_definitions[0].name if t.tool_definitions else t.name,
+                    "targetType": t.target_type,
+                }
+                for t in g.targets
+            ],
+            "deploymentStatus": status_by.get(f"gateway:{g.name}"),
+            "deployed": _dump(gw_state.get(g.name)),
+        }
+        for g in project.agent_core_gateways or []
+    ] + pending(
+        gw_state,
+        {g.name for g in project.agent_core_gateways or []},
+        lambda n, d: {"name": n, "targets": [], "deploymentStatus": "pending-removal", "deployed": _dump(d)},
+    )
+
+    mcp_runtime_tools = [
+        {"name": t.name, "bindings": [_dump(b) for b in t.bindings or []]} for t in project.mcp_runtime_tools or []
+    ]
+
+    ev_state = (tr.evaluators if tr else None) or {}
+    evaluators = [
+        {
+            "name": e.name,
+            "level": e.level,
+            "description": e.description,
+            "configType": "code-based" if e.config.code_based else "llm-as-a-judge",
+            "deploymentStatus": status_by.get(f"evaluator:{e.name}"),
+            "deployed": _dump(ev_state.get(e.name)),
+        }
+        for e in project.evaluators
+    ] + pending(
+        ev_state,
+        {e.name for e in project.evaluators},
+        lambda n, d: {
+            "name": n,
+            "level": "",
+            "configType": "llm-as-a-judge",
+            "deploymentStatus": "pending-removal",
+            "deployed": _dump(d),
+        },
+    )
+
+    oe_state = (tr.online_eval_configs if tr else None) or {}
+    online_eval_configs = [
+        {
+            "name": o.name,
+            "agent": o.agent,
+            "evaluators": o.evaluators,
+            "samplingRate": o.sampling_rate,
+            "description": o.description,
+            "deploymentStatus": status_by.get(f"online-eval:{o.name}"),
+            "deployed": _dump(oe_state.get(o.name)),
+        }
+        for o in project.online_eval_configs
+    ] + pending(
+        oe_state,
+        {o.name for o in project.online_eval_configs},
+        lambda n, d: {
+            "name": n,
+            "agent": "",
+            "evaluators": [],
+            "samplingRate": 0,
+            "deploymentStatus": "pending-removal",
+            "deployed": _dump(d),
+        },
+    )
+
+    pe_state = (tr.policy_engines if tr else None) or {}
+    pol_state = (tr.policies if tr else None) or {}
+    policy_engines = [
+        {
+            "name": pe.name,
+            "description": pe.description,
+            "policies": [
+                {
+                    "name": p.name,
+                    "description": p.description,
+                    "deploymentStatus": status_by.get(f"policy:{pe.name}/{p.name}"),
+                    "deployed": _dump(pol_state.get(f"{pe.name}/{p.name}") or pol_state.get(p.name)),
+                }
+                for p in pe.policies
+            ],
+            "deploymentStatus": status_by.get(f"policy-engine:{pe.name}"),
+            "deployed": _dump(pe_state.get(pe.name)),
+        }
+        for pe in project.policy_engines
+    ] + pending(
+        pe_state,
+        {pe.name for pe in project.policy_engines},
+        lambda n, d: {"name": n, "policies": [], "deploymentStatus": "pending-removal", "deployed": _dump(d)},
+    )
+
+    unassigned = [{"name": t.name, "targetType": t.target_type} for t in project.unassigned_targets or []]
+
+    return {
+        "success": True,
+        "project": project.name,
+        "agents": agents,
+        "harnesses": harnesses,
+        "memories": memories,
+        "credentials": credentials,
+        "gateways": gateways,
+        "mcpRuntimeTools": mcp_runtime_tools,
+        "evaluators": evaluators,
+        "onlineEvalConfigs": online_eval_configs,
+        "policyEngines": policy_engines,
+        "unassignedTargets": unassigned,
+        "deploymentTargets": deployment_targets,
+    }

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

@@ -0,0 +1,182 @@
+"""POST /api/start (port of handlers/start.ts): start an agent server on demand."""
+
+import json
+import time
+from concurrent.futures import Future
+from typing import Any
+
+from agentcore.operations.dev._server import Request, Response
+from agentcore.operations.dev.config import requires_exact_dev_port
+from agentcore.operations.dev.constants import A2A_DEFAULT_PORT, MCP_DEFAULT_PORT
+from agentcore.operations.dev.dev_server import DevServerCallbacks, DevServerOptions
+from agentcore.operations.dev.server import create_dev_server
+from agentcore.operations.dev.utils import find_available_port, wait_for_server_ready
+from agentcore.operations.dev.web_ui.constants import AgentError
+from agentcore.operations.dev.web_ui.handlers._common import send_json
+
+
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+
+def handle_start(ctx: Any, req: Request, res: Response, origin: str | None = None) -> None:
+    body = ctx.read_body(req)
+    agent_name = None
+    try:
+        parsed = json.loads(body)
+        agent_name = parsed.get("agentName") if isinstance(parsed, dict) else None
+    except ValueError:
+        pass
+    if not agent_name:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "agentName is required"})
+        return
+
+    if ctx.options.on_start:
+        result = ctx.options.on_start(agent_name)
+        send_json(ctx, res, origin, 200 if result.get("success") else 404, result)
+        return
+
+    with ctx.state_lock:
+        existing = ctx.running_agents.get(agent_name)
+        inflight = ctx.starting_agents.get(agent_name)
+        owner = False
+        if not existing and not inflight:
+            inflight = Future()
+            ctx.starting_agents[agent_name] = inflight
+            owner = True
+
+    if existing:
+        send_json(ctx, res, origin, 200, {"success": True, "name": agent_name, "port": existing.port})
+        return
+
+    assert inflight is not None
+    if not owner:  # a start is already in flight: wait for it instead of spawning a duplicate
+        result = inflight.result()
+        send_json(ctx, res, origin, 200 if result.get("success") else 500, result)
+        return
+
+    try:
+        try:
+            result = do_start_agent(ctx, agent_name)
+        except BaseException as err:
+            inflight.set_exception(err)
+            raise
+        inflight.set_result(result)
+        send_json(ctx, res, origin, 200 if result.get("success") else 500, result)
+    finally:
+        with ctx.state_lock:
+            ctx.starting_agents.pop(agent_name, None)
+
+
+def resolve_agent_target_port(
+    *,
+    protocol: str,
+    agent_name: str,
+    agent_index: int,
+    ui_port: int,
+    agent_base_port: int | None = None,
+    selected_agent: str | None = None,
+) -> int:
+    """MCP: 8000. Explicit -p for the selected runtime: literal. A2A: 9000+index. Else uiPort+1+index."""
+    safe_index = max(agent_index, 0)
+    if protocol == "MCP":
+        return MCP_DEFAULT_PORT
+    if agent_base_port is not None and agent_name == selected_agent:
+        return agent_base_port
+    if protocol == "A2A":
+        return A2A_DEFAULT_PORT + safe_index
+    return ui_port + 1 + safe_index
+
+
+def do_start_agent(ctx: Any, agent_name: str) -> dict[str, Any]:
+    opts = ctx.options
+    if not opts.get_dev_config:
+        return {"success": False, "name": agent_name, "port": 0, "error": "Dev config factory not provided"}
+    config = opts.get_dev_config(agent_name)
+    if not config:
+        return {
+            "success": False,
+            "name": agent_name,
+            "port": 0,
+            "error": f'Agent "{agent_name}" not found or not supported',
+        }
+
+    filtered_index = next((i for i, a in enumerate(opts.agents) if a.get("name") == agent_name), -1)
+    agent_index = filtered_index
+    if filtered_index >= 0 and opts.agents[filtered_index].get("runtimeIndex") is not None:
+        agent_index = opts.agents[filtered_index]["runtimeIndex"]
+
+    is_a2a = config.protocol == "A2A"
+    is_ts_http = not config.is_python and config.protocol == "HTTP"
+    target_port = resolve_agent_target_port(
+        protocol=config.protocol,
+        agent_name=agent_name,
+        agent_index=agent_index,
+        ui_port=opts.ui_port,
+        agent_base_port=opts.agent_base_port,
+        selected_agent=opts.selected_agent,
+    )
+    port_is_explicit = opts.agent_base_port is not None and agent_name == opts.selected_agent
+    agent_port = find_available_port(target_port)
+    if requires_exact_dev_port(config.protocol) and agent_port != target_port:
+        error = (
+            f"Port {target_port} is in use. MCP agents require port {target_port} (FastMCP default)."
+            if config.protocol == "MCP"
+            else f"Port {target_port} is in use. A2A agents require port {target_port}."
+        )
+        return {"success": False, "name": agent_name, "port": 0, "error": error}
+    if port_is_explicit and agent_port != target_port:
+        return {
+            "success": False,
+            "name": agent_name,
+            "port": 0,
+            "error": f"Port {target_port} is in use. Free it or pass a different --port "
+            "(no port is chosen automatically when --port is set explicitly).",
+        }
+    if agent_port != target_port:
+        ctx.log("info", f"[{agent_name}] Port {target_port} in use, using {agent_port}")
+
+    error_messages: list[str] = []
+
+    def on_log(level: str, msg: str) -> None:
+        if level == "error":
+            error_messages.append(msg)
+            if agent_name in ctx.running_agents:
+                ctx.agent_errors[agent_name] = AgentError(msg, _now_ms())
+        ctx.log("error" if level == "error" else "info", f"[{agent_name}] {msg}")
+
+    def on_exit(code: int | None) -> None:
+        ctx.log("info", f"[{agent_name}] Server exited with code {code if code is not None else 0}")
+        ctx.running_agents.pop(agent_name, None)
+        if code not in (0, None):
+            message = "\n".join(error_messages) if error_messages else f"Server exited with code {code}"
+            ctx.agent_errors[agent_name] = AgentError(message, _now_ms())
+
+    base_env = opts.get_env_vars() if opts.get_env_vars else (opts.env_vars or {})
+    agent_env = {
+        **base_env,
+        "OTEL_SERVICE_NAME": agent_name,
+        **({"AGENTCORE_RUNTIME_URL": f"http://localhost:{agent_port}/"} if is_a2a else {}),
+        **({"PORT": str(agent_port)} if is_ts_http else {}),
+    }
+    server = create_dev_server(
+        config, DevServerOptions(port=agent_port, env_vars=agent_env, callbacks=DevServerCallbacks(on_log, on_exit))
+    )
+    ctx.agent_errors.pop(agent_name, None)
+    child = server.start()
+    if child is None:
+        message = "\n".join(error_messages) if error_messages else "Agent server failed to start"
+        ctx.agent_errors[agent_name] = AgentError(message, _now_ms())
+        return {"success": False, "name": agent_name, "port": 0, "error": message}
+
+    if not wait_for_server_ready(agent_port):
+        message = (
+            "\n".join(error_messages) if error_messages else "Agent server started but is not accepting connections"
+        )
+        ctx.agent_errors[agent_name] = AgentError(message, _now_ms())
+        return {"success": False, "name": agent_name, "port": 0, "error": message}
+
+    from agentcore.operations.dev.web_ui.web_server import RunningAgent
+
+    ctx.running_agents[agent_name] = RunningAgent(server=server, port=agent_port, protocol=config.protocol)
+    return {"success": True, "name": agent_name, "port": agent_port}

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

@@ -0,0 +1,25 @@
+"""GET /api/status (port of handlers/status.ts)."""
+
+from typing import Any
+
+from agentcore.operations.dev._server import Response
+from agentcore.operations.dev.web_ui.handlers._common import send_json
+
+
+def handle_status(ctx: Any, res: Response, origin: str | None = None) -> None:
+    opts = ctx.options
+    send_json(
+        ctx,
+        res,
+        origin,
+        200,
+        {
+            "mode": opts.mode,
+            "agents": opts.agents,
+            "harnesses": [{"name": h.name} for h in opts.harnesses or []],
+            "running": [{"name": name, "port": a.port} for name, a in list(ctx.running_agents.items())],
+            "errors": [{"name": name, "message": e.message} for name, e in list(ctx.agent_errors.items())],
+            "selectedAgent": opts.selected_agent,
+            "selectedHarness": opts.selected_harness,
+        },
+    )

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

@@ -0,0 +1,50 @@
+"""GET /api/traces and /api/traces/:traceId (port of handlers/traces.ts)."""
+
+from typing import Any
+
+from agentcore.operations.dev._server import Request, Response
+from agentcore.operations.dev.web_ui.handlers._common import parse_time_params, send_json
+
+
+def handle_list_traces(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)
+    handler = ctx.options.on_list_traces
+    if not handler:
+        send_json(ctx, res, origin, 404, {"success": False, "error": "Traces are not available"})
+        return
+    agent_name = param("agentName")
+    ok, start, end = parse_time_params(ctx, res, origin, param)
+    if not ok:
+        return
+    try:
+        result = handler(agent_name, start, end)
+        send_json(ctx, res, origin, 200 if result.get("success") else 500, result)
+    except Exception as err:  # noqa: BLE001
+        ctx.log("error", f"List traces error: {err}")
+        send_json(ctx, res, origin, 500, {"success": False, "error": "Failed to list traces"})
+
+
+def handle_get_trace(ctx: Any, req: Request, res: Response, origin: str | None = None) -> None:
+    from agentcore.operations.dev.web_ui.web_server import parse_request_url
+
+    pathname, param = parse_request_url(req)
+    handler = ctx.options.on_get_trace
+    if not handler:
+        send_json(ctx, res, origin, 404, {"success": False, "error": "Traces are not available"})
+        return
+    trace_id = pathname.replace("/api/traces/", "", 1)
+    agent_name = param("agentName")
+    if not trace_id:
+        send_json(ctx, res, origin, 400, {"success": False, "error": "traceId is required in the URL path"})
+        return
+    ok, start, end = parse_time_params(ctx, res, origin, param)
+    if not ok:
+        return
+    try:
+        result = handler(agent_name, trace_id, start, end)
+        send_json(ctx, res, origin, 200 if result.get("success") else 500, result)
+    except Exception as err:  # noqa: BLE001
+        ctx.log("error", f"Get trace error: {err}")
+        send_json(ctx, res, origin, 500, {"success": False, "error": "Failed to get trace"})

agentcore/operations/dev/web_ui/run_web_ui.py

@@ -0,0 +1,60 @@
+"""Port of operations/dev/web-ui/run-web-ui.ts: launch the web UI and block until Ctrl+C."""
+
+import threading
+from collections.abc import Callable
+from typing import Any
+
+from agentcore.logging import ExecLogger
+from agentcore.operations.dev.utils import find_available_port, on_shutdown_signal, open_browser
+from agentcore.operations.dev.web_ui.constants import WEB_UI_DEFAULT_PORT
+from agentcore.operations.dev.web_ui.web_server import WebUIOptions, WebUIServer
+
+
+def run_web_ui(
+    server_options: dict[str, Any],
+    log_label: str,
+    on_log: Callable[[str, str], None] | None = None,
+) -> None:
+    """``server_options`` are WebUIOptions fields minus ui_port/on_ready/on_log."""
+    import sys
+
+    logger = ExecLogger(command=log_label)
+    ui_port = find_available_port(WEB_UI_DEFAULT_PORT)
+    if ui_port != WEB_UI_DEFAULT_PORT:
+        print(f"Port {WEB_UI_DEFAULT_PORT} in use, using {ui_port}")
+    print("Starting web UI...")
+    print(f"Log: {logger.get_relative_log_path()}")
+
+    def default_display(level: str, msg: str) -> None:
+        if level == "error":
+            print(f"Web UI: {msg}", file=sys.stderr)
+
+    display = on_log or default_display
+
+    def log(level: str, msg: str) -> None:
+        logger.log(msg, level)  # type: ignore[arg-type]
+        display(level, msg)
+
+    def on_ready(url: str) -> None:
+        print(f"\nChat UI: {url}")
+        print("Press Ctrl+C to stop\n", flush=True)
+        open_browser(url)
+
+    web_ui = WebUIServer(WebUIOptions(**server_options, ui_port=ui_port, on_ready=on_ready, on_log=log))
+    web_ui.start()
+
+    stopped = threading.Event()
+
+    def shutdown() -> None:
+        print("\nStopping servers...")
+        web_ui.stop()
+        logger.finalize(True)
+        stopped.set()
+
+    on_shutdown_signal(shutdown)
+    try:
+        while not stopped.wait(0.5):
+            pass
+    except KeyboardInterrupt:
+        if not stopped.is_set():
+            shutdown()