mixdog 0.8.0 → 0.9.0

package/src/runtime/agent/orchestrator/providers/grok-oauth.mjs

@@ -3,10 +3,7 @@
  *
  * Authenticates against xAI's shared OAuth client via PKCE (discovery at
  * https://auth.x.ai/.well-known/openid-configuration). Credentials come from
- * either mixdog's own token store (grok-oauth.json) OR the Grok CLI's
- * ~/.grok/auth.json — the same dual-source pattern openai-oauth uses with
- * ~/.codex/auth.json — so an existing `grok` CLI login is picked up without a
- * second sign-in.
+ * Mixdog's own token store (grok-oauth.json).
  *
  * Inference + catalog merge two sources, routed per model:
  *   - api.x.ai/v1 (default): grok-4.x chat models and the web_search backend.
@@ -24,7 +21,6 @@ import { createServer } from 'http';
 import { randomBytes, createHash } from 'crypto';
 import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from 'fs';
 import { join } from 'path';
-import { homedir } from 'os';
 import { getPluginData } from '../config.mjs';
 import { writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { enrichModels, getModelMetadataSync } from './model-catalog.mjs';
@@ -71,22 +67,11 @@ function isProxyOnlyModel(model) {
     return /^grok-composer/i.test(m) || PROXY_EXACT_MODELS.has(m);
 }
 
-// Use the REAL installed Grok CLI version for the proxy version gate
-// (x-grok-client-version), read from ~/.grok/version.json (or the version
-// stamped into models_cache.json). Cached; only falls back to a known-good
-// constant when neither local file is readable.
+// Use a Mixdog-controlled client version for the proxy version gate.
 let _grokCliVersionCache = null;
 function grokCliVersion() {
     if (_grokCliVersionCache) return _grokCliVersionCache;
-    const grokDir = join(homedir(), '.grok');
-    for (const [file, field] of [['version.json', 'version'], ['models_cache.json', 'grok_version']]) {
-        try {
-            const raw = JSON.parse(readFileSync(join(grokDir, file), 'utf-8'));
-            const v = String(raw?.[field] || raw?.stable_version || '').trim();
-            if (v) { _grokCliVersionCache = v; return v; }
-        } catch { /* try next source */ }
-    }
-    _grokCliVersionCache = GROK_CLI_VERSION_FALLBACK;
+    _grokCliVersionCache = String(process.env.MIXDOG_GROK_CLIENT_VERSION || '').trim() || GROK_CLI_VERSION_FALLBACK;
     return _grokCliVersionCache;
 }
 
@@ -132,11 +117,6 @@ const DISCOVERY_TIMEOUT_MS = 15_000;
 const TOKEN_TIMEOUT_MS = 30_000;
 const LOGIN_TIMEOUT_MS = 5 * 60_000;
 
-// Grok CLI credential file. Composite top-level key is "<issuer>::<client_id>".
-function grokCliAuthPath() {
-    return join(homedir(), '.grok', 'auth.json');
-}
-
 // SSRF guard for any endpoint pulled from the discovery document or saved
 // tokens. xAI OAuth endpoints must be https on x.ai / *.x.ai — reject
 // anything else outright so a hostile discovery response can't redirect the
@@ -189,8 +169,8 @@ function getOwnTokenPath() {
     return join(dir, 'grok-oauth.json');
 }
 
-// expires_at may arrive as a unix number (own store) or an ISO-8601 string
-// (Grok CLI auth.json). Normalize both to epoch milliseconds; 0 means unknown.
+// expires_at may arrive as a unix number or an ISO-8601 string. Normalize both
+// to epoch milliseconds; 0 means unknown.
 function _normalizeExpiresAt(value) {
     if (typeof value === 'string') {
         const ms = Date.parse(value);
@@ -215,6 +195,21 @@ function _expiryFromAccessToken(token) {
     } catch { return 0; }
 }
 
+function _identityFromAccessToken(token) {
+    try {
+        const parts = String(token || '').split('.');
+        if (parts.length !== 3) return {};
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString('utf-8'));
+        const userId = payload?.user_id
+            || payload?.userId
+            || payload?.principal_id
+            || payload?.principalId
+            || payload?.sub
+            || '';
+        return userId ? { user_id: String(userId) } : {};
+    } catch { return {}; }
+}
+
 function _mtimeMs(path) {
     try { return statSync(path).mtimeMs; } catch { return 0; }
 }
@@ -232,42 +227,16 @@ function _loadOwnTokens() {
             refresh_token: raw.refresh_token,
             expires_at: _normalizeExpiresAt(raw.expires_at ?? raw.expiresAt) || _expiryFromAccessToken(raw.access_token),
             token_endpoint: raw.token_endpoint || null,
+            user_id: raw.user_id || raw.userId || _identityFromAccessToken(raw.access_token).user_id || '',
             source: 'own',
             mtimeMs: _mtimeMs(path),
         };
     } catch { return null; }
 }
 
