python-codex 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

pycodex/tools/unified_exec_manager.py

@@ -14,6 +14,8 @@ Expected behavior:
 import asyncio
 import os
 import shlex
+import threading
+import typing
 import uuid
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -26,7 +28,6 @@ from ..utils.truncation import (
     approx_token_count,
     formatted_truncate_text,
 )
-import typing
 
 DEFAULT_EXEC_YIELD_TIME_MS = 10_000
 DEFAULT_WRITE_STDIN_YIELD_TIME_MS = 250
@@ -68,13 +69,14 @@ UNIFIED_EXEC_OUTPUT_SCHEMA = {
     "additionalProperties": False,
 }
 
+
 @dataclass
 class _HeadTailBuffer:
-    max_bytes: 'int' = UNIFIED_EXEC_OUTPUT_MAX_BYTES
-    head: 'bytearray' = field(default_factory=bytearray)
-    tail: 'bytearray' = field(default_factory=bytearray)
+    max_bytes: "int" = UNIFIED_EXEC_OUTPUT_MAX_BYTES
+    head: "bytearray" = field(default_factory=bytearray)
+    tail: "bytearray" = field(default_factory=bytearray)
 
-    def push_chunk(self, chunk: 'bytes') -> 'None':
+    def push_chunk(self, chunk: "bytes") -> "None":
         if not chunk or self.max_bytes <= 0:
             return
 
@@ -96,43 +98,45 @@ class _HeadTailBuffer:
             excess = len(self.tail) - tail_budget
             del self.tail[:excess]
 
-    def drain_bytes(self) -> 'bytes':
+    def drain_bytes(self) -> "bytes":
         combined = bytes(self.head) + bytes(self.tail)
         self.head.clear()
         self.tail.clear()
         return combined
 
-    def has_data(self) -> 'bool':
+    def has_data(self) -> "bool":
         return bool(self.head or self.tail)
 
 
 @dataclass
 class UnifiedExecSession:
-    session_id: 'int'
-    process: 'asyncio.subprocess.Process'
-    start_time: 'float'
-    command_display: 'str'
-    tty: 'bool'
-    unread_output: '_HeadTailBuffer' = field(default_factory=_HeadTailBuffer)
-    reader_task: 'typing.Union[asyncio.Task, None]' = None
-    output_event: 'asyncio.Event' = field(default_factory=asyncio.Event)
+    session_id: "int"
+    process: "asyncio.subprocess.Process"
+    start_time: "float"
+    command_display: "str"
+    tty: "bool"
+    unread_output: "_HeadTailBuffer" = field(default_factory=_HeadTailBuffer)
+    reader_task: "typing.Union[asyncio.Task, None]" = None
+    output_event: "asyncio.Event" = field(default_factory=asyncio.Event)
 
 
 class UnifiedExecManager:
-    def __init__(self, cwd: 'typing.Union[typing.Union[str, Path], None]' = None) -> 'None':
+    def __init__(
+        self, cwd: "typing.Union[typing.Union[str, Path], None]" = None
+    ) -> "None":
         self._default_cwd = Path(cwd or Path.cwd()).resolve()
         self._next_session_id = DEFAULT_SESSION_ID_START
-        self._sessions: 'typing.Dict[int, UnifiedExecSession]' = {}
-        self._lock = asyncio.Lock()
-        self._notify_hook: 'typing.Union[typing.Callable[[typing.Dict[str, object]], typing.Awaitable[typing.Any]], None]' = None
+        self._sessions: "typing.Dict[int, UnifiedExecSession]" = {}
+        self._lock = threading.Lock()
+        self._notify_hook: "typing.Union[typing.Callable[[typing.Dict[str, object]], typing.Awaitable[typing.Any]], None]" = (None)
 
     def set_notify_hook(
         self,
-        callback: 'typing.Union[typing.Callable[[typing.Dict[str, object]], typing.Awaitable[typing.Any]], None]',
-    ) -> 'None':
+        callback: "typing.Union[typing.Callable[[typing.Dict[str, object]], typing.Awaitable[typing.Any]], None]",
+    ) -> "None":
         self._notify_hook = callback
 
