codex-agent-framework 0.1.25__tar.gz → 0.1.26__tar.gz

{codex_agent_framework-0.1.25/codex_agent_framework.egg-info → codex_agent_framework-0.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-agent-framework
-Version: 0.1.25
+Version: 0.1.26
 Summary: A lightweight event-driven Codex agent runtime.
 Author: Baptiste
 License-Expression: MIT
@@ -17,7 +17,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: audioop-lts; python_version >= "3.13"
 Requires-Dist: beautifulsoup4
-Requires-Dist: codex-backend-sdk
+Requires-Dist: codex-backend-sdk>=0.3.1
 Requires-Dist: fastapi
 Requires-Dist: filetype
 Requires-Dist: modict
@@ -176,17 +176,16 @@ agent = Agent(session="latest")
 agent.interact()
 ```
 
-Voice is disabled by default. Enable it explicitly for a voice session:
+Voice features are disabled by default. The realtime voice plugin uses Codex/ChatGPT auth through `codex-backend-sdk`; the legacy synchronized TTS stream still uses the OpenAI SDK speech endpoint when explicitly enabled.
 
 ```python
 from codex_agent import Agent
 
 agent = Agent(
     session="latest",
-    openai_api_key="sk-...",
-    voice_enabled=True,
-    voice="nova",
+    builtin_plugins=["realtime", "memory", "planner", "scheduler"],
 )
+agent.load_builtin_plugin("realtime")
 agent.interact()
 ```
 
@@ -473,7 +472,7 @@ The default agent includes practical local tools grouped as plugins:
 | Desktop | `desktop_start_session`, `desktop_run_commands` | Screenshot-backed Linux desktop automation. |
 | Subagents | `subagents_run` | Ephemeral child agents from predefined profiles. |
 
-Current built-in plugin modules include `files`, `content`, `bash`, `python`, `interface`, `environment`, `memory`, `planner`, `scheduler`, `browser`, `desktop`, and `subagents`.
+Current built-in plugin modules include `files`, `content`, `bash`, `python`, `interface`, `environment`, `context`, `memory`, `planner`, `scheduler`, `browser`, `desktop`, and `subagents`.
 
 The `subagents` plugin ships an `explorer` profile: a read-only codebase inspection agent.
 
@@ -482,7 +481,7 @@ Select built-ins explicitly when you want a smaller agent:
 ```python
 agent = Agent(
     session="latest",
-    builtin_plugins=["files", "content", "bash", "python", "memory", "planner"],
+    builtin_plugins=["files", "content", "bash", "python", "environment", "context", "memory", "planner"],
 )
 ```
 
@@ -534,8 +533,8 @@ from codex_agent import Agent
 agent = Agent(
     session="latest",
     model="gpt-5.5",
-    reasoning_effort="medium",
-    verbosity="medium",
+    reasoning={"effort": "medium", "summary": "auto"},
+    text={"verbosity": "medium"},
     input_token_limit=128000,
     auto_compact=True,
     web_search_enabled=False,
@@ -550,9 +549,8 @@ Or update saved config from the CLI:
 ```bash
 codex-agent config get
 codex-agent config set input_token_limit 128000
-codex-agent config set voice_enabled=true
-codex-agent config set builtin_plugins='["memory", "planner", "scheduler"]'
-codex-agent config set --no-save verbosity low
+codex-agent config set builtin_plugins='["environment", "context", "memory", "planner", "scheduler", "realtime"]'
+codex-agent config set --no-save text='{"verbosity":"low"}'
 ```
 
 Saved local state lives in `~/.codex-agent` by default:
@@ -622,8 +620,13 @@ python -m build
 python -m twine check dist/*
 ```
 
+### Auth model for backend-backed features
+
+Core LLM calls, memory embeddings, non-streaming STT transcription, and realtime voice use the Codex backend SDK with Codex/ChatGPT auth. Legacy synchronized TTS playback and OpenAI input-token counting still use the OpenAI SDK and may require `openai_api_key` or `OPENAI_API_KEY` when those paths are enabled.
+
 ## Recent releases
 
+- `0.1.26`: align SDK-facing config with Responses API shapes, add the `context` management plugin with selective non-destructive wrapper pruning, keep wrappers out of memory retrieval and compaction payloads, move embeddings/STT/realtime onto Codex backend auth, streamline voice/TTS plugin config, and improve TUI streaming/windowing.
 - `0.1.25`: move built-in capabilities further into plugin-scoped modules, add bundled plugin requirement metadata, and replace the TUI conversation pane with a selectable rich chat area that preserves mouse scrolling, copy selection, lazy transcript loading, and bottom-aware auto-scroll.
 - `0.1.24`: add slash-command lifecycle events and TUI progress/result rendering so commands such as `/compact` and `/help` show running, done, failed, result, and error feedback instead of going silent.
 - `0.1.23`: add SDK event streaming with `Agent.stream()`, root `Agent.add_plugin()`, a faster README flow, the `~/.codex-agent` runtime default, text-first voice defaults, safer prompt templating limited to system messages, smarter `codex-agent` local-server attachment, and clearer TUI tool-call progress lines.

{codex_agent_framework-0.1.25 → codex_agent_framework-0.1.26}/README.md

@@ -127,17 +127,16 @@ agent = Agent(session="latest")
 agent.interact()
 ```
 
-Voice is disabled by default. Enable it explicitly for a voice session:
+Voice features are disabled by default. The realtime voice plugin uses Codex/ChatGPT auth through `codex-backend-sdk`; the legacy synchronized TTS stream still uses the OpenAI SDK speech endpoint when explicitly enabled.
 
 ```python
 from codex_agent import Agent
 
 agent = Agent(
     session="latest",
-    openai_api_key="sk-...",
-    voice_enabled=True,
-    voice="nova",
+    builtin_plugins=["realtime", "memory", "planner", "scheduler"],
 )
+agent.load_builtin_plugin("realtime")
 agent.interact()
 ```
 
@@ -424,7 +423,7 @@ The default agent includes practical local tools grouped as plugins:
 | Desktop | `desktop_start_session`, `desktop_run_commands` | Screenshot-backed Linux desktop automation. |
 | Subagents | `subagents_run` | Ephemeral child agents from predefined profiles. |
 
-Current built-in plugin modules include `files`, `content`, `bash`, `python`, `interface`, `environment`, `memory`, `planner`, `scheduler`, `browser`, `desktop`, and `subagents`.
+Current built-in plugin modules include `files`, `content`, `bash`, `python`, `interface`, `environment`, `context`, `memory`, `planner`, `scheduler`, `browser`, `desktop`, and `subagents`.
 
 The `subagents` plugin ships an `explorer` profile: a read-only codebase inspection agent.
 
@@ -433,7 +432,7 @@ Select built-ins explicitly when you want a smaller agent:
 ```python
 agent = Agent(
     session="latest",
-    builtin_plugins=["files", "content", "bash", "python", "memory", "planner"],
+    builtin_plugins=["files", "content", "bash", "python", "environment", "context", "memory", "planner"],
 )
 ```
 
@@ -485,8 +484,8 @@ from codex_agent import Agent
 agent = Agent(
     session="latest",
     model="gpt-5.5",
-    reasoning_effort="medium",
-    verbosity="medium",
+    reasoning={"effort": "medium", "summary": "auto"},
+    text={"verbosity": "medium"},
     input_token_limit=128000,
     auto_compact=True,
     web_search_enabled=False,
@@ -501,9 +500,8 @@ Or update saved config from the CLI:
 ```bash
 codex-agent config get
 codex-agent config set input_token_limit 128000
-codex-agent config set voice_enabled=true
-codex-agent config set builtin_plugins='["memory", "planner", "scheduler"]'
-codex-agent config set --no-save verbosity low
+codex-agent config set builtin_plugins='["environment", "context", "memory", "planner", "scheduler", "realtime"]'
+codex-agent config set --no-save text='{"verbosity":"low"}'
 ```
 
 Saved local state lives in `~/.codex-agent` by default:
@@ -573,8 +571,13 @@ python -m build
 python -m twine check dist/*
 ```
 
+### Auth model for backend-backed features
+
+Core LLM calls, memory embeddings, non-streaming STT transcription, and realtime voice use the Codex backend SDK with Codex/ChatGPT auth. Legacy synchronized TTS playback and OpenAI input-token counting still use the OpenAI SDK and may require `openai_api_key` or `OPENAI_API_KEY` when those paths are enabled.
+
 ## Recent releases
 
+- `0.1.26`: align SDK-facing config with Responses API shapes, add the `context` management plugin with selective non-destructive wrapper pruning, keep wrappers out of memory retrieval and compaction payloads, move embeddings/STT/realtime onto Codex backend auth, streamline voice/TTS plugin config, and improve TUI streaming/windowing.
 - `0.1.25`: move built-in capabilities further into plugin-scoped modules, add bundled plugin requirement metadata, and replace the TUI conversation pane with a selectable rich chat area that preserves mouse scrolling, copy selection, lazy transcript loading, and bottom-aware auto-scroll.
 - `0.1.24`: add slash-command lifecycle events and TUI progress/result rendering so commands such as `/compact` and `/help` show running, done, failed, result, and error feedback instead of going silent.
 - `0.1.23`: add SDK event streaming with `Agent.stream()`, root `Agent.add_plugin()`, a faster README flow, the `~/.codex-agent` runtime default, text-first voice defaults, safer prompt templating limited to system messages, smarter `codex-agent` local-server attachment, and clearer TUI tool-call progress lines.

{codex_agent_framework-0.1.25 → codex_agent_framework-0.1.26}/codex_agent/agent.py

@@ -200,12 +200,12 @@ class Agent:
     def save_session(self):
         return self.sessions_manager.save()
 
-    def compact_session(self, client=None, model=None, instructions=None, max_completed_turns=None):
+    def compact_session(self, client=None, model=None, instructions=None, max_compacted_turns=None):
         return self.sessions_manager.compact(
             client=client,
             model=model,
             instructions=instructions,
-            max_completed_turns=max_completed_turns,
+            max_compacted_turns=max_compacted_turns,
         )
 
     def add_message(self,msg,pending=False):
@@ -363,7 +363,7 @@ class Agent:
             messages=messages,
             tools=self.tools_manager.get_response_tools(),
             prompt_cache_key=self.current_session_id,
-            **self.config.extract('model','reasoning_effort','verbosity','parallel_tool_calls')
+            **self.config.extract('model','reasoning','text','parallel_tool_calls')
         )
         self.sessions_manager.append_message(message)
         for item in message.output_items:

