mixdog 1.4.1 → 1.4.2

package/src/runtime/agent/orchestrator/providers/custom-provider-config.mjs

@@ -12,13 +12,21 @@ export const CUSTOM_REASONING_LEVELS = CUSTOM_EFFORT_LEVELS;
 export const CUSTOM_REASONING_WIRE_FORMATS = Object.freeze(['standard', 'deepseek', 'together', 'vllm']);
 export const CUSTOM_PROVIDER_AUTH_MODES = Object.freeze(['key', 'none']);
 export const CUSTOM_MODEL_OVERRIDE_LIMIT = 500;
+export const CUSTOM_HEADER_LIMIT = 64;
 
 const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 const MAX_MODEL_ID = 256;
 const MAX_NAME = 200;
 const MAX_WIRE_VALUE = 64;
+const MAX_HEADER_TEXT = 4096;
 // biome-ignore lint/suspicious/noControlCharactersInRegex: rejecting control characters is the point.
 const CONTROL_CHARS = /[\u0000-\u001f\u007f]/;
+// RFC 9110 field-name token, and a field value of visible ASCII, space, tab and
+// obs-text (what a fetch Headers value can carry).
+const HEADER_NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const HEADER_VALUE = /^[\t\x20-\x7e\x80-\xff]*$/;
+// The API key field owns authentication; a header may not carry a credential.
+const AUTH_HEADERS = new Set(['authorization', 'x-api-key', 'api-key']);
 
 function fail(message) {
   throw new Error(`[custom-provider] ${message}`);
@@ -84,6 +92,7 @@ const V2_TOP_LEVEL_KEYS = new Set([
   'modelOverrides',
   'wires',
   'modelWires',
+  'headers',
   'id',
   'apiKey',
   'apiKeyEnv',
@@ -295,6 +304,34 @@ function normalizeModelWires(raw, protocol, wires) {
   return out;
 }
 
+// `headers`: extra HTTP headers sent with every request to the endpoint
+// (inference, model discovery, connection test). Names are case-insensitive
+// tokens; the credential headers belong to the API key field.
+function normalizeHeaders(raw) {
+  if (raw === undefined) return {};
+  if (!isPlainObject(raw)) fail('headers must be an object of header names to string values');
+  const names = Object.keys(raw);
+  if (names.length > CUSTOM_HEADER_LIMIT) fail(`at most ${CUSTOM_HEADER_LIMIT} headers are allowed`);
+  const seen = new Set();
+  const entries = [];
+  for (const name of names) {
+    if (name.length > MAX_HEADER_TEXT || !HEADER_NAME.test(name))
+      fail(`headers has an invalid header name: ${JSON.stringify(name.slice(0, 64))}`);
+    const lower = name.toLowerCase();
+    if (AUTH_HEADERS.has(lower)) fail(`headers must not set ${name}: authentication belongs to the API key field`);
+    if (seen.has(lower)) fail(`headers has duplicate header: ${name}`);
+    seen.add(lower);
+    if (typeof raw[name] !== 'string') fail(`headers.${name} must be a string`);
+    // Validate before trimming, and trim only HTTP whitespace (space, tab), so
+    // CR/LF is refused rather than stripped and other characters are kept.
+    if (!HEADER_VALUE.test(raw[name])) fail(`headers.${name} has an invalid value`);
+    const value = raw[name].replace(/^[ \t]+|[ \t]+$/g, '');
+    if (value.length > MAX_HEADER_TEXT) fail(`headers.${name} has an invalid value`);
+    entries.push([name, value]);
+  }
+  return Object.fromEntries(entries);
+}
+
 // Legacy (pre-v2) `models: [{ id, name?, contextWindow?, maxOutputTokens? }]`
 // become manual, visible overrides; their presence hides newly discovered ids.
 function migrateLegacy(input) {
@@ -336,6 +373,7 @@ export function normalizeCustomProviderConfig(input) {
       fail('modelOverrides and discovery require schemaVersion 2');
     if (input.wires !== undefined || input.modelWires !== undefined)
       fail('wires and modelWires require schemaVersion 2');
+    if (input.headers !== undefined) fail('headers require schemaVersion 2');
     source = migrateLegacy(input);
   } else if (Number.isInteger(version) && version > CUSTOM_PROVIDER_SCHEMA_VERSION)
     fail(`unsupported schemaVersion ${version}; update mixdog to use this provider`);
@@ -368,6 +406,7 @@ export function normalizeCustomProviderConfig(input) {
   const newModelsHidden = optionalBoolean(discovery.newModelsHidden, 'discovery.newModelsHidden') ?? false;
   const wires = normalizeWires(source.wires, protocol);
   const modelWires = normalizeModelWires(source.modelWires, protocol, wires);
+  const headers = normalizeHeaders(source.headers);
   return {
     type: 'custom',
     schemaVersion: CUSTOM_PROVIDER_SCHEMA_VERSION,
@@ -377,6 +416,7 @@ export function normalizeCustomProviderConfig(input) {
     enabled: source.enabled !== false,
     auth,
     ...(apiKeyEnv && auth === 'key' ? { apiKeyEnv } : {}),
+    ...(Object.keys(headers).length ? { headers } : {}),
     discovery: { newModelsHidden },
     modelOverrides: normalizeOverrides(source.modelOverrides, protocol, legacy),
     ...(wires ? { wires } : {}),

package/src/runtime/agent/orchestrator/providers/custom-provider-keys.mjs

@@ -0,0 +1,34 @@
+// The engine a custom provider sends with when one of its additional API keys
+// serves (account-pool.mjs `createCustomKeyPoolProvider`). Every key reaches
+// the same endpoint, so the engine is a view of the primary instance: the
+// catalog, discovered models, wire routes and settings stay the primary's,
+// and only the credential and the client built from it are the key's own.
+
+import { readCustomProviderKey } from '../../../shared/custom-provider-keys.mjs';
+
+function keyView(engine, providerId, keyId, key) {
+  const view = Object.create(engine);
+  const rekey = (value) => {
+    // The key is the only source: an environment variable names the primary key alone.
+    view.config = { ...engine.config, apiKey: value, apiKeyEnv: undefined };
+    view.apiKey = value;
+    view.client = view._createClient(value);
+  };
+  rekey(key);
+  // An auth retry re-reads this key, never the primary's keychain entry.
+  view.reloadApiKey = () => {
+    const fresh = readCustomProviderKey(providerId, keyId);
+    if (fresh) rekey(fresh);
+  };
+  return view;
+}
+
+/** `primary` sending with additional key `keyId` of custom provider `providerId`. */
+export function customKeyEngine(primary, providerId, keyId) {
+  const key = readCustomProviderKey(providerId, keyId);
+  if (!key) throw new Error(`An additional API key of ${providerId} is not readable; enter it again in its settings.`);
+  const engine = keyView(primary, providerId, keyId, key);
+  // A Messages-wire route sends through the bound Anthropic engine.
+  if (primary.messagesEngine) engine.messagesEngine = keyView(primary.messagesEngine, providerId, keyId, key);
+  return engine;
+}

package/src/runtime/agent/orchestrator/providers/custom-provider.mjs

@@ -120,6 +120,7 @@ async function discoverAnthropicModels(provider, signal, timeoutMs = DISCOVERY_T
     headers: {
       ...(provider._customKeyless ? {} : { 'x-api-key': provider._customKey() }),
       'anthropic-version': ANTHROPIC_VERSION,
+      ...(provider.config.extraHeaders || {}),
     },
   });
   if (!res.ok) throw Object.assign(new Error(`${provider.name} models ${res.status}`), { status: res.status });
@@ -153,6 +154,8 @@ export async function createCustomProvider(id, config) {
     apiKey: apiKey || undefined,
     ...(cfg.apiKeyEnv ? { apiKeyEnv: cfg.apiKeyEnv } : {}),
     ...(keyless ? { keyless: true } : {}),
+    // User-defined headers ride the engines' existing `extraHeaders` path.
+    ...(cfg.headers ? { extraHeaders: cfg.headers } : {}),
     ...(config.preconnect === false ? { preconnect: false } : {}),
   };
   let provider;

package/src/runtime/agent/orchestrator/providers/devin-auth.mjs

@@ -14,6 +14,10 @@ import {
   decodeJwtPayload,
   expiryFromAccessToken,
   normalizeAccountIdentity,
+  OAUTH_NETWORK_HINT,
+  oauthFailureReason,
+  oauthNetworkCause,
+  oauthPublicError,
 } from './lib/oauth-token-utils.mjs';
 
 const AUTHORIZE_URL = 'https://app.devin.ai/auth/cli/continue';
@@ -46,9 +50,11 @@ export const DEVIN_OAUTH_FAILURE_CODES = Object.freeze([
   'DEVIN_OAUTH_TOKEN_EXCHANGE_FAILED',
 ]);
 
+// Built from fixed text, statuses and error codes only, so a failure page may
+// show it; response bodies are never quoted (they may carry the login token).
 function loginFailure(code, text, props = {}) {
   const failureCode = `DEVIN_OAUTH_${code}`;
-  return Object.assign(new Error(`${failureCode}: ${text}`), { failureCode }, props);
+  return oauthPublicError(Object.assign(new Error(`${failureCode}: ${text}`), { failureCode }, props));
 }
 
 function credentialsPath() {
@@ -175,12 +181,13 @@ export async function exchangeDevinCode(code, verifier, { fetchFn = fetch, signa
     });
   } catch (error) {
     // A cancelled login keeps its own abort; any other failure to get an
-    // answer (network, timeout) is a coded exchange failure. The cause is not
-    // quoted: only its kind is.
+    // answer (network, timeout) is a coded exchange failure. Its message is
+    // not quoted: only its error code.
     if (signal?.aborted) throw error;
+    const cause = oauthNetworkCause(error) || 'network error';
     throw loginFailure(
       'TOKEN_EXCHANGE_FAILED',
-      error?.name === 'TimeoutError' ? 'Devin token exchange timed out' : 'Devin token exchange request failed'
+      `Devin token exchange request failed (${cause}). ${OAUTH_NETWORK_HINT}`
     );
   }
   // Response bodies may carry the login token itself, so none is ever quoted
@@ -341,9 +348,9 @@ async function startDevinOAuthLogin({ openBrowser = true, timeoutMs = LOGIN_TIME
     try {
       await acceptCode(code);
       reply(res, 200, oauthSuccessHtml('Devin'));
-    } catch {
-      // The shared exchange reports its error through waitForCallback.
-      reply(res, 500, oauthErrorHtml('Devin could not complete the token exchange.'));
+    } catch (error) {
+      // The shared exchange also reports its error through waitForCallback.
+      reply(res, 500, oauthErrorHtml(oauthFailureReason('Devin could not complete the token exchange.', error)));
     }
   };
 

package/src/runtime/agent/orchestrator/providers/devin-wire-transport.mjs

@@ -190,10 +190,11 @@ function connectError(
   const finalCode = tooLarge ? 'request_too_large' : mixdogCode;
   const head = `Devin ${operation} ${code || 'error'}${status ? ` (HTTP ${status})` : ''}`;
   const text = [head, detail].filter(Boolean).join(': ') + (detailsSummary ? ` [details: ${detailsSummary}]` : '');
+  // A reworded throttle reports its throttle status, not the carrier's.
+  const carrierStatus = reworded ? mappedStatus : status || mappedStatus;
   const error = new DevinWireError(text, {
     code: finalCode,
-    // A reworded throttle reports its throttle status, not the carrier's.
-    status: tooLarge ? 413 : reworded ? mappedStatus : status || mappedStatus,
+    status: tooLarge ? 413 : carrierStatus,
     retryable: tooLarge ? false : retryable,
     connectCode: code,
     detail: [detail, detailsSummary].filter(Boolean).join(' '),

package/src/runtime/agent/orchestrator/providers/gemini-response.mjs

@@ -115,7 +115,7 @@ export function geminiFailureUsage(opts, cachedContent, useModel) {
   };
 }
 
-export function resolveGeminiUsage(response, opts, cachedContent, useModel) {
+export function resolveGeminiUsage(response, opts, cachedContent, useModel, provider = 'gemini') {
   const um = response.usageMetadata || null;
   if (!um) return null;
   const iteration = Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null;
@@ -143,7 +143,7 @@ export function resolveGeminiUsage(response, opts, cachedContent, useModel) {
     model: useModel,
     modelDisplay: useModel,
     rawUsage: um,
-    provider: 'gemini',
+    provider,
   });
   return resolvedUsage;
 }

package/src/runtime/agent/orchestrator/providers/gemini-stream.mjs

@@ -589,6 +589,9 @@ export async function consumeGeminiRestStreamResponse(
     onChunk = null,
     failureUsage = null,
     firstByteTimeoutMs = GEMINI_FIRST_BYTE_TIMEOUT_MS,
+    // A first-byte window longer than the idle window must govern alone until
+    // the first payload, or the idle timer would cut the wait short.
+    idleAfterFirstChunk = false,
   }
 ) {
   const unwrap =
@@ -649,7 +652,7 @@ export async function consumeGeminiRestStreamResponse(
   }
 
   try {
-    watchdogs.resetIdle();
+    if (!idleAfterFirstChunk) watchdogs.resetIdle();
     while (true) {
       let chunk;
       try {

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

@@ -6,7 +6,13 @@ import { randomBytes } from 'node:crypto';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { createOAuthPkce, parseOAuthCodeInput } from './lib/oauth-pkce.mjs';
 import { OAUTH_PAGE_CONTENT_TYPE, oauthErrorHtml, oauthSuccessHtml } from './lib/oauth-page.mjs';
-import { emailFromJwts } from './lib/oauth-token-utils.mjs';
+import {
+  emailFromJwts,
+  oauthFailureReason,
+  oauthHttpError,
+  oauthRequestError,
+  oauthResponseJson,
+} from './lib/oauth-token-utils.mjs';
 import {
   CLIENT_ID,
   SCOPE,
@@ -65,34 +71,43 @@ export async function exchangeAuthorizationCode({ discovery, pkce, code, signal
   signal?.throwIfAborted();
   const cleanCode = String(code || '').trim();
   if (!cleanCode) throw new Error('[grok-oauth] authorization code is required');
-  const tokenRes = await fetch(discovery.token_endpoint, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-    body: new URLSearchParams({
-      grant_type: 'authorization_code',
-      client_id: CLIENT_ID,
-      code: cleanCode,
-      code_verifier: pkce.verifier,
-      redirect_uri: REDIRECT_URI,
-      // xAI re-validates the PKCE challenge at token exchange
-      // (not just the verifier), so echo it back. Omitting
-      // these makes the exchange fail. Matches the Grok CLI.
-      code_challenge: pkce.challenge,
-      code_challenge_method: 'S256',
-    }),
-    // Secret-bearing (authorization code + verifier): refuse
-    // redirects so they can't be replayed to an untrusted host.
-    redirect: 'error',
-    signal: signal
-      ? AbortSignal.any([signal, AbortSignal.timeout(TOKEN_TIMEOUT_MS)])
-      : AbortSignal.timeout(TOKEN_TIMEOUT_MS),
-    dispatcher: getLlmDispatcher(),
-  });
+  let tokenRes;
+  try {
+    tokenRes = await fetch(discovery.token_endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        grant_type: 'authorization_code',
+        client_id: CLIENT_ID,
+        code: cleanCode,
+        code_verifier: pkce.verifier,
+        redirect_uri: REDIRECT_URI,
+        // xAI re-validates the PKCE challenge at token exchange
+        // (not just the verifier), so echo it back. Omitting
+        // these makes the exchange fail. Matches the Grok CLI.
+        code_challenge: pkce.challenge,
+        code_challenge_method: 'S256',
+      }),
+      // Secret-bearing (authorization code + verifier): refuse
+      // redirects so they can't be replayed to an untrusted host.
+      redirect: 'error',
+      signal: signal
+        ? AbortSignal.any([signal, AbortSignal.timeout(TOKEN_TIMEOUT_MS)])
+        : AbortSignal.timeout(TOKEN_TIMEOUT_MS),
+      dispatcher: getLlmDispatcher(),
+    });
+  } catch (err) {
+    throw oauthRequestError('[grok-oauth] token exchange', err);
+  }
   if (!tokenRes.ok) {
     const text = await tokenRes.text().catch(() => '');
-    throw new Error(`[grok-oauth] token exchange ${tokenRes.status}: ${_scrubTokens(text).slice(0, 500)}`);
+    throw oauthHttpError('[grok-oauth] token exchange', tokenRes.status, text, [
+      cleanCode,
+      pkce.verifier,
+      pkce.challenge,
+    ]);
   }
-  const tokens = tokensFromGrant(await tokenRes.json(), discovery);
+  const tokens = tokensFromGrant(await oauthResponseJson(tokenRes, '[grok-oauth] token exchange'), discovery);
   // A cancelled login never stores the account it was exchanging.
   signal?.throwIfAborted();
   saveTokens(tokens);
@@ -338,14 +353,16 @@ export async function beginOAuthLogin({ openBrowser = true, sleep = defaultSleep
         res.end(oauthErrorHtml('The sign-in callback was invalid or did not match this login.'));
         return;
       }
+      // The login settles (closing its server) before this answer is sent, so
+      // the connection must not stay open to the closed login's handler.
       try {
         await acceptCode(code);
-        res.writeHead(200, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE });
+        res.writeHead(200, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE, Connection: 'close' });
         res.end(oauthSuccessHtml('Grok'));
-      } catch {
-        // The shared exchange reports its error through waitForCallback.
-        res.writeHead(500, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE });
-        res.end(oauthErrorHtml('Grok could not complete the token exchange.'));
+      } catch (err) {
+        // The shared exchange also reports its error through waitForCallback.
+        res.writeHead(500, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE, Connection: 'close' });
+        res.end(oauthErrorHtml(oauthFailureReason('Grok could not complete the token exchange.', err)));
       }
     });
     timeout = setTimeout(() => finish(null), LOGIN_TIMEOUT_MS);

package/src/runtime/agent/orchestrator/providers/lib/oauth-page.mjs

@@ -40,7 +40,6 @@ const COPY = {
     failureTitle: '로그인 실패',
     failureBody: 'Mixdog로 돌아가 다시 시도해 주세요.',
     reason: '사유',
-    close: '닫기',
   },
   en: {
     successTitle: 'Sign-in complete',
@@ -48,7 +47,6 @@ const COPY = {
     failureTitle: 'Sign-in failed',
     failureBody: 'Return to Mixdog and try again.',
     reason: 'Reason',
-    close: 'Close',
   },
 };
 
@@ -69,7 +67,6 @@ function renderPage({ kind, providerName, reason, lang }) {
   const reasonBlock = reason
     ? `<div class="reason"><span>${langs.map((code) => COPY[code].reason).join(' / ')}</span>${escapeHtml(reason)}</div>`
     : '';
-  const close = langs.map((code) => COPY[code].close).join(' · ');
   const documentTitle = escapeHtml(
     `${langs.map((code) => COPY[code][kind === 'success' ? 'successTitle' : 'failureTitle']).join(' / ')} · Mixdog`
   );
@@ -130,20 +127,6 @@ function renderPage({ kind, providerName, reason, lang }) {
       word-break: break-word;
     }
     .reason span { display: block; margin-bottom: 4px; color: var(--muted); font-family: inherit; font-size: 12px; }
-    button {
-      margin-top: 24px;
-      min-width: 120px;
-      height: 40px;
-      padding: 0 20px;
-      border: 1px solid var(--line);
-      border-radius: 10px;
-      background: transparent;
-      color: var(--fg);
-      font: inherit;
-      font-size: 14px;
-      cursor: pointer;
-    }
-    button:hover { border-color: var(--muted); }
   </style>
 </head>
 <body>
@@ -151,7 +134,6 @@ function renderPage({ kind, providerName, reason, lang }) {
     <div class="logo">${LOGO_SVG}</div>
     ${blocks}
     ${reasonBlock}
-    <button type="button" onclick="window.close()">${escapeHtml(close)}</button>
   </main>
 </body>
 </html>`;

package/src/runtime/agent/orchestrator/providers/lib/oauth-token-utils.mjs

@@ -140,14 +140,28 @@ export function isDefinitiveOAuthFailure(text, status = 0) {
   return s === 401;
 }
 
-export function scrubOAuthSecrets(text, secretValues = []) {
-  let scrubbed = String(text || '')
+// Fields whose string values are secrets, snake_case or camelCase. `code` is
+// not one: it is also every API's error/status code. The authorization code
+// is redacted by value — exchange paths pass it in `secretValues`.
+const SECRET_FIELD =
+  '(?:access_?token|refresh_?token|id_?token|client_?secret|code_?verifier|code_?challenge|device_?code|api_?key|token|key|secret|password|assertion)';
+const SECRET_KEY_RE = new RegExp(`^${SECRET_FIELD}$`, 'i');
+// Fallback for text that is not JSON. `"field": value` — a string (possibly
+// cut off) or a bare non-numeric value in malformed JSON.
+const JSON_SECRET_RE = new RegExp(
+  `"(${SECRET_FIELD})"\\s*:\\s*(?:"(?:[^"\\\\]|\\\\.)*"?|(?!-?\\d|true\\b|false\\b|null\\b)[^,}\\]\\s]+)`,
+  'gi'
+);
+// Form-encoded or query `field=value`.
+const FORM_SECRET_RE = new RegExp(`(^|[^A-Za-z0-9_])(${SECRET_FIELD})=[^&\\s"']*`, 'gi');
+const JWT_RE = /\beyJ[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}(?:\.[A-Za-z0-9_-]*)?/g;
+
+// Bearer/JWT/Anthropic tokens and the given secret values, anywhere in `text`.
+function scrubTokenText(text, secretValues) {
+  let scrubbed = text
     .replace(/Bearer [A-Za-z0-9._-]+/gi, 'Bearer [REDACTED]')
     .replace(/sk-ant-[A-Za-z0-9._-]+/g, '[REDACTED]')
-    .replace(
-      /"(accessToken|refreshToken|access_token|refresh_token|code|key)"\s*:\s*"[^"]+"/g,
-      (_match, key) => `"${key}":"[REDACTED]"`
-    );
+    .replace(JWT_RE, '[REDACTED]');
   for (const secret of secretValues) {
     if (typeof secret === 'string' && secret) {
       scrubbed = scrubbed.split(secret).join('[REDACTED]');
@@ -155,3 +169,121 @@ export function scrubOAuthSecrets(text, secretValues = []) {
   }
   return scrubbed;
 }
+
+// A JSON object or array is redacted on its parsed form, so escaped key names
+// (`client\u005fsecret`) cannot slip past a pattern. Numbers keep their exact
+// source text; an untouched body is returned as it came. Null when `text` is
+// not a JSON object or array.
+function scrubJsonSecrets(text, secretValues) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text, (_key, value, context) =>
+      typeof value === 'number' ? JSON.rawJSON(context.source) : value
+    );
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== 'object' || JSON.isRawJSON(parsed)) return null;
+  let changed = false;
+  // Each decoded string (keys too) gets the full redaction: it may hold
+  // form-encoded fields, a query string or JSON of its own.
+  const scrubString = (value) => {
+    const scrubbed = scrubOAuthSecrets(value, secretValues);
+    if (scrubbed !== value) changed = true;
+    return scrubbed;
+  };
+  const walk = (value) => {
+    if (typeof value === 'string') return scrubString(value);
+    if (!value || typeof value !== 'object' || JSON.isRawJSON(value)) return value;
+    if (Array.isArray(value)) return value.map(walk);
+    return Object.fromEntries(
+      Object.entries(value).map(([key, inner]) => {
+        if (SECRET_KEY_RE.test(key) && typeof inner === 'string') {
+          changed = true;
+          return [key, '[REDACTED]'];
+        }
+        return [scrubString(key), walk(inner)];
+      })
+    );
+  };
+  const scrubbed = walk(parsed);
+  return changed ? JSON.stringify(scrubbed) : text;
+}
+
+/** Redact OAuth secrets from a body or message: secret fields (decoded JSON
+ *  keys, or JSON-like and form-encoded text), bearer/JWT/Anthropic tokens,
+ *  and the given values. Numeric and status codes are kept. */
+export function scrubOAuthSecrets(text, secretValues = []) {
+  const raw = String(text || '');
+  const json = scrubJsonSecrets(raw, secretValues);
+  if (json !== null) return json;
+  return scrubTokenText(
+    raw
+      .replace(JSON_SECRET_RE, (_match, key) => `"${key}":"[REDACTED]"`)
+      .replace(FORM_SECRET_RE, (_match, lead, key) => `${lead}${key}=[REDACTED]`),
+    secretValues
+  );
+}
+
+// --- Token-exchange failures a sign-in page may show ---
+
+export const OAUTH_NETWORK_HINT = 'Check your proxy/VPN: Mixdog uses the system proxy, or HTTPS_PROXY.';
+const NETWORK_CODE = /^(?:E[A-Z0-9]+|UND_ERR_[A-Z0-9_]+|ERR_[A-Z0-9_]+)$/;
+
+/**
+ * The transport cause of a fetch that got no answer: its error code
+ * (ECONNRESET, UND_ERR_CONNECT_TIMEOUT, ENOTFOUND…) or "timed out". Only codes,
+ * never messages, which may quote anything. Null for a cancel or a non-network
+ * error.
+ */
+export function oauthNetworkCause(error) {
+  if (!error || typeof error !== 'object' || error.name === 'AbortError') return null;
+  if (error.name === 'TimeoutError') return 'timed out';
+  for (let e = error, depth = 0; e && typeof e === 'object' && depth < 5; e = e.cause, depth += 1) {
+    if (typeof e.code === 'string' && NETWORK_CODE.test(e.code)) return e.code;
+  }
+  return error.name === 'TypeError' ? 'network error' : null;
+}
+
+// Errors whose message was built only from codes, statuses and redacted
+// bodies: the only ones a failure page quotes.
+const publicErrors = new WeakSet();
+
+/** Mark `error` as safe to show on the sign-in failure page. */
+export function oauthPublicError(error) {
+  publicErrors.add(error);
+  return error;
+}
+
+/** A fetch failure as `<operation> request failed (<cause>). <hint>`; other errors unchanged. */
+export function oauthRequestError(operation, error) {
+  const cause = oauthNetworkCause(error);
+  return cause ? oauthPublicError(new Error(`${operation} request failed (${cause}). ${OAUTH_NETWORK_HINT}`)) : error;
+}
+
+/** A token endpoint's body for an error message: secrets redacted, whitespace folded, shortened. */
+export function oauthBodySummary(text, secretValues = []) {
+  return scrubOAuthSecrets(text, secretValues).replace(/\s+/g, ' ').trim().slice(0, 500);
+}
+
+/** A token endpoint's HTTP failure as `<operation> <status>: <redacted body>`. */
+export function oauthHttpError(operation, status, text, secretValues = []) {
+  const summary = oauthBodySummary(text, secretValues);
+  return oauthPublicError(new Error(`${operation} ${status}${summary ? `: ${summary}` : ''}`));
+}
+
+/** The token response's JSON. A body that does not parse is named by its
+ *  status only: the parser's message quotes the body, tokens included. */
+export async function oauthResponseJson(response, operation) {
+  try {
+    return await response.json();
+  } catch (error) {
+    if (error?.name !== 'SyntaxError') throw oauthRequestError(operation, error);
+    throw oauthPublicError(new Error(`${operation} returned a malformed response (HTTP ${response.status})`));
+  }
+}
+
+/** The failure page reason: the summary, plus the error's message only when it is page-safe. */
+export function oauthFailureReason(summary, error) {
+  return error && publicErrors.has(error) ? `${summary}\n${error.message}` : summary;
+}

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

@@ -195,7 +195,7 @@ export class MimoOAuthProvider {
     // publishes nothing. `_listRows` revalidates `seq` and the key before
     // touching shared state, since enrichment runs after this returns.
     let published = true;
-    if (items.length) published = publish(items.map(rosterRow));
+    if (items.length) published = await publish(items.map(rosterRow));
     else items = seedModelItems();
     return { items, published, seq, apiKey };
   }