chore: typing

Author: phil65

src/agentpool/agents/agui_agent/agui_converters.py

@@ -126,7 +126,7 @@ def agui_to_native_event(event: Event) -> Iterator[RichAgentStreamEvent[Any]]:
         # === Thinking/Reasoning Events ===
 
         case (
-            ThinkingTextMessageContentEvent(delta=delta)  # type: ignore[misc]
+            ThinkingTextMessageContentEvent(delta=delta)
             | ReasoningMessageContentEvent(delta=delta)
             | ReasoningMessageChunkEvent(delta=str() as delta)
         ):

src/agentpool/agents/claude_code_agent/claude_code_agent.py

@@ -528,7 +528,7 @@ async def _on_elicitation(self, request: SDKControlElicitationRequest) -> Elicit
             case ErrorData():
                 return ElicitResult(action="decline")
             case _ as unreachable_:
-                assert_never(unreachable_)  # ty:ignore[type-assertion-failure]
+                assert_never(unreachable_)
 
     async def __aenter__(self) -> Self:
         """Connect to Claude Code with deferred client connection."""

src/agentpool/mcp_server/client.py

@@ -397,7 +397,8 @@ async def elicitation_handler[T](
                         return ElicitResult(action="cancel")
                     case MCPElicitResult(action="decline"):
                         return ElicitResult(action="decline")
-                    case ErrorData():
+                    case ErrorData(code=code, message=message, data=data):
+                        logger.error("Elicitation error", code=code, message=message, data=data)
                         return ElicitResult(action="decline")
                     case _:
                         return ElicitResult(action="decline")

src/agentpool/talk/talk.py

@@ -263,15 +263,15 @@ async def _handle_message(
             for target in self.targets
             if await self._evaluate_condition(
                 self.filter_condition,
-                processed_message,
+                processed_message,  # ty:ignore[invalid-argument-type]
                 target,
                 default_return=True,
             )
         ]
         # 7. emit connection processed event
         await self.connection_processed.emit(
             self.ConnectionProcessed(
-                message=processed_message,
+                message=processed_message,  # ty:ignore[invalid-argument-type]
                 source=self.source,
                 targets=target_list,
                 queued=self.queued,
@@ -288,9 +288,9 @@ async def _handle_message(
         responses: list[ChatMessage[Any]] = []
         for target in target_list:
             if self.queued:
-                self._pending_messages[target.name].append(processed_message)
+                self._pending_messages[target.name].append(processed_message)  # ty:ignore[invalid-argument-type]
                 continue
-            if response := await self._process_for_target(processed_message, target, prompt):
+            if response := await self._process_for_target(processed_message, target, prompt):  # ty:ignore[invalid-argument-type]
                 responses.append(response)
 
         return responses
@@ -447,9 +447,9 @@ async def chainedtransform_fn(
                 intermediate = await execute(oldtransform_fn, data)
                 return await execute(transformer, intermediate)  # ty: ignore[invalid-return-type]
 
-            new_talk.transform_fn = chainedtransform_fn  # type: ignore[assignment]
+            new_talk.transform_fn = chainedtransform_fn  # type: ignore[assignment]  # ty:ignore[invalid-assignment]
         else:
-            new_talk.transform_fn = transformer  # type: ignore[assignment]
+            new_talk.transform_fn = transformer  # type: ignore[assignment]  # ty:ignore[invalid-assignment]
 
         return new_talk
 

src/agentpool/tool_impls/bash/tool.py

@@ -125,7 +125,7 @@ async def _execute(  # noqa: PLR0915
         except Exception as e:  # noqa: BLE001
             error_id = process_id or f"cmd_{uuid.uuid4().hex[:8]}"
             await ctx.events.process_started(error_id, command, success=False, error=str(e))
-            meta = {"output": "", "exit": None, "description": command}
+            meta: dict[str, Any] = {"output": "", "exit": None, "description": command}
             return ToolResult(content=f"Error executing command: {e}", metadata=meta)
 
         stdout = "".join(stdout_parts)
@@ -136,7 +136,7 @@ async def _execute(  # noqa: PLR0915
                 stderr = apply_linewise_regex_filter(stderr, filter_lines)
             except re.error as regex_err:
                 error_msg = f"Invalid filter regex: {regex_err}"
-                meta: dict[str, Any] = {"output": "", "exit": None, "description": command}
+                meta = {"output": "", "exit": None, "description": command}
                 return ToolResult(content=error_msg, metadata=meta)
             # Apply output limit if specified
         truncated = False

src/agentpool_server/acp_server/input_provider.py

@@ -212,75 +212,82 @@ async def get_elicitation(  # noqa: PLR0911
         """
         try:
             # Handle URL mode elicitation (OAuth, credentials, payments)
-            if isinstance(params, types.ElicitRequestURLParams):
-                msg = "URL elicitation request"
-                elicit_id = params.elicitationId
-                logger.info(msg, message=params.message, url=params.url, elicitation_id=elicit_id)
-                tool_call_id = f"elicit_url_{elicit_id}"
-                title = f"URL Authorization: {params.message}"
-                url_options = [
-                    PermissionOption(option_id="accept", name="Open URL", kind="allow_once"),
-                    PermissionOption(option_id="decline", name="Decline", kind="reject_once"),
-                ]
-                response = await self.session.requests.request_permission(
-                    tool_call_id=tool_call_id,
-                    title=title,
-                    options=url_options,
-                )
-                match response.outcome:
-                    case AllowedOutcome(option_id="accept"):
-                        webbrowser.open(params.url)
-                        return types.ElicitResult(action="accept")
-                    case AllowedOutcome():
-                        return types.ElicitResult(action="decline")
-                    case DeniedOutcome():
-                        return types.ElicitResult(action="cancel")
-                    case _ as unreachable:
-                        assert_never(unreachable)  # ty:ignore[type-assertion-failure]
-
-            # Form mode elicitation
-            schema = params.requestedSchema
-            logger.info("Elicitation request", message=params.message, schema=schema)
-            tool_call_id = f"elicit_{hash(params.message)}"
-            title = f"Elicitation: {params.message}"
-
-            if _is_boolean_schema(schema):
-                options: list[PermissionOption] | None = _create_boolean_elicitation_options()
-                response = await self.session.requests.request_permission(
-                    tool_call_id=tool_call_id,
-                    title=title,
-                    options=options,
-                )
-                return self._handle_boolean_elicitation_response(response, schema)
-            if _is_enum_schema(schema) and (options := _create_enum_elicitation_options(schema)):
-                response = await self.session.requests.request_permission(
-                    tool_call_id=tool_call_id,
-                    title=title,
-                    options=options,
-                )
-                return _handle_enum_elicitation_response(response, schema)
-
-            options = [
-                PermissionOption(option_id="accept", name="Accept", kind="allow_once"),
-                PermissionOption(option_id="decline", name="Decline", kind="reject_once"),
-            ]
-            response = await self.session.requests.request_permission(
-                tool_call_id=tool_call_id,
-                title=title,
-                options=options,
-            )
-
-            # Convert permission response to elicitation result
-            match response.outcome:
-                case AllowedOutcome(option_id="accept"):
-                    # For non-boolean schemas, return empty content
-                    return types.ElicitResult(action="accept", content={})
-                case AllowedOutcome():
-                    return types.ElicitResult(action="decline")
-                case DeniedOutcome():
-                    return types.ElicitResult(action="cancel")
+            match params:
+                case types.ElicitRequestURLParams(
+                    elicitationId=elicit_id,
+                    message=message,
+                    url=url,
+                ):
+                    msg = "URL elicitation request"
+                    logger.info(msg, message=message, url=url, elicitation_id=elicit_id)
+                    tool_call_id = f"elicit_url_{elicit_id}"
+                    title = f"URL Authorization: {message}"
+                    url_options = [
+                        PermissionOption(option_id="accept", name="Open URL", kind="allow_once"),
+                        PermissionOption(option_id="decline", name="Decline", kind="reject_once"),
+                    ]
+                    response = await self.session.requests.request_permission(
+                        tool_call_id=tool_call_id,
+                        title=title,
+                        options=url_options,
+                    )
+                    match response.outcome:
+                        case AllowedOutcome(option_id="accept"):
+                            webbrowser.open(params.url)
+                            return types.ElicitResult(action="accept")
+                        case AllowedOutcome():
+                            return types.ElicitResult(action="decline")
+                        case DeniedOutcome():
+                            return types.ElicitResult(action="cancel")
+                        case _ as unreachable:
+                            assert_never(unreachable)
+                case types.ElicitRequestFormParams(requestedSchema=schema, message=message):
+                    logger.info("Elicitation request", message=message, schema=schema)
+                    tool_call_id = f"elicit_{hash(message)}"
+                    title = f"Elicitation: {message}"
+                    if _is_boolean_schema(schema):
+                        options: list[PermissionOption] | None = (
+                            _create_boolean_elicitation_options()
+                        )
+                        response = await self.session.requests.request_permission(
+                            tool_call_id=tool_call_id,
+                            title=title,
+                            options=options,
+                        )
+                        return self._handle_boolean_elicitation_response(response, schema)
+                    if _is_enum_schema(schema) and (
+                        options := _create_enum_elicitation_options(schema)
+                    ):
+                        response = await self.session.requests.request_permission(
+                            tool_call_id=tool_call_id,
+                            title=title,
+                            options=options,
+                        )
+                        return _handle_enum_elicitation_response(response, schema)
+
+                    options = [
+                        PermissionOption(option_id="accept", name="Accept", kind="allow_once"),
+                        PermissionOption(option_id="decline", name="Decline", kind="reject_once"),
+                    ]
+                    response = await self.session.requests.request_permission(
+                        tool_call_id=tool_call_id,
+                        title=title,
+                        options=options,
+                    )
+
+                    # Convert permission response to elicitation result
+                    match response.outcome:
+                        case AllowedOutcome(option_id="accept"):
+                            # For non-boolean schemas, return empty content
+                            return types.ElicitResult(action="accept", content={})
+                        case AllowedOutcome():
+                            return types.ElicitResult(action="decline")
+                        case DeniedOutcome():
+                            return types.ElicitResult(action="cancel")
+                        case _ as unreachable:
+                            assert_never(unreachable)
                 case _ as unreachable:
-                    assert_never(unreachable)  # ty:ignore[type-assertion-failure]
+                    assert_never(unreachable)
 
         except Exception as e:
             logger.exception("Failed to handle elicitation")

src/agentpool_toolsets/mcp_discovery/toolset.py

@@ -112,7 +112,7 @@ def _get_search_index(self) -> Any:
             raise FileNotFoundError(msg)
 
         # Load parquet
-        arrow_table = pq.read_table(PARQUET_PATH)
+        arrow_table = pq.read_table(PARQUET_PATH)  # type: ignore[no-untyped-call]
 
         # Convert vector column to fixed-size list for LanceDB vector search
         # LanceDB requires fixed-size vectors, not variable-length lists