{codex_agent_framework-0.1.25 → codex_agent_framework-0.1.26}/codex_agent/ai.py

@@ -21,16 +21,7 @@ from .event import (
     ResponseToolCallsDeltaEvent,
     ServerToolCallEvent,
 )
-from codex_backend_sdk import (
-    CodexClient,
-    OutputItem,
-    ResponseAborted,
-    ResponseCompleted,
-    ReasoningDelta,
-    ResponseFailed,
-    TextDelta,
-    ToolCall,
-)
+from codex_backend_sdk import CodexClient
 
 class ChunkStreamer(MappingStreamProcessor):
     """Stream processor for AI response chunks, handling content, reasoning, and tool calls.
@@ -61,14 +52,14 @@ class AIBadRequestError(AIClientError):
 
 
 class APIAuthenticationError(AIClientError):
-    """Exception raised for OpenAI API authentication failures."""
+    """Exception raised for API authentication failures."""
     pass
 
 
 MAX_EMBEDDING_INPUT_TOKENS = 7500
 
 class AIClient:
-    """Client for Codex backend LLM calls and OpenAI voice/embedding calls."""
+    """Client for Codex backend LLM/embedding/STT calls plus OpenAI-key TTS/token helpers."""
 
     def __init__(self, agent):
         """Initialize AI clients from agent config.