-// Grok CLI store (~/.grok/auth.json). Read-only seed: the access token lives
-// under `key`, keyed by "<issuer>::<client_id>". We never write back here —
-// after the first refresh mixdog manages its own copy, mirroring how
-// openai-oauth treats ~/.codex/auth.json.
-function _loadGrokCliTokens() {
-    const path = grokCliAuthPath();
-    if (!existsSync(path)) return null;
-    try {
-        const raw = JSON.parse(readFileSync(path, 'utf-8'));
-        if (!raw || typeof raw !== 'object') return null;
-        // The Grok CLI keys every entry by "<issuer>::<client_id>" — look up
-        // exactly that. No scan-for-matching-client_id fallback: a different
-        // issuer under the same client_id is a different account/endpoint and
-        // must not be silently selected.
-        const entry = raw[`${ISSUER}::${CLIENT_ID}`];
-        if (!entry?.key || !entry?.refresh_token) return null;
-        return {
-            access_token: entry.key,
-            refresh_token: entry.refresh_token,
-            expires_at: _normalizeExpiresAt(entry.expires_at) || _expiryFromAccessToken(entry.key),
-            token_endpoint: null,
-            source: 'grok-cli',
-            mtimeMs: _mtimeMs(path),
-        };
-    } catch { return null; }
-}
-
-// Own store first (accurate expires_at). Fall back to the Grok CLI login.
+// Mixdog-owned token store only.
 function loadTokens() {
-    return _loadOwnTokens() || _loadGrokCliTokens();
+    return _loadOwnTokens();
 }
 
 function saveTokens(tokens) {
@@ -276,6 +245,7 @@ function saveTokens(tokens) {
         refresh_token: tokens.refresh_token,
         expires_at: tokens.expires_at || 0,
         token_endpoint: tokens.token_endpoint || null,
+        user_id: tokens.user_id || tokens.userId || _identityFromAccessToken(tokens.access_token).user_id || undefined,
     }, { lock: true, fsyncDir: true });
 }
 
@@ -287,8 +257,8 @@ function _scrubTokens(text) {
         .replace(/"key"\s*:\s*"[^"]+"/g, '"key":"[REDACTED]"');
 }
 
