codex-agent-framework 0.1.84__tar.gz → 0.1.86__tar.gz

{codex_agent_framework-0.1.84 → codex_agent_framework-0.1.86}/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to this project will be documented in this file.
 
 This project loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and uses semantic versioning where practical.
 
+## [0.1.86] - 2026-07-10
+### Changed
+- Simplify tool schema token accounting around a shared Responses-tool primitive while preserving local and server tool formats.
+- Remove inert plugin-config compatibility arguments, message `pending` hints, and a stale TUI transcript shim.
+- Restructure the code-quality guidance into concise, actionable maintainer principles.
+
+### Tests
+- Validate the simplification pass with the full offline suite (700 passed).
+
+## [0.1.85] - 2026-07-05
+### Changed
+- Simplify the CLI around the persisted active session: `codex-agent` and `run` now target the active session by default, with `--new` for starting fresh.
+- Add a human-oriented `plugins` CLI/API surface for listing, loading, unloading, and reloading builtin or custom plugins.
+- Improve TUI stream responsiveness with faster live flushes, local delta coalescing, and batched event queue draining.
+
+### Fixed
+- Make TUI reopening wait for real registration before reporting success, avoiding stale immediate status snapshots.
+- Preserve compaction summaries before recent conversation messages while keeping provider messages at the end of the active context.
+
+### Tests
+- Validate the CLI, server, context, plugin, TUI, and service changes with targeted coverage.
+
 ## [0.1.84] - 2026-07-03
 ### Changed
 - Include the desktop dock Tauri sources in Python source and wheel distributions, excluding generated build artifacts.

{codex_agent_framework-0.1.84/codex_agent_framework.egg-info → codex_agent_framework-0.1.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-agent-framework
-Version: 0.1.84
+Version: 0.1.86
 Summary: A lightweight event-driven Codex agent runtime.
 Author: Baptiste
 License-Expression: MIT
@@ -163,6 +163,7 @@ Useful CLI commands:
 ```bash
 codex-agent status --json
 codex-agent tools
+codex-agent plugins list
 codex-agent sessions list
 codex-agent config get
 codex-agent run "Run a quick repository health check."

{codex_agent_framework-0.1.84 → codex_agent_framework-0.1.86}/README.md

@@ -114,6 +114,7 @@ Useful CLI commands:
 ```bash
 codex-agent status --json
 codex-agent tools
+codex-agent plugins list
 codex-agent sessions list
 codex-agent config get
 codex-agent run "Run a quick repository health check."

{codex_agent_framework-0.1.84 → codex_agent_framework-0.1.86}/apps/desktop/src/App.test.ts

@@ -115,6 +115,69 @@ describe("dock native SSE event handling", () => {
     });
   });
 
