codexed 0.0.2__tar.gz → 0.0.4__tar.gz

{codexed-0.0.2 → codexed-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codexed
-Version: 0.0.2
+Version: 0.0.4
 Summary: Alternative codex app-server client
 Keywords: 
 Author: Philipp Temminghoff

{codexed-0.0.2 → codexed-0.0.4}/pyproject.toml

@@ -2,7 +2,7 @@
 
 [project]
 name = "codexed"
-version = "0.0.2"
+version = "0.0.4"
 description = "Alternative codex app-server client"
 readme = "README.md"
 requires-python = ">=3.13"

{codexed-0.0.2 → codexed-0.0.4}/src/codexed/client.py

@@ -104,6 +104,8 @@ from codexed.request_handlers import (
     SERVER_REQUEST_COMMAND_APPROVAL,
     SERVER_REQUEST_DYNAMIC_TOOL_CALL,
     SERVER_REQUEST_FILE_CHANGE_APPROVAL,
+    SERVER_REQUEST_MCP_ELICITATION,
+    SERVER_REQUEST_SKILL_APPROVAL,
     SERVER_REQUEST_TYPES,
     SERVER_REQUEST_USER_INPUT,
     create_auto_approve_dict,
@@ -141,10 +143,10 @@ if TYPE_CHECKING:
     )
     from codexed.models.request_params import HazelnutScope, LoginType, ProductSurface
     from codexed.request_handlers import (
-        CommandApprovalHandler,
+        ApprovalHandler,
         DynamicToolCallHandler,
-        FileChangeApprovalHandler,
         HandlerMethod,
+        McpElicitationHandler,
         ServerRequestHandler,
         UserInputHandler,
     )
@@ -354,10 +356,10 @@ class CodexClient:
         profile: str | None = None,
         env_vars: dict[str, str] | None = None,
         mcp_servers: Mapping[str, McpServerConfig] | None = None,
-        on_command_approval: CommandApprovalHandler | None = None,
-        on_file_change_approval: FileChangeApprovalHandler | None = None,
+        on_approval: ApprovalHandler | None = None,
         on_user_input: UserInputHandler | None = None,
         on_dynamic_tool_call: DynamicToolCallHandler | None = None,
+        on_mcp_elicitation: McpElicitationHandler | None = None,
     ) -> None:
         """Initialize the Codex app-server client.
 
@@ -367,10 +369,11 @@ class CodexClient:
             env_vars: Optional environment variables to set for the Codex process.
             mcp_servers: Optional MCP servers to inject programmatically.
                 Keys are server names, values are server configurations.
-            on_command_approval: Handler for command execution approval requests.
-            on_file_change_approval: Handler for file change approval requests.
+            on_approval: Handler for all approval requests
+                (command execution, file change, and skill approval).
             on_user_input: Handler for tool user input requests.
             on_dynamic_tool_call: Handler for dynamic tool call requests.
+            on_mcp_elicitation: Handler for MCP elicitation requests.
         """
         self._codex_command = codex_command
         self._profile = profile
@@ -385,14 +388,16 @@ class CodexClient:
         self._writer_lock = asyncio.Lock()
         self._active_threads: set[str] = set()
         self._server_request_handlers: dict[str, ServerRequestHandler] = {}
-        if on_command_approval:
-            self.register_handler(SERVER_REQUEST_COMMAND_APPROVAL, on_command_approval)  # type: ignore[arg-type]
-        if on_file_change_approval:
-            self.register_handler(SERVER_REQUEST_FILE_CHANGE_APPROVAL, on_file_change_approval)  # type: ignore[arg-type]
+        if on_approval:
+            self.register_handler(SERVER_REQUEST_COMMAND_APPROVAL, on_approval)  # type: ignore[arg-type]
+            self.register_handler(SERVER_REQUEST_FILE_CHANGE_APPROVAL, on_approval)  # type: ignore[arg-type]
+            self.register_handler(SERVER_REQUEST_SKILL_APPROVAL, on_approval)  # type: ignore[arg-type]
         if on_user_input:
             self.register_handler(SERVER_REQUEST_USER_INPUT, on_user_input)  # type: ignore[arg-type]
         if on_dynamic_tool_call:
             self.register_handler(SERVER_REQUEST_DYNAMIC_TOOL_CALL, on_dynamic_tool_call)  # type: ignore[arg-type]