@@ -99,11 +90,11 @@ class AIClient:
         """Client used for LLM calls through the ChatGPT Codex backend."""
         if self._codex_client is None:
             model = self.agent.config.get('model') or "gpt-5.4"
-            self._codex_client = CodexClient(model=model).authenticate()
+            self._codex_client = CodexClient(model=model).authenticate(request_api_key=False)
         return self._codex_client
 
     def abort(self):
-        if self._codex_client is not None:
+        if self._codex_client is not None and hasattr(self._codex_client, "abort"):
             self._codex_client.abort()
 
     def api_key_is_valid(self):
@@ -168,70 +159,63 @@ class AIClient:
     def audio_to_text(
         self,
         source: Union[str, io.BytesIO, bytes],
-        model: str = "whisper-1",
+        model: str = "gpt-4o-mini-transcribe",
         language: str = None,
         prompt: str = None,
         response_format: str = "text",
         temperature: float = 0.0
     ) -> str:
         """
-        Convert audio to text using OpenAI's Whisper model.
+        Convert audio to text using the Codex backend SDK OAuth client.
 
         Args:
             source: Audio data as file_path string, BytesIO object or bytes
-            model: Model to use (default: "whisper-1")
+            model: Transcription model to use (default: "gpt-4o-mini-transcribe")
             language: ISO-639-1 language code (e.g., "en", "fr"). If None, language is auto-detected.
             prompt: Optional text to guide the model's style
             response_format: Format of output ("text", "json", "verbose_json", "srt", "vtt")
             temperature: Sampling temperature between 0 and 1 (default: 0.0)
 
         Returns:
-            Transcribed text as a string
+            Transcribed text as a string, or raw subtitle text for srt/vtt formats.
         """
