agentpool 2.1.9__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool/agents/acp_agent/acp_converters.py

@@ -9,7 +9,7 @@ This is the reverse of the conversion done in acp_server/session.py handle_event
 from __future__ import annotations
 
 import base64
-from typing import TYPE_CHECKING, Any, overload
+from typing import TYPE_CHECKING, Any, assert_never, overload
 
 from pydantic_ai import (
     AudioUrl,
@@ -53,12 +53,24 @@ from agentpool.agents.events import (
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
-    from pydantic_ai import UserContent
-
-    from acp.schema import ContentBlock, SessionUpdate
-    from acp.schema.mcp import HttpMcpServer, McpServer, SseMcpServer, StdioMcpServer
-    from acp.schema.tool_call import ToolCallContent, ToolCallLocation
+    from pydantic_ai import FinishReason, UserContent
+
+    from acp.schema import (
+        ContentBlock,
+        HttpMcpServer,
+        McpServer,
+        SessionConfigOption,
+        SessionModelState,
+        SessionModeState,
+        SessionUpdate,
+        SseMcpServer,
+        StdioMcpServer,
+        StopReason,
+        ToolCallContent,
+        ToolCallLocation,
+    )
     from agentpool.agents.events import RichAgentStreamEvent, ToolCallContentItem
+    from agentpool.agents.modes import ModeCategory, ModeInfo
     from agentpool_config.mcp_server import (
         MCPServerConfig,
         SSEMCPServerConfig,
@@ -66,15 +78,122 @@ if TYPE_CHECKING:
         StreamableHTTPMCPServerConfig,
     )
 
+STOP_REASON_MAP: dict[StopReason, FinishReason] = {
+    "end_turn": "stop",
+    "max_tokens": "length",
+    "max_turn_requests": "length",
+    "refusal": "content_filter",
+    "cancelled": "error",
+}
+
+
+def get_modes(
+    config_options: list[SessionConfigOption],
+    available_modes: SessionModeState | None,
+    available_models: SessionModelState | None,
+) -> list[ModeCategory]:
+    from acp.schema import SessionConfigSelectGroup
+    from agentpool.agents.modes import ModeCategory, ModeInfo
+
+    categories: list[ModeCategory] = []
+
+    if config_options:
+        for config_opt in config_options:
+            # Extract options from the config (ungrouped or grouped)
+            mode_infos: list[ModeInfo] = []
+            if isinstance(config_opt.options, list):
+                for opt_item in config_opt.options:
+                    if isinstance(opt_item, SessionConfigSelectGroup):
+                        mode_infos.extend(
+                            ModeInfo(
+                                id=sub_opt.value,
+                                name=sub_opt.name,
+                                description=sub_opt.description or "",
+                                category_id=config_opt.id,
+                            )
+                            for sub_opt in opt_item.options
+                        )
+                    else:
+                        # Ungrouped options
+                        mode_infos.append(
+                            ModeInfo(
+                                id=opt_item.value,
+                                name=opt_item.name,
+                                description=opt_item.description or "",
+                                category_id=config_opt.id,
+                            )
+                        )
+
+            categories.append(
+                ModeCategory(
+                    id=config_opt.id,
+                    name=config_opt.name,
+                    available_modes=mode_infos,
+                    current_mode_id=config_opt.current_value,
+                    category=config_opt.category or "other",
+                )
+            )
+        return categories
+
+    # Legacy: Convert ACP SessionModeState to ModeCategory
+    if available_modes:
+        acp_modes = available_modes
+        modes = [
+            ModeInfo(
+                id=m.id,
+                name=m.name,
+                description=m.description or "",
+                category_id="permissions",
+            )
+            for m in acp_modes.available_modes
+        ]
+        categories.append(
+            ModeCategory(
+                id="permissions",
+                name="Mode",
+                available_modes=modes,
+                current_mode_id=acp_modes.current_mode_id,
+                category="mode",
+            )
+        )
+
+    # Legacy: Convert ACP SessionModelState to ModeCategory
+    if available_models:
+        acp_models = available_models
+        models = [
+            ModeInfo(
+                id=m.model_id,
+                name=m.name,
+                description=m.description or "",
+                category_id="model",
+            )
+            for m in acp_models.available_models
+        ]
+        categories.append(
+            ModeCategory(
+                id="model",
+                name="Model",
+                available_modes=models,
+                current_mode_id=acp_models.current_model_id,
+                category="model",
+            )
+        )
+
+    return categories
+
+
+def to_finish_reason(stop_reason: StopReason) -> FinishReason:
+    return STOP_REASON_MAP.get(stop_reason, "stop")
+
 
 def convert_acp_locations(
-    locations: list[ToolCallLocation] | None,
+    locations: Sequence[ToolCallLocation] | None,
 ) -> list[LocationContentItem]:
     """Convert ACP ToolCallLocation list to native LocationContentItem list."""
     return [LocationContentItem(path=loc.path, line=loc.line) for loc in locations or []]
 
 
-def convert_acp_content(content: list[ToolCallContent] | None) -> list[ToolCallContentItem]:
+def convert_acp_content(content: Sequence[ToolCallContent] | None) -> list[ToolCallContentItem]:
     """Convert ACP ToolCallContent list to native ToolCallContentItem list."""
     if not content:
         return []
@@ -189,42 +308,70 @@ def acp_to_native_event(update: SessionUpdate) -> RichAgentStreamEvent[Any] | No
         # Text message chunks -> PartDeltaEvent with TextPartDelta
         case AgentMessageChunk(content=TextContentBlock(text=text)):
             return PartDeltaEvent(index=0, delta=TextPartDelta(content_delta=text))
+
         # Thought chunks -> PartDeltaEvent with ThinkingPartDelta
         case AgentThoughtChunk(content=TextContentBlock(text=text)):
             return PartDeltaEvent(index=0, delta=ThinkingPartDelta(content_delta=text))
-        # User message echo - could emit as PartStartEvent if needed
+
+        # User message echo - usually ignored
         case UserMessageChunk():
-            return None  # Usually ignored
+            return None
+
         # Tool call start -> ToolCallStartEvent
-        case ToolCallStart() as tc:
+        case ToolCallStart(
+            tool_call_id=tool_call_id,
+            title=title,
+            kind=kind,
+            content=content,
+            locations=locations,
+            raw_input=raw_input,
+        ):
             return ToolCallStartEvent(
-                tool_call_id=tc.tool_call_id,
-                tool_name=tc.title,  # ACP uses title, not separate tool_name
-                title=tc.title,
-                kind=tc.kind or "other",
-                content=convert_acp_content(list(tc.content) if tc.content else None),
-                locations=convert_acp_locations(list(tc.locations) if tc.locations else None),
-                raw_input=tc.raw_input or {},
+                tool_call_id=tool_call_id,
+                tool_name=title,  # ACP uses title, not separate tool_name
+                title=title,
+                kind=kind or "other",
+                content=convert_acp_content(list(content) if content else None),
+                locations=convert_acp_locations(list(locations) if locations else None),
+                raw_input=raw_input or {},
             )
 
-        # Tool call progress -> ToolCallProgressEvent
-        case ToolCallProgress() as tc:
-            items = convert_acp_content(list(tc.content) if tc.content else None)
+        # Tool call progress -> ToolCallProgressEvent or ToolCallCompleteEvent
+        case ToolCallProgress(
+            tool_call_id=tool_call_id,
+            status=status,
+            title=title,
+            content=content,
+            raw_output=raw_output,
+        ):
+            # If completed, return ToolCallCompleteEvent for metadata injection
+            if status == "completed":
+                from agentpool.agents.events import ToolCallCompleteEvent
+
+                return ToolCallCompleteEvent(
+                    tool_call_id=tool_call_id,
+                    tool_name=title or "unknown",
+                    tool_input={},  # ACP doesn't provide input in progress updates
+                    tool_result=str(raw_output) if raw_output else "",
+                    agent_name="",  # Will be set by agent
+                    message_id="",
+                    metadata=None,  # Will be injected by agent from metadata accumulator
+                )
+            # Otherwise return progress event
             return ToolCallProgressEvent(
-                tool_call_id=tc.tool_call_id,
-                status=tc.status or "in_progress",
-                title=tc.title,
-                items=items,
-                message=str(tc.raw_output) if tc.raw_output else None,
+                tool_call_id=tool_call_id,
+                status=status or "in_progress",
+                title=title,
+                items=convert_acp_content(list(content) if content else None),
+                message=str(raw_output) if raw_output else None,
             )
 
         # Plan update -> PlanUpdateEvent
-        case AgentPlanUpdate(entries=acp_entries):
+        case AgentPlanUpdate(entries=entries):
             from agentpool.resource_providers.plan_provider import PlanEntry
 
             native_entries = [
-                PlanEntry(content=e.content, priority=e.priority, status=e.status)
-                for e in acp_entries
+                PlanEntry(content=e.content, priority=e.priority, status=e.status) for e in entries
             ]
             return PlanUpdateEvent(entries=native_entries)
 
@@ -233,24 +380,27 @@ def acp_to_native_event(update: SessionUpdate) -> RichAgentStreamEvent[Any] | No
 
 
 @overload
-def mcp_config_to_acp(config: StdioMCPServerConfig) -> StdioMcpServer | None: ...
+def mcp_config_to_acp(config: StdioMCPServerConfig) -> StdioMcpServer: ...
 
 
 @overload
-def mcp_config_to_acp(config: SSEMCPServerConfig) -> SseMcpServer | None: ...
+def mcp_config_to_acp(config: SSEMCPServerConfig) -> SseMcpServer: ...
 
 
 @overload
-def mcp_config_to_acp(config: StreamableHTTPMCPServerConfig) -> HttpMcpServer | None: ...
+def mcp_config_to_acp(config: StreamableHTTPMCPServerConfig) -> HttpMcpServer: ...
 
 
 @overload
-def mcp_config_to_acp(config: MCPServerConfig) -> McpServer | None: ...
+def mcp_config_to_acp(config: MCPServerConfig) -> McpServer: ...
 
 
-def mcp_config_to_acp(config: MCPServerConfig) -> McpServer | None:
+def mcp_config_to_acp(config: MCPServerConfig) -> McpServer:
     """Convert native MCPServerConfig to ACP McpServer format.
 
+    If the config has tool filtering (enabled_tools or disabled_tools),
+    the server is wrapped with mcp-filter proxy to apply the filtering.
+
     Args:
         config: agentpool MCP server configuration
 
@@ -265,21 +415,29 @@ def mcp_config_to_acp(config: MCPServerConfig) -> McpServer | None:
         StreamableHTTPMCPServerConfig,
     )
 
+    # If filtering is configured, wrap with mcp-filter first
+    if config.needs_tool_filtering():
+        config = config.wrap_with_mcp_filter()
+
     match config:
         case StdioMCPServerConfig(command=command, args=args):
             env_vars = config.get_env_vars() if hasattr(config, "get_env_vars") else {}
+            env_list = [EnvVariable(name=k, value=v) for k, v in env_vars.items()]
             return StdioMcpServer(
                 name=config.name or command,
                 command=command,
                 args=list(args) if args else [],
-                env=[EnvVariable(name=k, value=v) for k, v in env_vars.items()],
+                env=env_list,
             )
+
         case SSEMCPServerConfig(url=url):
             return SseMcpServer(name=config.name or str(url), url=url, headers=[])
+
         case StreamableHTTPMCPServerConfig(url=url):
             return HttpMcpServer(name=config.name or str(url), url=url, headers=[])
-        case _:
-            return None
+
+        case _ as unreachable:
+            assert_never(unreachable)
 
 
 def mcp_configs_to_acp(configs: Sequence[MCPServerConfig]) -> list[McpServer]:
@@ -291,4 +449,4 @@ def mcp_configs_to_acp(configs: Sequence[MCPServerConfig]) -> list[McpServer]:
     Returns:
         List of ACP-compatible McpServer instances (skips unconvertible configs)
     """
-    return [converted for config in configs if (converted := mcp_config_to_acp(config)) is not None]
+    return [mcp_config_to_acp(config) for config in configs]

agentpool/agents/acp_agent/client_handler.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import asyncio
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
-import uuid
 
 import anyio
 
@@ -21,13 +20,16 @@ from acp.schema import (
     WriteTextFileResponse,
 )
 from agentpool.log import get_logger
-from agentpool.tools.base import Tool
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from exxec import ExecutionEnvironment
+    from slashed import Command
 
     from acp.schema import (
+        AvailableCommand,
         CreateTerminalRequest,
         KillTerminalCommandRequest,
         ReadTextFileRequest,
@@ -75,7 +77,7 @@ class ACPClientHandler(Client):
         self.state = state
         self._input_provider = input_provider
         self._update_event = asyncio.Event()
-        # Map ACP terminal IDs to process manager IDs
+        # Map ACP terminal IDs to process manager IDs (for local execution only)
         self._terminal_to_process: dict[str, str] = {}
         # Copy tool confirmation mode from agent (can be updated via set_tool_confirmation_mode)
         self.tool_confirmation_mode: ToolConfirmationMode = agent.tool_confirmation_mode
@@ -98,11 +100,93 @@ class ACPClientHandler(Client):
         return self._agent.config.allow_terminal
 
     async def session_update(self, params: SessionNotification[Any]) -> None:
-        """Handle session update notifications from the agent."""
+        """Handle session update notifications from the agent.
+
+        Some updates are state changes (mode, model, config) that should update
+        session state. Others are stream events (text chunks, tool calls) that
+        should be queued for the run_stream consumer.
+        """
+        from acp.schema import (
+            AvailableCommandsUpdate,
+            ConfigOptionUpdate,
+            CurrentModelUpdate,
+            CurrentModeUpdate,
+        )
         from agentpool.agents.acp_agent.acp_converters import acp_to_native_event
 
         update = params.update
-        # Convert to native event and queue it
+
+        # Handle state updates - these modify session state, not stream events
+        match update:
+            case CurrentModeUpdate(current_mode_id=mode_id):
+                if self.state.modes:
+                    self.state.modes.current_mode_id = mode_id
+                    # Find ModeInfo and emit signal
+                    for acp_mode in self.state.modes.available_modes:
+                        if acp_mode.id == mode_id:
+                            from agentpool.agents.modes import ModeInfo
+
+                            mode_info = ModeInfo(
+                                id=acp_mode.id,
+                                name=acp_mode.name,
+                                description=acp_mode.description or "",
+                                category_id="remote",
+                            )
+                            await self._agent.state_updated.emit(mode_info)
+                            break
+                self.state.current_mode_id = mode_id
+                logger.debug("Mode updated", mode_id=mode_id)
+                self._update_event.set()
+                return
+
+            case CurrentModelUpdate(current_model_id=model_id):
+                self.state.current_model_id = model_id
+                if self.state.models:
+                    self.state.models.current_model_id = model_id
+                    # Find ModelInfo and emit signal
+                    for acp_model in self.state.models.available_models:
+                        if acp_model.model_id == model_id:
+                            from tokonomics.model_discovery.model_info import (
+                                ModelInfo as TokoModelInfo,
+                            )
+
+                            model_info = TokoModelInfo(
+                                id=acp_model.model_id,
+                                name=acp_model.name,
+                                description=acp_model.description,
+                            )
+                            await self._agent.state_updated.emit(model_info)
+                            break
+                logger.debug("Model updated", model_id=model_id)
+                self._update_event.set()
+                return
+
+            case ConfigOptionUpdate():
+                await self._agent.state_updated.emit(update)
+                logger.debug("Config option updated", update=update)
+                self._update_event.set()
+                return
+
+            case AvailableCommandsUpdate():
+                self.state.available_commands = update
+                # Populate command store with remote commands
+                self._populate_command_store(update.available_commands)
+                # Emit to parent session - remote commands will be merged with local ones.
+                # The "way back" works because session.split_commands() only extracts
+                # LOCAL commands; remote commands pass through to the agent prompt.
+                await self._agent.state_updated.emit(update)
+                logger.debug("Available commands updated", count=len(update.available_commands))
+                self._update_event.set()
+                return
+
+        # TODO: AgentPlanUpdate handling is complex and needs design work.
+        # Options:
+        # 1. Update pool.todos - requires merging with existing todos
+        # 2. Pass through to UI - but then todos aren't centrally managed
+        # 3. Switch to agent-owned todos instead of pool-owned
+        # For now, AgentPlanUpdate falls through to stream events.
+
+        # All other updates are stream events - convert and queue
         if native_event := acp_to_native_event(update):
             self.state.events.append(native_event)
         self._update_event.set()
@@ -138,11 +222,21 @@ class ACPClientHandler(Client):
 
         if self._input_provider:
             ctx = self._agent.get_context()  # Use the agent's NodeContext
+            # Attach tool call metadata for permission event matching
+            ctx.tool_call_id = params.tool_call.tool_call_id
+            ctx.tool_name = params.tool_call.title
+            args = (
+                params.tool_call.raw_input if isinstance(params.tool_call.raw_input, dict) else {}
+            )
+            ctx.tool_input = args
             # Create a dummy tool representation from ACP params
-            tool = Tool(callable=lambda: None, name=params.tool_call.tool_call_id, description=name)
-            # Extract arguments - ACP doesn't expose them in ToolCall
+            from agentpool.tools import FunctionTool
+
+            tool = FunctionTool(
+                callable=lambda: None, name=params.tool_call.tool_call_id, description=name
+            )
             try:
-                result = await self._input_provider.get_tool_confirmation(ctx, tool=tool, args={})
+                result = await self._input_provider.get_tool_confirmation(ctx, tool=tool, args=args)
                 # Map confirmation result to ACP response
                 if result == "allow":
                     option_id = params.options[0].option_id if params.options else "allow"
@@ -177,9 +271,10 @@ class ACPClientHandler(Client):
             logger.debug("Read file", path=params.path, num_chars=len(content))
             return ReadTextFileResponse(content=content)
 
-        except FileNotFoundError:
-            logger.exception("File not found", path=params.path)
-            raise
+        except (FileNotFoundError, KeyError):
+            # Match Zed behavior: return empty string for non-existent files
+            logger.debug("File not found, returning empty string", path=params.path)
+            return ReadTextFileResponse(content="")
         except Exception:
             logger.exception("Failed to read file", path=params.path)
             raise
@@ -202,11 +297,18 @@ class ACPClientHandler(Client):
             raise
 
     async def create_terminal(self, params: CreateTerminalRequest) -> CreateTerminalResponse:
-        """Create a new terminal session via ProcessManager."""
+        """Create a new terminal session via the configured ExecutionEnvironment.
+
+        The ProcessManager implementation determines where the terminal runs
+        (local, Docker, E2B, SSH, or forwarded to parent ACP client like Zed).
+
+        The terminal_id returned by process_manager.start_process() is used directly.
+        """
         if not self.allow_terminal:
             raise RuntimeError("Terminal operations not allowed")
+
         try:
-            process_id = await self.env.process_manager.start_process(
+            terminal_id = await self.env.process_manager.start_process(
                 command=params.command,
                 args=list(params.args) if params.args else None,
                 cwd=params.cwd,
@@ -216,10 +318,10 @@ class ACPClientHandler(Client):
             logger.exception("Failed to create terminal", command=params.command)
             raise
         else:
-            terminal_id = f"term_{uuid.uuid4().hex[:8]}"
-            self._terminal_to_process[terminal_id] = process_id
-            msg = "Created terminal"
-            logger.info(msg, terminal_id=terminal_id, process_id=process_id, cmd=params.command)
+            # Use the ID from process_manager directly - for ACPProcessManager this
+            # is already the parent's terminal ID (e.g., Zed's)
+            self._terminal_to_process[terminal_id] = terminal_id
+            logger.info("Created terminal", terminal_id=terminal_id, command=params.command)
             return CreateTerminalResponse(terminal_id=terminal_id)
 
     async def terminal_output(self, params: TerminalOutputRequest) -> TerminalOutputResponse:
@@ -231,8 +333,7 @@ class ACPClientHandler(Client):
         if terminal_id not in self._terminal_to_process:
             raise ValueError(f"Terminal {terminal_id} not found")
 
-        process_id = self._terminal_to_process[terminal_id]
-        proc_output = await self.env.process_manager.get_output(process_id)
+        proc_output = await self.env.process_manager.get_output(terminal_id)
         output = proc_output.combined or proc_output.stdout or ""
         return TerminalOutputResponse(output=output, truncated=proc_output.truncated)
 
@@ -247,8 +348,7 @@ class ACPClientHandler(Client):
         if terminal_id not in self._terminal_to_process:
             raise ValueError(f"Terminal {terminal_id} not found")
 
-        process_id = self._terminal_to_process[terminal_id]
-        exit_code = await self.env.process_manager.wait_for_exit(process_id)
+        exit_code = await self.env.process_manager.wait_for_exit(terminal_id)
         logger.debug("Terminal exited", terminal_id=terminal_id, exit_code=exit_code)
         return WaitForTerminalExitResponse(exit_code=exit_code)
 
@@ -263,8 +363,7 @@ class ACPClientHandler(Client):
         if terminal_id not in self._terminal_to_process:
             raise ValueError(f"Terminal {terminal_id} not found")
 
-        process_id = self._terminal_to_process[terminal_id]
-        await self.env.process_manager.kill_process(process_id)
+        await self.env.process_manager.kill_process(terminal_id)
         logger.info("Killed terminal", terminal_id=terminal_id)
         return KillTerminalCommandResponse()
 
@@ -276,8 +375,8 @@ class ACPClientHandler(Client):
         terminal_id = params.terminal_id
         if terminal_id not in self._terminal_to_process:
             raise ValueError(f"Terminal {terminal_id} not found")
-        process_id = self._terminal_to_process[terminal_id]
-        await self.env.process_manager.release_process(process_id)
+
+        await self.env.process_manager.release_process(terminal_id)
         del self._terminal_to_process[terminal_id]
         logger.info("Released terminal", terminal_id=terminal_id)
         return ReleaseTerminalResponse()
@@ -301,13 +400,79 @@ class ACPClientHandler(Client):
         """Handle extension notifications."""
         logger.debug("Extension notification", method=method)
 
+    def _populate_command_store(self, commands: Sequence[AvailableCommand]) -> None:
+        """Populate the agent's command store with remote ACP commands.
+
+        Args:
+            commands: List of AvailableCommand objects from the remote agent
+        """
+        store = self._agent.command_store
+
+        for cmd in commands:
+            command = self._create_acp_command(cmd)
+            # Unregister if already exists (in case of update)
+            if store.get_command(cmd.name):
+                store.unregister_command(cmd.name)
+            store.register_command(command)
+
+        logger.debug("Populated command store", command_count=len(store.list_commands()))
+
+    def _create_acp_command(self, cmd: AvailableCommand) -> Command:
+        """Create a slashed Command from an ACP AvailableCommand.
+
+        The command, when executed, sends a prompt with the slash command
+        to the remote ACP agent.
+
+        Args:
+            cmd: AvailableCommand from remote agent
+
+        Returns:
+            A slashed Command that sends the command to the remote agent
+        """
+        from pydantic_ai import PartDeltaEvent, TextPartDelta
+        from slashed import Command
+
+        name = cmd.name
+        description = cmd.description
+        input_hint = cmd.input.root.hint if cmd.input else None
+
+        async def execute_command(
+            ctx: Any,
+            args: list[str],
+            kwargs: dict[str, str],
+        ) -> None:
+            """Execute the remote ACP slash command."""
+            # Build command string
+            args_str = " ".join(args) if args else ""
+            if kwargs:
+                kwargs_str = " ".join(f"{k}={v}" for k, v in kwargs.items())
+                args_str = f"{args_str} {kwargs_str}".strip()
+
+            full_command = f"/{name} {args_str}".strip()
+
+            # Execute via agent run_stream - the slash command goes as a prompt
+            async for event in self._agent.run_stream(full_command):
+                # Extract text from PartDeltaEvent with TextPartDelta
+                if isinstance(event, PartDeltaEvent):
+                    delta = event.delta
+                    if isinstance(delta, TextPartDelta):
+                        await ctx.print(delta.content_delta)
+
+        return Command.from_raw(
+            execute_command,
+            name=name,
+            description=description,
+            category="remote",
+            usage=input_hint,
+        )
+
 
 if __name__ == "__main__":
     from agentpool.agents.acp_agent import ACPAgent
 
     async def main() -> None:
         """Demo: Basic call to an ACP agent."""
-        args = ["run", "agentpool", "serve-acp", "--model-provider", "openai"]
+        args = ["run", "agentpool", "serve-acp"]
         cwd = str(Path.cwd())
         async with ACPAgent(command="uv", args=args, cwd=cwd, event_handlers=["detailed"]) as agent:
             print("Response (streaming): ", end="", flush=True)