openai-agents 0.2.8__py3-none-any.whl → 0.6.8__py3-none-any.whl

agents/extensions/experimental/codex/__init__.py

@@ -0,0 +1,92 @@
+from .codex import Codex
+from .codex_options import CodexOptions
+from .codex_tool import (
+    CodexToolOptions,
+    CodexToolResult,
+    CodexToolStreamEvent,
+    OutputSchemaDescriptor,
+    codex_tool,
+)
+from .events import (
+    ItemCompletedEvent,
+    ItemStartedEvent,
+    ItemUpdatedEvent,
+    ThreadError,
+    ThreadErrorEvent,
+    ThreadEvent,
+    ThreadStartedEvent,
+    TurnCompletedEvent,
+    TurnFailedEvent,
+    TurnStartedEvent,
+    Usage,
+)
+from .items import (
+    AgentMessageItem,
+    CommandExecutionItem,
+    ErrorItem,
+    FileChangeItem,
+    FileUpdateChange,
+    McpToolCallError,
+    McpToolCallItem,
+    McpToolCallResult,
+    ReasoningItem,
+    ThreadItem,
+    TodoItem,
+    TodoListItem,
+    WebSearchItem,
+)
+from .thread import Input, RunResult, RunStreamedResult, Thread, Turn, UserInput
+from .thread_options import (
+    ApprovalMode,
+    ModelReasoningEffort,
+    SandboxMode,
+    ThreadOptions,
+    WebSearchMode,
+)
+from .turn_options import TurnOptions
+
+__all__ = [
+    "Codex",
+    "CodexOptions",
+    "Thread",
+    "Turn",
+    "RunResult",
+    "RunStreamedResult",
+    "Input",
+    "UserInput",
+    "ThreadOptions",
+    "TurnOptions",
+    "ApprovalMode",
+    "SandboxMode",
+    "ModelReasoningEffort",
+    "WebSearchMode",
+    "ThreadEvent",
+    "ThreadStartedEvent",
+    "TurnStartedEvent",
+    "TurnCompletedEvent",
+    "TurnFailedEvent",
+    "ItemStartedEvent",
+    "ItemUpdatedEvent",
+    "ItemCompletedEvent",
+    "ThreadError",
+    "ThreadErrorEvent",
+    "Usage",
+    "ThreadItem",
+    "AgentMessageItem",
+    "ReasoningItem",
+    "CommandExecutionItem",
+    "FileChangeItem",
+    "FileUpdateChange",
+    "McpToolCallItem",
+    "McpToolCallResult",
+    "McpToolCallError",
+    "WebSearchItem",
+    "TodoItem",
+    "TodoListItem",
+    "ErrorItem",
+    "codex_tool",
+    "CodexToolOptions",
+    "CodexToolResult",
+    "CodexToolStreamEvent",
+    "OutputSchemaDescriptor",
+]

agents/extensions/experimental/codex/codex.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, overload
+
+from agents.exceptions import UserError
+
+from .codex_options import CodexOptions, coerce_codex_options
+from .exec import CodexExec
+from .thread import Thread
+from .thread_options import ThreadOptions, coerce_thread_options
+
+
+class _UnsetType:
+    pass
+
+
+_UNSET = _UnsetType()
+
+
+class Codex:
+    @overload
+    def __init__(self, options: CodexOptions | Mapping[str, Any] | None = None) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        codex_path_override: str | None = None,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        env: Mapping[str, str] | None = None,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        options: CodexOptions | Mapping[str, Any] | None = None,
+        *,
+        codex_path_override: str | None | _UnsetType = _UNSET,
+        base_url: str | None | _UnsetType = _UNSET,
+        api_key: str | None | _UnsetType = _UNSET,
+        env: Mapping[str, str] | None | _UnsetType = _UNSET,
+    ) -> None:
+        kw_values = {
+            "codex_path_override": codex_path_override,
+            "base_url": base_url,
+            "api_key": api_key,
+            "env": env,
+        }
+        has_kwargs = any(value is not _UNSET for value in kw_values.values())
+        if options is not None and has_kwargs:
+            raise UserError(
+                "Codex options must be provided as a CodexOptions/mapping or keyword arguments, "
+                "not both."
+            )
+        if has_kwargs:
+            options = {key: value for key, value in kw_values.items() if value is not _UNSET}
+        resolved_options = coerce_codex_options(options) or CodexOptions()
+        self._exec = CodexExec(
+            executable_path=resolved_options.codex_path_override,
+            env=_normalize_env(resolved_options),
+        )
+        self._options = resolved_options
+
+    def start_thread(self, options: ThreadOptions | Mapping[str, Any] | None = None) -> Thread:
+        resolved_options = coerce_thread_options(options) or ThreadOptions()
+        return Thread(
+            exec_client=self._exec,
+            options=self._options,
+            thread_options=resolved_options,
+        )
+
+    def resume_thread(
+        self, thread_id: str, options: ThreadOptions | Mapping[str, Any] | None = None
+    ) -> Thread:
+        resolved_options = coerce_thread_options(options) or ThreadOptions()
+        return Thread(
+            exec_client=self._exec,
+            options=self._options,
+            thread_options=resolved_options,
+            thread_id=thread_id,
+        )
+
+
+def _normalize_env(options: CodexOptions) -> dict[str, str] | None:
+    if options.env is None:
+        return None
+    # Normalize mapping values to strings for subprocess environment.
+    return {str(key): str(value) for key, value in options.env.items()}

agents/extensions/experimental/codex/codex_options.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, fields
+from typing import Any
+
+from agents.exceptions import UserError
+
+
+@dataclass(frozen=True)
+class CodexOptions:
+    # Optional absolute path to the codex CLI binary.
+    codex_path_override: str | None = None
+    # Override OpenAI base URL for the Codex CLI process.
+    base_url: str | None = None
+    # API key passed to the Codex CLI (CODEX_API_KEY).
+    api_key: str | None = None
+    # Environment variables for the Codex CLI process (do not inherit os.environ).
+    env: Mapping[str, str] | None = None
+
+
+def coerce_codex_options(
+    options: CodexOptions | Mapping[str, Any] | None,
+) -> CodexOptions | None:
+    if options is None or isinstance(options, CodexOptions):
+        return options
+    if not isinstance(options, Mapping):
+        raise UserError("CodexOptions must be a CodexOptions or a mapping.")
+
+    allowed = {field.name for field in fields(CodexOptions)}
+    unknown = set(options.keys()) - allowed
+    if unknown:
+        raise UserError(f"Unknown CodexOptions field(s): {sorted(unknown)}")
+
+    return CodexOptions(**dict(options))