+  it("ignores live-only duplicate events during replay", async () => {
+    const { handleSSE } = await import("./App");
+
+    handleSSE({ type: "message_submitted_event", message: { role: "user", content: "hello" } }, true);
+    handleSSE({ type: "tool_call_start_event", tool_call: { id: "tool-1", name: "read", input: { file_path: "README.md" } } }, true);
+    handleSSE({ type: "tool_call_done_event", tool_call: { id: "tool-1" }, content: "ok" }, true);
+    handleSSE({ type: "desktop_control_event", action: "close" }, true);
+
+    expect(useStore.getState().messages).toHaveLength(0);
+    expect(useStore.getState().toolRegistry).toEqual({});
+  });
+
+  it("still handles durable replay messages", async () => {
+    const { handleSSE } = await import("./App");
+
+    handleSSE({ type: "message_added_event", message: { role: "user", content: "hello" } }, true);
+    handleSSE({
+      type: "message_added_event",
+      message: {
+        role: "assistant",
+        content: "checking",
+        tool_calls: [{ call_id: "tool-1", name: "read", arguments: JSON.stringify({ file_path: "README.md" }) }],
+      },
+    }, true);
+
+    expect(useStore.getState().messages).toHaveLength(2);
+    expect(useStore.getState().messages[0]).toMatchObject({ role: "user", content: [{ type: "text", text: "hello" }] });
+    expect(useStore.getState().toolRegistry["tool-1"]).toMatchObject({ id: "tool-1", name: "read" });
+  });
+
+  it("does not duplicate live tool calls when finalized messages arrive", async () => {
+    const { handleSSE } = await import("./App");
+
+    handleSSE({
+      type: "tool_call_start_event",
+      tool_call: { id: "tool-1", name: "read", input: { file_path: "README.md" } },
+    });
+    handleSSE({
+      type: "tool_call_done_event",
+      tool_call: { id: "tool-1" },
+      content: "ok",
+    });
+    handleSSE({
+      type: "message_added_event",
+      message: {
+        role: "assistant",
+        content: "checking",
+        tool_calls: [{ call_id: "tool-1", name: "read", arguments: JSON.stringify({ file_path: "README.md" }) }],
+      },
+    });
+    handleSSE({
+      type: "message_added_event",
+      message: { type: "tool_result_message", role: "tool", call_id: "tool-1", content: "ok" },
+    });
+
+    const toolUseBlocks = useStore.getState().messages.flatMap((message) => message.content).filter((block) => block.type === "tool_use");
+    const toolResultBlocks = useStore.getState().messages.flatMap((message) => message.content).filter((block) => block.type === "tool_result");
+
+    expect(toolUseBlocks).toHaveLength(1);
+    expect(toolResultBlocks).toHaveLength(1);
+    expect(useStore.getState().toolRegistry["tool-1"]).toMatchObject({ done: true, output: "ok" });
+  });
+
   it("tracks native tool start and done events", async () => {
     const { handleSSE } = await import("./App");
 

{codex_agent_framework-0.1.84 → codex_agent_framework-0.1.86}/apps/desktop/src/App.tsx

@@ -6,7 +6,8 @@ import { SettingsPanel } from "./components/SettingsPanel";
 import { Chat } from "./components/Chat";
 import { Splash, isSplashDone, resetSplash } from "./components/Splash";
 import { useStore, type ContentBlock, type ShowBlock } from "./store";
-import { getStatus, getRecentEvents, subscribeSSE, getDockUI, saveDockUI, registerDesktop, unregisterDesktop, type SSEEvent, type DockUI } from "./api";
+import { invoke } from "@tauri-apps/api/core";
+import { getStatus, getRecentEvents, subscribeSSE, getDockUI, saveDockUI, registerDesktop, unregisterDesktop, type SSEEvent, type DockUI, type DesktopState } from "./api";
 
 const isTauri = "__TAURI_INTERNALS__" in window;
 // Cache dock UI in localStorage for instant restore, sync with server file
@@ -30,6 +31,23 @@ function getLogicalContentHeight(el: HTMLElement): number {
   return Math.ceil(el.offsetHeight * zoom);
 }
 
+async function dockRegistrationState(collapsed: boolean): Promise<DesktopState> {
+  const state: DesktopState = {
+    label: "main",
+    url: window.location.href,
+    user_agent: navigator.userAgent,
+    visible: true,
+    focused: document.hasFocus(),
+    collapsed,
+  };
+  if (isTauri) {
+    try {
+      state.pid = await invoke<number>("current_pid");
+    } catch { /* PID is best-effort; server unregister fallback still applies. */ }
+  }
+  return state;
+}
+
 async function trackWindowGeo() {
   if (!isTauri) return;
   const { getCurrentWindow } = await import("@tauri-apps/api/window");
@@ -56,7 +74,15 @@ async function trackWindowGeo() {
 
 
 // ── SSE event handler ──────────────────────────────────────────────
+const REPLAY_IGNORED_EVENT_TYPES = new Set([
+  "message_submitted_event",
+  "tool_call_start_event",
+  "tool_call_done_event",
+  "desktop_control_event",
+]);
+
 export function handleSSE(event: SSEEvent, isReplay = false) {
+  if (isReplay && REPLAY_IGNORED_EVENT_TYPES.has(event.type)) return;
   const store = useStore.getState();
   if (event.session_id) store.setSessionId(event.session_id);
 
@@ -181,6 +207,18 @@ function handleStatusEvent(event: SSEEvent) {
   if (typeof status.session_id === "string") useStore.getState().setSessionId(status.session_id);
 }
 
+function hasDisplayedToolUse(id: string): boolean {
+  return useStore.getState().messages.some((message) =>
+    message.content.some((block) => block.type === "tool_use" && block.id === id),
+  );
+}
+
+function hasDisplayedToolResult(id: string): boolean {
+  return useStore.getState().messages.some((message) =>
+    message.content.some((block) => block.type === "tool_result" && block.tool_use_id === id),
+  );
+}
+
 function handleMessageEvent(event: SSEEvent) {
   const message = isRecord(event.message) ? event.message : null;
   if (!message) return;
@@ -207,7 +245,9 @@ function handleMessageEvent(event: SSEEvent) {
       useStore.getState().registerToolUse(callId, toolName, {});
       useStore.getState().resolveToolResult(callId, isError, output);
     }
-    useStore.getState().addMessage({ role: "assistant", content: [{ type: "tool_result", tool_use_id: callId, output, is_error: isError }] });
+    if (!callId || !hasDisplayedToolResult(callId)) {
+      useStore.getState().addMessage({ role: "assistant", content: [{ type: "tool_result", tool_use_id: callId, output, is_error: isError }] });
+    }
     return;
   }
 
@@ -237,7 +277,9 @@ function handleToolCallStart(
   const input = toolCallInput(toolCall);
   if (id) {
     useStore.getState().registerToolUse(id, name, input, opts);
-    useStore.getState().addMessage({ role: "assistant", content: [{ type: "tool_use", id, name, input }] });
+    if (!hasDisplayedToolUse(id)) {
+      useStore.getState().addMessage({ role: "assistant", content: [{ type: "tool_use", id, name, input }] });
+    }
   }
   useStore.getState().setAgentPhase("tool_use");
   useStore.getState().setLastToolName(name);
@@ -249,10 +291,12 @@ function handleToolCallDone(event: SSEEvent) {
   const output = textFromContent(event.content ?? event.result ?? objectField(toolCall, "output"));
   const isError = Boolean(event.is_error) || output.startsWith("<error>");
   if (id) useStore.getState().resolveToolResult(id, isError, output);
-  useStore.getState().addMessage({
-    role: "assistant",
-    content: [{ type: "tool_result", tool_use_id: id, output, is_error: isError }],
-  });
+  if (!id || !hasDisplayedToolResult(id)) {
+    useStore.getState().addMessage({
+      role: "assistant",
+      content: [{ type: "tool_result", tool_use_id: id, output, is_error: isError }],
+    });
+  }
 }
 
 function handleInteractionRequested(event: SSEEvent) {
@@ -318,7 +362,7 @@ function blocksFromToolCalls(toolCalls: unknown): ContentBlock[] {
     const name = stringField(call, "name") || "unknown";
     const input = toolCallInput(call);
     if (id) store.registerToolUse(id, name, input);
-    blocks.push({ type: "tool_use", id, name, input });
+    if (id && !hasDisplayedToolUse(id)) blocks.push({ type: "tool_use", id, name, input });
   }
   return blocks;
 }
@@ -604,16 +648,22 @@ export default function App() {
     };
   }, [setConnected]);
 
-  // Register the desktop dock with the local agent server for lightweight control/status.
+  // Register the desktop dock like the TUI: the server tracks a live PID and
+  // discards stale state automatically when that process exits.
   useEffect(() => {
-    const state = { label: "main", url: window.location.href, user_agent: navigator.userAgent, visible: true, focused: document.hasFocus(), collapsed };
-    registerDesktop(state).catch(() => {});
+    dockRegistrationState(collapsed).then(registerDesktop).catch(() => {});
   }, [collapsed]);
 
   useEffect(() => {
     if (!isTauri) return;
-    registerDesktop({ label: "main", url: window.location.href, user_agent: navigator.userAgent, visible: true, focused: document.hasFocus(), collapsed }).catch(() => {});
-    const cleanup = () => { unregisterDesktop().catch(() => {}); };
+    let pid: number | undefined;
+    dockRegistrationState(collapsed)
+      .then((state) => {
+        pid = state.pid;
+        return registerDesktop(state);
+      })
+      .catch(() => {});
+    const cleanup = () => { unregisterDesktop(pid).catch(() => {}); };
     window.addEventListener("beforeunload", cleanup);
     return () => {
       window.removeEventListener("beforeunload", cleanup);

{codex_agent_framework-0.1.84 → codex_agent_framework-0.1.86}/apps/desktop/src/components/SettingsPanel.tsx

@@ -3,7 +3,7 @@ import { useStore } from "../store";
 import { MODELS, normalizeModel } from "../models";
 import { XIcon } from "./icons";
 import {
-  getServerInfo, getStatus, getUsage, getRateLimits, getMcpStatus,
+  getServerInfo, getStatus, getConfig, getUsage, getRateLimits, getMcpStatus,
   getWakeups, scheduleWakeup, cancelWakeup,
   getCurrentSession, getSessions, newSession, loadSession, renameSession, deleteSession,
   getPlugins, loadPlugin, unloadPlugin, reloadPlugin,
@@ -506,9 +506,9 @@ function SchedulerSettings() {
 export function SettingsPanel() {
   const { settingsOpen, toggleSettings } = useStore();
   const sessionId = useStore((s) => s.sessionId);
-  const [model, setModelState] = useState("gpt-5.4");
+  const [model, setModelState] = useState("gpt-5.6-terra");
   const [permMode, setPermModeState] = useState("bypassPermissions");
-  const [effort, setEffortState] = useState("high");
+  const [effort, setEffortState] = useState("medium");
   const [usage, setUsage] = useState<UsageInfo | null>(null);
   const [rateLimits, setRateLimits] = useState<RateLimits | null>(null);
   const [account, setAccount] = useState<{ email: string; planType: string } | null>(null);
@@ -517,11 +517,13 @@ export function SettingsPanel() {
 
   useEffect(() => {
     if (!settingsOpen) return;
-    getStatus()
-      .then((s) => {
-        if (s.model) setModelState((cur) => normalizeModel(s.model || cur, cur));
-        if (s.permission_mode) setPermModeState(s.permission_mode);
-        if (s.thinking_effort) setEffortState(s.thinking_effort);
+    Promise.all([getStatus().catch(() => null), getConfig().catch(() => null)])
+      .then(([status, config]) => {
+        const configuredModel = status?.model || config?.model;
+        if (configuredModel) setModelState((cur) => normalizeModel(configuredModel, cur));
+        if (status?.permission_mode) setPermModeState(status.permission_mode);
+        const configuredEffort = config?.reasoning?.effort || status?.thinking_effort;
+        if (configuredEffort) setEffortState(configuredEffort);
       })
       .catch(() => {});
     getUsage().then(setUsage).catch(() => {});

{codex_agent_framework-0.1.84 → codex_agent_framework-0.1.86}/apps/desktop/src/models.test.ts

@@ -3,23 +3,28 @@ import { modelLabel, normalizeModel } from "./models";
 
 describe("model helpers", () => {
   it("keeps known model ids unchanged", () => {
+    expect(normalizeModel("gpt-5.6-sol")).toBe("gpt-5.6-sol");
+    expect(normalizeModel("gpt-5.6-terra")).toBe("gpt-5.6-terra");
+    expect(normalizeModel("gpt-5.6-luna")).toBe("gpt-5.6-luna");
     expect(normalizeModel("gpt-5.5")).toBe("gpt-5.5");
     expect(normalizeModel("gpt-5.4")).toBe("gpt-5.4");
     expect(normalizeModel("gpt-5.4-mini")).toBe("gpt-5.4-mini");
   });
 
   it("maps backend variants to dock-supported models", () => {
+    expect(normalizeModel("openai/gpt-5.6-terra-latest")).toBe("gpt-5.6-terra");
     expect(normalizeModel("openai/gpt-5.5-latest")).toBe("gpt-5.5");
     expect(normalizeModel("gpt-5.4-mini-2026-04-01")).toBe("gpt-5.4-mini");
-    expect(normalizeModel("unknown-model")).toBe("gpt-5.4");
+    expect(normalizeModel("unknown-model")).toBe("gpt-5.6-terra");
   });
 
   it("falls back to the current model when raw model is empty", () => {
     expect(normalizeModel("", "gpt-5.5")).toBe("gpt-5.5");
-    expect(normalizeModel("")).toBe("gpt-5.4");
+    expect(normalizeModel("")).toBe("gpt-5.6-terra");
   });
 
   it("returns compact status labels", () => {
+    expect(modelLabel("gpt-5.6-terra")).toBe("gpt-5.6 terra");
     expect(modelLabel("gpt-5.5")).toBe("gpt-5.5");
     expect(modelLabel("gpt-5.4-mini")).toBe("gpt-5.4 mini");
     expect(modelLabel("")).toBe("");

{codex_agent_framework-0.1.84 → codex_agent_framework-0.1.86}/apps/desktop/src/models.ts

@@ -11,20 +11,26 @@ export interface ModelDef {
 }
 
 export const MODELS: ModelDef[] = [
-  { id: "gpt-5.5",      label: "GPT-5.5",      cmd: "5.5",  desc: "Puissant" },
-  { id: "gpt-5.4",      label: "GPT-5.4",      cmd: "5.4",  desc: "Intermédiaire" },
-  { id: "gpt-5.4-mini", label: "GPT-5.4 Mini", cmd: "mini", desc: "Économique" },
+  { id: "gpt-5.6-sol",   label: "GPT-5.6 Sol",   cmd: "sol",   desc: "Puissant" },
+  { id: "gpt-5.6-terra", label: "GPT-5.6 Terra", cmd: "terra", desc: "Équilibré" },
+  { id: "gpt-5.6-luna",  label: "GPT-5.6 Luna",  cmd: "luna",  desc: "Léger" },
+  { id: "gpt-5.5",      label: "GPT-5.5",       cmd: "5.5",   desc: "Puissant" },
+  { id: "gpt-5.4",      label: "GPT-5.4",       cmd: "5.4",   desc: "Intermédiaire" },
+  { id: "gpt-5.4-mini", label: "GPT-5.4 Mini",  cmd: "mini",  desc: "Économique" },
 ];
 
 /**
  * Map a raw backend model string to a canonical MODELS id.
  */
 export function normalizeModel(raw: string, current?: string): string {
-  if (!raw) return current ?? "gpt-5.4";
+  if (!raw) return current ?? "gpt-5.6-terra";
   if (MODELS.some((m) => m.id === raw)) return raw;
+  if (raw.includes("5.6-sol")) return "gpt-5.6-sol";
+  if (raw.includes("5.6-terra")) return "gpt-5.6-terra";
+  if (raw.includes("5.6-luna")) return "gpt-5.6-luna";
   if (raw.includes("5.5")) return "gpt-5.5";
   if (raw.includes("mini")) return "gpt-5.4-mini";
-  return "gpt-5.4";
+  return "gpt-5.6-terra";
 }
 
 /** Short display label for the status bar. */

{codex_agent_framework-0.1.84 → codex_agent_framework-0.1.86}/apps/desktop/src-tauri/src/main.rs

@@ -42,6 +42,11 @@ fn ensure_background_services() {
     }
 }
 
+#[tauri::command]
+fn current_pid() -> u32 {
+    std::process::id()
+}
+
 #[tauri::command]
 fn open_external_url(url: String) -> Result<(), String> {
     let lower = url.to_ascii_lowercase();
@@ -67,7 +72,7 @@ fn main() {
     std::env::set_var("GDK_BACKEND", "x11");
 
     tauri::Builder::default()
-        .invoke_handler(tauri::generate_handler![open_external_url])
+        .invoke_handler(tauri::generate_handler![current_pid, open_external_url])
         .setup(|_app| {
             std::thread::spawn(ensure_background_services);
             Ok(())

{codex_agent_framework-0.1.84 → codex_agent_framework-0.1.86}/codex_agent/agent.py

@@ -247,7 +247,7 @@ class Agent:
         """Authenticate the Codex backend client through stored or interactive OAuth credentials."""
         from codex_backend_sdk import CodexClient
 
-        client = CodexClient(model=self.config.get("model") or "gpt-5.4").authenticate(
+        client = CodexClient(model=self.config.get("model") or "gpt-5.6-terra").authenticate(
             interactive=interactive,
             request_api_key=request_api_key,
         )
@@ -395,33 +395,19 @@ class Agent:
             max_compacted_turns=max_compacted_turns,
         )
 
-    def add_message(self, msg, pending=False):
-        """Queue a message for the next flush, except tool results.
-
-        The ``pending`` argument is kept for compatibility; pending routing is
-        controlled by the current mainloop state.
-        """
+    def add_message(self, msg):
+        """Queue a message for the next flush, except tool results."""
         if isinstance(msg, ToolResultMessage):
             return self.sessions_manager.append_message(msg)
         if self.mainloop_manager.dumping_pending:
             return self.sessions_manager.append_message(msg)
         return self.mainloop_manager.add_pending_message(msg)
 
-    def new_message(self, pending=False, **kwargs):
-        """Helper to create and add a message based on provided keyword arguments.
-
-        Args:
-            pending: Backward-compatible hint; pending routing is controlled by
-                the current mainloop state.
-            **kwargs: Message fields. Must include an explicit ``type``.
-
-        Returns:
-            The created message object.
-        """
-        msg = message_from_data(kwargs)
-        return self.add_message(msg, pending=pending)
+    def new_message(self, **kwargs):
+        """Create and queue a message from explicit message fields."""
+        return self.add_message(message_from_data(kwargs))
 
-    def add_image(self, source, pending=False, **kwargs):
+    def add_image(self, source, **kwargs):
         if source:
             img = ImageMessage(
                 content=source,
@@ -429,7 +415,7 @@ class Agent:
             )
             if not img.is_valid():
                 raise ValueError(f"Invalid or inaccessible image source: {source!r}")
-            self.add_message(img, pending=pending)
+            self.add_message(img)
             return img
 
     def add_tool(

{codex_agent_framework-0.1.84 → codex_agent_framework-0.1.86}/codex_agent/ai.py

@@ -90,7 +90,7 @@ class AIClient:
     def codex_client(self):
         """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"
+            model = self.agent.config.get('model') or "gpt-5.6-terra"
             self._codex_client = CodexClient(model=model).authenticate(request_api_key=False)
         return self._codex_client
 
@@ -366,7 +366,7 @@ class AIClient:
     def _to_codex_response_params(self, params):
         instructions, history = self._split_codex_messages(params.get("messages", []))
         tools = params.get("tools") or []
-        model = params.get("model") or "gpt-5.4"
+        model = params.get("model") or "gpt-5.6-terra"
         reasoning = modict(params.get("reasoning") or {})
         text = modict(params.get("text") or {})
         if not reasoning and params.get("reasoning_effort"):

codex_agent_framework-0.1.86/codex_agent/builtin_plugins/interface/__init__.py

@@ -0,0 +1,108 @@
+"""Built-in local interface plugin."""
+
+import time
+
+from ...dock import current_dock, open_dock
+from ...plugin import Plugin
+from ...provider import provider
+from ...tool import tool
+from ...tui import current_tui, open_tui_terminal, terminate_tui, wait_for_tui_registration
+
+
+class InterfacePlugin(Plugin):
+    name = "interface"
+    description = "Control the local TUI and Pandora desktop dock."
+    prefix_tools = False
+
+    @provider
+    def tui_status(self):
+        """Expose whether the local TUI client is currently open."""
+        tui = current_tui()
+        if not tui:
+            return "TUI status: closed."
+        return (
+            "TUI status: open. "
+            f"pid={tui.get('pid')} "
+            f"base_url={tui.get('base_url')} "
+            f"timestamp={tui.get('timestamp')}"
+        )
+
+    @provider
+    def dock_status(self):
+        """Expose whether the local Pandora desktop dock is currently open."""
+        dock = current_dock()
+        if not dock:
+            return "Dock status: closed."
+        return f"Dock status: open. pid={dock.get('pid')} timestamp={dock.get('timestamp')}"
+
+    def control_dock(self, action):
+        dock = current_dock()
+        if not dock:
+            return {"status": "not_open"}
+        self.agent.emit("desktop_control_event", action=action, desktop=dock)
+        return {"status": "requested", "action": action, "dock": dock}
+
+    @tool(name="open_dock")
+    def open_dock(self):
+        """
+        description: Open the local Pandora desktop dock, or show it when it is already open.
+        parameters: {}
+        required: []
+        """
+        dock = current_dock()
+        return self.control_dock("open") if dock else dict(open_dock())
+
+    @tool(name="focus_dock")
+    def focus_dock(self):
+        """
+        description: Focus the currently open Pandora desktop dock window.
+        parameters: {}
+        required: []
+        """
+        return self.control_dock("focus")
+
+    @tool(name="close_dock")
+    def close_dock(self):
+        """
+        description: Close the currently open Pandora desktop dock window.
+        parameters: {}
+        required: []
+        """
+        return self.control_dock("close")
+
+    @tool(name="open_tui")
+    def open_tui(self):
+        """
+        description: Open the Textual chat TUI client in a separate terminal connected to the local agent server.
+        parameters: {}
+        required: []
+        """
+        tui = current_tui()
+        if tui:
+            return {"status": "already_open", "tui": tui}
+        base_url = self.agent.config.get("server_url", "http://127.0.0.1:8765")
+        process = open_tui_terminal(base_url=base_url)
+        if process is None:
+            raise RuntimeError("No supported terminal emulator found to open the TUI")
+        registered_tui = wait_for_tui_registration()
+        if not registered_tui:
+            return {
+                "status": "not_registered",
+                "pid": process.pid,
+                "reason": "terminal launched but TUI did not register",
+            }
+        time.sleep(0.25)
+        return {"status": "opened", "pid": process.pid, "tui": registered_tui}
+
+    @tool(name="close_tui")
+    def close_tui(self):
+        """
+        description: Close the currently registered Textual chat TUI client process.
+        parameters: {}
+        required: []
+        """
+        tui = current_tui()
+        if not tui:
+            return {"status": "not_open"}
+        terminate_tui(tui.pid)
+        return {"status": "closed", "tui": tui}

{codex_agent_framework-0.1.84 → codex_agent_framework-0.1.86}/codex_agent/builtin_plugins/tts/__init__.py

@@ -240,8 +240,6 @@ class TTSPlugin(Plugin):
         enabled=False,
         buffer_size=2,
     )
-    config_legacy_aliases = {}
-    config_legacy_sections = ("plugins.tts",)
     system_prompt = """
 # TTS and Conversation tone