-// Public predicate used by config.buildDefaultConfig — enabled when either
-// token source carries credentials. Single truth: same loader the runtime uses.
+// Public predicate used by config.buildDefaultConfig — enabled when Mixdog's
+// token store carries credentials. Single truth: same loader the runtime uses.
 export function hasGrokOAuthCredentials() {
     try {
         const tokens = loadTokens();
@@ -300,17 +270,13 @@ export function describeGrokOAuthCredentials() {
     try {
         const tokens = loadTokens();
         if (!tokens?.access_token) {
-            return { authenticated: false, status: 'Not Set', detail: '~/.grok/auth.json or mixdog token store' };
+            return { authenticated: false, status: 'Not Set', detail: 'Mixdog token store' };
         }
         const hasRefresh = Boolean(tokens.refresh_token);
         const expiresAt = _normalizeExpiresAt(tokens.expires_at);
         const expiring = expiresAt > 0 && expiresAt < Date.now() + TOKEN_REFRESH_SKEW_MS;
         const expired = expiresAt > 0 && expiresAt <= Date.now();
-        const detail = tokens.source === 'own'
-            ? 'Mixdog token store'
-            : tokens.source === 'grok-cli'
-                ? '~/.grok/auth.json'
-                : (tokens.source || 'oauth');
+        const detail = tokens.source === 'own' ? 'Mixdog token store' : (tokens.source || 'oauth');
         if (!hasRefresh) {
             return {
                 authenticated: expiresAt === 0 || !expired,
@@ -334,54 +300,13 @@ export function forgetGrokOAuthCredentials() {
         unlinkSync(ownPath);
         removed = true;
     }
-    const cliPath = grokCliAuthPath();
-    if (existsSync(cliPath)) {
-        try {
-            const raw = JSON.parse(readFileSync(cliPath, 'utf-8'));
-            const key = `${ISSUER}::${CLIENT_ID}`;
-            if (raw?.[key]) {
-                delete raw[key];
-                writeJsonAtomicSync(cliPath, raw, { lock: true, fsyncDir: true });
-                removed = true;
-            }
-        } catch (err) {
-            throw new Error(`Grok OAuth reset failed for ${cliPath}: ${err?.message || err}`);
-        }
-    }
     return { removed };
 }
 
-// Write rotated tokens back to the Grok CLI store (~/.grok/auth.json) so the
-// CLI — and any other reader of this single-use refresh-token lineage — picks
-// up the rotation instead of replaying a now-consumed token. Mirrors
-// anthropic-oauth's credential write-back. Best-effort:
-// the own store is the authority, so a failed write-back never breaks a
-// successful refresh. Host-owned file: no secret/mode so we don't re-permission it.
-function _writeBackGrokCliTokens(refreshed) {
-    const path = grokCliAuthPath();
-    if (!existsSync(path)) return;
-    try {
-        const raw = JSON.parse(readFileSync(path, 'utf-8'));
-        const entry = raw?.[`${ISSUER}::${CLIENT_ID}`];
-        if (!entry || typeof entry !== 'object') return;
-        entry.key = refreshed.access_token;
-        entry.refresh_token = refreshed.refresh_token;
-        entry.expires_at = new Date(refreshed.expires_at || Date.now()).toISOString();
-        // Preserve the host file's existing POSIX mode — writeJsonAtomicSync
-        // otherwise defaults the replacement to 0o600, re-permissioning a file
-        // the Grok CLI owns.
-        let mode;
-        try { mode = statSync(path).mode & 0o777; } catch { /* keep helper default */ }
-        writeJsonAtomicSync(path, raw, { lock: true, fsyncDir: true, mode });
-    } catch (err) {
-        process.stderr.write(`[grok-oauth] CLI store write-back failed: ${_scrubTokens(err?.message || String(err)).slice(0, 200)}\n`);
-    }
-}
-
 let _refreshInFlight = null;
 async function refreshTokens(tokens) {
     if (!tokens?.refresh_token) {
-        throw new Error('[grok-oauth] refresh token not available — run the Grok CLI login or the Setup login again');
+        throw new Error('[grok-oauth] refresh token not available — open /providers in mixdog to sign in again');
     }
     const tokenEndpoint = tokens.token_endpoint
         ? assertTrustedXaiEndpoint(tokens.token_endpoint, 'token endpoint')
@@ -408,9 +333,7 @@ async function refreshTokens(tokens) {
         try { json = text ? JSON.parse(text) : null; } catch { /* handled below */ }
         if (!res.ok) {
             // 400/401 (or an explicit invalid_grant/revoked/reused body) means
-            // this refresh_token was already consumed by the CLI's single-use
-            // lineage. Tag it so refreshTokensWithFallback can adopt the CLI's
-            // newer token and retry instead of dead-ending.
+            // this refresh_token was revoked or already consumed.
             const isInvalidGrant = res.status === 400 || res.status === 401
                 || /invalid_grant|revoked|reused/i.test(text);
             throw Object.assign(
@@ -429,11 +352,8 @@ async function refreshTokens(tokens) {
                 ? Date.now() + json.expires_in * 1000
                 : _normalizeExpiresAt(json?.expires_at),
             token_endpoint: tokenEndpoint,
+            user_id: tokens.user_id || tokens.userId || _identityFromAccessToken(accessToken).user_id || '',
         };
-        // Write the CLI store first, own store last: the own store then carries
-        // the newest mtime, so ensureAuth's freshest-wins resync treats our own
-        // refresh as authoritative and doesn't needlessly flip back to the CLI.
-        _writeBackGrokCliTokens(refreshed);
         saveTokens(refreshed);
         return { ...refreshed, source: 'own', mtimeMs: _mtimeMs(getOwnTokenPath()) };
     } finally {
@@ -441,29 +361,6 @@ async function refreshTokens(tokens) {
     }
 }
 
-// invalid_grant means our refresh_token was already consumed/rotated elsewhere
-// (the Grok CLI shares this single-use lineage). Re-read BOTH on-disk stores
-// and retry once with whichever carries a different (newer) refresh_token —
-// own-store still holds the dead one, so the CLI store is the likely source of
-// the rotation. Mirrors anthropic-oauth's refreshOAuthCredentialsWithFallback.
-async function refreshTokensWithFallback(tokens) {
-    try {
-        return await refreshTokens(tokens);
-    } catch (firstErr) {
-        if (!firstErr?.isInvalidGrant) throw firstErr;
-        process.stderr.write('[grok-oauth] invalid_grant — re-reading disk, retrying refresh\n');
-        // Prefer the freshest store first so we adopt the most recent CLI
-        // rotation and never replay an even older stale lineage before it.
-        const candidates = [_loadOwnTokens(), _loadGrokCliTokens()].filter(Boolean)
-            .sort((a, b) => (b.mtimeMs || 0) - (a.mtimeMs || 0));
-        const fresh = candidates.find(c => c.refresh_token && c.refresh_token !== tokens.refresh_token);
-        if (!fresh) {
-            throw new Error('[grok-oauth] refresh token revoked and no newer token on disk — run the Grok CLI login or the Setup login again');
-        }
-        return await refreshTokens(fresh);
-    }
-}
-
 // --- Model catalog cache (24h disk TTL) ---
 const _modelCache = makeModelCache({ fileName: 'grok-oauth-models.json', ttlMs: MODEL_CACHE_TTL_MS });
 const PROXY_MODEL_METADATA = {
@@ -624,21 +521,16 @@ export class GrokOAuthProvider {
     async ensureAuth({ forceRefresh = false } = {}) {
         if (!this.tokens) this.tokens = loadTokens();
         if (!this.tokens) {
-            throw new Error('[grok-oauth] credentials not found — run the Grok CLI login or the Setup login first');
+            throw new Error('[grok-oauth] credentials not found — open /providers in mixdog to sign in first');
         }
-        // Freshest-wins resync across BOTH stores. The single-use refresh-token
-        // lineage is shared with the Grok CLI, so an independent CLI refresh must
-        // be adopted proactively — not only reactively on invalid_grant. A disk
-        // scan watermark guarantees termination: if the newest file isn't
-        // loadable (e.g. a logged-out host file beside a valid own store) we
-        // still record the scanned mtime so the same check can't re-fire forever.
+        // Pick up Mixdog-owned token updates without touching external CLI
+        // stores. The scan watermark guarantees the same unreadable write does
+        // not re-fire forever.
         const ownM = _mtimeMs(getOwnTokenPath());
-        const cliM = _mtimeMs(grokCliAuthPath());
-        const maxM = Math.max(ownM, cliM);
-        if (maxM > (this._lastDiskScan || 0) && maxM > (this.tokens.mtimeMs || 0)) {
-            const disk = (ownM >= cliM ? _loadOwnTokens() : _loadGrokCliTokens()) || loadTokens();
+        if (ownM > (this._lastDiskScan || 0) && ownM > (this.tokens.mtimeMs || 0)) {
+            const disk = _loadOwnTokens();
             if (disk?.access_token) this.tokens = disk;
-            this._lastDiskScan = maxM;
+            this._lastDiskScan = ownM;
         }
         const expiring = this.tokens.expires_at
             && this.tokens.expires_at < Date.now() + TOKEN_REFRESH_SKEW_MS;
@@ -646,7 +538,7 @@ export class GrokOAuthProvider {
             if (_refreshInFlight) {
                 this.tokens = await _refreshInFlight;
             } else {
-                _refreshInFlight = refreshTokensWithFallback(this.tokens)
+                _refreshInFlight = refreshTokens(this.tokens)
                     .finally(() => { _refreshInFlight = null; });
                 this.tokens = await _refreshInFlight;
             }
@@ -683,6 +575,9 @@ export class GrokOAuthProvider {
     }
 
     async send(messages, model, tools, sendOpts) {
+        // Re-warm a kept-alive socket before the turn (TTL-gated no-op while
+        // hot) so a post-idle request skips the cold TLS handshake.
+        preconnect(INFERENCE_BASE_URL);
         const useModel = normalizeGrokModelId(
             model || await ensureLatestGrokModel(this),
         );
@@ -867,11 +762,32 @@ async function exchangeAuthorizationCode({ discovery, pkce, code }) {
             ? Date.now() + json.expires_in * 1000
             : _normalizeExpiresAt(json.expires_at),
         token_endpoint: discovery.token_endpoint,
+        user_id: _identityFromAccessToken(json.access_token).user_id || '',
     };
     saveTokens(tokens);
     return tokens;
 }
 
+function parseOAuthCodeInput(input) {
+    const value = String(input || '').trim();
+    if (!value) return { code: '', state: '' };
+    try {
+        const url = new URL(value);
+        const code = url.searchParams.get('code') || '';
+        const state = url.searchParams.get('state') || '';
+        if (code || state) return { code, state };
+    } catch { /* not a URL */ }
+    if (value.includes('#')) {
+        const [code, state] = value.split('#', 2);
+        return { code: String(code || '').trim(), state: String(state || '').trim() };
+    }
+    if (value.includes('code=')) {
+        const params = new URLSearchParams(value.startsWith('?') ? value.slice(1) : value);
+        return { code: params.get('code') || '', state: params.get('state') || '' };
+    }
+    return { code: value, state: '' };
+}
+
 export async function beginOAuthLogin() {
     const discovery = await fetchDiscovery();
     const pkce = generatePKCE();
@@ -942,8 +858,10 @@ export async function beginOAuthLogin() {
         provider: 'grok-oauth',
         url: url.toString(),
         waitForCallback,
-        completeCode: async (code) => {
-            const tokens = await exchangeAuthorizationCode({ discovery, pkce, code });
+        completeCode: async (input) => {
+            const parsed = parseOAuthCodeInput(input);
+            if (parsed.state && parsed.state !== state) throw new Error('[grok-oauth] OAuth state mismatch');
+            const tokens = await exchangeAuthorizationCode({ discovery, pkce, code: parsed.code });
             finish?.(tokens);
             return tokens;
         },

package/src/runtime/agent/orchestrator/providers/media-normalization.mjs

@@ -17,6 +17,14 @@ function imageInfo(block) {
     return null;
 }
 
+function geminiInlineInfo(block) {
+    if (!block || typeof block !== 'object') return null;
+    const inline = block.inlineData || block.inline_data;
+    const data = inline?.data;
+    if (typeof data !== 'string' || !data) return null;
+    return { data, mimeType: cleanMimeType(inline.mimeType || inline.mime_type || inline.mediaType || inline.media_type) };
+}
+
 function imageUrlFromPart(block) {
     if (!block || typeof block !== 'object') return null;
     if (block.type === 'image_url') {
@@ -29,16 +37,48 @@ function imageUrlFromPart(block) {
         if (typeof value === 'string') return value;
         if (value && typeof value.url === 'string') return value.url;
     }
+    if (block.type === 'image' && block.source?.type === 'url' && typeof block.source.url === 'string') {
+        return block.source.url;
+    }
     const info = imageInfo(block);
     return info ? `data:${info.mimeType};base64,${info.data}` : null;
 }
 
+function imageFileUriFromPart(block) {
+    if (!block || typeof block !== 'object') return null;
+    const fileData = block.fileData || block.file_data;
+    const fileUri = fileData?.fileUri || fileData?.file_uri;
+    if (typeof fileUri === 'string' && fileUri) {
+        return { fileUri, mimeType: cleanMimeType(fileData.mimeType || fileData.mime_type || fileData.mediaType || fileData.media_type) };
+    }
+    if (block.type === 'image' && typeof block.uri === 'string' && block.uri) {
+        return { fileUri: block.uri, mimeType: cleanMimeType(block.mime_type || block.mimeType || block.media_type || block.mediaType) };
+    }
+    return null;
+}
+
+function imageFileIdFromPart(block) {
+    if (!block || typeof block !== 'object') return null;
+    if (block.type === 'input_image' && typeof block.file_id === 'string' && block.file_id) {
+        return block.file_id;
+    }
+    if (block.type === 'image' && block.source?.type === 'file' && typeof block.source.file_id === 'string' && block.source.file_id) {
+        return block.source.file_id;
+    }
+    return null;
+}
+
 function imageInfoFromDataUrl(url) {
     const m = String(url || '').match(/^data:(image\/[a-z0-9.+_-]+);base64,(.+)$/is);
     if (!m) return null;
     return { mimeType: cleanMimeType(m[1]), data: m[2] };
 }
 
+function imageMimeFromDataUrl(url) {
+    const m = String(url || '').match(/^data:(image\/[a-z0-9.+_-]+);base64,/i);
+    return m ? cleanMimeType(m[1]) : null;
+}
+
 function textFromPart(block) {
     if (typeof block === 'string') return block;
     if (!block || typeof block !== 'object') return '';
@@ -63,14 +103,14 @@ function jsonFallbackFromPart(block) {
     const text = textFromPart(block);
     if (text) return text;
     if (!block || typeof block !== 'object') return block == null ? '' : String(block);
-    if (imageUrlFromPart(block)) return '';
+    if (imageUrlFromPart(block) || imageFileIdFromPart(block) || imageFileUriFromPart(block) || geminiInlineInfo(block)) return '';
     return stringifyFallback(block);
 }
 
 export function contentHasImage(content) {
     const parts = contentParts(content);
     if (!parts) return false;
-    return parts.some((part) => !!imageUrlFromPart(part));
+    return parts.some((part) => !!imageUrlFromPart(part) || !!imageFileIdFromPart(part) || !!imageFileUriFromPart(part) || !!geminiInlineInfo(part));
 }
 
 export function contentToText(content, fallback = '') {
@@ -81,6 +121,41 @@ export function contentToText(content, fallback = '') {
     return text || fallback;
 }
 
+function storedHistoryImagePlaceholder(part) {
+    const info = imageInfo(part) || geminiInlineInfo(part);
+    const url = imageUrlFromPart(part);
+    const fileUri = imageFileUriFromPart(part);
+    const mimeType = info?.mimeType || imageMimeFromDataUrl(url) || fileUri?.mimeType || (part?.type === 'image' ? DEFAULT_IMAGE_MIME : '');
+    return `[Image omitted from stored history${mimeType ? `: ${mimeType}` : ''}]`;
+}
+
+function sanitizePartForStoredHistory(part) {
+    if (typeof part === 'string') return part;
+    if (!part || typeof part !== 'object') return part;
+    if (part.type === 'image' || part.type === 'image_url' || part.type === 'input_image' || imageUrlFromPart(part) || imageFileIdFromPart(part) || imageFileUriFromPart(part) || geminiInlineInfo(part)) {
+        return { type: 'text', text: storedHistoryImagePlaceholder(part) };
+    }
+    if (Array.isArray(part.content)) {
+        const nextContent = sanitizeContentForStoredHistory(part.content);
+        if (nextContent !== part.content) return { ...part, content: nextContent };
+    }
+    return part;
+}
+
+export function sanitizeContentForStoredHistory(content) {
+    if (typeof content === 'string') return content;
+    const parts = contentParts(content);
+    if (!parts) return content;
+    let changed = false;
+    const out = parts.map((part) => {
+        const next = sanitizePartForStoredHistory(part);
+        if (next !== part) changed = true;
+        return next;
+    });
+    if (!changed) return content;
+    return Array.isArray(content) ? out : { ...content, content: out };
+}
+
 export function normalizeContentForAnthropic(content) {
     const parts = contentParts(content);
     if (!parts) return content;
@@ -98,8 +173,28 @@ export function normalizeContentForAnthropic(content) {
             if (part.cache_control) out.cache_control = part.cache_control;
             return out;
         }
+        const fileId = imageFileIdFromPart(part);
+        if (fileId) {
+            return { type: 'image', source: { type: 'file', file_id: fileId } };
+        }
+        const url = imageUrlFromPart(part);
+        const dataUrlInfo = imageInfoFromDataUrl(url);
+        if (dataUrlInfo) {
+            return {
+                type: 'image',
+                source: {
+                    type: 'base64',
+                    media_type: dataUrlInfo.mimeType,
+                    data: dataUrlInfo.data,
+                },
+            };
+        }
+        if (url) {
+            return { type: 'image', source: { type: 'url', url } };
+        }
         if (part?.type === 'image') {
             if (part.source?.type === 'url' && typeof part.source.url === 'string') return part;
+            if (part.source?.type === 'file' && typeof part.source.file_id === 'string') return part;
             return { type: 'text', text: `[unsupported image content: ${stringifyFallback(part)}]` };
         }
         if (part?.type === 'tool_result') {
@@ -124,6 +219,16 @@ export function normalizeContentForOpenAIChat(content, { role = 'user' } = {}) {
     if (!parts) return content;
     const out = [];
     for (const part of parts) {
+        const fileId = imageFileIdFromPart(part);
+        if (fileId) {
+            out.push({ type: 'text', text: `[unsupported image file_id for OpenAI Chat-compatible request: ${fileId}]` });
+            continue;
+        }
+        const fileUri = imageFileUriFromPart(part);
+        if (fileUri) {
+            out.push({ type: 'image_url', image_url: { url: fileUri.fileUri } });
+            continue;
+        }
         const url = imageUrlFromPart(part);
         if (url) {
             out.push({ type: 'image_url', image_url: { url } });
@@ -146,6 +251,16 @@ export function normalizeContentForOpenAIResponses(content, { role = 'user' } =
     }
     const out = [];
     for (const part of parts) {
+        const fileId = imageFileIdFromPart(part);
+        if (fileId) {
+            out.push({ type: 'input_image', file_id: fileId });
+            continue;
+        }
+        const fileUri = imageFileUriFromPart(part);
+        if (fileUri) {
+            out.push({ type: 'input_image', image_url: fileUri.fileUri });
+            continue;
+        }
         const url = imageUrlFromPart(part);
         if (url) {
             out.push({ type: 'input_image', image_url: url });
@@ -166,6 +281,21 @@ export function normalizeContentForGeminiParts(content) {
     }
     const out = [];
     for (const part of parts) {
+        const inlineInfo = geminiInlineInfo(part);
+        if (inlineInfo) {
+            out.push({ inlineData: { mimeType: inlineInfo.mimeType, data: inlineInfo.data } });
+            continue;
+        }
+        const fileUri = imageFileUriFromPart(part);
+        if (fileUri) {
+            out.push({ fileData: { mimeType: fileUri.mimeType, fileUri: fileUri.fileUri } });
+            continue;
+        }
+        const fileId = imageFileIdFromPart(part);
+        if (fileId) {
+            out.push({ text: `[unsupported image file_id for Gemini request: ${fileId}]` });
+            continue;
+        }
         const info = imageInfo(part);
         if (info) {
             out.push({ inlineData: { mimeType: info.mimeType, data: info.data } });

package/src/runtime/agent/orchestrator/providers/model-catalog.mjs

@@ -304,7 +304,7 @@ function _modelsDevMetadataSync(id, provider) {
  *   2. disk cache one-shot read if memory is cold (first call after boot),
  *   3. null if neither is available (async loadCatalog will fill later).
  *
- * Used by hot-path loggers (bridge-trace usage row) that must not await.
+ * Used by hot-path loggers (agent-trace usage row) that must not await.
  * The disk fallback is a single ~5ms blocking read on cold start; all
  * subsequent calls hit memory. TTL is intentionally ignored here — stale
  * catalog beats no catalog, and the async path refreshes on schedule.
@@ -358,6 +358,7 @@ function _normalize(entry) {
         cacheWriteCostPerM: entry.cache_creation_input_token_cost != null ? entry.cache_creation_input_token_cost * 1_000_000 : null,
         supportsVision: entry.supports_vision === true,
         supportsFunctionCalling: entry.supports_function_calling === true,
+        supportsWebSearch: entry.supports_web_search === true || entry.supports_websearch === true,
         supportsPromptCaching: entry.supports_prompt_caching === true,
         supportsReasoning: entry.supports_reasoning === true,
         reasoningOptions: Array.isArray(entry.reasoning_options) ? entry.reasoning_options : [],
@@ -375,6 +376,7 @@ function mergeModelMetadata(base, overlay) {
         outputTokens: overlay.outputTokens || base.outputTokens || null,
         supportsVision: base.supportsVision || overlay.supportsVision,
         supportsFunctionCalling: base.supportsFunctionCalling || overlay.supportsFunctionCalling,
+        supportsWebSearch: base.supportsWebSearch || overlay.supportsWebSearch,
         supportsPromptCaching: base.supportsPromptCaching || overlay.supportsPromptCaching,
         supportsReasoning: base.supportsReasoning || overlay.supportsReasoning,
         reasoningOptions: overlay.reasoningOptions?.length ? overlay.reasoningOptions : (base.reasoningOptions || []),
@@ -430,6 +432,7 @@ export async function enrichModels(models) {
             cacheWriteCostPerM: meta.cacheWriteCostPerM,
             supportsVision: meta.supportsVision,
             supportsFunctionCalling: meta.supportsFunctionCalling,
+            supportsWebSearch: meta.supportsWebSearch || m.supportsWebSearch === true,
             supportsPromptCaching: meta.supportsPromptCaching,
             supportsReasoning: meta.supportsReasoning,
             reasoningOptions: meta.reasoningOptions || m.reasoningOptions || [],

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -0,0 +1,45 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
+
+const ANTHROPIC_DEFAULT_CREDENTIALS_PATH = join(resolvePluginData(), 'anthropic-oauth-credentials.json');
+
+function readJsonIfExists(path) {
+    if (!path || !existsSync(path)) return null;
+    try { return JSON.parse(readFileSync(path, 'utf-8')); }
+    catch { return null; }
+}
+
+function pushUnique(list, value) {
+    if (!value || typeof value !== 'string') return;
+    if (!list.includes(value)) list.push(value);
+}
+
+export function hasAnthropicOAuthCredentials() {
+    const paths = [];
+    pushUnique(paths, process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH);
+    pushUnique(paths, ANTHROPIC_DEFAULT_CREDENTIALS_PATH);
+    for (const path of paths) {
+        const raw = readJsonIfExists(path);
+        const oauth = raw?.claudeAiOauth;
+        if (oauth?.accessToken && Array.isArray(oauth.scopes) && oauth.scopes.includes('user:inference')) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export function hasOpenAIOAuthCredentials() {
+    const paths = [join(resolvePluginData(), 'openai-oauth.json')];
+    for (const path of paths) {
+        const raw = readJsonIfExists(path);
+        const tokens = raw?.tokens || raw;
+        if (tokens?.access_token && tokens?.refresh_token) return true;
+    }
+    return false;
+}
+
+export function hasGrokOAuthCredentials() {
+    const own = readJsonIfExists(join(resolvePluginData(), 'grok-oauth.json'));
+    return !!(own?.access_token && own?.refresh_token);
+}