-    def running_session_count(self) -> 'int':
+    def running_session_count(self) -> "int":
         return sum(
             1
             for session in self._sessions.values()
@@ -141,14 +145,14 @@ class UnifiedExecManager:
 
     async def exec_command(
         self,
-        cmd: 'str',
-        workdir: 'typing.Union[str, None]' = None,
-        shell: 'typing.Union[str, None]' = None,
-        login: 'bool' = DEFAULT_LOGIN,
-        tty: 'bool' = DEFAULT_TTY,
-        yield_time_ms: 'int' = DEFAULT_EXEC_YIELD_TIME_MS,
-        max_output_tokens: 'typing.Union[int, None]' = None,
-    ) -> 'str':
+        cmd: "str",
+        workdir: "typing.Union[str, None]" = None,
+        shell: "typing.Union[str, None]" = None,
+        login: "bool" = DEFAULT_LOGIN,
+        tty: "bool" = DEFAULT_TTY,
+        yield_time_ms: "int" = DEFAULT_EXEC_YIELD_TIME_MS,
+        max_output_tokens: "typing.Union[int, None]" = None,
+    ) -> "str":
         session_id = await self._allocate_session_id()
         command = self._build_shell_command(cmd, shell, login)
         cwd = self._resolve_workdir(workdir)
@@ -178,7 +182,7 @@ class UnifiedExecManager:
         )
         session.reader_task = asyncio.create_task(self._pump_output(session))
 
-        async with self._lock:
+        with self._lock:
             self._sessions[session_id] = session
 
         output = await self._wait_and_snapshot(
@@ -193,11 +197,11 @@ class UnifiedExecManager:
 
     async def write_stdin(
         self,
-        session_id: 'int',
-        chars: 'str' = "",
-        yield_time_ms: 'int' = DEFAULT_WRITE_STDIN_YIELD_TIME_MS,
-        max_output_tokens: 'typing.Union[int, None]' = None,
-    ) -> 'str':
+        session_id: "int",
+        chars: "str" = "",
+        yield_time_ms: "int" = DEFAULT_WRITE_STDIN_YIELD_TIME_MS,
+        max_output_tokens: "typing.Union[int, None]" = None,
+    ) -> "str":
         session = await self._get_session(session_id)
         if session is None:
             return f"Error: session_id {session_id} is not running."
@@ -205,7 +209,9 @@ class UnifiedExecManager:
         if chars:
             if session.process.stdin is None:
                 return f"Error: session_id {session_id} does not accept stdin."
-            logger.debug("write_stdin session_id={} chars_len={}", session_id, len(chars))
+            logger.debug(
+                "write_stdin session_id={} chars_len={}", session_id, len(chars)
+            )
             if session.tty:
                 session.unread_output.push_chunk(self._tty_echo(chars))
             session.process.stdin.write(chars.encode("utf-8"))
@@ -217,22 +223,24 @@ class UnifiedExecManager:
             max_output_tokens,
         )
 
-    async def _allocate_session_id(self) -> 'int':
-        async with self._lock:
+    async def _allocate_session_id(self) -> "int":
+        with self._lock:
             session_id = self._next_session_id
             self._next_session_id += 1
             return session_id
 
-    async def _get_session(self, session_id: 'int') -> 'typing.Union[UnifiedExecSession, None]':
-        async with self._lock:
+    async def _get_session(
+        self, session_id: "int"
+    ) -> "typing.Union[UnifiedExecSession, None]":
+        with self._lock:
             return self._sessions.get(session_id)
 
     async def _wait_and_snapshot(
         self,
-        session_id: 'int',
-        yield_time_ms: 'int',
-        max_output_tokens: 'typing.Union[int, None]',
-    ) -> 'str':
+        session_id: "int",
+        yield_time_ms: "int",
+        max_output_tokens: "typing.Union[int, None]",
+    ) -> "str":
         session = await self._get_session(session_id)
         if session is None:
             return f"Error: session_id {session_id} is not running."
