pythinker-code 2.0.0__py3-none-any.whl

pythinker_code/tools/web/search.py

@@ -0,0 +1,163 @@
+from pathlib import Path
+from typing import override
+
+import aiohttp
+from pydantic import BaseModel, Field, ValidationError
+from pythinker_core.tooling import CallableTool2, ToolReturnValue
+
+from pythinker_code.config import Config
+from pythinker_code.constant import USER_AGENT
+from pythinker_code.soul.agent import Runtime
+from pythinker_code.soul.toolset import get_current_tool_call_or_none
+from pythinker_code.tools import SkipThisTool
+from pythinker_code.tools.utils import ToolResultBuilder, load_desc
+from pythinker_code.utils.aiohttp import new_client_session
+from pythinker_code.utils.logging import logger
+
+
+class Params(BaseModel):
+    query: str = Field(description="The query text to search for.")
+    limit: int = Field(
+        description=(
+            "The number of results to return. "
+            "Typically you do not need to set this value. "
+            "When the results do not contain what you need, "
+            "you probably want to give a more concrete query."
+        ),
+        default=5,
+        ge=1,
+        le=20,
+    )
+    include_content: bool = Field(
+        description=(
+            "Whether to include the content of the web pages in the results. "
+            "It can consume a large amount of tokens when this is set to True. "
+            "You should avoid enabling this when `limit` is set to a large value."
+        ),
+        default=False,
+    )
+
+
+class SearchWeb(CallableTool2[Params]):
+    name: str = "SearchWeb"
+    description: str = load_desc(Path(__file__).parent / "search.md", {})
+    params: type[Params] = Params
+
+    def __init__(self, config: Config, runtime: Runtime):
+        super().__init__()
+        if config.services.pythinker_ai_search is None:
+            raise SkipThisTool()
+        self._runtime = runtime
+        self._base_url = config.services.pythinker_ai_search.base_url
+        self._api_key = config.services.pythinker_ai_search.api_key
+        self._oauth_ref = config.services.pythinker_ai_search.oauth
+        self._custom_headers = config.services.pythinker_ai_search.custom_headers or {}
+
+    @override
+    async def __call__(self, params: Params) -> ToolReturnValue:
+        builder = ToolResultBuilder(max_line_length=None)
+
+        api_key = self._runtime.oauth.resolve_api_key(self._api_key, self._oauth_ref)
+        if not self._base_url or not api_key:
+            return builder.error(
+                "Search service is not configured. You may want to try other methods to search.",
+                brief="Search service not configured",
+            )
+
+        tool_call = get_current_tool_call_or_none()
+        assert tool_call is not None, "Tool call is expected to be set"
+
+        try:
+            # Server-side timeout is 30s, but page crawling can take longer.
+            search_timeout = aiohttp.ClientTimeout(total=180, sock_read=90, sock_connect=15)
+            async with (
+                new_client_session(timeout=search_timeout) as session,
+                session.post(
+                    self._base_url,
+                    headers={
+                        "User-Agent": USER_AGENT,
+                        "Authorization": f"Bearer {api_key}",
+                        "X-Msh-Tool-Call-Id": tool_call.id,
+                        **self._runtime.oauth.common_headers(),
+                        **self._custom_headers,
+                    },
+                    json={
+                        "text_query": params.query,
+                        "limit": params.limit,
+                        "enable_page_crawling": params.include_content,
+                        "timeout_seconds": 30,
+                    },
+                ) as response,
+            ):
+                if response.status != 200:
+                    logger.warning(
+                        "SearchWeb HTTP error: status={status}, query={query}",
+                        status=response.status,
+                        query=params.query,
+                    )
+                    return builder.error(
+                        (
+                            f"Failed to search. Status: {response.status}. "
+                            "This may indicate that the search service is currently unavailable."
+                        ),
+                        brief="Failed to search",
+                    )
+
+                try:
+                    results = Response(**await response.json()).search_results
+                except ValidationError as e:
+                    logger.warning(
+                        "SearchWeb response parse error: {error}, query={query}",
+                        error=e,
+                        query=params.query,
+                    )
+                    return builder.error(
+                        (
+                            f"Failed to parse search results. Error: {e}. "
+                            "This may indicate that the search service is currently unavailable."
+                        ),
+                        brief="Failed to parse search results",
+                    )
+        except TimeoutError:
+            logger.warning("SearchWeb request timed out: query={query}", query=params.query)
+            return builder.error(
+                "Search request timed out. The search service may be slow or unavailable.",
+                brief="Search request timed out",
+            )
+        except aiohttp.ClientError as e:
+            logger.warning(
+                "SearchWeb network error: {error}, query={query}",
+                error=e,
+                query=params.query,
+            )
+            return builder.error(
+                f"Search request failed: {e}. The search service may be unavailable.",
+                brief="Search request failed",
+            )
+
+        for i, result in enumerate(results):
+            if i > 0:
+                builder.write("---\n\n")
+            builder.write(
+                f"Title: {result.title}\nDate: {result.date}\n"
+                f"URL: {result.url}\nSummary: {result.snippet}\n\n"
+            )
+            if result.content:
+                builder.write(f"{result.content}\n\n")
+
+        return builder.ok()
+
+
+class SearchResult(BaseModel):
+    site_name: str
+    title: str
+    url: str
+    snippet: str
+    content: str = ""
+    date: str = ""
+    icon: str = ""
+    mime: str = ""
+
+
+class Response(BaseModel):
+    search_results: list[SearchResult]

