codexapi 0.1.1__tar.gz → 0.1.3__tar.gz

codexapi-0.1.3/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.1
+Name: codexapi
+Version: 0.1.3
+Summary: Minimal Python API for running the Codex CLI.
+License: MIT
+Keywords: codex,agent,cli,openai
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# CodexAPI
+
+Use OpenAI's codex from python as easily as calling a function with your codex credits instead of the API.
+
+*Note: this project is not affiliated with OpenAI in any way. Thanks for the awesome tools and models though!*
+
+## Requirements
+
+- Codex CLI installed and authenticated (`codex` must be on your PATH).
+- Python 3.8+.
+
+## Install
+
+```bash
+pip install codexapi
+```
+
+## Quickstart
+
+```python
+from codexapi import agent, Agent, Task
+
+# Run one-shot tasks as a function call
+print(agent("Say hello"))
+
+# Run a multi-turn conversation as a session
+session = Agent(cwd="/path/to/project")
+print(session("Summarize this repo."))
+print(session("Now list any risks."))
+
+# Save and resume a session later
+thread_id = session.thread_id
+session2 = Agent(cwd="/path/to/project", thread_id=thread_id)
+print(session2("Continue from where we left off."))
+
+# Define a task with a checker
+class RepoTask(Task):
+    def check(self):
+        # Return an error string if something is wrong, or None/"" if OK
+        return None
+
+task = RepoTask("Summarize this repo.", cwd="/path/to/project")
+result = task()
+print(result.success, result.summary)
+```
+
+## API
+
+### `agent(prompt, cwd=None, yolo=False, flags=None, full_auto=False) -> str`
+
+Runs a single Codex turn and returns only the agent's message. Any reasoning
+items are filtered out.
+
+- `prompt` (str): prompt to send to Codex.
+- `cwd` (str | PathLike | None): working directory for the Codex session.
+- `yolo` (bool): pass `--yolo` to Codex when true.
+- `flags` (str | None): extra CLI flags to pass to Codex.
+- `full_auto` (bool): enable `--full-auto` for workspace-write and on-request approvals.
+
+### `Agent(cwd=None, yolo=False, thread_id=None, flags=None, full_auto=False)`
+
+Creates a stateful session wrapper. Calling the instance sends the prompt into
+the same conversation and returns only the agent's message.
+
+- `__call__(prompt) -> str`: send a prompt to Codex and return the message.
+- `thread_id -> str | None`: expose the underlying session id once created.
+- `yolo` (bool): pass `--yolo` to Codex when true.
+- `flags` (str | None): extra CLI flags to pass to Codex.
+- `full_auto` (bool): enable `--full-auto` for workspace-write and on-request approvals.
+
+### `Task(prompt, max_attempts=10, cwd=None, yolo=False, thread_id=None, flags=None, full_auto=True)`
+
+Runs a Codex task with checker-driven retries. Subclass it and implement
+`check()` to return an error string when the task is incomplete, or return
+`None`/`""` when the task passes.
+
+- `__call__() -> TaskResult`: run the task.
+- `set_up()`: optional setup hook.
+- `tear_down()`: optional cleanup hook.
+- `check() -> str | None`: return an error description or `None`/`""`.
+- `on_success(result)`: optional success hook.
+- `on_failure(result)`: optional failure hook.
+- `full_auto` (bool): enable `--full-auto` for workspace-write and on-request approvals.
+
+### `TaskResult(success, summary, attempts, errors, thread_id)`
+
+Simple result object returned by `Task.__call__`.
+
+- `success` (bool): whether the task completed successfully.
+- `summary` (str): agent summary of what happened.
+- `attempts` (int): how many attempts were used.
+- `errors` (str | None): last checker error, if any.
+- `thread_id` (str | None): Codex thread id for the session.
+
+## Behavior notes
+
+- Uses `codex exec --json` and parses JSONL events for `agent_message` items.
+- Automatically passes `--skip-git-repo-check` so it can run outside a git repo.
+- Passes `--yolo` when enabled (use with care).
+- Raises `RuntimeError` if Codex exits non-zero or returns no agent message.
+
+## Configuration
+
+Set `CODEX_BIN` to point at a non-default Codex binary:
+
+```bash
+export CODEX_BIN=/path/to/codex
+```