@@ -240,7 +248,9 @@ class UnifiedExecManager:
         loop = asyncio.get_running_loop()
         start_wait = loop.time()
         try:
-            await asyncio.wait_for(session.process.wait(), timeout=yield_time_ms / 1000.0)
+            await asyncio.wait_for(
+                session.process.wait(), timeout=yield_time_ms / 1000.0
+            )
         except asyncio.TimeoutError:
             remaining_seconds = (yield_time_ms / 1000.0) - (loop.time() - start_wait)
             if (
@@ -250,7 +260,9 @@ class UnifiedExecManager:
             ):
                 session.output_event.clear()
                 try:
-                    await asyncio.wait_for(session.output_event.wait(), timeout=remaining_seconds)
+                    await asyncio.wait_for(
+                        session.output_event.wait(), timeout=remaining_seconds
+                    )
                 except asyncio.TimeoutError:
                     pass
 
@@ -269,7 +281,6 @@ class UnifiedExecManager:
         output_text = self._truncate_output(output_text, max_output_tokens)
 
         lines = [
-            f"Command: {session.command_display}",
             f"Chunk ID: {uuid.uuid4().hex[:6]}",
             f"Wall time: {wall_time:.4f} seconds",
         ]
@@ -287,19 +298,21 @@ class UnifiedExecManager:
 
         return "\n".join(lines)
 
-    async def _close_session(self, session_id: 'int') -> 'None':
-        async with self._lock:
+    async def _close_session(self, session_id: "int") -> "None":
+        with self._lock:
             session = self._sessions.pop(session_id, None)
         if session is None:
             return
-        if session.process.stdin is not None and not stream_writer_is_closing(session.process.stdin):
+        if session.process.stdin is not None and not stream_writer_is_closing(
+            session.process.stdin
+        ):
             session.process.stdin.close()
 
     async def _drain_reader_after_exit(
         self,
-        session: 'UnifiedExecSession',
-        timeout_seconds: 'float',
-    ) -> 'None':
+        session: "UnifiedExecSession",
+        timeout_seconds: "float",
+    ) -> "None":
         reader_task = session.reader_task
         if reader_task is None:
             return
@@ -319,7 +332,7 @@ class UnifiedExecManager:
         await asyncio.gather(reader_task, return_exceptions=True)
         session.output_event.set()
 
-    async def _pump_output(self, session: 'UnifiedExecSession') -> 'None':
+    async def _pump_output(self, session: "UnifiedExecSession") -> "None":
         stream = session.process.stdout
         if stream is None:
             return
@@ -331,17 +344,21 @@ class UnifiedExecManager:
             session.output_event.set()
         session.output_event.set()
 
-    async def _notify_when_session_completes(self, session_id: 'int') -> 'None':
-        callback = self._notify_hook
-        if callback is None:
+    async def _notify_when_session_completes(self, session_id: "int") -> "None":
+        from ..agent import TurnInterrupted
+
+        if self._notify_hook is None:
             return
         session = await self._get_session(session_id)
         if session is None:
             return
         await session.process.wait()
-        async with self._lock:
+        with self._lock:
             if self._sessions.get(session_id) is not session:
                 return
+        callback = self._notify_hook
+        if callback is None:
+            return
         try:
             await callback(
                 {
@@ -351,10 +368,20 @@ class UnifiedExecManager:
                     "command": session.command_display,
                 }
             )
-        except Exception:  # pragma: no cover - background notification must not break tools
+        except TurnInterrupted:
+            # A steer ended the notification turn at a safe boundary.
             return
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            asyncio.get_running_loop().call_exception_handler(
+                {
+                    "message": "Exec completion notification failed",
+                    "exception": exc,
+                }
+            )
 
-    def _resolve_workdir(self, workdir: 'typing.Union[str, None]') -> 'Path':
+    def _resolve_workdir(self, workdir: "typing.Union[str, None]") -> "Path":
         if not workdir:
             return self._default_cwd
         path = Path(workdir)
