Restructure: split cli.py and agent/loop.py, consolidate the MCP layer

P1: pion/cli.py (1049 lines) becomes the pion/cli/ package —
app.py (typer commands), bootstrap.py (_async_main assembly),
profiles.py (connection-profile flows), plain.py (REPL), with
__init__.py re-exporting the full public API and __main__.py keeping
"python -m pion.cli mcp" working. Names that tests monkeypatch on the
pion.cli module are resolved through the package namespace at call time.

P2: pion/agent/loop.py (776 lines) splits into loop.py (state machine
and public config types), streaming.py (LLM event stream handling) and
tool_execution.py (tool-call preparation/execution/finalization).
No public names moved; agent.py and tests import unchanged.

P3: pion/mcp.py and pion/mcp_server.py consolidate into the pion/mcp/
package (client.py + sandbox_server.py), with __init__.py re-exporting
the client API.

P4: the unguarded module-level tool instances (DEFAULT_TOOLS & co.)
move to pion/tools/legacy.py with a deprecation note, re-exported for
compatibility; build_default_tools(runtime) is the single supported
entry point.

Pure moves throughout — no behavior changes. Full suite stays green
(288 passed, 2 skipped), entry points and the stdio MCP sandbox server
verified.

Author: Ariasu123

pion/agent/loop.py

@@ -0,0 +1,99 @@
+"""Assistant response streaming — LLM event stream -> AgentEvent conversion.
+
+Split out of `loop.py` (pure move). `_stream_assistant_response` streams one
+assistant response, updating the context as partials arrive and emitting
+`message_start`/`message_update`/`message_end` events.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Optional
+
+from ..llm.event_stream import AssistantMessageEventStream, StreamOptions
+from ..llm.types import AssistantMessage, Context, Tool, sanitize_message
+from .events import AgentEvent
+from .loop import _maybe_await
+
+if TYPE_CHECKING:
+    from .loop import AgentContext, AgentEventSink, AgentLoopConfig, StreamFn
+
+
+async def _stream_assistant_response(
+    context: AgentContext,
+    config: AgentLoopConfig,
+    abort: Optional[asyncio.Event],
+    emit: AgentEventSink,
+    stream_fn: StreamFn,
+) -> AssistantMessage:
+    """Stream one assistant response, updating the context as partials arrive."""
+    messages = context.messages
+    if config.transform_context is not None:
+        messages = await _maybe_await(config.transform_context(messages))
+
+    llm_messages = await _maybe_await(config.convert_to_llm(messages))
+
+    llm_context = Context(
+        system_prompt=context.system_prompt,
+        messages=llm_messages,
+        tools=[
+            Tool(name=tool.name, description=tool.description, parameters=tool.parameters)
+            for tool in context.tools
+        ],
+    )
+
+    options = StreamOptions(api_key=config.api_key, abort=abort)
+    response: AssistantMessageEventStream = await _maybe_await(
+        stream_fn(config.model, llm_context, options)
+    )
+
+    partial: Optional[AssistantMessage] = None
+    added_partial = False
+
+    async for event in response:
+        if event.type == "start":
+            partial = event.partial if event.partial is not None else AssistantMessage()
+            context.messages.append(partial)
+            added_partial = True
+            await emit(AgentEvent(type="message_start", message=partial))
+        elif event.type in (
+            "text_start",
+            "text_delta",
+            "text_end",
+            "thinking_start",
+            "thinking_delta",
+            "thinking_end",
+            "toolcall_start",
+            "toolcall_delta",
+            "toolcall_end",
+        ):
+            if partial is not None:
+                if event.partial is not None:
+                    partial = event.partial
+                    context.messages[-1] = partial
+                await emit(
+                    AgentEvent(type="message_update", assistant_event=event, message=partial)
+                )
+        elif event.type in ("done", "error"):
+            final_message = await response.result()
+            # Scrub lone surrogates coming from the provider (unpaired
+            # \uXXXX escapes) before the message enters the context.
+            final_message = sanitize_message(final_message)
+            if added_partial:
+                context.messages[-1] = final_message
+            else:
+                context.messages.append(final_message)
+                await emit(AgentEvent(type="message_start", message=final_message))
+            await emit(AgentEvent(type="message_end", message=final_message))
+            return final_message
+
+    # Stream ended without done/error: result() raises (contract violation).
+    final_message = await response.result()
+    final_message = sanitize_message(final_message)
+    if added_partial:
+        context.messages[-1] = final_message
+    else:
+        context.messages.append(final_message)
+        await emit(AgentEvent(type="message_start", message=final_message))
+    await emit(AgentEvent(type="message_end", message=final_message))
+    return final_message