codexapi-0.1.3/README.md

@@ -0,0 +1,108 @@
+# CodexAPI
+
+Use OpenAI's codex from python as easily as calling a function with your codex credits instead of the API.
+
+*Note: this project is not affiliated with OpenAI in any way. Thanks for the awesome tools and models though!*
+
+## Requirements
+
+- Codex CLI installed and authenticated (`codex` must be on your PATH).
+- Python 3.8+.
+
+## Install
+
+```bash
+pip install codexapi
+```
+
+## Quickstart
+
+```python
+from codexapi import agent, Agent, Task
+
+# Run one-shot tasks as a function call
+print(agent("Say hello"))
+
+# Run a multi-turn conversation as a session
+session = Agent(cwd="/path/to/project")
+print(session("Summarize this repo."))
+print(session("Now list any risks."))
+
+# Save and resume a session later
+thread_id = session.thread_id
+session2 = Agent(cwd="/path/to/project", thread_id=thread_id)
+print(session2("Continue from where we left off."))
+
+# Define a task with a checker
+class RepoTask(Task):
+    def check(self):
+        # Return an error string if something is wrong, or None/"" if OK
+        return None
+
+task = RepoTask("Summarize this repo.", cwd="/path/to/project")
+result = task()
+print(result.success, result.summary)
+```
+
+## API
+
+### `agent(prompt, cwd=None, yolo=False, flags=None, full_auto=False) -> str`
+
+Runs a single Codex turn and returns only the agent's message. Any reasoning
+items are filtered out.
+
+- `prompt` (str): prompt to send to Codex.
+- `cwd` (str | PathLike | None): working directory for the Codex session.
+- `yolo` (bool): pass `--yolo` to Codex when true.
+- `flags` (str | None): extra CLI flags to pass to Codex.
+- `full_auto` (bool): enable `--full-auto` for workspace-write and on-request approvals.
+
+### `Agent(cwd=None, yolo=False, thread_id=None, flags=None, full_auto=False)`
+
+Creates a stateful session wrapper. Calling the instance sends the prompt into
+the same conversation and returns only the agent's message.
+
+- `__call__(prompt) -> str`: send a prompt to Codex and return the message.
+- `thread_id -> str | None`: expose the underlying session id once created.
+- `yolo` (bool): pass `--yolo` to Codex when true.
+- `flags` (str | None): extra CLI flags to pass to Codex.
+- `full_auto` (bool): enable `--full-auto` for workspace-write and on-request approvals.
+
+### `Task(prompt, max_attempts=10, cwd=None, yolo=False, thread_id=None, flags=None, full_auto=True)`
+
+Runs a Codex task with checker-driven retries. Subclass it and implement
+`check()` to return an error string when the task is incomplete, or return
+`None`/`""` when the task passes.
+
+- `__call__() -> TaskResult`: run the task.
+- `set_up()`: optional setup hook.
+- `tear_down()`: optional cleanup hook.
+- `check() -> str | None`: return an error description or `None`/`""`.
+- `on_success(result)`: optional success hook.
+- `on_failure(result)`: optional failure hook.
+- `full_auto` (bool): enable `--full-auto` for workspace-write and on-request approvals.
+
+### `TaskResult(success, summary, attempts, errors, thread_id)`
+
+Simple result object returned by `Task.__call__`.
+
+- `success` (bool): whether the task completed successfully.
+- `summary` (str): agent summary of what happened.
+- `attempts` (int): how many attempts were used.
+- `errors` (str | None): last checker error, if any.
+- `thread_id` (str | None): Codex thread id for the session.
+
+## Behavior notes
+
+- Uses `codex exec --json` and parses JSONL events for `agent_message` items.
+- Automatically passes `--skip-git-repo-check` so it can run outside a git repo.
+- Passes `--yolo` when enabled (use with care).
+- Raises `RuntimeError` if Codex exits non-zero or returns no agent message.
+
+## Configuration
+
+Set `CODEX_BIN` to point at a non-default Codex binary:
+
+```bash
+export CODEX_BIN=/path/to/codex
+```