@@ -364,10 +391,10 @@ class UnifiedExecManager:
 
     def _build_shell_command(
         self,
-        cmd: 'str',
-        shell: 'typing.Union[str, None]',
-        login: 'bool',
-    ) -> 'typing.List[str]':
+        cmd: "str",
+        shell: "typing.Union[str, None]",
+        login: "bool",
+    ) -> "typing.List[str]":
         shell_path = shell or os.environ.get("SHELL") or "/bin/bash"
         shell_name = Path(shell_path).name.lower()
         if shell_name in {"cmd", "cmd.exe"}:
@@ -376,13 +403,19 @@ class UnifiedExecManager:
             return [shell_path, "-NoProfile", "-Command", cmd]
         return [shell_path, "-lc" if login else "-c", cmd]
 
-    def _estimate_token_count(self, output: 'str') -> 'typing.Union[int, None]':
+    def _estimate_token_count(self, output: "str") -> "typing.Union[int, None]":
         return approx_token_count(output)
 
-    def _truncate_output(self, output: 'str', max_output_tokens: 'typing.Union[int, None]') -> 'str':
-        token_budget = DEFAULT_MAX_OUTPUT_TOKENS if max_output_tokens is None else max_output_tokens
+    def _truncate_output(
+        self, output: "str", max_output_tokens: "typing.Union[int, None]"
+    ) -> "str":
+        token_budget = (
+            DEFAULT_MAX_OUTPUT_TOKENS
+            if max_output_tokens is None
+            else max_output_tokens
+        )
         return formatted_truncate_text(output, max(token_budget, 0))
 
-    def _tty_echo(self, chars: 'str') -> 'bytes':
+    def _tty_echo(self, chars: "str") -> "bytes":
         normalized = chars.replace("\n", "\r\n")
         return normalized.encode("utf-8")

pycodex/tools/update_plan_tool.py

@@ -10,10 +10,11 @@ Expected behavior:
   confirmation text Codex uses.
 """
 
+import typing
+
 from ..protocol import JSONDict, JSONValue
 from ..runtime_services import PlanItem, PlanStore
 from .base_tool import BaseTool, ToolContext
-import typing
 
 VALID_PLAN_STATUSES = {"pending", "in_progress", "completed"}
 
@@ -59,16 +60,16 @@ class UpdatePlanTool(BaseTool):
     }
     supports_parallel = False
 
-    def __init__(self, plan_store: 'PlanStore') -> 'None':
+    def __init__(self, plan_store: "PlanStore") -> "None":
         self._plan_store = plan_store
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         del context
         raw_plan = args.get("plan")
         if not isinstance(raw_plan, list):
             return "Error: `plan` must be a list."
 
-        plan_items: 'typing.List[PlanItem]' = []
+        plan_items: "typing.List[PlanItem]" = []
         for item in raw_plan:
             if not isinstance(item, dict):
                 return "Error: each `plan` item must be an object."
@@ -81,6 +82,8 @@ class UpdatePlanTool(BaseTool):
             plan_items.append(PlanItem(step=step, status=status))
 
         explanation_value = args.get("explanation")
-        explanation = None if explanation_value in (None, "") else str(explanation_value)
+        explanation = (
+            None if explanation_value in (None, "") else str(explanation_value)
+        )
         self._plan_store.update(explanation, tuple(plan_items))
         return "Plan updated"

pycodex/tools/view_image_tool.py

@@ -14,12 +14,12 @@ Expected behavior:
   item that Codex uses when feeding image tool output back to the model.
 """
 
+import typing
 from pathlib import Path
 
-from ..image_utils import ImageProcessingError, load_image_data_url
 from ..protocol import JSONDict, JSONValue
+from ..utils.image_utils import ImageProcessingError, load_image_data_url
 from .base_tool import BaseTool, StructuredToolOutput, ToolContext
-import typing
 
 VIEW_IMAGE_OUTPUT_SCHEMA = {
     "type": "object",
@@ -63,10 +63,12 @@ class ViewImageTool(BaseTool):
     }
     output_schema = VIEW_IMAGE_OUTPUT_SCHEMA
 