+        filename = "audio.mp3"
         if isinstance(source, str) and os.path.isfile(source):
+            filename = os.path.basename(source) or filename
             with open(source, "rb") as f:
                 audio = io.BytesIO(f.read())
         elif isinstance(source, bytes):
-                audio = io.BytesIO(source)
+            audio = io.BytesIO(source)
         elif isinstance(source, io.BytesIO):
             audio = source
+            filename = getattr(source, "name", filename) or filename
         else:
             raise NotImplementedError(f"Unsupported audio source: {source}")
 
-        # Ensure the BytesIO object is at the start
         audio.seek(0)
+        audio.name = filename
 
-        # Prepare the file for upload
-        audio.name = "audio.mp3"  # Add a name attribute
-
-        # Prepare transcription parameters
         transcription_params = {
             "model": model,
             "file": audio,
             "response_format": response_format,
-            "temperature": temperature
+            "temperature": temperature,
         }
-
-        # Add optional parameters if provided
         if language:
             transcription_params["language"] = language
         if prompt:
             transcription_params["prompt"] = prompt
 
-        # Call OpenAI transcription API (retries handled by client)
         try:
-            transcript = self.client.audio.transcriptions.create(**transcription_params)
+            transcript = self.codex_client.audio.transcriptions.create(**transcription_params)
         except Exception as e:
-            raise AIClientError(f"Failed to transcribe audio: {str(e)}")
+            raise AIClientError(f"Failed to transcribe audio with Codex backend SDK: {str(e)}")
 
-        # Extract text from response
-        if response_format == "text":
+        if isinstance(transcript, str):
             return transcript
-        elif response_format in ["json", "verbose_json"]:
+        if hasattr(transcript, "text"):
             return transcript.text
-        else:
-            # For srt and vtt formats, return as-is
-            return transcript
+        return transcript
 
     def _stream_chunks(self, params):
         params['tools'] = [
@@ -240,11 +224,8 @@ class AIClient:
         ] or None
 
         try:
-            stream_params = self._to_codex_stream_params(params)
-            response = self.codex_client.stream(
-                stream_params.pop('user_message'),
-                **stream_params
-            )
+            response_params = self._to_codex_response_params(params)
+            response = self.codex_client.responses.create(**response_params, stream=True)
         except Exception as e:
             if self.is_bad_request_error(e):
                 raise AIBadRequestError(str(e)) from e
