npm - @bitkyc08/opencodex - Versions diffs - 2.7.2 → 2.7.4-preview.20260710 - Mend

@bitkyc08/opencodex 2.7.2 → 2.7.4-preview.20260710

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/README.ko.md +1 -1
package/README.md +1 -1
package/README.zh-CN.md +1 -1
package/gui/dist/assets/{index-DGFbiUtS.js → index-DulXo5ZJ.js} +5 -5
package/gui/dist/index.html +1 -1
package/package.json +1 -1
package/src/cli/debug.ts +19 -6
package/src/lib/debug-settings.ts +14 -2
package/src/server/management-api.ts +4 -3
package/src/server/responses.ts +45 -84

package/gui/dist/index.html CHANGED Viewed

@@ -16,7 +16,7 @@
         } catch (e) {}
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-DGFbiUtS.js"></script>
+    <script type="module" crossorigin src="/assets/index-DulXo5ZJ.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-D7o1qwy-.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.7.2",
+  "version": "2.7.4-preview.20260710",
   "description": "Universal provider proxy for OpenAI Codex — use any LLM with Codex CLI/App/SDK",
   "type": "module",
   "main": "./bin/package-main.mjs",

package/src/cli/debug.ts CHANGED Viewed

@@ -2,7 +2,7 @@ import { findLiveProxy, probeHostname } from "../server/proxy-liveness";
 import { DEBUG_ENV, type DebugSettingsView } from "../lib/debug-settings";
 import { runningProxyUpdateHeaders } from "../oauth/login-cli";
-type DebugScope = "provider" | "usage";
+type DebugScope = "provider" | "usage" | "injection";
 async function requireLiveProxy() {
   const live = await findLiveProxy();
@@ -50,10 +50,14 @@ function printScopeStatus(scope: DebugScope, view: DebugSettingsView): void {
     console.log(`Provider debug: ${view.enabled ? "ON" : "off"}`);
     console.log(`  env=${view.env.debug ? "on" : "off"}, runtime=${view.runtimeOverride.debug === undefined ? "env/default" : view.runtimeOverride.debug ? "on" : "off"}`);
     console.log("  Tail: ocx debug provider logs [-f]");
-  } else {
+  } else if (scope === "usage") {
     console.log(`Usage debug: ${view.usage ? "ON" : "off"}`);
     console.log(`  env=${view.env.usage ? "on" : "off"}, runtime=${view.runtimeOverride.usage === undefined ? "env/default" : view.runtimeOverride.usage ? "on" : "off"}`);
     console.log("  Tail: ocx debug usage logs [-f] (via running proxy API)");
+  } else {
+    console.log(`Injection debug: ${view.injection ? "ON" : "off"}`);
+    console.log(`  env=${view.env.injection ? "on" : "off"}, runtime=${view.runtimeOverride.injection === undefined ? "env/default" : view.runtimeOverride.injection ? "on" : "off"}`);
+    console.log("  Lines appear on the proxy console when multi-agent guidance is injected.");
   }
 }
@@ -138,7 +142,7 @@ async function handleScopeCommand(scope: DebugScope, actionArgv: string[]): Prom
   if (action === "on" || action === "off") {
     const enabled = action === "on";
-    const body = scope === "provider" ? { debug: enabled } : { usage: enabled };
+    const body = scope === "provider" ? { debug: enabled } : scope === "usage" ? { usage: enabled } : { injection: enabled };
     printScopeStatus(scope, await putDebugSettings(body));
     console.log(`\n${scope} debug is now ${enabled ? "enabled" : "disabled"}.`);
     return;
@@ -150,20 +154,26 @@ async function handleScopeCommand(scope: DebugScope, actionArgv: string[]): Prom
   }
   if (action === "reset") {
-    const resetKey = scope === "provider" ? "provider" : "usage";
+    const resetKey = scope === "provider" ? "provider" : scope;
     printScopeStatus(scope, await putDebugSettings({ reset: resetKey }));
     console.log(`\nRuntime override cleared for ${scope}; effective value follows env again.`);
     return;
   }
   if (action === "logs") {
+    if (scope === "injection") {
+      console.error("Injection debug has no buffered log stream; lines print on the proxy console.");
+      process.exit(1);
+    }
     const follow = actionArgv.slice(1).some(arg => arg === "-f" || arg === "--follow");
     if (scope === "provider") await printProviderLogs(follow);
     else await printUsageLogs(follow);
     return;
   }
-  console.error(`Usage: ocx debug ${scope} on|off|status|reset|logs [-f]`);
+  console.error(scope === "injection"
+    ? "Usage: ocx debug injection on|off|status|reset"
+    : `Usage: ocx debug ${scope} on|off|status|reset|logs [-f]`);
   process.exit(1);
 }