{codexapi-0.1.1 → codexapi-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codexapi"
-version = "0.1.1"
+version = "0.1.3"
 description = "Minimal Python API for running the Codex CLI."
 readme = "README.md"
 requires-python = ">=3.8"

codexapi-0.1.3/src/codexapi/__init__.py

@@ -0,0 +1,7 @@
+"""Minimal Python API for running the Codex CLI."""
+
+from .agent import Agent, agent
+from .task import Task, TaskResult
+
+__all__ = ["Agent", "Task", "TaskResult", "agent"]
+__version__ = "0.1.2"

codexapi-0.1.1/src/codexapi/client.py → codexapi-0.1.3/src/codexapi/agent.py

@@ -1,41 +1,32 @@
 """Codex CLI wrapper used by the codexapi public interface."""
 
-from __future__ import annotations
-
 import json
 import os
+import shlex
 import subprocess
-from typing import Optional, Tuple, Union
-
-Pathish = Union[str, os.PathLike]
 
 _CODEX_BIN = os.environ.get("CODEX_BIN", "codex")
 
 
-def agent(
-    prompt: str,
-    cwd: Optional[Pathish] = None,
-    *,
-    yolo: bool = False,
-    agent: str = "codex",
-) -> str:
+def agent(prompt, cwd=None, yolo=False, flags=None, full_auto=False):
     """Run a single Codex turn and return only the agent's message.
 
     Args:
         prompt: The user prompt to send to Codex.
         cwd: Optional working directory for the Codex session.
         yolo: Whether to pass --yolo to Codex.
-        agent: Agent backend to use (only "codex" is supported).
+        flags: Additional raw CLI flags to pass to Codex.
 
     Returns:
         The agent's visible response text with reasoning traces removed.
     """
-    _require_codex_agent(agent)
     message, _thread_id = _run_codex(
-        prompt=prompt,
-        cwd=cwd,
+        prompt,
+        cwd,
         thread_id=None,
         yolo=yolo,
+        flags=flags,
+        full_auto=full_auto,
     )
     return message
 
@@ -51,12 +42,12 @@ class Agent:
 
     def __init__(
         self,
-        cwd: Optional[Pathish] = None,
-        *,
-        yolo: bool = False,
-        agent: str = "codex",
-        trace_id: Optional[str] = None,
-    ) -> None:
+        cwd=None,
+        yolo=False,
+        thread_id=None,
+        flags=None,
+        full_auto=False,
+    ):
         """Create a new session wrapper.
 
         Args:
@@ -64,39 +55,32 @@ class Agent:
             yolo: Whether to pass --yolo to Codex.
             agent: Agent backend to use (only "codex" is supported).
             trace_id: Optional Codex thread id to resume from the first call.
+            flags: Additional raw CLI flags to pass to Codex.
         """
-        _require_codex_agent(agent)
-        self._cwd = cwd
+        self.cwd = cwd
         self._yolo = yolo
-        self._thread_id: Optional[str] = trace_id
+        self._flags = flags
+        self._full_auto = full_auto
+        self.thread_id = thread_id
 
-    def __call__(self, prompt: str) -> str:
+    def __call__(self, prompt):
         """Send a prompt to Codex and return only the agent's message."""
         message, thread_id = _run_codex(
-            prompt=prompt,
-            cwd=self._cwd,
-            thread_id=self._thread_id,
-            yolo=self._yolo,
+            prompt,
+            self.cwd,
+            self.thread_id,
+            self._yolo,
+            self._flags,
+            self._full_auto,
         )
         if thread_id:
-            self._thread_id = thread_id
+            self.thread_id = thread_id
         return message
 
-    @property
-    def thread_id(self) -> Optional[str]:
-        """Return the current Codex session id, if any."""
-        return self._thread_id
 
-
-def _run_codex(
-    *,
-    prompt: str,
-    cwd: Optional[Pathish],
-    thread_id: Optional[str],
-    yolo: bool,
-) -> Tuple[str, Optional[str]]:
+def _run_codex(prompt, cwd, thread_id, yolo, flags, full_auto):
     """Invoke the Codex CLI and return the message plus thread id (if any)."""
-    cmd = [
+    command = [
         _CODEX_BIN,
         "exec",
         "--json",
@@ -105,20 +89,24 @@ def _run_codex(
         "--skip-git-repo-check",
     ]
     if yolo:
-        cmd.append("--yolo")
-    if cwd is not None:
-        cmd.extend(["--cd", os.fspath(cwd)])
+        command.append("--yolo")
+    if full_auto:
+        command.append("--full-auto")
+    if flags:
+        command.extend(shlex.split(flags))
+    if cwd:
+        command.extend(["--cd", os.fspath(cwd)])
     if thread_id:
-        cmd.extend(["resume", thread_id, "-"])
+        command.extend(["resume", thread_id, "-"])
     else:
-        cmd.append("-")
+        command.append("-")
 
     result = subprocess.run(
-        cmd,
+        command,
         input=prompt,
         text=True,
         capture_output=True,
-        cwd=os.fspath(cwd) if cwd is not None else None,
+        cwd=os.fspath(cwd) if cwd else None,
     )
     if result.returncode != 0:
         stderr = result.stderr.strip()
@@ -130,16 +118,11 @@ def _run_codex(
     return _parse_jsonl(result.stdout)
 
 
-def _require_codex_agent(agent_name: str) -> None:
-    if agent_name != "codex":
-        raise ValueError('Only agent="codex" is supported right now.')
-
-
-def _parse_jsonl(output: str) -> Tuple[str, Optional[str]]:
+def _parse_jsonl(output):
     """Extract agent messages and the latest thread id from Codex JSONL output."""
-    thread_id: Optional[str] = None
-    messages: list[str] = []
-    raw_lines: list[str] = []
+    thread_id = None
+    messages = []
+    raw_lines = []
 
     for line in output.splitlines():
         line = line.strip()

codexapi-0.1.3/src/codexapi/task.py

@@ -0,0 +1,145 @@
+"""Task wrapper for running Codex Agent flows with checkers."""
+
+import logging
+
+from .agent import Agent
+
+_logger = logging.getLogger(__name__)
+
+
+class TaskResult:
+    """Outcome summary for a task run."""
+
+    def __init__(self, success, summary, attempts, errors, thread_id):
+        self.success = success
+        self.summary = summary
+        self.attempts = attempts
+        self.errors = errors
+        self.thread_id = thread_id
+
+    def __repr__(self):
+        return (
+            "TaskResult("
+            f"success={self.success}, "
+            f"attempts={self.attempts}, "
+            f"errors={self.errors!r}, "
+            f"thread_id={self.thread_id!r}, "
+            f"summary={self.summary!r}"
+            ")"
+        )
+
+
+class Task:
+    """ Run a Codex Agent in a directory until it is verifiably done.
+        Subclass and override these functions:
+            set_up     : prepare working directory, install things etc.
+            tear_down  : undo the above and leave machine in a clean state
+            check      : check if the task is done, return an error string if not
+            on_success : run if the task succeeds, e.g. commit and push
+            on_failure : run if the tsak fails, e.g. record why
+
+    """
+
+    def __init__(
+        self,
+        prompt,
+        max_attempts=10,
+        cwd=None,
+        yolo=False,
+        thread_id=None,
+        flags=None,
+        full_auto=True,
+    ):
+        if max_attempts < 1:
+            raise ValueError("max_attempts must be >= 1")
+        self.prompt = prompt
+        self.max_attempts = max_attempts
+        self.cwd = cwd
+        self.agent = Agent(
+            cwd=cwd,
+            yolo=yolo,
+            thread_id=thread_id,
+            flags=flags,
+            full_auto=full_auto,
+        )
+
+    def set_up(self):
+        """Clone a repo, set up a directory etc."""
+
+    def tear_down(self):
+        """Delete the directory etc."""
+
+    def check(self):
+        """ Check if the task is done, return a string describing the problems if not.
+            This can be any combination of running tests, python code or running an agent
+            with a specific prompt in self.cwd.
+         """
+
+    def on_success(self, result):
+        """Hook called after a successful task, e.g. commit the changes."""
+
+    def on_failure(self, result):
+        """Hook called after a failed run, e.g. log the failure reason."""
+
+    def fix_prompt(self, error):
+        """Build a prompt that asks the agent to fix checker failures."""
+        return (
+            "The following checks failed:\n"
+            f"{error}\n\n"
+            "Can you please dive in and see if you agree with this assessment, then fix these issues while staying as close as you can to the spirit of the original task?"
+        )
+
+    def success_prompt(self):
+        """Ask the agent to summarize what it did."""
+        return "Awesome - great job! Can you please produce a short summary of what you've done?"
+
+    def failure_prompt(self, error):
+        """Ask the agent to summarize remaining issues after retries."""
+        return (
+            "We ran out of attempts. Can you please look back at everything you tried and summarize what it was that made this task too hard to complete, including anything you wish you'd known at the start that would have helped improve things?\n\n"
+            f"Outstanding issues:\n{error}"
+        )
+
+    def __call__(self, debug=False):
+        """Run the task with checker-driven retries.
+            If debug is True, log debug messages.
+        """
+        try:
+            # If this fails in the middle we will still try to tear down
+            self.set_up()
+
+            # Start with the initial prompt
+            output = self.agent(self.prompt)
+            if debug:
+                _logger.debug("Initial output: %s", output)
+            
+            # Try correcting it up to max_attempts times
+            for attempt in range(self.max_attempts):
+                error = self.check()
+                if debug:
+                    _logger.debug("Check error: %s", error)
+                    
+                if error:
+                    # if there were errors, tell the agent to fix them
+                    output = self.agent(self.fix_prompt(error))
+                    if debug:
+                        _logger.debug("Fix output: %s", output)
+                else:
+                    # otherwise get a summary of what was done and run on_success
+                    summary = self.agent(self.success_prompt())
+                    if debug:
+                        _logger.debug("Success summary: %s", summary)
+                    result = TaskResult(True, summary, attempt + 1, error, self.agent.thread_id)
+                    self.on_success(result)
+                    return result
+
+            # Ran out of attempts - get a reason why and run on_failure
+            summary = self.agent(self.failure_prompt(error))
+            if debug:
+                _logger.debug("Failure summary: %s", summary)
+            result = TaskResult(False, summary, attempt + 1, error, self.agent.thread_id)
+            self.on_failure(result)
+            return result
+        finally:
+            # No matter what, once we have set_up we will always tear_down
+            self.tear_down()

codexapi-0.1.3/src/codexapi.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.1
+Name: codexapi
+Version: 0.1.3
+Summary: Minimal Python API for running the Codex CLI.
+License: MIT
+Keywords: codex,agent,cli,openai
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# CodexAPI
+
+Use OpenAI's codex from python as easily as calling a function with your codex credits instead of the API.
+
+*Note: this project is not affiliated with OpenAI in any way. Thanks for the awesome tools and models though!*
+
+## Requirements
+
+- Codex CLI installed and authenticated (`codex` must be on your PATH).
+- Python 3.8+.
+
+## Install
+
+```bash
+pip install codexapi
+```
+
+## Quickstart
+
+```python
+from codexapi import agent, Agent, Task
+
+# Run one-shot tasks as a function call
+print(agent("Say hello"))
+
+# Run a multi-turn conversation as a session
+session = Agent(cwd="/path/to/project")
+print(session("Summarize this repo."))
+print(session("Now list any risks."))
+
+# Save and resume a session later
+thread_id = session.thread_id
+session2 = Agent(cwd="/path/to/project", thread_id=thread_id)
+print(session2("Continue from where we left off."))
+
+# Define a task with a checker
+class RepoTask(Task):
+    def check(self):
+        # Return an error string if something is wrong, or None/"" if OK
+        return None
+
+task = RepoTask("Summarize this repo.", cwd="/path/to/project")
+result = task()
+print(result.success, result.summary)
+```
+
+## API
+
+### `agent(prompt, cwd=None, yolo=False, flags=None, full_auto=False) -> str`
+
+Runs a single Codex turn and returns only the agent's message. Any reasoning
+items are filtered out.
+
+- `prompt` (str): prompt to send to Codex.
+- `cwd` (str | PathLike | None): working directory for the Codex session.
+- `yolo` (bool): pass `--yolo` to Codex when true.
+- `flags` (str | None): extra CLI flags to pass to Codex.
+- `full_auto` (bool): enable `--full-auto` for workspace-write and on-request approvals.
+
+### `Agent(cwd=None, yolo=False, thread_id=None, flags=None, full_auto=False)`
+
+Creates a stateful session wrapper. Calling the instance sends the prompt into
+the same conversation and returns only the agent's message.
+
+- `__call__(prompt) -> str`: send a prompt to Codex and return the message.
+- `thread_id -> str | None`: expose the underlying session id once created.
+- `yolo` (bool): pass `--yolo` to Codex when true.
+- `flags` (str | None): extra CLI flags to pass to Codex.
+- `full_auto` (bool): enable `--full-auto` for workspace-write and on-request approvals.
+
+### `Task(prompt, max_attempts=10, cwd=None, yolo=False, thread_id=None, flags=None, full_auto=True)`
+
+Runs a Codex task with checker-driven retries. Subclass it and implement
+`check()` to return an error string when the task is incomplete, or return
+`None`/`""` when the task passes.
+
+- `__call__() -> TaskResult`: run the task.
+- `set_up()`: optional setup hook.
+- `tear_down()`: optional cleanup hook.
+- `check() -> str | None`: return an error description or `None`/`""`.
+- `on_success(result)`: optional success hook.
+- `on_failure(result)`: optional failure hook.
+- `full_auto` (bool): enable `--full-auto` for workspace-write and on-request approvals.
+
+### `TaskResult(success, summary, attempts, errors, thread_id)`
+
+Simple result object returned by `Task.__call__`.
+
+- `success` (bool): whether the task completed successfully.
+- `summary` (str): agent summary of what happened.
+- `attempts` (int): how many attempts were used.
+- `errors` (str | None): last checker error, if any.
+- `thread_id` (str | None): Codex thread id for the session.
+
+## Behavior notes
+
+- Uses `codex exec --json` and parses JSONL events for `agent_message` items.
+- Automatically passes `--skip-git-repo-check` so it can run outside a git repo.
+- Passes `--yolo` when enabled (use with care).
+- Raises `RuntimeError` if Codex exits non-zero or returns no agent message.
+
+## Configuration
+
+Set `CODEX_BIN` to point at a non-default Codex binary:
+
+```bash
+export CODEX_BIN=/path/to/codex
+```

{codexapi-0.1.1 → codexapi-0.1.3}/src/codexapi.egg-info/SOURCES.txt

@@ -2,7 +2,8 @@ LICENSE
 README.md
 pyproject.toml
 src/codexapi/__init__.py
-src/codexapi/client.py
+src/codexapi/agent.py
+src/codexapi/task.py
 src/codexapi.egg-info/PKG-INFO
 src/codexapi.egg-info/SOURCES.txt
 src/codexapi.egg-info/dependency_links.txt

codexapi-0.1.1/PKG-INFO

@@ -1,78 +0,0 @@
-Metadata-Version: 2.1
-Name: codexapi
-Version: 0.1.1
-Summary: Minimal Python API for running the Codex CLI.
-License: MIT
-Keywords: codex,agent,cli,openai
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# CodexAPI
-
-Use codex from python as easily as calling a function with your codex credits instead of the API.
-
-## Requirements
-
-- Codex CLI installed and authenticated (`codex` must be on your PATH).
-- Python 3.8+.
-
-## Install
-
-```bash
-pip install codexapi
-```
-
-## Quickstart
-
-```python
-from codexapi import agent, Agent
-
-# Run one-shot tasks as a function call
-print(agent("Say hello"))
-
-# Run a multi-turn conversation as a session
-session = Agent(cwd="/path/to/project")
-print(session("Summarize this repo."))
-print(session("Now list any risks."))
-```
-
-## API
-
-### `agent(prompt, cwd=None, *, yolo=False, agent="codex") -> str`
-
-Runs a single Codex turn and returns only the agent's message. Any reasoning
-items are filtered out.
-
-- `prompt` (str): prompt to send to Codex.
-- `cwd` (str | PathLike | None): working directory for the Codex session.
-- `yolo` (bool): pass `--yolo` to Codex when true.
-- `agent` (str): agent backend to use (only `"codex"` is supported).
-
-### `Agent(cwd=None, *, yolo=False, agent="codex", trace_id=None)`
-
-Creates a stateful session wrapper. Calling the instance sends the prompt into
-the same conversation and returns only the agent's message.
-
-- `__call__(prompt) -> str`: send a prompt to Codex and return the message.
-- `thread_id -> str | None`: expose the underlying session id once created.
-- `trace_id` (str | None): Codex thread id to resume from the first call.
-- `yolo` (bool): pass `--yolo` to Codex when true.
-- `agent` (str): agent backend to use (only `"codex"` is supported).
-
-## Behavior notes
-
-- Uses `codex exec --json` and parses JSONL events for `agent_message` items.
-- Automatically passes `--skip-git-repo-check` so it can run outside a git repo.
-- Passes `--yolo` when enabled (use with care).
-- Raises `RuntimeError` if Codex exits non-zero or returns no agent message.
-
-## Configuration
-
-Set `CODEX_BIN` to point at a non-default Codex binary:
-
-```bash
-export CODEX_BIN=/path/to/codex
-```

codexapi-0.1.1/README.md

@@ -1,66 +0,0 @@
-# CodexAPI
-
-Use codex from python as easily as calling a function with your codex credits instead of the API.
-
-## Requirements
-
-- Codex CLI installed and authenticated (`codex` must be on your PATH).
-- Python 3.8+.
-
-## Install
-
-```bash
-pip install codexapi
-```
-
-## Quickstart
-
-```python
-from codexapi import agent, Agent
-
-# Run one-shot tasks as a function call
-print(agent("Say hello"))
-
-# Run a multi-turn conversation as a session
-session = Agent(cwd="/path/to/project")
-print(session("Summarize this repo."))
-print(session("Now list any risks."))
-```
-
-## API
-
-### `agent(prompt, cwd=None, *, yolo=False, agent="codex") -> str`
-
-Runs a single Codex turn and returns only the agent's message. Any reasoning
-items are filtered out.
-
-- `prompt` (str): prompt to send to Codex.
-- `cwd` (str | PathLike | None): working directory for the Codex session.
-- `yolo` (bool): pass `--yolo` to Codex when true.
-- `agent` (str): agent backend to use (only `"codex"` is supported).
-
-### `Agent(cwd=None, *, yolo=False, agent="codex", trace_id=None)`
-
-Creates a stateful session wrapper. Calling the instance sends the prompt into
-the same conversation and returns only the agent's message.
-
-- `__call__(prompt) -> str`: send a prompt to Codex and return the message.
-- `thread_id -> str | None`: expose the underlying session id once created.
-- `trace_id` (str | None): Codex thread id to resume from the first call.
-- `yolo` (bool): pass `--yolo` to Codex when true.
-- `agent` (str): agent backend to use (only `"codex"` is supported).
-
-## Behavior notes
-
-- Uses `codex exec --json` and parses JSONL events for `agent_message` items.
-- Automatically passes `--skip-git-repo-check` so it can run outside a git repo.
-- Passes `--yolo` when enabled (use with care).
-- Raises `RuntimeError` if Codex exits non-zero or returns no agent message.
-
-## Configuration
-
-Set `CODEX_BIN` to point at a non-default Codex binary:
-
-```bash
-export CODEX_BIN=/path/to/codex
-```

codexapi-0.1.1/src/codexapi/__init__.py

@@ -1,6 +0,0 @@
-"""Minimal Python API for running the Codex CLI."""
-
-from .client import Agent, agent
-
-__all__ = ["Agent", "agent"]
-__version__ = "0.1.1"

codexapi-0.1.1/src/codexapi.egg-info/PKG-INFO

@@ -1,78 +0,0 @@
-Metadata-Version: 2.1
-Name: codexapi
-Version: 0.1.1
-Summary: Minimal Python API for running the Codex CLI.
-License: MIT
-Keywords: codex,agent,cli,openai
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# CodexAPI
-
-Use codex from python as easily as calling a function with your codex credits instead of the API.
-
-## Requirements
-
-- Codex CLI installed and authenticated (`codex` must be on your PATH).
-- Python 3.8+.
-
-## Install
-
-```bash
-pip install codexapi
-```
-
-## Quickstart
-
-```python
-from codexapi import agent, Agent
-
-# Run one-shot tasks as a function call
-print(agent("Say hello"))
-
-# Run a multi-turn conversation as a session
-session = Agent(cwd="/path/to/project")
-print(session("Summarize this repo."))
-print(session("Now list any risks."))
-```
-
-## API
-
-### `agent(prompt, cwd=None, *, yolo=False, agent="codex") -> str`
-
-Runs a single Codex turn and returns only the agent's message. Any reasoning
-items are filtered out.
-
-- `prompt` (str): prompt to send to Codex.
-- `cwd` (str | PathLike | None): working directory for the Codex session.
-- `yolo` (bool): pass `--yolo` to Codex when true.
-- `agent` (str): agent backend to use (only `"codex"` is supported).
-
-### `Agent(cwd=None, *, yolo=False, agent="codex", trace_id=None)`
-
-Creates a stateful session wrapper. Calling the instance sends the prompt into
-the same conversation and returns only the agent's message.
-
-- `__call__(prompt) -> str`: send a prompt to Codex and return the message.
-- `thread_id -> str | None`: expose the underlying session id once created.
-- `trace_id` (str | None): Codex thread id to resume from the first call.
-- `yolo` (bool): pass `--yolo` to Codex when true.
-- `agent` (str): agent backend to use (only `"codex"` is supported).
-
-## Behavior notes
-
-- Uses `codex exec --json` and parses JSONL events for `agent_message` items.
-- Automatically passes `--skip-git-repo-check` so it can run outside a git repo.
-- Passes `--yolo` when enabled (use with care).
-- Raises `RuntimeError` if Codex exits non-zero or returns no agent message.
-
-## Configuration
-
-Set `CODEX_BIN` to point at a non-default Codex binary:
-
-```bash
-export CODEX_BIN=/path/to/codex
-```