@monotykamary/pi-better-openai 0.1.24 → 0.1.26

package/README.md

@@ -34,11 +34,13 @@ Usage display, image generation, and live voice require pi's `openai-codex` OAut
 - Interactive settings picker via `/openai-settings`.
 - Footer customization for model, thinking, fast mode, usage, and token/cost context.
 - OpenAI image generation/editing through the `openai_image` tool and `/openai-image` command.
+- Live web search through the `openai_websearch` tool and `/openai-websearch` command, backed by the ChatGPT Codex search backend.
 - Codex-backed realtime voice through `/live`, with an animated microphone waveform and coding-task delegation into the active pi session.
 - Animated Codex custom pets rendered in the Better OpenAI footer.
 - Commands:
   - `/fast` toggles fast mode.
   - `/openai-image <prompt>` generates an image directly.
+  - `/openai-websearch <query>` searches the web and inserts the cited answer into the session.
   - `/live` starts or stops realtime voice mode. `Ctrl+Shift+L` is the keyboard toggle.
   - `/pets [help|list|wake [slug]|tuck|select <slug>]` renders or manages custom pets from `${CODEX_HOME:-~/.codex}/pets`.
   - `/openai-usage` shows current OpenAI subscription usage.
@@ -151,6 +153,31 @@ Save modes:
 
 The repository ignores `.pi/`, so generated images and local config should not be committed.
 
+## Web search
+
+Use the command for a quick search:
+
+```text
+/openai-websearch latest tanstack query release
+```
+
+Agents can call the `openai_websearch` tool directly. Supported parameters:
+
+- `query` (required): the web search query.
+- `responseLength`: `short`, `medium`, or `long`. Defaults to the configured value.
+
+The tool returns a synthesized answer plus cited source URLs. It calls the
+undocumented `chatgpt.com/backend-api/codex/alpha/search` endpoint with your ChatGPT
+OAuth credentials (`openai-codex` login), so it can change or break without notice;
+OAuth/API-key-only setups without ChatGPT login are not supported.
+
+Settings under `websearch` in the config file or the `/openai-settings` picker:
+
+- `enabled` (default `true`), `model` (default `gpt-5.6-luna`),
+  `reasoningEffort` (default `max`), `responseLength` (default `short`),
+  `maxOutputTokens` (default `4096`, clamped to 256-100000), and
+  `timeoutMs` (default `25000`, clamped to 5000-120000).
+
 ## Codex pets
 
 Codex pets are an OpenAI Codex app feature, so the floating overlay and pet picker are still controlled by Codex (`Settings → Appearance → Pets` or `/pet`). This extension can also render compatible custom pet spritesheets directly in pi's Better OpenAI footer.

package/index.ts

@@ -24,10 +24,12 @@ import {
   DEFAULT_LIVE_CONFIG,
   DEFAULT_PET_CONFIG,
   DEFAULT_SUPPORTED_MODELS,
+  DEFAULT_WEBSEARCH_CONFIG,
   PET_STATES,
   FOOTER_SETTING_DESCRIPTORS,
   USAGE_SETTING_DESCRIPTORS,
   IMAGE_SETTING_DESCRIPTORS,
+  WEBSEARCH_SETTING_DESCRIPTORS,
   LIVE_SETTING_DESCRIPTORS,
   PET_SETTING_DESCRIPTORS,
   FAST_SETTING_DESCRIPTORS,
@@ -51,6 +53,7 @@ import {
   readCodexAuth,
 } from "./src/usage.ts";
 import { registerOpenAIImage, _imageTest } from "./src/image.ts";
+import { registerOpenAIWebSearch, _websearchTest } from "./src/websearch.ts";
 import { registerOpenAILive } from "./src/live/index.ts";
 import {
   type CodexPetPackage,
@@ -296,6 +299,8 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
       "",
       `Image enabled: ${cfg.image.enabled}`,
       `Image default save: ${cfg.image.defaultSave}`,
+      `Websearch enabled: ${cfg.websearch.enabled}`,
+      `Websearch model: ${cfg.websearch.model} (${cfg.websearch.reasoningEffort}/${cfg.websearch.responseLength}, ${cfg.websearch.maxOutputTokens} tokens, ${cfg.websearch.timeoutMs}ms)`,
       `Live enabled: ${cfg.live.enabled}`,
       `Live voice: ${cfg.live.voice}`,
       `Pet enabled: ${cfg.pets.enabled}`,
@@ -538,6 +543,12 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
       : "disabled";
   }
 
+  function websearchSettingsSummary(cfg: ResolvedConfig): string {
+    return cfg.websearch.enabled
+      ? `enabled · ${cfg.websearch.model} · ${cfg.websearch.reasoningEffort}/${cfg.websearch.responseLength}`
+      : "disabled";
+  }
+
   function liveSettingsSummary(cfg: ResolvedConfig): string {
     return cfg.live.enabled ? `enabled · ${cfg.live.voice}` : "disabled";
   }
@@ -596,6 +607,10 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     return settingsItemsFromDescriptors(IMAGE_SETTING_DESCRIPTORS, cfg);
   }
 
