ima2-gen 1.1.0 → 1.1.2

package/lib/historyList.js

@@ -1,5 +1,5 @@
 import { mkdir, readFile, readdir, stat } from "fs/promises";
-import { join } from "path";
+import { dirname, join } from "path";
 import { config } from "../config.js";
 
 async function listImageFiles(baseDir) {
@@ -25,15 +25,10 @@ async function listImageFiles(baseDir) {
 export async function listHistoryRows(baseDir = config.storage.generatedDir) {
   await mkdir(baseDir, { recursive: true });
   const imgs = await listImageFiles(baseDir);
+  const setRows = await listCardNewsSetRows(baseDir);
   const rows = await Promise.all(imgs.map(async ({ full, rel, name }) => {
     const st = await stat(full).catch(() => null);
-    let meta = null;
-    try {
-      const raw = await readFile(full + ".json", "utf-8");
-      meta = JSON.parse(raw);
-    } catch (e) {
-      if (e.code !== "ENOENT") console.warn("[history] sidecar parse fail:", rel, e.message);
-    }
+    const meta = await readImageSidecar(full, rel);
     return {
       filename: rel,
       url: `/generated/${rel.split("/").map(encodeURIComponent).join("/")}`,
@@ -55,10 +50,17 @@ export async function listHistoryRows(baseDir = config.storage.generatedDir) {
       clientNodeId: meta?.clientNodeId || null,
       requestId: meta?.requestId || null,
       kind: meta?.kind || null,
+      setId: meta?.setId || null,
+      cardId: meta?.cardId || null,
+      cardOrder: Number.isFinite(meta?.cardOrder) ? meta.cardOrder : null,
+      headline: meta?.headline || null,
+      body: meta?.body || null,
+      cards: meta?.cards || null,
       refsCount: Number.isFinite(meta?.refsCount) ? meta.refsCount : 0,
     };
   }));
 
+  rows.push(...setRows);
   rows.sort((a, b) => {
     if (b.createdAt !== a.createdAt) return b.createdAt - a.createdAt;
     return b.filename < a.filename ? -1 : b.filename > a.filename ? 1 : 0;
@@ -66,3 +68,75 @@ export async function listHistoryRows(baseDir = config.storage.generatedDir) {
 
   return rows;
 }
+
+async function readImageSidecar(full, rel) {
+  const sibling = full.replace(/\.(png|jpe?g|webp)$/i, ".json");
+  for (const candidate of [`${full}.json`, sibling]) {
+    try {
+      return JSON.parse(await readFile(candidate, "utf-8"));
+    } catch (e) {
+      if (e.code !== "ENOENT") console.warn("[history] sidecar parse fail:", rel, e.message);
+    }
+  }
+  return null;
+}
+
+async function listCardNewsSetRows(baseDir) {
+  const root = join(baseDir, "cardnews");
+  const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+  const rows = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    try {
+      const manifestPath = join(root, entry.name, "manifest.json");
+      const manifest = JSON.parse(await readFile(manifestPath, "utf-8"));
+      const first = (manifest.cards || []).find((card) => card.imageFilename);
+      const filename = `cardnews/${entry.name}/manifest.json`;
+      rows.push({
+        filename,
+        url: first?.imageFilename
+          ? `/generated/cardnews/${encodeURIComponent(entry.name)}/${encodeURIComponent(first.imageFilename)}`
+          : "",
+        createdAt: manifest.createdAt || 0,
+        prompt: null,
+        userPrompt: null,
+        revisedPrompt: null,
+        promptMode: null,
+        quality: null,
+        size: manifest.size || null,
+        format: "card-news-set",
+        model: null,
+        provider: "oauth",
+        usage: null,
+        webSearchCalls: 0,
+        sessionId: manifest.sessionId || null,
+        nodeId: null,
+        parentNodeId: null,
+        clientNodeId: null,
+        requestId: manifest.requestId || null,
+        kind: "card-news-set",
+        setId: manifest.setId || entry.name,
+        cardId: null,
+        cardOrder: null,
+        title: manifest.title || "Untitled card news",
+        headline: manifest.title || "Untitled card news",
+        body: null,
+        cards: (manifest.cards || []).map((card) => ({
+          url: card.imageFilename
+            ? `/generated/cardnews/${encodeURIComponent(entry.name)}/${encodeURIComponent(card.imageFilename)}`
+            : "",
+          headline: card.headline,
+          body: card.body,
+          cardOrder: card.cardOrder,
+          imageFilename: card.imageFilename,
+          status: card.status || "generated",
+        })),
+        refsCount: 0,
+        dir: dirname(manifestPath),
+      });
+    } catch (e) {
+      if (e.code !== "ENOENT") console.warn("[history] card-news manifest parse fail:", entry.name, e.message);
+    }
+  }
+  return rows;
+}

package/lib/inflight.js

@@ -1,14 +1,15 @@
 import { config } from "../config.js";
+import { getDb } from "./db.js";
 import { logEvent } from "./logger.js";
 
-// In-memory inflight job registry.
+// SQLite-backed inflight job registry.
 // Tracks generation requests that are currently running on the server so clients
 // can reconcile optimistic UI state after a reload or across tabs.
 //
-// This is intentionally process-local: if the server restarts, inflight jobs
-// are lost (which is correct — the fetch they came from is already gone).
+// A restarted process cannot continue the original upstream fetch, but keeping
+// metadata durable lets the UI reconcile requestIds and eventually prune stale
+// work without losing the recovery breadcrumb.
 
-const jobs = new Map(); // requestId -> { requestId, kind, prompt, meta, startedAt, phase, phaseAt }
 const terminalJobs = new Map(); // requestId -> terminal snapshot, active-only API stays default
 
 // Phases: "queued" → "streaming" (upstream connection open, waiting for image)
@@ -16,38 +17,60 @@ const terminalJobs = new Map(); // requestId -> terminal snapshot, active-only A
 export function startJob({ requestId, kind, prompt, meta = {} }) {
   if (!requestId) return;
   const startedAt = Date.now();
-  jobs.set(requestId, {
-    requestId,
-    kind,
-    prompt: typeof prompt === "string" ? prompt.slice(0, 500) : "",
-    meta,
-    startedAt,
-    phase: "queued",
-    phaseAt: startedAt,
-  });
+  const normalizedPrompt = typeof prompt === "string" ? prompt.slice(0, 500) : "";
+  const normalizedMeta = normalizeMeta(meta);
+  getDb()
+    .prepare(`
+      INSERT OR REPLACE INTO inflight (
+        request_id,
+        kind,
+        prompt,
+        meta,
+        session_id,
+        parent_node_id,
+        client_node_id,
+        started_at,
+        phase,
+        phase_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `)
+    .run(
+      requestId,
+      kind,
+      normalizedPrompt,
+      JSON.stringify(normalizedMeta),
+      stringOrNull(normalizedMeta.sessionId),
+      stringOrNull(normalizedMeta.parentNodeId),
+      stringOrNull(normalizedMeta.clientNodeId),
+      startedAt,
+      "queued",
+      startedAt,
+    );
   terminalJobs.delete(requestId);
   logEvent("inflight", "start", {
     requestId,
     kind,
-    sessionId: meta?.sessionId || null,
-    parentNodeId: meta?.parentNodeId || null,
-    clientNodeId: meta?.clientNodeId || null,
+    sessionId: normalizedMeta.sessionId || null,
+    parentNodeId: normalizedMeta.parentNodeId || null,
+    clientNodeId: normalizedMeta.clientNodeId || null,
     promptChars: typeof prompt === "string" ? prompt.length : 0,
   });
 }
 
 export function setJobPhase(requestId, phase) {
   if (!requestId) return;
-  const j = jobs.get(requestId);
+  const j = getJob(requestId);
   if (!j) return;
-  j.phase = phase;
-  j.phaseAt = Date.now();
+  getDb()
+    .prepare("UPDATE inflight SET phase = ?, phase_at = ? WHERE request_id = ?")
+    .run(phase, Date.now(), requestId);
   logEvent("inflight", "phase", { requestId, kind: j.kind, phase });
 }
 
 export function finishJob(requestId, options = {}) {
   if (!requestId) return;
-  const j = jobs.get(requestId);
+  const j = getJob(requestId);
   if (j) {
     const finishedAt = Date.now();
     const status = options.canceled ? "canceled" : options.status || "completed";
@@ -76,7 +99,7 @@ export function finishJob(requestId, options = {}) {
       errorCode: options.errorCode,
     });
   }
-  jobs.delete(requestId);
+  getDb().prepare("DELETE FROM inflight WHERE request_id = ?").run(requestId);
   reapTerminalJobs();
 }
 
@@ -88,19 +111,23 @@ function reapTerminalJobs() {
 }
 
 export function listJobs(filters = {}) {
-  // Stale reaping: > TTL is almost certainly a crashed fetch.
-  const now = Date.now();
-  for (const [id, j] of jobs) {
-    if (now - j.startedAt > config.inflight.ttlMs) jobs.delete(id);
-  }
+  purgeStaleJobs();
   const { kind, sessionId } = filters;
-  return Array.from(jobs.values())
-    .filter((j) => {
-      if (kind && j.kind !== kind) return false;
-      if (sessionId && j.meta?.sessionId !== sessionId) return false;
-      return true;
-    })
-    .sort((a, b) => a.startedAt - b.startedAt);
+  const clauses = [];
+  const params = [];
+  if (kind) {
+    clauses.push("kind = ?");
+    params.push(kind);
+  }
+  if (sessionId) {
+    clauses.push("session_id = ?");
+    params.push(sessionId);
+  }
+  const where = clauses.length ? ` WHERE ${clauses.join(" AND ")}` : "";
+  return getDb()
+    .prepare(`SELECT * FROM inflight${where} ORDER BY started_at ASC`)
+    .all(...params)
+    .map(rowToJob);
 }
 
 export function listTerminalJobs(filters = {}) {
@@ -116,6 +143,62 @@ export function listTerminalJobs(filters = {}) {
 }
 
 export function _resetForTests() {
-  jobs.clear();
+  getDb().prepare("DELETE FROM inflight").run();
   terminalJobs.clear();
 }
+
+export function purgeStaleJobs(now = Date.now()) {
+  getDb()
+    .prepare("DELETE FROM inflight WHERE started_at < ?")
+    .run(now - config.inflight.ttlMs);
+}
+
+function getJob(requestId) {
+  const row = getDb()
+    .prepare("SELECT * FROM inflight WHERE request_id = ?")
+    .get(requestId);
+  return row ? rowToJob(row) : null;
+}
+
+function rowToJob(row) {
+  const meta = normalizeMeta(parseMeta(row.meta));
+  const sessionId = stringOrNull(row.session_id) ?? stringOrNull(meta.sessionId);
+  const parentNodeId =
+    stringOrNull(row.parent_node_id) ?? stringOrNull(meta.parentNodeId);
+  const clientNodeId =
+    stringOrNull(row.client_node_id) ?? stringOrNull(meta.clientNodeId);
+  return {
+    requestId: row.request_id,
+    kind: row.kind,
+    prompt: row.prompt || "",
+    meta: {
+      ...meta,
+      ...(sessionId ? { sessionId } : {}),
+      ...(parentNodeId ? { parentNodeId } : {}),
+      ...(clientNodeId ? { clientNodeId } : {}),
+    },
+    startedAt: Number(row.started_at),
+    phase: row.phase || "queued",
+    phaseAt: Number(row.phase_at || row.started_at),
+  };
+}
+
+function parseMeta(raw) {
+  if (typeof raw !== "string" || !raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? parsed
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function normalizeMeta(meta) {
+  return meta && typeof meta === "object" && !Array.isArray(meta) ? meta : {};
+}
+
+function stringOrNull(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}

package/lib/logger.js

@@ -1,5 +1,12 @@
 const REDACTED = "[redacted]";
 const MAX_VALUE_LEN = 240;
+const LOG_LEVELS = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  silent: 50,
+};
 
 const SECRET_KEYS = new Set([
   "authorization",
@@ -26,6 +33,9 @@ const SECRET_KEYS = new Set([
 
 const ALLOWED_PROMPT_METRICS = new Set(["promptChars", "promptMode"]);
 
+let activeLevel = "info";
+let activeSink = console;
+
 function shouldRedactKey(key) {
   if (ALLOWED_PROMPT_METRICS.has(key)) return false;
   if (SECRET_KEYS.has(key)) return true;
@@ -96,17 +106,41 @@ export function formatLog(scope, event, fields = {}) {
   return `[${scope}.${event}]${parts.length ? ` ${parts.join(" ")}` : ""}`;
 }
 
+export function normalizeLogLevel(level) {
+  return typeof level === "string" && Object.hasOwn(LOG_LEVELS, level) ? level : "info";
+}
+
+export function configureLogger(options = {}) {
+  activeLevel = normalizeLogLevel(options.level);
+  activeSink = options.sink || console;
+}
+
+export function shouldLog(level) {
+  const normalized = normalizeLogLevel(level);
+  return LOG_LEVELS[normalized] >= LOG_LEVELS[activeLevel] && activeLevel !== "silent";
+}
+
+function writeLog(level, line) {
+  if (!shouldLog(level)) return;
+  const writer = activeSink[level] || activeSink.log || console.log;
+  writer.call(activeSink, line);
+}
+
+export function logDebug(scope, event, fields = {}) {
+  writeLog("debug", formatLog(scope, event, fields));
+}
+
 export function logEvent(scope, event, fields = {}) {
-  console.log(formatLog(scope, event, fields));
+  writeLog("info", formatLog(scope, event, fields));
 }
 
 export function logWarn(scope, event, fields = {}) {
-  console.warn(formatLog(scope, event, fields));
+  writeLog("warn", formatLog(scope, event, fields));
 }
 
 export function logError(scope, event, err, fields = {}) {
   const safe = sanitizeError(err);
-  console.error(formatLog(scope, event, {
+  writeLog("error", formatLog(scope, event, {
     ...fields,
     errorName: safe.name,
     errorCode: safe.code,

package/lib/oauthLauncher.js

@@ -1,31 +1,64 @@
 import { spawnBin } from "../bin/lib/platform.js";
 import { config } from "../config.js";
+import { parseLocalhostPortFromUrl, parseOAuthReadyUrl } from "./runtimePorts.js";
 
 export function startOAuthProxy(options = {}) {
   const oauthPort = options.oauthPort ?? config.oauth.proxyPort;
   const restartDelayMs = options.restartDelayMs ?? config.oauth.restartDelayMs;
+  let currentChild = null;
+  let stopping = false;
+  let restartTimer = null;
 
-  console.log(`Starting openai-oauth on port ${oauthPort}...`);
-  const child = spawnBin("npx", ["openai-oauth", "--port", String(oauthPort)], {
-    stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env },
-  });
+  const spawnProxy = () => {
+    console.log(`Starting openai-oauth on port ${oauthPort}...`);
+    const child = spawnBin("npx", ["openai-oauth", "--port", String(oauthPort)], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env },
+    });
+    currentChild = child;
 
-  child.stdout.on("data", (d) => {
-    const msg = d.toString().trim();
-    if (msg) console.log(`[oauth] ${msg}`);
-  });
+    child.stdout.on("data", (d) => {
+      const msg = d.toString().trim();
+      if (!msg) return;
+      console.log(`[oauth] ${msg}`);
+      for (const line of msg.split(/\r?\n/)) {
+        const url = parseOAuthReadyUrl(line);
+        if (!url) continue;
+        const port = parseLocalhostPortFromUrl(url);
+        if (port && port !== oauthPort) {
+          console.log(`[oauth] requested port ${oauthPort}, actual port ${port}`);
+        }
+        options.onReady?.({ url, port: port || oauthPort, requestedPort: oauthPort });
+      }
+    });
 
-  child.stderr.on("data", (d) => {
-    const msg = d.toString().trim();
-    if (msg && !msg.includes("npm warn")) console.error(`[oauth] ${msg}`);
-  });
+    child.stderr.on("data", (d) => {
+      const msg = d.toString().trim();
+      if (msg && !msg.includes("npm warn")) console.error(`[oauth] ${msg}`);
+    });
 
-  child.on("exit", (code) => {
-    console.log(`[oauth] exited with code ${code}, restarting in ${Math.round(restartDelayMs / 1000)}s...`);
-    setTimeout(() => startOAuthProxy(options), restartDelayMs);
-  });
+    child.on("exit", (code) => {
+      if (currentChild === child) currentChild = null;
+      if (stopping) return;
+      options.onExit?.({ code });
+      console.log(`[oauth] exited with code ${code}, restarting in ${Math.round(restartDelayMs / 1000)}s...`);
+      restartTimer = setTimeout(spawnProxy, restartDelayMs);
+    });
+  };
 
-  return child;
-}
+  spawnProxy();
 
+  return {
+    get child() {
+      return currentChild;
+    },
+    kill(signal = "SIGTERM") {
+      this.stop(signal);
+    },
+    stop(signal = "SIGTERM") {
+      stopping = true;
+      if (restartTimer) clearTimeout(restartTimer);
+      try { currentChild?.kill(signal); } catch {}
+    },
+  };
+}

package/lib/oauthProxy.js

@@ -34,10 +34,33 @@ export function buildEditTextPrompt(userPrompt, mode) {
   return `Edit this image: ${userPrompt}${AUTO_PROMPT_FIDELITY_SUFFIX}`;
 }
 
+export function buildEditResearchTextPrompt(userPrompt, mode) {
+  if (mode === "direct") return buildEditTextPrompt(userPrompt, mode);
+  return `Edit this image: ${userPrompt}${RESEARCH_SUFFIX}${AUTO_PROMPT_FIDELITY_SUFFIX}`;
+}
+
 function getOAuthUrl(ctx = {}) {
   return ctx.oauthUrl || `http://127.0.0.1:${config.oauth.proxyPort}`;
 }
 
+export async function waitForOAuthReady(ctx = {}) {
+  if (!ctx || !Object.prototype.hasOwnProperty.call(ctx, "oauthReadyState")) return;
+  if (ctx.oauthReadyState === "ready" || ctx.oauthReadyState === "disabled") return;
+  if (ctx.oauthReadyState === "failed") {
+    throw makeOAuthError("OAuth proxy is unavailable", { code: "OAUTH_UNAVAILABLE", status: 503 });
+  }
+  const timeoutMs = ctx.config?.oauth?.statusTimeoutMs ?? config.oauth.statusTimeoutMs;
+  if (ctx.oauthReadyPromise) {
+    await Promise.race([
+      ctx.oauthReadyPromise,
+      new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+    ]);
+  }
+  if (ctx.oauthReadyState !== "ready" && ctx.oauthReadyState !== "disabled") {
+    throw makeOAuthError("OAuth proxy is not ready yet", { code: "OAUTH_UNAVAILABLE", status: 503 });
+  }
+}
+
 function extractSseData(block) {
   let eventData = "";
   for (const line of block.split("\n")) {
@@ -64,15 +87,30 @@ function extractPartialImage(data) {
   return { b64, index, eventType: data.type };
 }
 
-function makeOAuthError(message, { status, code = "OAUTH_UPSTREAM_ERROR", upstreamBodyChars, eventType } = {}) {
+function makeOAuthError(message, { status, code = "OAUTH_UPSTREAM_ERROR", upstreamBodyChars, eventType, eventCount, cause } = {}) {
   const err = new Error(message);
   err.code = code;
   if (status) err.status = status;
   if (typeof upstreamBodyChars === "number") err.upstreamBodyChars = upstreamBodyChars;
   if (eventType) err.eventType = eventType;
+  if (typeof eventCount === "number") err.eventCount = eventCount;
+  if (cause) err.cause = cause;
   return err;
 }
 
+async function fetchOAuth(url, init, { requestId, scope } = {}) {
+  try {
+    return await fetch(url, init);
+  } catch (err) {
+    logEvent(scope || "oauth", "proxy_unavailable", { requestId, message: err?.message });
+    throw makeOAuthError("OAuth proxy is unavailable", {
+      code: "OAUTH_UNAVAILABLE",
+      status: 503,
+      cause: err,
+    });
+  }
+}
+
 async function readImageStream(res, { requestId = null, scope = "oauth", onPartialImage = null } = {}) {
   const reader = res.body.getReader();
   const decoder = new TextDecoder();
@@ -129,9 +167,12 @@ async function readImageStream(res, { requestId = null, scope = "oauth", onParti
           if (typeof wsNum === "number" && wsNum > webSearchCalls) webSearchCalls = wsNum;
         }
         if (data.type === "error") {
+          const code = data.error?.code || "OAUTH_STREAM_ERROR";
+          logEvent(scope, "stream_error", { requestId, code, eventType: data.type, eventCount });
           throw makeOAuthError("OAuth stream returned an error", {
-            code: data.error?.code || "OAUTH_STREAM_ERROR",
+            code,
             eventType: data.type,
+            eventCount,
           });
         }
       } catch (e) {
@@ -154,6 +195,7 @@ export async function generateViaOAuth(
   ctx = {},
   options = {},
 ) {
+  await waitForOAuthReady(ctx);
   const oauthUrl = getOAuthUrl(ctx);
   const model = options.model || ctx.config?.imageModels?.default || "gpt-5.4-mini";
   const tools = [
@@ -178,7 +220,7 @@ export async function generateViaOAuth(
       ]
     : textPrompt;
 
-  const res = await fetch(`${oauthUrl}/v1/responses`, {
+  const res = await fetchOAuth(`${oauthUrl}/v1/responses`, {
     method: "POST",
     headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
     body: JSON.stringify({
@@ -191,7 +233,7 @@ export async function generateViaOAuth(
       tool_choice: "auto",
       stream: true,
     }),
-  });
+  }, { requestId, scope: "oauth" });
 
   logEvent("oauth", "response", {
     requestId,
@@ -199,7 +241,6 @@ export async function generateViaOAuth(
     status: res.status,
     contentType: res.headers.get("content-type"),
   });
-  if (requestId) setJobPhase(requestId, "streaming");
 
   if (!res.ok) {
     const text = await res.text();
@@ -210,6 +251,8 @@ export async function generateViaOAuth(
     });
   }
 
+  if (requestId) setJobPhase(requestId, "streaming");
+
   const contentType = res.headers.get("content-type") || "";
   if (!contentType.includes("text/event-stream")) {
     logEvent("oauth", "json_response", { requestId });
@@ -234,7 +277,7 @@ export async function generateViaOAuth(
 
   if (!imageB64) {
     logEvent("oauth", "retry_json", { requestId });
-    const retryRes = await fetch(`${oauthUrl}/v1/responses`, {
+    const retryRes = await fetchOAuth(`${oauthUrl}/v1/responses`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -243,7 +286,7 @@ export async function generateViaOAuth(
         tools: [{ type: "image_generation", quality, size, moderation }],
         stream: false,
       }),
-    });
+    }, { requestId, scope: "oauth" });
 
     if (retryRes.ok) {
       const json = await retryRes.json();
@@ -263,11 +306,33 @@ export async function generateViaOAuth(
 }
 
 export async function editViaOAuth(prompt, imageB64, quality, size, moderation = "low", mode = "auto", ctx = {}, requestId = null, options = {}) {
+  await waitForOAuthReady(ctx);
   const oauthUrl = getOAuthUrl(ctx);
   const model = options.model || ctx.config?.imageModels?.default || "gpt-5.4-mini";
-  const textPrompt = buildEditTextPrompt(prompt, mode);
+  const searchMode = options.searchMode === "on" ? "on" : "off";
+  const textPrompt = searchMode === "on"
+    ? buildEditResearchTextPrompt(prompt, mode)
+    : buildEditTextPrompt(prompt, mode);
+  const references = Array.isArray(options.references) ? options.references : [];
+  const referenceContent = references.map((b64) => ({
+    type: "input_image",
+    image_url: `data:image/png;base64,${b64}`,
+  }));
+  const tools = [
+    ...(searchMode === "on" ? [{ type: "web_search" }] : []),
+    { type: "image_generation", quality, size, moderation },
+  ];
 
-  const res = await fetch(`${oauthUrl}/v1/responses`, {
+  logEvent("oauth-edit", "request", {
+    requestId,
+    model,
+    refsCount: references.length,
+    inputImageCount: 1 + references.length,
+    parentImagePresent: true,
+    webSearchEnabled: searchMode === "on",
+  });
+
+  const res = await fetchOAuth(`${oauthUrl}/v1/responses`, {
     method: "POST",
     headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
     body: JSON.stringify({
@@ -278,15 +343,16 @@ export async function editViaOAuth(prompt, imageB64, quality, size, moderation =
           role: "user",
           content: [
             { type: "input_image", image_url: `data:image/png;base64,${imageB64}` },
+            ...referenceContent,
             { type: "input_text", text: textPrompt },
           ],
         },
       ],
-      tools: [{ type: "image_generation", quality, size, moderation }],
+      tools,
       tool_choice: "required",
       stream: true,
     }),
-  });
+  }, { requestId, scope: "oauth-edit" });
 
   logEvent("oauth-edit", "response", {
     requestId,
@@ -294,7 +360,6 @@ export async function editViaOAuth(prompt, imageB64, quality, size, moderation =
     status: res.status,
     contentType: res.headers.get("content-type"),
   });
-  if (requestId) setJobPhase(requestId, "streaming");
 
   if (!res.ok) {
     const text = await res.text();
@@ -305,11 +370,13 @@ export async function editViaOAuth(prompt, imageB64, quality, size, moderation =
     });
   }
 
-  const { imageB64: resultB64, usage, revisedPrompt } = await readImageStream(res, {
+  if (requestId) setJobPhase(requestId, "streaming");
+
+  const { imageB64: resultB64, usage, revisedPrompt, webSearchCalls } = await readImageStream(res, {
     scope: "oauth-edit",
     requestId,
   });
   logEvent("oauth-edit", "stream_end", { requestId, hasImage: !!resultB64 });
-  if (resultB64) return { b64: resultB64, usage, revisedPrompt };
+  if (resultB64) return { b64: resultB64, usage, revisedPrompt, webSearchCalls };
   throw new Error("No image data received from OAuth edit");
 }