openhands-agent-server 1.45.0__tar.gz → 1.47.0__tar.gz

{openhands_agent_server-1.45.0 → openhands_agent_server-1.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.45.0
+Version: 1.47.0
 Summary: OpenHands Agent Server - REST/WebSocket interface for OpenHands AI Agent
 Project-URL: Source, https://github.com/OpenHands/software-agent-sdk
 Project-URL: Homepage, https://github.com/OpenHands/software-agent-sdk

{openhands_agent_server-1.45.0 → openhands_agent_server-1.47.0}/openhands/agent_server/canvas_extensions_router.py

@@ -24,8 +24,12 @@ from openhands.agent_server.canvas_extensions.installed import (
     list_installed_canvas_extensions,
     uninstall_canvas_extension,
 )
-from openhands.agent_server.canvas_extensions.manifest import CanvasExtensionManifest
+from openhands.agent_server.canvas_extensions.manifest import (
+    MANIFEST_FILENAME,
+    CanvasExtensionManifest,
+)
 from openhands.sdk.extensions.fetch import ExtensionFetchError
+from openhands.sdk.utils.redact import redact_url_credentials
 
 
 canvas_extensions_router = APIRouter(
@@ -144,7 +148,7 @@ class UninstallCanvasExtensionResponse(BaseModel):
     "/install",
     response_model=InstalledCanvasExtensionResponse,
     responses={
-        400: {"description": "Failed to fetch canvas extension source"},
+        400: {"description": "Could not read canvas extension source"},
         409: {"description": "Canvas extension already installed (use force=true)"},
         422: {"description": "Invalid canvas extension (bad manifest, etc.)"},
     },
@@ -173,12 +177,27 @@ def install_canvas_extension_endpoint(
             status_code=409,
             detail="Canvas extension already installed. Use force=true to overwrite.",
         )
-    except ExtensionFetchError:
+    except ExtensionFetchError as e:
+        # Pass the specific reason through -- which of source/ref/repo_path is
+        # wrong is the whole diagnostic, and a generic message misattributes a
+        # bad repo_path to the source. Redacted in case a URL carried a token.
+        # Deliberately not worded "failed to fetch": the canvas client treats
+        # that phrase as a network outage and hides the reason behind a
+        # "Disconnected, check your network" toast.
         raise HTTPException(
             status_code=400,
             detail=(
-                "Failed to fetch canvas extension source. "
-                "Check that the source is valid."
+                "Could not read canvas extension source: "
+                f"{redact_url_credentials(str(e))}"
+            ),
+        )
+    except FileNotFoundError:
+        raise HTTPException(
+            status_code=422,
+            detail=(
+                f"No {MANIFEST_FILENAME} found at the resolved location. "
+                "Source plus Path must point at the extension's own "
+                "directory, not the repository root."
             ),
         )
     except (ValidationError, ValueError, OSError):

{openhands_agent_server-1.45.0 → openhands_agent_server-1.47.0}/openhands/agent_server/event_service.py

@@ -31,6 +31,7 @@ from openhands.sdk.agent.acp_file_credentials import (
     CODEX_AUTH_SECRET_NAME,
     is_valid_codex_auth,
 )
+from openhands.sdk.agent.stream_context import StreamProgress
 from openhands.sdk.conversation.base import BaseConversation
 from openhands.sdk.conversation.events_list_base import EventsListBase
 from openhands.sdk.conversation.exceptions import ConversationRunError
@@ -135,6 +136,11 @@ class EventService:
     _pub_sub: PubSub[Event] = field(
         default_factory=lambda: PubSub[Event](max_subscribers=50), init=False
     )
+    # Its own fan-out, not the event bus: frames are not events, and only the
+    # session socket consumes them.
+    _stream_pub_sub: PubSub[StreamProgress] = field(
+        default_factory=lambda: PubSub[StreamProgress](max_subscribers=50), init=False
+    )
     _run_task: asyncio.Task | None = field(default=None, init=False)
     # Set when a send_message(run=True) is rejected because a run is still
     # wrapping up; consumed by _run_and_publish to re-run the stranded message.
@@ -848,6 +854,19 @@ class EventService:
     async def unsubscribe_from_events(self, subscriber_id: UUID) -> bool:
         return self._pub_sub.unsubscribe(subscriber_id)
 
+    async def subscribe_to_stream_progress(
+        self, subscriber: Subscriber[StreamProgress]
+    ) -> UUID:
+        """Register for stream-progress frames.
+
+        No initial push, unlike :meth:`subscribe_to_events`: a client that
+        connects mid-stream gets the real text with the durable event.
+        """
+        return self._stream_pub_sub.subscribe(subscriber)
+
+    async def unsubscribe_from_stream_progress(self, subscriber_id: UUID) -> bool:
+        return self._stream_pub_sub.unsubscribe(subscriber_id)
+
     def _emit_event_from_thread(self, event: Event) -> None:
         """Helper to safely emit events from non-async contexts (e.g., callbacks).
 
@@ -1075,6 +1094,16 @@ class EventService:
             with suppress(RuntimeError):  # main loop already closed during teardown
                 asyncio.run_coroutine_threadsafe(self._pub_sub(event), self._main_loop)
 
+        def _publish_stream_progress(frame: StreamProgress) -> None:
+            # Same cross-thread hop as _publish_stream_delta: called from the
+            # run thread, or the ACP portal thread.
+            if not self._main_loop or not self._main_loop.is_running():
+                return
+            with suppress(RuntimeError):  # main loop already closed during teardown
+                asyncio.run_coroutine_threadsafe(
+                    self._stream_pub_sub(frame), self._main_loop
+                )
+
         def _token_streaming_callback(chunk: LLMStreamChunk | str) -> None:
             if isinstance(chunk, str):
                 _publish_stream_delta(content=chunk)
@@ -1099,6 +1128,7 @@ class EventService:
             conversation_id=self.stored.id,
             callbacks=[self._callback_wrapper],
             token_callbacks=([_token_streaming_callback] if streaming_enabled else []),
+            stream_callbacks=[_publish_stream_progress],
             max_iteration_per_run=self.stored.max_iterations,
             stuck_detection=self.stored.stuck_detection,
             visualizer=None,
@@ -1357,6 +1387,17 @@ class EventService:
             # Create task but don't await it - runs in background
             self._run_task = asyncio.create_task(_run_and_publish())
 
+    async def wait_for_run_completion(
+        self, timeout: float | None = None
+    ) -> ConversationExecutionStatus:
+        """Wait for the active run task without cancelling it on timeout."""
+        run_task = self._run_task
+        if run_task is not None:
+            done, _ = await asyncio.wait({run_task}, timeout=timeout)
+            if not done:
+                raise TimeoutError("Conversation run timed out")
+        return await self._get_execution_status()
+
     async def start_goal_loop(
         self,
         objective: str,
@@ -1774,6 +1815,7 @@ class EventService:
             self._run_task = None
 
         await self._pub_sub.close()
+        await self._stream_pub_sub.close()
         if self._conversation:
             loop = asyncio.get_running_loop()
             await loop.run_in_executor(None, self._conversation.close)

openhands_agent_server-1.47.0/openhands/agent_server/openai/models.py

@@ -0,0 +1,133 @@
+"""Models for the OpenAI-compatible agent-server gateway."""
+
+from typing import Literal
+
+from openai.types import CompletionUsage, Model
+from openai.types.chat import ChatCompletion, ChatCompletionChunk
+from openai.types.chat.chat_completion import Choice
+from openai.types.chat.chat_completion_chunk import Choice as ChunkChoice, ChoiceDelta
+from openai.types.chat.chat_completion_message import ChatCompletionMessage
+from pydantic import BaseModel, ConfigDict
+
+
+OpenAIChatCompletionChoice = Choice
+OpenAIChatCompletionChunk = ChatCompletionChunk
+OpenAIChatCompletionChunkChoice = ChunkChoice
+OpenAIChatCompletionChunkChoiceDelta = ChoiceDelta
+OpenAIChatCompletionResponse = ChatCompletion
+OpenAIModel = Model
+OpenAIResponseMessage = ChatCompletionMessage
+OpenAIUsage = CompletionUsage
+
+
+class OpenAIResponseInputTokensDetails(BaseModel):
+    cached_tokens: int
+
+
+class OpenAIResponseOutputTokensDetails(BaseModel):
+    reasoning_tokens: int
+
+
+class OpenAIResponseUsage(BaseModel):
+    input_tokens: int
+    input_tokens_details: OpenAIResponseInputTokensDetails
+    output_tokens: int
+    output_tokens_details: OpenAIResponseOutputTokensDetails
+    total_tokens: int
+
+
+class OpenAIResponseOutputText(BaseModel):
+    annotations: list[dict[str, object]]
+    text: str
+    type: Literal["output_text"] = "output_text"
+
+
+class OpenAIResponseOutputMessage(BaseModel):
+    id: str
+    content: list[OpenAIResponseOutputText]
+    role: Literal["assistant"] = "assistant"
+    status: Literal["completed"] = "completed"
+    type: Literal["message"] = "message"
+
+
+class OpenAIResponse(BaseModel):
+    id: str
+    created_at: float
+    completed_at: float
+    instructions: str | None = None
+    metadata: dict[str, str] | None = None
+    model: str
+    object: Literal["response"] = "response"
+    output: list[OpenAIResponseOutputMessage]
+    parallel_tool_calls: bool = False
+    previous_response_id: str | None = None
+    status: Literal["completed"] = "completed"
+    tool_choice: Literal["none"] = "none"
+    tools: list[dict[str, str]]
+    usage: OpenAIResponseUsage
+
+
+class OpenAIImageURL(BaseModel):
+    url: str
+
+
+class OpenAIContentPart(BaseModel):
+    type: str
+    text: str | None = None
+    image_url: OpenAIImageURL | str | None = None
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class OpenAIChatMessage(BaseModel):
+    role: Literal["system", "developer", "user", "assistant", "tool"]
+    content: str | list[OpenAIContentPart] | None = None
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class OpenAIStreamOptions(BaseModel):
+    include_usage: bool = False
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class OpenAIChatCompletionRequest(BaseModel):
+    model: str
+    messages: list[OpenAIChatMessage]
+    stream: bool = False
+    stream_options: OpenAIStreamOptions | None = None
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class OpenAIResponseInputContentPart(BaseModel):
+    type: str
+    text: str | None = None
+    image_url: str | None = None
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class OpenAIResponseInputMessage(BaseModel):
+    role: Literal["system", "developer", "user", "assistant"]
+    content: str | list[OpenAIResponseInputContentPart]
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class OpenAIResponseRequest(BaseModel):
+    model: str
+    input: str | list[OpenAIResponseInputMessage]
+    instructions: str | None = None
+    previous_response_id: str | None = None
+    store: bool = False
+    stream: bool = False
+    metadata: dict[str, str] | None = None
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class OpenAIModelListResponse(BaseModel):
+    object: Literal["list"] = "list"
+    data: list[OpenAIModel]

{openhands_agent_server-1.45.0 → openhands_agent_server-1.47.0}/openhands/agent_server/openai/router.py

@@ -16,11 +16,14 @@ from openhands.agent_server.openai.models import (
     OpenAIChatCompletionRequest,
     OpenAIChatCompletionResponse,
     OpenAIModelListResponse,
+    OpenAIResponse,
+    OpenAIResponseRequest,
 )
 from openhands.agent_server.openai.service import (
     iter_openai_chat_completion_sse,
     list_openai_models,
     run_chat_completion,
+    run_response,
 )
 from openhands.sdk.conversation.types import (
     ConversationObservabilityMetadata,
@@ -167,3 +170,37 @@ async def create_chat_completion(
 
     response.headers["X-OpenHands-ServerConversation-ID"] = conversation_id
     return result.response
+
+
+@openai_router.post(
+    "/v1/responses",
+    response_model=OpenAIResponse,
+    response_model_exclude_none=True,
+)
+async def create_response(
+    body: OpenAIResponseRequest,
+    request: Request,
+    response: Response,
+    x_openhands_observability_span_name: Annotated[
+        str | None, Header(alias="X-OpenHands-Observability-Span-Name")
+    ] = None,
+    x_openhands_observability_tags: Annotated[
+        str | None, Header(alias="X-OpenHands-Observability-Tags")
+    ] = None,
+    x_openhands_observability_metadata: Annotated[
+        str | None, Header(alias="X-OpenHands-Observability-Metadata")
+    ] = None,
+    conversation_service: ConversationService = Depends(get_conversation_service),
+) -> OpenAIResponse:
+    result = await run_response(
+        request=body,
+        config=_get_config(request),
+        conversation_service=conversation_service,
+        observability_overrides=_parse_observability_overrides(
+            span_name=x_openhands_observability_span_name,
+            tags=x_openhands_observability_tags,
+            metadata=x_openhands_observability_metadata,
+        ),
+    )
+    response.headers["X-OpenHands-ServerConversation-ID"] = str(result.conversation_id)
+    return result.response