-    def __init__(self, cwd: 'typing.Union[typing.Union[str, Path], None]' = None) -> 'None':
+    def __init__(
+        self, cwd: "typing.Union[typing.Union[str, Path], None]" = None
+    ) -> "None":
         self._workspace_root = Path(cwd or Path.cwd()).resolve()
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         del context
         path_value = str(args.get("path", "")).strip()
         if not path_value:
@@ -101,7 +103,7 @@ class ViewImageTool(BaseTool):
             "image_url": image_url,
             "detail": detail,
         }
-        image_item: 'JSONDict' = {
+        image_item: "JSONDict" = {
             "type": "input_image",
             "image_url": image_url,
             "detail": detail,

pycodex/tools/wait_agent_tool.py

@@ -9,7 +9,10 @@ Expected behavior:
   wait times out.
 """
 
-from ..protocol import JSONDict, JSONValue
+import json
+import typing
+
+from ..protocol import JSONDict, JSONValue, UserMessage
 from ..runtime_services import SubAgentManager
 from .agent_tool_schemas import AGENT_STATUS_SCHEMA
 from .base_tool import BaseTool, ToolContext
@@ -63,10 +66,10 @@ class WaitAgentTool(BaseTool):
     output_schema = WAIT_AGENT_OUTPUT_SCHEMA
     supports_parallel = False
 
-    def __init__(self, subagent_manager: 'SubAgentManager') -> 'None':
+    def __init__(self, subagent_manager: "SubAgentManager") -> "None":
         self._subagent_manager = subagent_manager
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         del context
         ids = args.get("ids")
         if not isinstance(ids, list) or not ids:
@@ -77,7 +80,27 @@ class WaitAgentTool(BaseTool):
         timeout_ms = self._timeout_ms(args)
         return await self._subagent_manager.wait_agents(agent_ids, timeout_ms)
 
-    def _timeout_ms(self, args: 'JSONDict') -> 'int':
+    def follow_up_messages(
+        self, output: "JSONValue"
+    ) -> "typing.Tuple[UserMessage, ...]":
+        if not isinstance(output, dict):
+            return ()
+        return tuple(
+            UserMessage(
+                text=(
+                    "<subagent_notification>\n"
+                    + json.dumps(
+                        {"agent_id": agent_id, "status": status},
+                        ensure_ascii=False,
+                        separators=(",", ":"),
+                    )
+                    + "\n</subagent_notification>"
+                )
+            )
+            for agent_id, status in output["status"].items()
+        )
+
+    def _timeout_ms(self, args: "JSONDict") -> "int":
         value = int(args.get("timeout_ms", DEFAULT_WAIT_AGENT_TIMEOUT_MS))
         return min(
             max(value, MIN_WAIT_AGENT_TIMEOUT_MS),

pycodex/tools/wait_tool.py

@@ -9,10 +9,11 @@ Expected behavior:
 - Return only the new output since the previous `exec` / `wait` snapshot.
 """
 
+import typing
+
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
 from .code_mode_manager import DEFAULT_WAIT_YIELD_TIME_MS, CodeModeManager
-import typing
 
 
 class WaitTool(BaseTool):
@@ -59,10 +60,10 @@ class WaitTool(BaseTool):
     }
     supports_parallel = False
 
-    def __init__(self, manager: 'CodeModeManager') -> 'None':
+    def __init__(self, manager: "CodeModeManager") -> "None":
         self._manager = manager
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         del context
         cell_id = str(args.get("cell_id", "")).strip()
         if not cell_id:
@@ -74,7 +75,7 @@ class WaitTool(BaseTool):
             terminate=bool(args.get("terminate", False)),
         )
 
-    def _optional_int(self, args: 'JSONDict', key: 'str') -> 'typing.Union[int, None]':
+    def _optional_int(self, args: "JSONDict", key: "str") -> "typing.Union[int, None]":
         value = args.get(key)
         if value in (None, ""):
             return None

pycodex/tools/web_search_tool.py

@@ -24,6 +24,8 @@ class WebSearchTool(BaseTool):
     }
     supports_parallel = False
 
-    async def run(self, context: 'ToolContext', args: 'JSONValue') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONValue") -> "JSONValue":
         del context, args
