@bitkyc08/opencodex 2.11.0 → 2.11.1

package/src/vision/index.ts

@@ -1,8 +1,10 @@
 import { createHash } from "node:crypto";
 import type { OcxConfig, OcxContentPart, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxTextContent } from "../types";
 import { modelInList } from "../types";
+import type { VisionReasoningEffort } from "../reasoning-effort";
 import { describeImage, type DescribeOutcome, type VisionSettings } from "./describe";
 import { describeImageAnthropic } from "./anthropic-describe";
+import { normalizeVisionReasoningForModel } from "./reasoning";
 import type { CodexAuthContext } from "../codex/auth-context";
 import { getAccountSet } from "../oauth/store";
 import type { ResolvedOpenAiForwardSidecar } from "../providers/openai-sidecar";
@@ -16,6 +18,7 @@ export { describeImageAnthropic, parseAnthropicVisionSSE } from "./anthropic-des
 const DEFAULT_VISION_MODEL = "gpt-5.4-mini";
 const DEFAULT_ANTHROPIC_VISION_MODEL = "claude-sonnet-5";
 const DEFAULT_TIMEOUT_MS = 45_000;
+const DEFAULT_REASONING: VisionReasoningEffort = "low";
 const DEFAULT_MAX_DESCRIPTIONS_PER_TURN = 8;
 const DESCRIPTION_CACHE_MAX_ENTRIES = 256;
 export const VISION_DESCRIPTION_CACHE_MAX_BYTES = 1024 * 1024;