@@ -259,10 +240,11 @@ class AIClient:
             tool_call_index = 0
             for event in self._iter_response_events(response):
                 self.agent.mainloop_manager.touch_activity("response_stream")
-                if isinstance(event, ResponseCompleted):
+                if getattr(event, "type", None) == "response.completed":
+                    completed = self._event_response(event)
                     self.agent.status_manager.cache_api_status(
-                        usage=event.usage,
-                        model=stream_params.get("model"),
+                        usage=modict(completed.get("usage") or {}),
+                        model=completed.get("model") or response_params.get("model"),
                         quota=self.get_quota_usage(),
                     )
                     continue
@@ -271,8 +253,6 @@ class AIClient:
                     tool_call_index += 1
                 if msg_chunk:
                     yield msg_chunk
-        except ResponseAborted:
-            raise AssistantInterrupted()
         except Exception as e:
             if self.is_bad_request_error(e):
                 raise AIBadRequestError(str(e)) from e
@@ -325,7 +305,7 @@ class AIClient:
 
     def get_quota_usage(self):
         try:
-            return self.codex_client.usage()
+            return self.codex_client.codex.usage()
         except Exception:
             return None
 
@@ -356,59 +336,103 @@ class AIClient:
                 history.append(response_format)
         return "\n\n".join(instructions), history
 
-    def _to_codex_stream_params(self, params):
+    def _to_codex_response_params(self, params):
         instructions, history = self._split_codex_messages(params.get("messages", []))
         tools = params.get("tools") or []
-        reasoning = params.get("reasoning_effort")
         model = params.get("model") or "gpt-5.4"
