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

agentpool_server/opencode_server/routes/message_routes.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from fastapi import APIRouter, HTTPException, Query
+from fastapi import APIRouter, HTTPException, Query, status
 from pydantic_ai import FunctionToolCallEvent
 from pydantic_ai.messages import (
     PartDeltaEvent,
@@ -14,18 +14,18 @@ from pydantic_ai.messages import (
     ToolCallPart as PydanticToolCallPart,
 )
 
-from agentpool.agents.claude_code_agent.converters import derive_rich_tool_info
 from agentpool.agents.events import (
     CompactionEvent,
     FileContentItem,
     LocationContentItem,
     StreamCompleteEvent,
+    SubAgentEvent,
     TextContentItem,
     ToolCallCompleteEvent,
     ToolCallProgressEvent,
     ToolCallStartEvent,
 )
-from agentpool.messaging.messages import ChatMessage
+from agentpool.agents.events.infer_info import derive_rich_tool_info
 from agentpool.utils import identifiers as identifier
 from agentpool.utils.pydantic_ai_helpers import safe_args_as_dict
 from agentpool_server.opencode_server.converters import (
@@ -33,22 +33,20 @@ from agentpool_server.opencode_server.converters import (
     extract_user_prompt_from_parts,
     opencode_to_chat_message,
 )
-from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
-from agentpool_server.opencode_server.models import (  # noqa: TC001
+from agentpool_server.opencode_server.dependencies import StateDep
+from agentpool_server.opencode_server.models import (
     AssistantMessage,
     MessagePath,
     MessageRequest,
     MessageTime,
     MessageUpdatedEvent,
     MessageWithParts,
-    Part,
     PartUpdatedEvent,
     SessionCompactedEvent,
     SessionErrorEvent,
     SessionIdleEvent,
     SessionStatus,
     SessionStatusEvent,
-    SessionUpdatedEvent,
     StepFinishPart,
     StepStartPart,
     TextPart,
@@ -71,14 +69,14 @@ from agentpool_server.opencode_server.models.parts import (
     TimeStartEndOptional,
     TokenCache,
 )
-from agentpool_server.opencode_server.routes.session_routes import (
-    get_or_load_session,
-    opencode_to_session_data,
-)
+from agentpool_server.opencode_server.routes.session_routes import get_or_load_session
 from agentpool_server.opencode_server.time_utils import now_ms
 
 
 if TYPE_CHECKING:
+    from agentpool_server.opencode_server.models import (
+        Part,
+    )
     from agentpool_server.opencode_server.state import ServerState
 
 
@@ -172,48 +170,6 @@ async def persist_message_to_storage(
         pass
 
 
-async def _generate_session_title(
-    state: ServerState,
-    session_id: str,
-    user_prompt: str,
-    assistant_response: str,
-) -> None:
-    """Generate a title for the session in the background."""
-    try:
-        if not state.pool.storage:
-            return
-
-        # Create ChatMessage objects for the title generator
-        messages = [
-            ChatMessage[str](role="user", content=user_prompt),
-            ChatMessage[str](role="assistant", content=assistant_response),
-        ]
-
-        # Generate title using storage manager
-        title = await state.pool.storage.generate_conversation_title(
-            messages=messages,
-            conversation_id=session_id,
-        )
-
-        if title and session_id in state.sessions:
-            # Update session with new title
-            session = state.sessions[session_id]
-            updated_session = session.model_copy(update={"title": title})
-            state.sessions[session_id] = updated_session
-            session_data = opencode_to_session_data(
-                updated_session,
-                agent_name=state.agent.name,
-                pool_id=state.pool.manifest.config_file_path,
-            )
-            await state.pool.sessions.store.save(session_data)
-
-            # Broadcast session update
-            await state.broadcast_event(SessionUpdatedEvent.create(updated_session))
-    except Exception:  # noqa: BLE001
-        # Don't fail if title generation fails
-        pass
-
-
 router = APIRouter(prefix="/session/{session_id}", tags=["message"])
 
 
@@ -234,13 +190,16 @@ async def list_messages(
     return messages
 
 
-@router.post("/message")
-async def send_message(  # noqa: PLR0915
+async def _process_message(  # noqa: PLR0915
     session_id: str,
     request: MessageRequest,
     state: StateDep,
 ) -> MessageWithParts:
-    """Send a message and get response from the agent."""
+    """Internal helper to process a message request.
+
+    This does the actual work of creating messages, running the agent,
+    and broadcasting events. Used by both sync and async endpoints.
+    """
     session = await get_or_load_session(state, session_id)
     if session is None:
         raise HTTPException(status_code=404, detail="Session not found")
@@ -280,7 +239,8 @@ async def send_message(  # noqa: PLR0915
     for part in user_parts:
         await state.broadcast_event(PartUpdatedEvent.create(part))
     state.session_status[session_id] = SessionStatus(type="busy")
-    await state.broadcast_event(SessionStatusEvent.create(session_id, SessionStatus(type="busy")))
+    status_event = SessionStatusEvent.create(session_id, SessionStatus(type="busy"))
+    await state.broadcast_event(status_event)
     # Extract user prompt text
     user_prompt = extract_user_prompt_from_parts([p.model_dump() for p in request.parts])
     # Create assistant message with sortable ID (must come after user message)
@@ -331,7 +291,7 @@ async def send_message(  # noqa: PLR0915
             agent = state.agent.agent_pool.all_agents.get(request.agent, state.agent)
 
         # Stream events from the agent
-        async for event in agent.run_stream(user_prompt):
+        async for event in agent.run_stream(user_prompt, conversation_id=session_id):
             match event:
                 # Text streaming start
                 case PartStartEvent(part=PydanticTextPart(content=delta)):
@@ -460,6 +420,8 @@ async def send_message(  # noqa: PLR0915
                     tool_input=event_tool_input,
                 ) if tool_call_id:
                     # Extract text content from items and accumulate
+                    # TODO: Handle TerminalContentItem for bash tool streaming - need to
+                    # properly stream terminal output to OpenCode UI metadata
                     new_output = ""
                     file_paths: list[str] = []
                     for item in items:
@@ -536,6 +498,7 @@ async def send_message(  # noqa: PLR0915
                 case ToolCallCompleteEvent(
                     tool_call_id=tool_call_id,
                     tool_result=result,
+                    metadata=event_metadata,
                 ) if tool_call_id in tool_parts:
                     existing = tool_parts[tool_call_id]
                     result_str = str(result) if result else ""
@@ -555,6 +518,7 @@ async def send_message(  # noqa: PLR0915
                             title=f"Completed {existing.tool}",
                             input=tool_input,
                             output=result_str,
+                            metadata=event_metadata or {},
                             time=TimeStartEndCompacted(start=now, end=now_ms()),
                         )
 
@@ -582,6 +546,70 @@ async def send_message(  # noqa: PLR0915
                         # Cost is in Decimal dollars, OpenCode expects float dollars
                         total_cost = float(msg.cost_info.total_cost)
 
+                # Sub-agent/team event - show final results only
+                case SubAgentEvent(
+                    source_name=source_name,
+                    source_type=source_type,
+                    event=wrapped_event,
+                    depth=depth,
+                ):
+                    indent = "  " * (depth - 1)
+
+                    match wrapped_event:
+                        # Final message from sub-agent/team
+                        case StreamCompleteEvent(message=msg):
+                            # Show indicator
+                            icon = "⚡" if source_type == "team_parallel" else "→"
+                            type_label = (
+                                " (parallel)"
+                                if source_type == "team_parallel"
+                                else " (sequential)"
+                                if source_type == "team_sequential"
+                                else ""
+                            )
+                            indicator = f"{indent}{icon} {source_name}{type_label}"
+
+                            indicator_part = TextPart(
+                                id=identifier.ascending("part"),
+                                message_id=assistant_msg_id,
+                                session_id=session_id,
+                                text=indicator,
+                                time=TimeStartEndOptional(start=now_ms()),
+                            )
+                            assistant_msg_with_parts.parts.append(indicator_part)
+                            await state.broadcast_event(PartUpdatedEvent.create(indicator_part))
+
+                            # Show complete message content
+                            content = str(msg.content) if msg.content else "(no output)"
+                            content_part = TextPart(
+                                id=identifier.ascending("part"),
+                                message_id=assistant_msg_id,
+                                session_id=session_id,
+                                text=content,
+                                time=TimeStartEndOptional(start=now_ms()),
+                            )
+                            assistant_msg_with_parts.parts.append(content_part)
+                            await state.broadcast_event(PartUpdatedEvent.create(content_part))
+
+                        # Tool call completed - show one-line summary
+                        case ToolCallCompleteEvent(tool_name=tool_name, tool_result=result):
+                            # Preview result (first 60 chars)
+                            result_str = str(result) if result else ""
+                            preview = (
+                                result_str[:60] + "..." if len(result_str) > 60 else result_str  # noqa: PLR2004
+                            )
+                            summary = f"{indent}  ├─ {tool_name}: {preview}"
+
+                            summary_part = TextPart(
+                                id=identifier.ascending("part"),
+                                message_id=assistant_msg_id,
+                                session_id=session_id,
+                                text=summary,
+                                time=TimeStartEndOptional(start=now_ms()),
+                            )
+                            assistant_msg_with_parts.parts.append(summary_part)
+                            await state.broadcast_event(PartUpdatedEvent.create(summary_part))
+
                 # Compaction event - emit session.compacted SSE event
                 case CompactionEvent(session_id=compact_session_id, phase=phase):
                     if phase == "completed":
@@ -676,17 +704,45 @@ async def send_message(  # noqa: PLR0915
     state.sessions[session_id] = session.model_copy(
         update={"time": TimeCreatedUpdated(created=session.time.created, updated=response_time)}
     )
-    # Trigger title generation if session has default title
-    if session.title == "New Session" and state.pool.storage:
-        # Convert user_prompt to string if it's a list
-        prompt_str = user_prompt if isinstance(user_prompt, str) else str(user_prompt)
-        state.create_background_task(
-            _generate_session_title(state, session_id, prompt_str, response_text),
-            name=f"generate_title_{session_id}",
-        )
+    # Title generation now handled by StorageManager signal (on_title_generated in server.py)
+    # Agent calls log_conversation() → _generate_title_from_prompt() → emits title_generated signal
     return assistant_msg_with_parts
 
 
+@router.post("/message")
+async def send_message(
+    session_id: str,
+    request: MessageRequest,
+    state: StateDep,
+) -> MessageWithParts:
+    """Send a message and wait for the agent's response.
+
+    This is the synchronous version - waits for completion before returning.
+    For async processing, use POST /session/{id}/prompt_async instead.
+    """
+    return await _process_message(session_id, request, state)
+
+
+@router.post("/prompt_async", status_code=status.HTTP_204_NO_CONTENT)
+async def send_message_async(
+    session_id: str,
+    request: MessageRequest,
+    state: StateDep,
+) -> None:
+    """Send a message asynchronously without waiting for response.
+
+    Starts the agent processing in the background and returns immediately.
+    Client should listen to SSE events to get updates.
+
+    Returns 204 No Content immediately.
+    """
+    # Create background task to process the message
+    state.create_background_task(
+        _process_message(session_id, request, state),
+        name=f"process_message_{session_id}",
+    )
+
+
 @router.get("/message/{message_id}")
 async def get_message(
     session_id: str,

agentpool_server/opencode_server/routes/permission_routes.py

@@ -0,0 +1,63 @@
+"""Permission routes for OpenCode TUI compatibility."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+
+from agentpool_server.opencode_server.dependencies import StateDep
+from agentpool_server.opencode_server.models.events import PermissionResolvedEvent
+from agentpool_server.opencode_server.routes.session_routes import PermissionResponse
+
+
+router = APIRouter(prefix="/permission", tags=["permission"])
+
+
+@router.post("/{permission_id}/reply")
+async def reply_to_permission(
+    permission_id: str,
+    body: PermissionResponse,
+    state: StateDep,
+) -> bool:
+    """Respond to a pending permission request (OpenCode TUI compatibility).
+
+    This endpoint handles the OpenCode TUI's expected format:
+    POST /permission/{permission_id}/reply
+
+    The response can be:
+    - "once": Allow this tool execution once
+    - "always": Always allow this tool (remembered for session)
+    - "reject": Reject this tool execution
+    """
+    print(f"DEBUG permission endpoint: received reply '{body.reply}' for perm_id={permission_id}")
+    print(f"DEBUG permission endpoint: searching in {len(state.input_providers)} sessions")
+    # Find which session has this permission request
+    for session_id, input_provider in state.input_providers.items():
+        pending_perms = list(input_provider._pending_permissions.keys())
+        print(
+            f"DEBUG permission endpoint: session {session_id} has "
+            f"{len(pending_perms)} pending: {pending_perms}"
+        )
+        # Check if this permission belongs to this session
+        if permission_id in input_provider._pending_permissions:
+            print(f"DEBUG permission endpoint: found permission in session {session_id}")
+            # Resolve the permission
+            resolved = input_provider.resolve_permission(permission_id, body.reply)
+            print(f"DEBUG permission endpoint: resolve_permission returned {resolved}")
+            if not resolved:
+                raise HTTPException(
+                    status_code=404,
+                    detail="Permission not found or already resolved",
+                )
+
+            await state.broadcast_event(
+                PermissionResolvedEvent.create(
+                    session_id=session_id,
+                    request_id=permission_id,
+                    reply=body.reply,
+                )
+            )
+
+            return True
+
+    # Permission not found in any session
+    raise HTTPException(status_code=404, detail="Permission not found")

agentpool_server/opencode_server/routes/pty_routes.py

@@ -10,17 +10,15 @@ import contextlib
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
-from fastapi import APIRouter, HTTPException, WebSocketDisconnect
+from fastapi import APIRouter, HTTPException, WebSocket, WebSocketDisconnect  # noqa: TC002
 
-from agentpool_server.opencode_server.models import PtyInfo
+from agentpool_server.opencode_server.dependencies import StateDep
+from agentpool_server.opencode_server.models import PtyCreateRequest, PtyInfo, PtyUpdateRequest
 
 
 if TYPE_CHECKING:
     from exxec.pty_manager import PtyManagerProtocol
-    from fastapi import WebSocket
 
-    from agentpool_server.opencode_server.dependencies import StateDep
-    from agentpool_server.opencode_server.models import PtyCreateRequest, PtyUpdateRequest
     from agentpool_server.opencode_server.state import ServerState
 
 
@@ -96,10 +94,15 @@ async def create_pty(request: PtyCreateRequest, state: StateDep) -> PtyInfo:
     from agentpool_server.opencode_server.models.events import PtyCreatedEvent
 
     manager = _get_pty_manager(state)
+    # Limit number of PTY sessions to prevent resource exhaustion
+    sessions = await manager.list_sessions()
+    if len(sessions) >= 20:  # Max 20 concurrent PTY sessions  # noqa: PLR2004
+        detail = f"Too many PTY sessions ({len(sessions)}). Close some terminals first."
+        raise HTTPException(status_code=429, detail=detail)
 
     # Use working dir from state if not specified
     cwd = request.cwd or state.working_dir
-
+    print(f"Creating PTY: command={request.command}, args={request.args}, cwd={cwd}")
     try:
         info = await manager.create(
             command=request.command,
@@ -107,25 +110,22 @@ async def create_pty(request: PtyCreateRequest, state: StateDep) -> PtyInfo:
             cwd=cwd,
             env=request.env,
         )
+        print(f"PTY created successfully: {info.id}, status={info.status}")
     except Exception as e:
         raise HTTPException(status_code=400, detail=f"Failed to create PTY: {e}") from e
 
     pty_id = info.id
     title = request.title or f"Terminal {pty_id[-4:]}"
-
     # Create session tracker for WebSocket subscribers
     session = PtySession(pty_id=pty_id)
     _pty_sessions[pty_id] = session
-
+    print(f"PTY session registered: {pty_id}, total sessions: {len(_pty_sessions)}")
     # Start background task to read output and distribute to subscribers
     session.read_task = asyncio.create_task(_read_pty_output(manager, pty_id, state))
-
     pty_info = _convert_pty_info(info, title=title)
-
     # Broadcast PTY created event
     event = PtyCreatedEvent.create(info=pty_info.model_dump(by_alias=True))
     await state.broadcast_event(event)
-
     return pty_info
 
 
@@ -178,6 +178,7 @@ async def get_pty(pty_id: str, state: StateDep) -> PtyInfo:
     return _convert_pty_info(info)
 
 
+@router.put("/{pty_id}")
 @router.patch("/{pty_id}")
 async def update_pty(pty_id: str, request: PtyUpdateRequest, state: StateDep) -> PtyInfo:
     """Update PTY session (title, resize)."""
@@ -200,13 +201,10 @@ async def update_pty(pty_id: str, request: PtyUpdateRequest, state: StateDep) ->
 
     # Title is handled at the API level, not in the PTY manager
     title = request.title if request.title else f"Terminal {pty_id[-4:]}"
-
     pty_info = _convert_pty_info(info, title=title)
-
     # Broadcast PTY updated event
     event = PtyUpdatedEvent.create(info=pty_info.model_dump(by_alias=True))
     await state.broadcast_event(event)
-
     return pty_info
 
 
@@ -216,12 +214,10 @@ async def remove_pty(pty_id: str, state: StateDep) -> dict[str, bool]:
     from agentpool_server.opencode_server.models.events import PtyDeletedEvent
 
     manager = _get_pty_manager(state)
-
     # Kill the PTY session
     success = await manager.kill(pty_id)
     if not success:
         raise HTTPException(status_code=404, detail="PTY session not found")
-
     # Cleanup session tracker
     session = _pty_sessions.pop(pty_id, None)
     if session:
@@ -249,26 +245,32 @@ async def connect_pty(websocket: WebSocket, pty_id: str) -> None:
     # Get state from websocket's app
 
     state: ServerState = websocket.app.state.server_state
-
     try:
         manager = _get_pty_manager(state)
     except HTTPException:
-        await websocket.close(code=4501, reason="PTY not supported")
+        # Must accept before we can close
+        await websocket.accept()
+        await websocket.close(code=1003, reason="PTY not supported")
+        return
+    except Exception as e:  # noqa: BLE001
+        await websocket.accept()
+        await websocket.close(code=1011, reason=f"Error: {e}")
         return
 
+    # Check if PTY exists - if not, immediately reject like OpenCode does
     info = await manager.get_info(pty_id)
     if not info:
-        await websocket.close(code=4004, reason="PTY session not found")
+        await websocket.accept()
+        await websocket.close(code=1003, reason="PTY session not found")
         return
 
+    # PTY exists, accept the WebSocket connection
     await websocket.accept()
-
     # Get or create session tracker
     if pty_id not in _pty_sessions:
         _pty_sessions[pty_id] = PtySession(pty_id=pty_id)
     session = _pty_sessions[pty_id]
     session.subscribers.add(websocket)
-
     # Send buffered output
     if session.buffer:
         try:
@@ -281,7 +283,6 @@ async def connect_pty(websocket: WebSocket, pty_id: str) -> None:
         while True:
             # Receive input from client
             data = await websocket.receive_text()
-
             # Write to PTY stdin
             info = await manager.get_info(pty_id)
             if info and info.status == "running":

agentpool_server/opencode_server/routes/question_routes.py

@@ -0,0 +1,128 @@
+"""Question routes for OpenCode compatibility."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+
+from agentpool_server.opencode_server.dependencies import StateDep
+from agentpool_server.opencode_server.input_provider import OpenCodeInputProvider
+from agentpool_server.opencode_server.models.events import (
+    QuestionRejectedEvent,
+    QuestionRepliedEvent,
+)
+from agentpool_server.opencode_server.models.question import QuestionReply, QuestionRequest
+
+
+router = APIRouter(prefix="/question", tags=["question"])
+
+
+@router.get("/", response_model=list[QuestionRequest])
+async def list_questions(state: StateDep) -> list[QuestionRequest]:
+    """List all pending question requests.
+
+    Returns a list of all pending questions awaiting user response.
+    """
+    questions = []
+    for question_id, pending in state.pending_questions.items():
+        questions.append(
+            QuestionRequest(
+                id=question_id,
+                session_id=pending.session_id,
+                questions=pending.questions,
+                tool=pending.tool,
+            )
+        )
+    return questions
+
+
+@router.post("/{requestID}/reply")
+async def reply_to_question(
+    requestID: str,  # noqa: N803
+    reply: QuestionReply,
+    state: StateDep,
+) -> bool:
+    """Reply to a question request.
+
+    The user provides answers to the questions. Answers must be provided
+    as an array of arrays, where each inner array contains the selected
+    label(s) for that question.
+
+    Args:
+        requestID: The question request ID
+        reply: The user's answers
+        state: Server state
+
+    Returns:
+        True if the question was resolved successfully
+
+    Raises:
+        HTTPException: If question not found or invalid provider
+    """
+    pending = state.pending_questions.get(requestID)
+    if not pending:
+        raise HTTPException(status_code=404, detail="Question request not found")
+
+    session_id = pending.session_id
+    provider = state.input_providers.get(session_id)
+
+    if not isinstance(provider, OpenCodeInputProvider):
+        raise HTTPException(status_code=500, detail="Invalid provider for session")
+
+    # Resolve via provider
+    success = provider.resolve_question(requestID, reply.answers)
+
+    if not success:
+        raise HTTPException(status_code=404, detail="Question already resolved")
+
+    # Broadcast replied event
+    event = QuestionRepliedEvent.create(
+        session_id=session_id,
+        request_id=requestID,
+        answers=reply.answers,
+    )
+    await state.broadcast_event(event)
+
+    return True
+
+
+@router.post("/{requestID}/reject")
+async def reject_question(
+    requestID: str,  # noqa: N803
+    state: StateDep,
+) -> bool:
+    """Reject a question request.
+
+    Called when the user dismisses the question without providing an answer.
+
+    Args:
+        requestID: The question request ID
+        state: Server state
+
+    Returns:
+        True if the question was rejected successfully
+
+    Raises:
+        HTTPException: If question not found
+    """
+    pending = state.pending_questions.get(requestID)
+    if not pending:
+        raise HTTPException(status_code=404, detail="Question request not found")
+
+    session_id = pending.session_id
+    future = pending.future
+
+    # Cancel the future
+    if not future.done():
+        future.cancel()
+
+    # Remove from pending
+    del state.pending_questions[requestID]
+
+    # Broadcast rejected event
+    event = QuestionRejectedEvent.create(
+        session_id=session_id,
+        request_id=requestID,
+    )
+    await state.broadcast_event(event)
+
+    return True