-        return "Error: web_search is provider-native and should not be executed locally."
+        return (
+            "Error: web_search is provider-native and should not be executed locally."
+        )

pycodex/tools/write_stdin_tool.py

@@ -10,6 +10,8 @@ Expected behavior:
 - Reuse the same `session_id` until the process exits.
 """
 
+import typing
+
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
 from .unified_exec_manager import (
@@ -17,7 +19,6 @@ from .unified_exec_manager import (
     UNIFIED_EXEC_OUTPUT_SCHEMA,
     UnifiedExecManager,
 )
-import typing
 
 MIN_WRITE_YIELD_TIME_MS = 250
 MAX_WRITE_YIELD_TIME_MS = 30_000
@@ -54,10 +55,10 @@ class WriteStdinTool(BaseTool):
     output_schema = UNIFIED_EXEC_OUTPUT_SCHEMA
     supports_parallel = False
 
-    def __init__(self, manager: 'UnifiedExecManager') -> 'None':
+    def __init__(self, manager: "UnifiedExecManager") -> "None":
         self._manager = manager
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         del context
         session_id = args.get("session_id")
         if session_id is None:
@@ -71,7 +72,7 @@ class WriteStdinTool(BaseTool):
             max_output_tokens=self._optional_int(args, "max_output_tokens"),
         )
 
-    def _yield_time_ms(self, args: 'JSONDict', chars: 'str') -> 'int':
+    def _yield_time_ms(self, args: "JSONDict", chars: "str") -> "int":
         if chars:
             return self._bounded_int(
                 args,
@@ -88,7 +89,7 @@ class WriteStdinTool(BaseTool):
             MAX_WRITE_STDIN_POLL_YIELD_TIME_MS,
         )
 
-    def _optional_int(self, args: 'JSONDict', key: 'str') -> 'typing.Union[int, None]':
+    def _optional_int(self, args: "JSONDict", key: "str") -> "typing.Union[int, None]":
         value = args.get(key)
         if value in (None, ""):
             return None
@@ -96,11 +97,11 @@ class WriteStdinTool(BaseTool):
 
     def _bounded_int(
         self,
-        args: 'JSONDict',
-        key: 'str',
-        default: 'int',
-        minimum: 'int',
-        maximum: 'int',
-    ) -> 'int':
+        args: "JSONDict",
+        key: "str",
+        default: "int",
+        minimum: "int",
+        maximum: "int",
+    ) -> "int":
         value = int(args.get(key, default))
         return min(max(value, minimum), maximum)

pycodex/utils/__init__.py

@@ -1,35 +1,20 @@
-from .dotenv import DOTENV_FILENAME, load_codex_dotenv, parse_dotenv, parse_dotenv_value
+from .compactor import DEFAULT_COMPACT_PROMPT, SUMMARY_PREFIX, compact
 from .debug import get_debug_dir
+from .dotenv import DOTENV_FILENAME, load_codex_dotenv, parse_dotenv, parse_dotenv_value
 from .get_env import build_user_agent, get_shell_name, get_timezone_name
 from .random_ids import uuid7_string
-from .compactor import DEFAULT_COMPACT_PROMPT, SUMMARY_PREFIX, compact
-from .toolcall_visualize import colorize_cli_message, tool_summary
-from .visualize import (
-    CliSessionView,
-    cli_color_enabled,
-    format_cli_tool_call_message,
-    short_id,
-    shorten_title,
-)
 
 __all__ = [
-    "CliSessionView",
     "DEFAULT_COMPACT_PROMPT",
     "DOTENV_FILENAME",
     "SUMMARY_PREFIX",
     "build_user_agent",
-    "cli_color_enabled",
-    "colorize_cli_message",
-    "format_cli_tool_call_message",
     "get_debug_dir",
     "get_shell_name",
     "get_timezone_name",
     "load_codex_dotenv",
     "parse_dotenv",
     "parse_dotenv_value",
-    "short_id",
-    "shorten_title",
-    "tool_summary",
     "compact",
     "uuid7_string",
 ]