-        verbosity = params.get("verbosity")
-        parallel_tool_calls = params.get("parallel_tool_calls")
-        return {
-            "user_message": None,
-            "conversation_history": history,
+        reasoning = modict(params.get("reasoning") or {})
+        text = modict(params.get("text") or {})
+        if not reasoning and params.get("reasoning_effort"):
+            reasoning = modict(effort=params.get("reasoning_effort"), summary="auto")
+        if not text and params.get("verbosity"):
+            text = modict(verbosity=params.get("verbosity"))
+        payload = {
+            "input": history,
             "instructions": instructions,
             "model": model,
-            "verbosity": verbosity,
             "tools": tools or None,
             "tool_choice": "auto" if tools else "none",
-            "parallel_tool_calls": bool(parallel_tool_calls) if tools else False,
-            "reasoning": reasoning,
-            "reasoning_summary": "auto" if reasoning else None,
-            "include_reasoning": bool(reasoning),
+            "parallel_tool_calls": params.get("parallel_tool_calls"),
             "prompt_cache_key": params.get("prompt_cache_key"),
         }
+        if reasoning:
+            payload["reasoning"] = reasoning
+            payload["include"] = ["reasoning.encrypted_content"]
+        if text:
+            payload["text"] = text
+        return payload
 
     def _codex_event_to_message_chunk(self, event, tool_call_index=0):
-        if isinstance(event, TextDelta):
-            return MessageChunk(content=event.text)
-        if isinstance(event, ReasoningDelta):
-            return MessageChunk(reasoning=event.text)
-        if isinstance(event, ToolCall):
+        event_type = getattr(event, "type", "")
+        if event_type in {"response.output_text.delta", "response.content_part.delta"}:
+            return MessageChunk(content=self._event_delta_text(event))
+        if event_type == "response.reasoning_summary_part.delta":
+            return MessageChunk(reasoning=self._event_delta_text(event))
+        if event_type == "response.output_item.done":
+            item = modict(getattr(event, "item", None) or {})
+            if item.get("type") in {"function_call", "custom_tool_call"}:
+                return self._tool_call_item_to_message_chunk(item, tool_call_index)
+            if item.get("type") == "reasoning":
+                return MessageChunk(reasoning=self._reasoning_item_text(item))
+            return MessageChunk(output_items=[item])
+        if event_type in {"response.failed", "error"}:
+            error = self._event_error(event)
+            code = str(error.get("code") or "")
+            message = str(error.get("message") or "Response failed")
+            if code == "400" or "bad_request" in code.lower():
+                raise AIBadRequestError(message)
+            return MessageChunk(
+                content=(
+                    "Hmmm, sorry! The Codex backend returned an error:\n\n"
+                    f"```\n[{code or 'error'}] {message}\n```"
+                )
+            )
+        return None
+
+    def _tool_call_item_to_message_chunk(self, item, tool_call_index=0):
+        if item.get("type") == "custom_tool_call":
             tool_call = modict({
                 "index": tool_call_index,
-                "type": "function_call",
-                "call_id": event.call_id,
-                "name": event.name,
-                "arguments": event.arguments,
+                "type": "custom_tool_call",
+                "call_id": item.get("call_id", ""),
+                "name": item.get("name", ""),
+                "input": item.get("input", ""),
             })
             return MessageChunk(tool_calls=[tool_call])
-        if isinstance(event, OutputItem):
-            item = modict(event.raw)
-            if item.get("type") == "custom_tool_call":
-                tool_call = modict({
-                    "index": tool_call_index,
-                    "type": "custom_tool_call",
-                    "call_id": item.get("call_id", ""),
-                    "name": item.get("name", ""),
-                    "input": item.get("input", ""),
-                })
-                return MessageChunk(tool_calls=[tool_call])
-            return MessageChunk(output_items=[item])
-        if isinstance(event, ResponseFailed):
-            if getattr(event, "code", None) == 400 or "bad_request" in str(getattr(event, "code", "")).lower():
-                raise AIBadRequestError(str(getattr(event, "message", "") or event))
-            return MessageChunk(content=f"Hmmm, sorry! The Codex backend returned an error:\n\n```\n[{event.code}] {event.message}\n```")
-        return None
+        tool_call = modict({
+            "index": tool_call_index,
+            "type": "function_call",
+            "call_id": item.get("call_id", ""),
+            "name": item.get("name", ""),
+            "arguments": item.get("arguments", "{}"),
+        })
+        return MessageChunk(tool_calls=[tool_call])
+
+    def _event_delta_text(self, event):
+        delta = getattr(event, "delta", "")
+        if isinstance(delta, dict):
+            return delta.get("text", "")
+        return delta or ""
+
+    def _reasoning_item_text(self, item):
+        parts = []
+        for part in item.get("summary") or []:
+            if isinstance(part, dict):
+                parts.append(part.get("text", ""))
+        return "".join(parts) or item.get("encrypted_content", "")
+
+    def _event_response(self, event):
+        response = getattr(event, "response", None)
+        if hasattr(response, "model_dump"):
+            return response.model_dump()
+        return response if isinstance(response, dict) else {}
+
+    def _event_error(self, event):
+        response = self._event_response(event)
+        error = response.get("error") or getattr(event, "error", None) or {}
+        if hasattr(error, "model_dump"):
+            return error.model_dump()
+        return error if isinstance(error, dict) else {"message": str(error)}
 
     def run(self, **params):
         stream = ChunkStreamer(self.agent)(self._stream_chunks(params))
@@ -481,13 +505,13 @@ class AIClient:
 
     def embed_content(self, content: str, precision=5, dimensions=128, model="text-embedding-3-small"):
         """
-        Embed a text string using OpenAI embeddings.
+        Embed a text string using the Codex backend SDK OAuth client.
 
         Args:
             content: Text string to embed
             precision: Number of decimal places for rounding (default: 5)
             dimensions: Embedding dimensions (default: 128)
-            model: OpenAI embedding model to use (default: text-embedding-3-small)
+            model: Embedding model to use (default: text-embedding-3-small)
 
         Returns:
             A normalized embedding vector
@@ -499,7 +523,7 @@ class AIClient:
             raise ValueError("Content must not be empty")
 
         try:
-            response = self.client.embeddings.create(
+            response = self.codex_client.embeddings.create(
                 model=model,
                 input=content,
                 dimensions=dimensions
@@ -512,19 +536,19 @@ class AIClient:
 
     def embed_contents(self, contents: List[str], precision=5, dimensions=128, model="text-embedding-3-small"):
         """
-        Embed multiple text strings using OpenAI embeddings.
+        Embed multiple text strings using the Codex backend SDK OAuth client.
 
         Args:
             contents: List of text strings to embed
             precision: Number of decimal places for rounding (default: 5)
             dimensions: Embedding dimensions (default: 128)
-            model: OpenAI embedding model to use (default: text-embedding-3-small)
+            model: Embedding model to use (default: text-embedding-3-small)
 
         Returns:
             List of normalized embedding vectors
 
         Note:
-            OpenAI API handles batching automatically for better performance.
+            The embeddings API handles batching automatically for better performance.
         """
         if not contents:
             return []
@@ -535,7 +559,7 @@ class AIClient:
             raise ValueError("Embedding contents must not contain empty strings")
 
         try:
-            response = self.client.embeddings.create(
+            response = self.codex_client.embeddings.create(
                 model=model,
                 input=contents,
                 dimensions=dimensions
@@ -569,7 +593,7 @@ class AIClient:
             msg: Message object with text content
             precision: Number of decimal places for rounding (default: 5)
             dimensions: Embedding dimensions (default: 128)
-            model: OpenAI embedding model to use (default: text-embedding-3-small)
+            model: Embedding model to use through the Codex backend SDK (default: text-embedding-3-small)
 
         Returns:
             The embedding vector (also assigned to msg.embedding)

{codex_agent_framework-0.1.25 → codex_agent_framework-0.1.26}/codex_agent/builtin_commands.py

@@ -6,8 +6,9 @@ from .tool import get_agent
 
 MODEL_CONFIG_KEYS = (
     "model",
-    "reasoning_effort",
-    "verbosity",
+    "reasoning",
+    "text",
+    "parallel_tool_calls",
     "input_token_limit",
     "max_input_tokens",
     "auto_compact",
@@ -27,6 +28,9 @@ def parse_config_value(value):
         return False
     if value.isdigit():
         return int(value)
+    if (value.startswith("{") and value.endswith("}")) or (value.startswith("[") and value.endswith("]")):
+        import json
+        return json.loads(value)
     return value
 
 
@@ -53,19 +57,19 @@ def help():
 
 
 @command
-def compact(max_completed_turns=None):
+def compact(max_compacted_turns=None):
     agent = get_agent()
-    max_completed_turns = None if max_completed_turns in (None, "", "all") else int(max_completed_turns)
+    max_compacted_turns = None if max_compacted_turns in (None, "", "all") else int(max_compacted_turns)
     message = agent.compact_session(
         model=agent.config.model,
         instructions=agent.config_manager.system_message().content,
-        max_completed_turns=max_completed_turns,
+        max_compacted_turns=max_compacted_turns,
     )
     if message is None:
         return "Nothing to compact."
     if message.get("status") == "failed":
         return f"Compaction failed: {message.error}"
-    suffix = "" if max_completed_turns is None else f" from {max_completed_turns} completed turn(s)"
+    suffix = "" if max_compacted_turns is None else f" from {max_compacted_turns} compacted turn(s)"
     return f"Compacted {message.compacted_message_count} messages{suffix}."
 
 
@@ -129,13 +133,20 @@ def model(value=None):
 
 @command
 def reasoning(value=None):
+    agent = get_agent()
     if value is None:
-        return f"reasoning_effort: {get_agent().config.reasoning_effort!r}"
-    return update_model_config(reasoning_effort=value)
+        return f"reasoning: {agent.config.get('reasoning')!r}"
+    current = dict(agent.config.get("reasoning") or {})
+    current["effort"] = value
+    current.setdefault("summary", "auto")
+    return update_model_config(reasoning=current)
 
 
 @command
 def verbosity(value=None):
+    agent = get_agent()
     if value is None:
-        return f"verbosity: {get_agent().config.verbosity!r}"
-    return update_model_config(verbosity=value)
+        return f"text: {agent.config.get('text')!r}"
+    current = dict(agent.config.get("text") or {})
+    current["verbosity"] = value
+    return update_model_config(text=current)