+  function buildWebsearchSettingsItems(cfg: ResolvedConfig): SettingsPickerItem[] {
+    return settingsItemsFromDescriptors(WEBSEARCH_SETTING_DESCRIPTORS, cfg);
+  }
+
   function buildLiveSettingsItems(cfg: ResolvedConfig): SettingsPickerItem[] {
     return settingsItemsFromDescriptors(LIVE_SETTING_DESCRIPTORS, cfg);
   }
@@ -690,6 +705,19 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
             () => done(imageSettingsSummary(config(ctx))),
           ),
       },
+      {
+        id: "section.websearch",
+        label: "Web search tool",
+        currentValue: websearchSettingsSummary(cfg),
+        description: "Configure ChatGPT Codex web search defaults.",
+        submenu: (_value, done) =>
+          settingsSubmenu(
+            "Web search tool settings",
+            () => buildWebsearchSettingsItems(config(ctx)),
+            ctx,
+            () => done(websearchSettingsSummary(config(ctx))),
+          ),
+      },
       {
         id: "section.live",
         label: "Live voice",
@@ -854,6 +882,7 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
   });
 
   registerOpenAIImage(pi, config);
+  registerOpenAIWebSearch(pi, config);
   registerOpenAILive(pi, config);
   registerOpenAIPets(pi, {
     wake: async (ctx, slug) => {
@@ -1302,6 +1331,7 @@ export const _test = {
   DEFAULT_IMAGE_CONFIG,
   DEFAULT_LIVE_CONFIG,
   DEFAULT_PET_CONFIG,
+  DEFAULT_WEBSEARCH_CONFIG,
   SERVICE_TIER,
   configPaths,
   abbreviateHomePath,
@@ -1324,5 +1354,6 @@ export const _test = {
   readCodexAuth,
   textPanel,
   imageTest: _imageTest,
+  websearchTest: _websearchTest,
   petsTest: _petsTest,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-better-openai",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "Improve OpenAI in pi with fast mode, usage stats, realtime voice, image generation, and footer polish.",
   "keywords": [
     "fast",

package/src/config.ts

@@ -13,6 +13,8 @@ import { piAgentDir } from "./paths.ts";
 export const FOOTER_MODES = ["replace", "status", "off"] as const;
 export const IMAGE_SAVE_MODES = ["none", "project", "global", "custom"] as const;
 export const IMAGE_OUTPUT_FORMATS = ["png", "jpeg", "webp"] as const;
+export const WEBSEARCH_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"] as const;
+export const WEBSEARCH_RESPONSE_LENGTHS = ["short", "medium", "long"] as const;
 export const PET_PLACEMENTS = [
   "stacked",
   "inline-left",
@@ -45,6 +47,8 @@ export const DEFAULT_SUPPORTED_MODELS = [
 export type FooterMode = (typeof FOOTER_MODES)[number];
 export type ImageSaveMode = (typeof IMAGE_SAVE_MODES)[number];
 export type ImageOutputFormat = (typeof IMAGE_OUTPUT_FORMATS)[number];
+export type WebsearchReasoningEffort = (typeof WEBSEARCH_REASONING_EFFORTS)[number];
+export type WebsearchResponseLength = (typeof WEBSEARCH_RESPONSE_LENGTHS)[number];
 export type PetPlacement = (typeof PET_PLACEMENTS)[number];
 export type PetState = (typeof PET_STATES)[number];
 
@@ -67,6 +71,15 @@ export type ImageConfig = {
   timeoutMs?: number;
 };
 
+export type WebsearchConfig = {
+  enabled?: boolean;
+  model?: string;
+  reasoningEffort?: WebsearchReasoningEffort;
+  responseLength?: WebsearchResponseLength;
+  maxOutputTokens?: number;
+  timeoutMs?: number;
+};
+
 export type LiveConfig = {
   enabled?: boolean;
   voice?: LiveVoice;
@@ -93,6 +106,7 @@ export interface ConfigFile {
   usage?: UsageConfig;
   footer?: FooterConfig;
   image?: ImageConfig;
+  websearch?: WebsearchConfig;
   live?: LiveConfig;
   pets?: PetConfig;
 }
@@ -115,6 +129,7 @@ export interface ResolvedConfig {
   usage: Required<UsageConfig>;
   footer: Required<FooterConfig>;
   image: Required<ImageConfig>;
+  websearch: Required<WebsearchConfig>;
   live: Required<LiveConfig>;
   pets: Required<PetConfig>;
 }
@@ -140,6 +155,17 @@ export const DEFAULT_IMAGE_CONFIG: Required<ImageConfig> = {
   timeoutMs: 180_000,
 };
 
+export const DEFAULT_WEBSEARCH_MODEL = "gpt-5.6-luna";
+
+export const DEFAULT_WEBSEARCH_CONFIG: Required<WebsearchConfig> = {
+  enabled: true,
+  model: DEFAULT_WEBSEARCH_MODEL,
+  reasoningEffort: "max",
+  responseLength: "short",
+  maxOutputTokens: 4096,
+  timeoutMs: 25_000,
+};
+
 export const DEFAULT_LIVE_CONFIG: Required<LiveConfig> = {
   enabled: true,
   voice: DEFAULT_LIVE_VOICE,
@@ -166,11 +192,19 @@ export const DEFAULT_CONFIG: ConfigFile = {
   usage: DEFAULT_USAGE_CONFIG,
   footer: DEFAULT_FOOTER_CONFIG,
   image: DEFAULT_IMAGE_CONFIG,
+  websearch: DEFAULT_WEBSEARCH_CONFIG,
   live: DEFAULT_LIVE_CONFIG,
   pets: DEFAULT_PET_CONFIG,
 };
 
-export type SettingsOptionSection = "root" | "usage" | "footer" | "image" | "live" | "pets";
+export type SettingsOptionSection =
+  | "root"
+  | "usage"
+  | "footer"
+  | "image"
+  | "websearch"
+  | "live"
+  | "pets";
 
 export type SettingsValueContext = {
   petEmptyValue?: string;
@@ -314,6 +348,69 @@ export const IMAGE_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
   },
 ];
 
+export const WEBSEARCH_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
+  {
+    id: "websearch.enabled",
+    section: "websearch",
+    key: "enabled",
+    label: "Web search tool",
+    currentValue: (cfg) => String(cfg.websearch.enabled),
+    values: ["true", "false"],
+    description: "Allow the openai_websearch tool to make search requests.",
+    parse: booleanSetting,
+  },
+  {
+    id: "websearch.model",
+    section: "websearch",
+    key: "model",
+    label: "Search model",
+    currentValue: (cfg) => cfg.websearch.model,
+    values: ["gpt-5.6-luna"],
+    description: "Model used by the ChatGPT Codex search backend.",
+    parse: stringSetting,
+  },
+  {
+    id: "websearch.reasoningEffort",
+    section: "websearch",
+    key: "reasoningEffort",
+    label: "Search reasoning",
+    currentValue: (cfg) => cfg.websearch.reasoningEffort,
+    values: WEBSEARCH_REASONING_EFFORTS,
+    description: "Reasoning effort requested from the search backend.",
+    parse: stringSetting,
+  },
+  {
+    id: "websearch.responseLength",
+    section: "websearch",
+    key: "responseLength",
+    label: "Answer length",
+    currentValue: (cfg) => cfg.websearch.responseLength,
+    values: WEBSEARCH_RESPONSE_LENGTHS,
+    description: "Default answer length produced by the search backend.",
+    parse: stringSetting,
+  },
+  {
+    id: "websearch.maxOutputTokens",
+    section: "websearch",
+    key: "maxOutputTokens",
+    label: "Max output tokens",
+    currentValue: (cfg) => String(cfg.websearch.maxOutputTokens),
+    values: ["1024", "2048", "4096", "8192"],
+    description: "Maximum output tokens for a search request.",
+    parse: numberSetting,
+  },
+  {
+    id: "websearch.timeoutMs",
+    section: "websearch",
+    key: "timeoutMs",
+    label: "Search timeout",
+    currentValue: (cfg) => String(cfg.websearch.timeoutMs),
+    values: ["10000", "25000", "60000", "120000"],
+    description: "Web search request timeout in milliseconds.",
+    parse: numberSetting,
+  },
+];
+
 export const LIVE_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
   {
     id: "live.enabled",
@@ -446,6 +543,7 @@ export const SETTINGS_OPTION_DESCRIPTORS: readonly SettingsOptionDescriptor[] =
   ...FOOTER_SETTING_DESCRIPTORS,
   ...USAGE_SETTING_DESCRIPTORS,
   ...IMAGE_SETTING_DESCRIPTORS,
+  ...WEBSEARCH_SETTING_DESCRIPTORS,
   ...LIVE_SETTING_DESCRIPTORS,
   ...PET_SETTING_DESCRIPTORS,
 ];
@@ -553,6 +651,28 @@ export function readConfig(path: string): ConfigFile | undefined {
       config.image.outputFormat = parsed.image.outputFormat as ImageOutputFormat;
     if (typeof parsed.image.timeoutMs === "number") config.image.timeoutMs = parsed.image.timeoutMs;
   }
+  if (isRecord(parsed.websearch)) {
+    config.websearch = {};
+    if (typeof parsed.websearch.enabled === "boolean")
+      config.websearch.enabled = parsed.websearch.enabled;
+    if (typeof parsed.websearch.model === "string" && parsed.websearch.model.trim())
+      config.websearch.model = parsed.websearch.model.trim();
+    if (
+      typeof parsed.websearch.reasoningEffort === "string" &&
+      (WEBSEARCH_REASONING_EFFORTS as readonly string[]).includes(parsed.websearch.reasoningEffort)
+    )
+      config.websearch.reasoningEffort = parsed.websearch
+        .reasoningEffort as WebsearchReasoningEffort;
+    if (
+      typeof parsed.websearch.responseLength === "string" &&
+      (WEBSEARCH_RESPONSE_LENGTHS as readonly string[]).includes(parsed.websearch.responseLength)
+    )
+      config.websearch.responseLength = parsed.websearch.responseLength as WebsearchResponseLength;
+    if (typeof parsed.websearch.maxOutputTokens === "number")
+      config.websearch.maxOutputTokens = parsed.websearch.maxOutputTokens;
+    if (typeof parsed.websearch.timeoutMs === "number")
+      config.websearch.timeoutMs = parsed.websearch.timeoutMs;
+  }
   if (isRecord(parsed.live)) {
     config.live = {};
     if (typeof parsed.live.enabled === "boolean") config.live.enabled = parsed.live.enabled;
@@ -701,6 +821,29 @@ export function resolveConfig(cwd: string): ResolvedConfig {
         ),
       ),
     },
+    websearch: {
+      ...DEFAULT_WEBSEARCH_CONFIG,
+      ...globalConfig.websearch,
+      ...projectConfig.websearch,
+      maxOutputTokens: Math.max(
+        256,
+        Math.min(
+          100_000,
+          projectConfig.websearch?.maxOutputTokens ??
+            globalConfig.websearch?.maxOutputTokens ??
+            DEFAULT_WEBSEARCH_CONFIG.maxOutputTokens,
+        ),
+      ),
+      timeoutMs: Math.max(
+        5_000,
+        Math.min(
+          120_000,
+          projectConfig.websearch?.timeoutMs ??
+            globalConfig.websearch?.timeoutMs ??
+            DEFAULT_WEBSEARCH_CONFIG.timeoutMs,
+        ),
+      ),
+    },
     live: {
       ...DEFAULT_LIVE_CONFIG,
       ...globalConfig.live,

package/src/live/controller.ts

@@ -25,7 +25,14 @@ Treat delegation context as your own internal progress and result. Never mention
 
 For greetings, clarification, or ordinary conversation that needs no tools, answer directly without delegating. Preserve one-assistant continuity: converse here, delegate execution, then communicate the returned result as your own.`;
 
-export type LivePhase = "connecting" | "listening" | "working" | "speaking" | "muted" | "error";
+export type LivePhase =
+  | "standby"
+  | "connecting"
+  | "listening"
+  | "working"
+  | "speaking"
+  | "muted"
+  | "error";
 
 export interface LiveTranscript {
   role: "user" | "assistant";

package/src/live/focus.ts

@@ -0,0 +1,92 @@
+// Terminal focus tracking via private mode 1004 (xterm focus-event reporting).
+// Enabling `CSI ? 1004 h` makes the terminal emit `CSI I` on focus-in and
+// `CSI O` on focus-out as input sequences; pi-tui's stdin buffer frames them
+// as generic CSI and forwards them to input listeners unmodified, so an
+// extension can observe them without any upstream keymap changes. Support is
+// detected with a DECRQM probe (`CSI ? 1004 $ p` -> `CSI ? 1004 ; 1 $ y` set /
+// `; 2 $ y` reset); terminals that ignore both sequences simply fall back to
+// the FIFO floor policy. Supported by iTerm2, kitty, WezTerm, Alacritty, foot,
+// Windows Terminal, xterm.js, and modern tmux.
+
+export const FOCUS_REPORTING_ENABLE = "\x1b[?1004h";
+export const FOCUS_REPORTING_DISABLE = "\x1b[?1004l";
+export const FOCUS_IN_SEQUENCE = "\x1b[I";
+export const FOCUS_OUT_SEQUENCE = "\x1b[O";
+export const DECRQM_FOCUS_QUERY = "\x1b[?1004$p";
+
+export type FocusInputListener = (data: string) => { consume?: boolean; data?: string } | undefined;
+
+export interface FocusTerminalHandle {
+  write(data: string): void;
+  addInputListener(listener: FocusInputListener): () => void;
+}
+
+export function parseFocusSequence(data: string): boolean | undefined {
+  if (data === FOCUS_IN_SEQUENCE) return true;
+  if (data === FOCUS_OUT_SEQUENCE) return false;
+  return undefined;
+}
+
+export function parseDecrqmFocusResponse(data: string): boolean | undefined {
+  if (data === "\x1b[?1004;1$y" || data === "\x1b[?1004;3$y") return true;
+  if (data === "\x1b[?1004;2$y" || data === "\x1b[?1004;4$y") return false;
+  return undefined;
+}
+
+export function probeFocusReporting(
+  handle: FocusTerminalHandle,
+  timeoutMs = 400,
+): Promise<boolean> {
+  return new Promise((resolve) => {
+    let settled = false;
+    let removeListener: (() => void) | undefined;
+    const done = (supported: boolean) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      removeListener?.();
+      resolve(supported);
+    };
+    const timer = setTimeout(() => done(false), timeoutMs);
+    timer.unref?.();
+    try {
+      removeListener = handle.addInputListener((data) => {
+        const state = parseDecrqmFocusResponse(data);
+        if (state === undefined) return undefined;
+        done(true);
+        return { consume: true };
+      });
+      handle.write(DECRQM_FOCUS_QUERY);
+    } catch {
+      done(false);
+    }
+  });
+}
+
+export function attachFocusReporting(
+  handle: FocusTerminalHandle,
+  onFocus: (focused: boolean) => void,
+): () => void {
+  const removeListener = handle.addInputListener((data) => {
+    const focused = parseFocusSequence(data);
+    if (focused === undefined) return undefined;
+    onFocus(focused);
+    return { consume: true };
+  });
+  try {
+    handle.write(FOCUS_REPORTING_ENABLE);
+  } catch {
+    // The terminal write path is best-effort; focus events simply never arrive.
+  }
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    removeListener();
+    try {
+      handle.write(FOCUS_REPORTING_DISABLE);
+    } catch {
+      // Nothing to undo on a torn-down tty.
+    }
+  };
+}