@@ -172,16 +182,18 @@ function printTopLevelHelp(): void {
   console.log("");
   console.log("  ocx debug provider on|off|status|reset|logs [-f]");
   console.log("  ocx debug usage on|off|status|reset|logs [-f]");
+  console.log("  ocx debug injection on|off|status|reset");
   console.log("");
   console.log("Env defaults on start:");
   console.log("  provider → OCX_DEBUG=1 (legacy OCX_DEBUG_FRAMES still works)");
   console.log(`  usage    → ${DEBUG_ENV.usage}=1`);
+  console.log(`  injection→ ${DEBUG_ENV.injection}=1`);
 }
 export async function handleDebugCommand(argv: string[]): Promise<void> {
   const sub = (argv[0] ?? "").trim().toLowerCase();
-  if (sub === "provider" || sub === "usage") {
+  if (sub === "provider" || sub === "usage" || sub === "injection") {
     await handleScopeCommand(sub, argv.slice(1));
     return;
   }
@@ -192,6 +204,7 @@ export async function handleDebugCommand(argv: string[]): Promise<void> {
       console.log("Proxy is not running — env defaults for the next start:");
       console.log(`  provider → OCX_DEBUG = ${envDebugEnabled() ? "on" : "off"}`);
       console.log(`  usage    → ${DEBUG_ENV.usage} = ${process.env[DEBUG_ENV.usage] === "1" ? "on" : "off"}`);
+      console.log(`  injection→ ${DEBUG_ENV.injection} = ${process.env[DEBUG_ENV.injection] === "1" ? "on" : "off"}`);
       console.log("");
     }
     printTopLevelHelp();

package/src/lib/debug-settings.ts CHANGED Viewed

@@ -2,12 +2,15 @@
  * Runtime-controllable debug flags.
  * Provider debug: `ocx debug provider on|off|status|reset|logs [-f]` (or OCX_DEBUG=1 on start).
  * Usage capture: `ocx debug usage on|off|status|reset|logs [-f]` (or OPENCODEX_USAGE_DEBUG=1).
+ * Injection log: `ocx debug injection on|off|status|reset` (or OCX_INJECTION_DEBUG=1) —
+ * multi-agent guidance-injection console lines, default OFF.
  * `/api/debug` and `ocx debug` override env defaults without restart.
  */
 export const DEBUG_ENV = {
   debug: "OCX_DEBUG",
   usage: "OPENCODEX_USAGE_DEBUG",
+  injection: "OCX_INJECTION_DEBUG",
 } as const;
 /** Legacy env var that still enables provider debug logging. */
@@ -18,6 +21,7 @@ export type DebugFlag = keyof typeof DEBUG_ENV;
 export interface DebugSettingsView {
   enabled: boolean;
   usage: boolean;
+  injection: boolean;
   runtimeOverride: Partial<Record<DebugFlag, boolean>>;
   env: Record<DebugFlag, boolean>;
 }
@@ -47,20 +51,28 @@ export function isUsageDebugEnabled(): boolean {
   return envFlag(DEBUG_ENV.usage);
 }
+/** Multi-agent guidance-injection log lines (default OFF; GUI checkbox / API / CLI). */
+export function isInjectionDebugEnabled(): boolean {
+  if (runtimeOverride.injection !== undefined) return runtimeOverride.injection;
+  return envFlag(DEBUG_ENV.injection);
+}
 export function getDebugSettings(): DebugSettingsView {
   return {
     enabled: isDebugEnabled(),
     usage: isUsageDebugEnabled(),
+    injection: isInjectionDebugEnabled(),
     runtimeOverride: { ...runtimeOverride },
     env: {
       debug: envFlag(DEBUG_ENV.debug) || legacyDebugEnvEnabled(),
       usage: envFlag(DEBUG_ENV.usage),
+      injection: envFlag(DEBUG_ENV.injection),
     },
   };
 }
 export function setDebugSettings(partial: Partial<Record<DebugFlag, boolean>>): DebugSettingsView {
-  for (const key of ["debug", "usage"] as const) {
+  for (const key of ["debug", "usage", "injection"] as const) {
     if (partial[key] !== undefined) runtimeOverride[key] = partial[key];
   }
   return getDebugSettings();
@@ -72,7 +84,7 @@ export function clearDebugSetting(flag: DebugFlag): DebugSettingsView {
 }
 export function clearDebugSettings(): DebugSettingsView {
-  for (const key of ["debug", "usage"] as const) {
+  for (const key of ["debug", "usage", "injection"] as const) {
     delete runtimeOverride[key];
   }
   return getDebugSettings();

package/src/server/management-api.ts CHANGED Viewed

@@ -208,19 +208,20 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
   }
   if (url.pathname === "/api/debug" && req.method === "PUT") {
-    let body: { debug?: unknown; usage?: unknown; reset?: unknown };
+    let body: { debug?: unknown; usage?: unknown; injection?: unknown; reset?: unknown };
     try { body = await req.json(); } catch { return jsonResponse({ error: "invalid JSON body" }, 400); }
     if (body.reset === true) return jsonResponse(clearDebugSettings());
     if (body.reset === "debug" || body.reset === "provider") return jsonResponse(clearDebugSetting("debug"));
     if (body.reset === "usage") return jsonResponse(clearDebugSetting("usage"));
+    if (body.reset === "injection") return jsonResponse(clearDebugSetting("injection"));
     const partial: Partial<Record<DebugFlag, boolean>> = {};
-    for (const key of ["debug", "usage"] as const) {
+    for (const key of ["debug", "usage", "injection"] as const) {
       if (body[key] === undefined) continue;
       if (typeof body[key] !== "boolean") return jsonResponse({ error: `${key} must be a boolean` }, 400);
       partial[key] = body[key];
     }
     if (Object.keys(partial).length === 0) {
-      return jsonResponse({ error: "provide debug/usage booleans or reset:true" }, 400);
+      return jsonResponse({ error: "provide debug/usage/injection booleans or reset:true" }, 400);
     }
     return jsonResponse(setDebugSettings(partial));
   }

package/src/server/responses.ts CHANGED Viewed

@@ -9,6 +9,7 @@ import { buildCompactV1Output, COMPACT_PROMPT, decodeCompactionSummary, extractC
 import { FORWARD_HEADERS } from "../adapters/openai-responses";
 import { expandPreviousResponseInput, previousResponseConversationId, rememberResponseState } from "../responses/state";
 import { routeModel } from "../router";
+import { isInjectionDebugEnabled } from "../lib/debug-settings";
 import { modelInList, namespacedToolName } from "../types";
 import type { AdapterEvent, OcxConfig, OcxParsedRequest, OcxProviderConfig } from "../types";
 import {
@@ -133,25 +134,12 @@ export function collabSurface(parsed: OcxParsedRequest): "v1" | "v2" | null {
 /**
  * Multi-agent guidance for this turn, or null when nothing applies.
  *
- * codex-rs only emits its Proactive delegation developer message on the v2 surface,
- * so when a v1-surface turn arrives at the synthetic top tier (codex converts
- * ultra -> max on the wire, so max arrival means the user picked the top rung) the
- * proxy supplies the same one-liner, wrapped in codex's own <multi_agent_mode> tags
- * (v1 turns never carry that fragment, so there is nothing to collide with).
- * Ultra is always advertised, so the guidance fires regardless of the multi_agent_v2
- * toggle.
- *
- * Dynamic model injection: when the user has configured a specific injectionModel,
- * the prompt names it so the agent knows which routed model to delegate to.
- *
- * Effort gate relaxation: when an injectionModel is set, the prompt fires at every
- * effort level, not just max/ultra — the user opted into delegation.
- *
- * Reasoning-effort injection: when an injectionEffort is configured alongside the
- * model, the prompt also tells the agent to pass `reasoning_effort` in spawn_agent
- * calls (codex-rs validates spawn efforts by catalog membership; unsupported rungs
- * are clamped on the wire). An effort WITHOUT a model changes nothing — the gate
- * and the base prompt stay exactly as before.
+ * V1 surface: codex-rs only emits its Proactive delegation developer message on the
+ * v2 surface, so when a v1-surface turn arrives at the synthetic top tier (codex
+ * converts ultra -> max on the wire, so max arrival means the user picked the top
+ * rung) the proxy supplies the same one-liner, wrapped in codex's own
+ * <multi_agent_mode> tags. That is ALL v1 gets — no model designation, no roster
+ * (kept lean by request, devlog 260710): ultra-tier injection is sufficient there.
  *
  * V2 surface (flat spawn_agent — sol/terra under the default mode, EVERY model when
  * `ocx v2 mode v2` forces the pins): codex-rs already emits its own Proactive text
@@ -169,16 +157,12 @@ export function collabSurface(parsed: OcxParsedRequest): "v1" | "v2" | null {
  * regardless of the flag (spawn.rs), so the prompt tells the model to pass the
  * arguments even though the schema does not list them.
  *
- * Prompt structure follows the OpenAI prompt-engineering guidance (developers.openai.com):
- * explicit rule lists first, a concrete few-shot example call, reference context (the
- * roster) last. A user-configured `injectionPrompt` replaces the built-in body with
- * {{model}}/{{effort}}/{{roster}} placeholder substitution; firing gates are unchanged.
- *
- * Featured roster: whenever guidance fires (either surface), the configured
- * `subagentModels` (the 5-list the catalog features for spawn_agent) are appended
- * with the effort ladder each advertises in the injected catalog — the same list
- * codex-rs validates spawn efforts against — so the agent can pick per-task models
- * and honest effort rungs instead of flying blind behind the hidden schema.
+ * The v2 body is budgeted to <= 700 chars (V2_GUIDANCE_CHAR_BUDGET): rules first,
+ * then the preferred model, then the compact roster of configured `subagentModels`
+ * with the effort ladder each advertises in the injected catalog (the list codex-rs
+ * validates spawn efforts against). A user-configured `injectionPrompt` replaces the
+ * v2 body with {{model}}/{{effort}}/{{roster}} placeholder substitution (own length,
+ * user-owned); firing gates are unchanged.
  */
 export async function multiAgentGuidanceText(parsed: OcxParsedRequest, injectionModel?: string, injectionEffort?: string, subagentModels?: string[], injectionPrompt?: string): Promise<string | null> {
   const surface = collabSurface(parsed);
@@ -193,60 +177,33 @@ export async function multiAgentGuidanceText(parsed: OcxParsedRequest, injection
     if (injectionPrompt) {
       return `<multi_agent_mode>${applyInjectionPlaceholders(injectionPrompt, injectionModel, injectionEffort, roster)}</multi_agent_mode>`;
     }
-    const rules = [
-      "- This spawn_agent tool ACCEPTS optional \"model\" and \"reasoning_effort\" string arguments even though its published schema does not list them. The runtime parses and applies both. Never claim sub-agent models cannot be selected.",
-      "- When the user names a sub-agent model, pass it in the \"model\" argument exactly as given.",
-      "- Any spawn_agent call that sets \"model\" or \"reasoning_effort\" MUST also set \"fork_turns\" to \"none\" (or a positive integer string such as \"3\" for a partial fork); overrides are rejected on a full-history fork.",
-      "- With fork_turns \"none\", the child receives NO parent context: write a fully self-contained task message with paths, goals, and constraints.",
-    ];
+    let text = "spawn_agent also accepts hidden \"model\" and \"reasoning_effort\" string arguments "
+      + "(not in the schema, but parsed and applied) — never claim sub-agent models cannot be selected. "
+      + "When setting either, set fork_turns to \"none\" (or e.g. \"3\"; full-history forks reject overrides) "
+      + "and make the message self-contained.";
     if (injectionModel) {
-      rules.push(`- A preferred sub-agent model is configured: "${injectionModel}". Use it for independent sub-tasks unless the user explicitly asks for another model.`);
+      text += ` Preferred sub-agent: model "${injectionModel}"`
+        + (injectionEffort ? `, reasoning_effort "${injectionEffort}"` : "")
+        + " — use it unless the user names another.";
     }
-    if (injectionEffort) {
-      rules.push(`- A preferred sub-agent reasoning effort is configured: "${injectionEffort}". Pass it in the "reasoning_effort" argument of those spawn_agent calls.`);
+    text += roster;
+    if (text.length > V2_GUIDANCE_CHAR_BUDGET) {
+      // Roster is the only unbounded part — drop it before breaking the budget.
+      text = text.slice(0, text.length - roster.length);
     }
-    const exampleModel = injectionModel ?? "gpt-5.6-terra";
-    const example = "## Example spawn_agent call\n"
-      + "```json\n"
-      + JSON.stringify({
-        task_name: "example_task",
-        message: "Self-contained task description with paths, goals, and constraints.",
-        fork_turns: "none",
-        model: exampleModel,
-        ...(injectionEffort ? { reasoning_effort: injectionEffort } : {}),
-      }, null, 2)
-      + "\n```";
-    const text = `## Sub-agent model selection rules\n${rules.join("\n")}\n\n${example}${roster}`;
     return `<multi_agent_mode>${text}</multi_agent_mode>`;
   }
   const effort = parsed.options.reasoning;
-  // When the user has selected a specific injection model, fire the delegation prompt
-  // at ANY effort level. Otherwise preserve the original gate: top tier only (max/ultra).
-  if (!injectionModel && effort !== "max" && effort !== "ultra") return null;
-  if (injectionPrompt) {
-    const roster = await subagentRosterText(subagentModels);
-    return `<multi_agent_mode>${applyInjectionPlaceholders(injectionPrompt, injectionModel, injectionEffort, roster)}</multi_agent_mode>`;
-  }
-  let text = PROACTIVE_MULTI_AGENT_MODE_TEXT;
-  // Append the selected model when the user has configured a specific injection target.
-  if (injectionModel) {
-    text += `\n\nA preferred sub-agent model is configured: "${injectionModel}". `
-      + `When delegating, call spawn_agent and set its model argument to exactly "${injectionModel}". `
-      + "Use it for independent sub-tasks unless the user explicitly asks for another model.";
-    if (injectionEffort) {
-      text += ` A preferred sub-agent reasoning effort is also configured: "${injectionEffort}". `
-        + `Set the reasoning_effort argument of spawn_agent to exactly "${injectionEffort}" for those sub-agents.`;
-    }
-  }
-  text += await subagentRosterText(subagentModels);
-  return `<multi_agent_mode>${text}</multi_agent_mode>`;
+  // v1 keeps only the upstream-parity behavior: Proactive text at the top tier
+  // (ultra arrives as max on the wire). No designation/roster payload here.
+  if (effort !== "max" && effort !== "ultra") return null;
+  return `<multi_agent_mode>${PROACTIVE_MULTI_AGENT_MODE_TEXT}</multi_agent_mode>`;
 }
+/** Hard budget for the built-in v2 guidance body (user request: keep injection lean). */
+export const V2_GUIDANCE_CHAR_BUDGET = 700;
 /** {{model}}/{{effort}}/{{roster}} substitution for the user-configured injectionPrompt. */
 function applyInjectionPlaceholders(prompt: string, model?: string, effort?: string, roster?: string): string {
   return prompt
@@ -256,7 +213,7 @@ function applyInjectionPlaceholders(prompt: string, model?: string, effort?: str
 }
 /**
- * "\n\nOther available sub-agent models..." roster block, or "" when no configured
+ * Compact one-line roster of configured sub-agent models, or "" when no configured
  * model resolves to a catalog entry. Efforts come from the injected catalog
  * (catalogModelEfforts) so only rungs codex-rs will actually accept are advertised.
  */
@@ -265,13 +222,17 @@ async function subagentRosterText(subagentModels?: string[]): Promise<string> {
   if (featured.length === 0) return "";
   const { catalogModelEfforts } = await import("../codex/catalog");
   const efforts = catalogModelEfforts(featured);
-  const lines = featured
-    .filter(id => efforts.has(id))
-    .map(id => `- "${id}" (reasoning_effort options: ${efforts.get(id)!.join(", ")})`);
-  if (lines.length === 0) return "";
-  return "\n\nConfigured sub-agent model roster (valid values for spawn_agent's \"model\" argument, "
-    + "with the reasoning_effort each supports):\n"
-    + lines.join("\n");
+  const resolved = featured.filter(id => efforts.has(id));
+  if (resolved.length === 0) return "";
+  const ladders = new Set(resolved.map(id => efforts.get(id)!.join("/")));
+  if (ladders.size === 1) {
+    // Shared ladder (the common case: the injected catalog advertises one rung set)
+    // -> state it once instead of per model, keeping the roster inside the budget.
+    const ids = resolved.map(id => `"${id}"`).join(", ");
+    return ` Available models (reasoning_effort ${[...ladders][0]}): ${ids}.`;
+  }
+  const entries = resolved.map(id => `"${id}" (${efforts.get(id)!.join("/")})`);
+  return ` Available models (valid reasoning_effort): ${entries.join(", ")}.`;
 }
 /**
@@ -503,8 +464,8 @@ export async function handleResponses(
     const guidance = await multiAgentGuidanceText(parsed, config.injectionModel, config.injectionEffort, config.subagentModels, config.injectionPrompt);
     if (guidance) {
       injectDeveloperMessage(parsed, guidance);
-      console.log(`[opencodex] ${route.modelId}: multi-agent guidance injected (surface=${collabSurface(parsed)}, ${guidance.length} chars)`);
-    } else if (collabSurface(parsed) !== null) {
+      if (isInjectionDebugEnabled()) console.log(`[opencodex] ${route.modelId}: multi-agent guidance injected (surface=${collabSurface(parsed)}, ${guidance.length} chars)`);
+    } else if (isInjectionDebugEnabled() && collabSurface(parsed) !== null) {
       console.log(`[opencodex] ${route.modelId}: collab surface=${collabSurface(parsed)}, guidance silent (effort=${parsed.options.reasoning ?? "unset"}, injectionModel=${config.injectionModel ?? "unset"})`);
     }
   }