@@ -186,7 +189,7 @@ export function resolveVisionBackend(
 
 /** Native model used by the OpenAI vision helper, including its bounded default. */
 export function resolveOpenAiVisionModel(config: Pick<OcxConfig, "visionSidecar">): string {
-  return config.visionSidecar?.model ?? DEFAULT_VISION_MODEL;
+  return config.visionSidecar?.model || DEFAULT_VISION_MODEL;
 }
 
 /** A user/developer/toolResult message can carry images (toolResult: e.g. Codex view_image output). */
@@ -242,19 +245,29 @@ export function planVisionSidecar(
 
   if (backend === "anthropic") {
     if (!anthropicSidecar) return undefined;
+    const model = cfg.model || DEFAULT_ANTHROPIC_VISION_MODEL;
     return {
       backend,
       anthropicSidecar,
-      settings: { model: cfg.model ?? DEFAULT_ANTHROPIC_VISION_MODEL, timeoutMs: cfg.timeoutMs ?? DEFAULT_TIMEOUT_MS },
+      settings: {
+        model,
+        reasoning: normalizeVisionReasoningForModel(model, cfg.reasoning) ?? DEFAULT_REASONING,
+        timeoutMs: cfg.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      },
       maxDescriptionsPerTurn,
     };
   }
 
   if (!openAiSidecar) return undefined;
+  const model = resolveOpenAiVisionModel(config);
   return {
     backend,
     forwardSidecar: openAiSidecar,
-    settings: { model: resolveOpenAiVisionModel(config), timeoutMs: cfg.timeoutMs ?? DEFAULT_TIMEOUT_MS },
+    settings: {
+      model,
+      reasoning: normalizeVisionReasoningForModel(model, cfg.reasoning) ?? DEFAULT_REASONING,
+      timeoutMs: cfg.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    },
     maxDescriptionsPerTurn,
   };
 }
@@ -363,6 +376,7 @@ function descriptionIdentity(job: ImageJob, plan: VisionPlan): { key: string; pe
     key: JSON.stringify([
       plan.backend,
       plan.settings.model,
+      ...(plan.backend === "openai" ? [plan.settings.reasoning] : []),
       job.detail ?? "high",
       imageHash,
       sha256(normalizedContext(job.contextText)),
@@ -418,7 +432,6 @@ export async function describeImagesInPlace(
   recordSidecarOutcome?: SidecarOutcomeRecorder,
   translatorBudget?: TranslatorBudget,
 ): Promise<void> {
-  // 1. Gather every image part across messages, each with its own message's text as context.
   const jobs: ImageJob[] = [];
   const targets: { msg: OcxMessage; parts: OcxContentPart[] }[] = [];
   for (const msg of parsed.context.messages) {
@@ -440,7 +453,6 @@ export async function describeImagesInPlace(
     return;
   }
 
-  // 2. Admit misses in source order. Cache hits and same-turn waiters do not consume the cap.
   const inFlight = new Map<string, Promise<DescribeOutcome>>();
   const executions: Array<() => Promise<void>> = [];
   const outcomePromises: Array<Promise<DescribeOutcome>> = [];
@@ -492,7 +504,6 @@ export async function describeImagesInPlace(
   await runBounded(executions, VISION_CONCURRENCY, execute => execute());
   const outcomes = await Promise.all(outcomePromises);
 
-  // 3. Rebuild each message, replacing image parts with their descriptions in order.
   let oi = 0;
   const descriptions: string[] = [];
   for (const { msg, parts } of targets) {

package/src/vision/reasoning.ts

@@ -0,0 +1,55 @@
+import { NATIVE_OPENAI_MODELS, nativeReasoningEfforts } from "../codex/catalog/metadata";
+import {
+  VISION_REASONING_EFFORTS,
+  sanitizeVisionReasoning,
+  type VisionReasoningEffort,
+} from "../reasoning-effort";
+
+/** Keep the public config type aligned without replacing the heavily-changed shared types file. */
+declare module "../types" {
+  interface OcxVisionSidecarConfig {
+    /** OpenAI Responses reasoning effort used by the vision describer. Default: low. */
+    reasoning?: VisionReasoningEffort;
+  }
+}
+
+const NATIVE_VISION_MODELS = new Set(NATIVE_OPENAI_MODELS);
+
+/**
+ * Return the known vision reasoning ladder for a native OpenAI model.
+ * Unknown/custom models deliberately return undefined so callers stay permissive when reliable
+ * capability metadata is unavailable.
+ */
+export function nativeVisionReasoningEfforts(modelId: string): VisionReasoningEffort[] | undefined {
+  if (!NATIVE_VISION_MODELS.has(modelId)) return undefined;
+  const advertised = new Set(nativeReasoningEfforts(modelId));
+  const supported = VISION_REASONING_EFFORTS.filter(effort => advertised.has(effort));
+  return supported.length > 0 ? [...supported] : undefined;
+}
+
+/**
+ * Normalize one configured effort against a model's known ladder. Invalid enum values degrade to
+ * undefined; valid values on unknown/custom models are preserved. A known native model clamps to
+ * the highest supported rung at or below the requested value.
+ */
+export function normalizeVisionReasoningForModel(
+  modelId: string,
+  value: unknown,
+): VisionReasoningEffort | undefined {
+  const requested = sanitizeVisionReasoning(value);
+  if (!requested) return undefined;
+  const supported = nativeVisionReasoningEfforts(modelId);
+  if (!supported || supported.includes(requested)) return requested;
+
+  const requestedRank = VISION_REASONING_EFFORTS.indexOf(requested);
+  let best = supported[0];
+  let bestRank = VISION_REASONING_EFFORTS.indexOf(best);
+  for (const effort of supported) {
+    const rank = VISION_REASONING_EFFORTS.indexOf(effort);
+    if (rank <= requestedRank && rank >= bestRank) {
+      best = effort;
+      bestRank = rank;
+    }
+  }
+  return best;
+}

package/src/web-search/parse.ts

@@ -155,11 +155,23 @@ export async function parseSidecarSSE(response: Response): Promise<WebSearchResu
 
   const handle = (payload: string): void => {
     if (!payload || payload === "[DONE]") return;
-    let data: Record<string, unknown>;
-    try { data = JSON.parse(payload) as Record<string, unknown>; } catch {
-      console.warn(`[web-search-parse] malformed SSE JSON (${payload.length} chars): ${payload.slice(0, 120)}`);
+    // Neither warning below copies the frame's content. An upstream SSE payload can carry model
+    // output or credential material, and a malformed frame is exactly the case where the content
+    // is least trustworthy. Length plus a classification separates the two failure modes in a log
+    // without reproducing anything from the wire.
+    let parsed: unknown;
+    try { parsed = JSON.parse(payload); } catch {
+      console.warn(`[web-search-parse] malformed SSE JSON (${payload.length} chars)`);
       return;
     }
+    // `JSON.parse("null")` returns null rather than throwing, so the catch above cannot cover it
+    // and the `data.type` read below threw out of parseSidecarSSE.
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      const shape = Array.isArray(parsed) ? "array" : parsed === null ? "null" : typeof parsed;
+      console.warn(`[web-search-parse] non-record SSE JSON frame (${payload.length} chars, ${shape})`);
+      return;
+    }
+    const data = parsed as Record<string, unknown>;
     const type = data.type as string | undefined;
     if (type === "response.output_text.delta" && typeof data.delta === "string") {
       acc.deltaText += data.delta;