+        if on_mcp_elicitation:
+            self.register_handler(SERVER_REQUEST_MCP_ELICITATION, on_mcp_elicitation)  # type: ignore[arg-type]
 
     async def __aenter__(self) -> Self:
         """Async context manager entry - starts the app-server."""
@@ -1768,7 +1773,10 @@ class CodexClient:
             return
 
         try:
-            parsed_params = params_type.model_validate(params)
+            if isinstance(params_type, TypeAdapter):
+                parsed_params = params_type.validate_python(params)
+            else:
+                parsed_params = params_type.model_validate(params)
             response_model = await handler(parsed_params)
             await self._send_server_request_response(request_id, response_model)
         except Exception:

{codexed-0.0.2 → codexed-0.0.4}/src/codexed/models/request_params.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
 from collections.abc import Sequence  # noqa: TC003
-from typing import Any, Literal, Self
+from typing import Annotated, Any, Literal, Self
+
+import mcp.types
+from pydantic import Discriminator, TypeAdapter
 
 from codexed.models.base import CodexBaseModel
 from codexed.models.codex_types import (  # noqa: TC001
@@ -507,34 +510,85 @@ McpElicitationAction = Literal["accept", "decline", "cancel"]
 """Action taken by the user on an elicitation request."""
 
 
-class McpElicitationFormParams(CodexBaseModel):
-    """Form-mode MCP elicitation request."""
+class _McpElicitationBase(CodexBaseModel):
+    """Common fields for MCP elicitation requests."""
 
-    mode: Literal["form"] = "form"
+    thread_id: str
+    turn_id: str | None = None
+    server_name: str
     meta: Any | None = None
     message: str
+
+
+class McpElicitationFormParams(_McpElicitationBase):
+    """Form-mode MCP elicitation request."""
+
+    mode: Literal["form"] = "form"
     requested_schema: dict[str, Any]
 
+    def to_mcp(self) -> mcp.types.ElicitRequestFormParams:
+        return mcp.types.ElicitRequestFormParams(
+            message=self.message,
+            requestedSchema=self.requested_schema,
+        )
 
-class McpElicitationUrlParams(CodexBaseModel):
+    @classmethod
+    def from_mcp(
+        cls,
+        params: mcp.types.ElicitRequestFormParams,
+        thread_id: str,
+        server_name: str,
+        turn_id: str | None = None,
+    ) -> McpElicitationFormParams:
+        """Create from MCP ElicitRequestFormParams."""
+        return cls(
+            message=params.message,
+            requested_schema=dict(params.requestedSchema),
+            thread_id=thread_id,
+            server_name=server_name,
+            turn_id=turn_id,
+        )
+
+
+class McpElicitationUrlParams(_McpElicitationBase):
     """URL-mode MCP elicitation request (browser-based auth)."""
 
     mode: Literal["url"] = "url"
-    meta: Any | None = None
-    message: str
     url: str
     elicitation_id: str
 
+    def to_mcp(self) -> mcp.types.ElicitRequestURLParams:
+        return mcp.types.ElicitRequestURLParams(
+            message=self.message,
+            url=self.url,
+            elicitationId=self.elicitation_id,
+        )
 
-class McpServerElicitationRequestParams(CodexBaseModel):
-    """Parameters for mcpServer/elicitation/request server request."""
-
-    thread_id: str
-    turn_id: str | None = None
-    server_name: str
-    mode: Literal["form", "url"]
-    meta: Any | None = None
-    message: str
-    requested_schema: dict[str, Any] | None = None
-    url: str | None = None
-    elicitation_id: str | None = None
+    @classmethod
+    def from_mcp(
+        cls,
+        params: mcp.types.ElicitRequestURLParams,
+        thread_id: str,
+        server_name: str,
+        turn_id: str | None = None,
+    ) -> McpElicitationUrlParams:
+        """Create from MCP ElicitRequestURLParams."""
+        return cls(
+            message=params.message,
+            url=params.url,
+            elicitation_id=params.elicitationId,
+            thread_id=thread_id,
+            server_name=server_name,
+            turn_id=turn_id,
+        )
+
+
+McpServerElicitationRequestParams = Annotated[
+    McpElicitationFormParams | McpElicitationUrlParams,
+    Discriminator("mode"),
+]
+"""Parameters for mcpServer/elicitation/request, discriminated by mode."""
+
+mcp_elicitation_adapter: TypeAdapter[McpServerElicitationRequestParams] = TypeAdapter(
+    McpServerElicitationRequestParams
+)

{codexed-0.0.2 → codexed-0.0.4}/src/codexed/models/responses.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import Any, Literal
 
+import mcp.types
+
 from codexed.models.base import CodexBaseModel
 from codexed.models.codex_types import (  # noqa: TC001
     AskForApproval,
@@ -62,6 +64,14 @@ class McpServerElicitationResponse(CodexBaseModel):
     content: Any | None = None
     meta: Any | None = None
 
+    def to_mcp(self) -> mcp.types.ElicitResult:
+        return mcp.types.ElicitResult(action=self.action, content=self.content)
+
+    @classmethod
+    def from_mcp(cls, result: mcp.types.ElicitResult) -> McpServerElicitationResponse:
+        """Create from MCP ElicitResult."""
+        return cls(action=result.action, content=result.content)
+
 
 class ThreadReadResponse(CodexBaseModel):
     """Response for thread/read request."""

{codexed-0.0.2 → codexed-0.0.4}/src/codexed/request_handlers.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 from collections.abc import Awaitable, Callable
 from typing import Literal
 
+from pydantic import TypeAdapter
+
 from codexed.models import (
     CommandExecutionRequestApprovalParams,
     CommandExecutionRequestApprovalResponse,
@@ -12,11 +14,18 @@ from codexed.models import (
     DynamicToolCallResponse,
     FileChangeRequestApprovalParams,
     FileChangeRequestApprovalResponse,
-    McpServerElicitationRequestParams,
     McpServerElicitationResponse,
+    SkillRequestApprovalParams,
+    SkillRequestApprovalResponse,
     ToolRequestUserInputParams,
     ToolRequestUserInputResponse,
 )
+from codexed.models.request_params import (
+    McpElicitationFormParams,
+    McpElicitationUrlParams,
+    McpServerElicitationRequestParams,
+    mcp_elicitation_adapter,
+)
 
 
 # Server request method constants
@@ -24,6 +33,7 @@ SERVER_REQUEST_COMMAND_APPROVAL = "item/commandExecution/requestApproval"
 SERVER_REQUEST_FILE_CHANGE_APPROVAL = "item/fileChange/requestApproval"
 SERVER_REQUEST_USER_INPUT = "item/tool/requestUserInput"
 SERVER_REQUEST_DYNAMIC_TOOL_CALL = "item/tool/call"
+SERVER_REQUEST_SKILL_APPROVAL = "skill/requestApproval"
 SERVER_REQUEST_MCP_ELICITATION = "mcpServer/elicitation/request"
 
 HandlerMethod = Literal[
@@ -31,21 +41,25 @@ HandlerMethod = Literal[
     "item/fileChange/requestApproval",
     "item/tool/requestUserInput",
     "item/tool/call",
+    "skill/requestApproval",
     "mcpServer/elicitation/request",
 ]
 # Type for server request parameter models
 ServerRequestParams = (
     CommandExecutionRequestApprovalParams
     | FileChangeRequestApprovalParams
+    | SkillRequestApprovalParams
     | ToolRequestUserInputParams
     | DynamicToolCallParams
-    | McpServerElicitationRequestParams
+    | McpElicitationFormParams
+    | McpElicitationUrlParams
 )
 
 # Type for server request response models
 ServerRequestResponse = (
     CommandExecutionRequestApprovalResponse
     | FileChangeRequestApprovalResponse
+    | SkillRequestApprovalResponse
     | ToolRequestUserInputResponse
     | DynamicToolCallResponse
     | McpServerElicitationResponse
@@ -69,8 +83,24 @@ McpElicitationHandler = Callable[
     [McpServerElicitationRequestParams], Awaitable[McpServerElicitationResponse]
 ]
 
-# Map from wire method names to param/response model types
-SERVER_REQUEST_TYPES: dict[str, tuple[type[ServerRequestParams], type[ServerRequestResponse]]] = {
+# Unified approval handler: one callback for all approval types
+ApprovalParams = (
+    CommandExecutionRequestApprovalParams
+    | FileChangeRequestApprovalParams
+    | SkillRequestApprovalParams
+)
+ApprovalResponse = (
+    CommandExecutionRequestApprovalResponse
+    | FileChangeRequestApprovalResponse
+    | SkillRequestApprovalResponse
+)
+ApprovalHandler = Callable[[ApprovalParams], Awaitable[ApprovalResponse]]
+
+# Validator: either a model class or a TypeAdapter for discriminated unions
+ParamsValidator = type[ServerRequestParams] | TypeAdapter[ServerRequestParams]
+
+# Map from wire method names to param validator + response model type
+SERVER_REQUEST_TYPES: dict[str, tuple[ParamsValidator, type[ServerRequestResponse]]] = {
     SERVER_REQUEST_COMMAND_APPROVAL: (
         CommandExecutionRequestApprovalParams,
         CommandExecutionRequestApprovalResponse,
@@ -84,8 +114,12 @@ SERVER_REQUEST_TYPES: dict[str, tuple[type[ServerRequestParams], type[ServerRequ
         ToolRequestUserInputResponse,
     ),
     SERVER_REQUEST_DYNAMIC_TOOL_CALL: (DynamicToolCallParams, DynamicToolCallResponse),
+    SERVER_REQUEST_SKILL_APPROVAL: (
+        SkillRequestApprovalParams,
+        SkillRequestApprovalResponse,
+    ),
     SERVER_REQUEST_MCP_ELICITATION: (
-        McpServerElicitationRequestParams,
+        mcp_elicitation_adapter,  # type: ignore[dict-item]
         McpServerElicitationResponse,
     ),
 }
@@ -118,6 +152,11 @@ def create_auto_approve_dict() -> dict[str, ServerRequestHandler]:
     ) -> ServerRequestResponse:
         return DynamicToolCallResponse(content_items=[], success=False)
 
+    async def auto_approve_skill(
+        _params: ServerRequestParams,
+    ) -> ServerRequestResponse:
+        return SkillRequestApprovalResponse(decision="allow")
+
     async def auto_decline_elicitation(
         _params: ServerRequestParams,
     ) -> ServerRequestResponse:
@@ -128,5 +167,6 @@ def create_auto_approve_dict() -> dict[str, ServerRequestHandler]:
     dct[SERVER_REQUEST_FILE_CHANGE_APPROVAL] = auto_approve_file_change
     dct[SERVER_REQUEST_USER_INPUT] = auto_approve_user_input
     dct[SERVER_REQUEST_DYNAMIC_TOOL_CALL] = auto_approve_dynamic_tool
+    dct[SERVER_REQUEST_SKILL_APPROVAL] = auto_approve_skill
     dct[SERVER_REQUEST_MCP_ELICITATION] = auto_decline_elicitation
     return dct