pythinker_code/ui/acp/__init__.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from typing import Any, NoReturn
+
+import acp
+
+from pythinker_code.acp.types import ACPContentBlock, MCPServer
+from pythinker_code.soul import Soul
+from pythinker_code.utils.logging import logger
+
+_DEPRECATED_MESSAGE = (
+    "`pythinker --acp` is deprecated. "
+    "Update your ACP client settings to use `pythinker acp` without any flags or options."
+)
+
+
+class ACPServerSingleSession:
+    def __init__(self, soul: Soul):
+        self.soul = soul
+
+    def on_connect(self, conn: acp.Client) -> None:
+        logger.info("ACP client connected")
+
+    def _raise(self) -> NoReturn:
+        logger.error(_DEPRECATED_MESSAGE)
+        raise acp.RequestError.invalid_params({"error": _DEPRECATED_MESSAGE})
+
+    async def initialize(
+        self,
+        protocol_version: int,
+        client_capabilities: acp.schema.ClientCapabilities | None = None,
+        client_info: acp.schema.Implementation | None = None,
+        **kwargs: Any,
+    ) -> acp.InitializeResponse:
+        self._raise()
+
+    async def new_session(
+        self, cwd: str, mcp_servers: list[MCPServer] | None = None, **kwargs: Any
+    ) -> acp.NewSessionResponse:
+        self._raise()
+
+    async def load_session(
+        self, cwd: str, session_id: str, mcp_servers: list[MCPServer] | None = None, **kwargs: Any
+    ) -> None:
+        self._raise()
+
+    async def resume_session(
+        self, cwd: str, session_id: str, mcp_servers: list[MCPServer] | None = None, **kwargs: Any
+    ) -> acp.schema.ResumeSessionResponse:
+        self._raise()
+
+    async def fork_session(
+        self, cwd: str, session_id: str, mcp_servers: list[MCPServer] | None = None, **kwargs: Any
+    ) -> acp.schema.ForkSessionResponse:
+        self._raise()
+
+    async def list_sessions(
+        self, cursor: str | None = None, cwd: str | None = None, **kwargs: Any
+    ) -> acp.schema.ListSessionsResponse:
+        self._raise()
+
+    async def set_session_mode(
+        self, mode_id: str, session_id: str, **kwargs: Any
+    ) -> acp.SetSessionModeResponse | None:
+        self._raise()
+
+    async def set_session_model(
+        self, model_id: str, session_id: str, **kwargs: Any
+    ) -> acp.SetSessionModelResponse | None:
+        self._raise()
+
+    async def authenticate(self, method_id: str, **kwargs: Any) -> acp.AuthenticateResponse | None:
+        self._raise()
+
+    async def prompt(
+        self, prompt: list[ACPContentBlock], session_id: str, **kwargs: Any
+    ) -> acp.PromptResponse:
+        self._raise()
+
+    async def cancel(self, session_id: str, **kwargs: Any) -> None:
+        self._raise()
+
+    async def ext_method(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        self._raise()
+
+    async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
+        self._raise()
+
+
+class ACP:
+    """ACP server using the official acp library."""
+
+    def __init__(self, soul: Soul):
+        self.soul = soul
+
+    async def run(self):
+        """Run the ACP server."""
+        logger.info("Starting ACP server (single session) on stdio")
+        await acp.run_agent(ACPServerSingleSession(self.soul))