mixdog 1.0.12 → 1.1.0

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

@@ -4,120 +4,92 @@
 // runtime reuses the existing OpenAI-compat / Anthropic engines, constructed
 // under the custom id so model routes and provider identity stay `custom-…`.
 
+import { effectiveCustomModelRows, normalizeCustomProviderConfig } from './custom-provider-config.mjs';
 import { ANTHROPIC_VERSION } from './lib/anthropic-models.mjs';
-import { assertSafeBaseURL } from './provider-base-url.mjs';
-import { listCompatModels } from './openai-compat-models.mjs';
+import { enrichModels } from './model-catalog.mjs';
+import { fetchCompatModelItems, listCompatModels } from './openai-compat-models.mjs';
 
-export const CUSTOM_PROVIDER_PROTOCOLS = Object.freeze(['openai-chat', 'openai-responses', 'anthropic']);
+export {
+  CUSTOM_PROVIDER_PROTOCOLS,
+  CUSTOM_PROVIDER_SCHEMA_VERSION,
+  CUSTOM_REASONING_LEVELS,
+  assertCustomReasoningPatch,
+  canonicalReasoningLevel,
+  effectiveCustomModelRows,
+  normalizeCustomProviderConfig,
+} from './custom-provider-config.mjs';
 
-function fail(message) {
-  throw new Error(`[custom-provider] ${message}`);
-}
-
-function text(value) {
-  return typeof value === 'string' ? value.trim() : '';
-}
-
-function positiveInt(value, label) {
-  if (value === undefined || value === null || value === '') return undefined;
-  const n = Number(value);
-  if (!Number.isInteger(n) || n <= 0) fail(`${label} must be a positive integer`);
-  return n;
-}
-
-function normalizeBaseURL(raw) {
-  const value = text(raw);
-  if (!value) fail('baseURL is required');
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    fail(`invalid baseURL: ${value}`);
-  }
-  if (url.protocol !== 'https:' && url.protocol !== 'http:') fail('baseURL must use http or https');
-  if (url.username || url.password) fail('baseURL must not embed credentials');
-  if (url.search || url.hash || /[?#]/.test(value)) fail('baseURL must not contain a query or hash');
-  return assertSafeBaseURL(value.replace(/\/+$/, ''), 'custom');
-}
-
-function normalizeModels(raw, requireModels) {
-  if (raw === undefined || raw === null) raw = [];
-  if (!Array.isArray(raw)) fail('models must be an array');
-  const seen = new Set();
-  const models = raw.map((entry) => {
-    const id = text(entry?.id);
-    if (!id) fail('every model needs an id');
-    if (seen.has(id)) fail(`duplicate model id: ${id}`);
-    seen.add(id);
-    const name = text(entry.name);
-    const contextWindow = positiveInt(entry.contextWindow, `model ${id} contextWindow`);
-    const maxOutputTokens = positiveInt(entry.maxOutputTokens, `model ${id} maxOutputTokens`);
-    return {
-      id,
-      ...(name ? { name } : {}),
-      ...(contextWindow ? { contextWindow } : {}),
-      ...(maxOutputTokens ? { maxOutputTokens } : {}),
-    };
-  });
-  if (requireModels && models.length === 0) fail('at least one model is required');
-  return models;
-}
+const DISCOVERY_TIMEOUT_MS = 10_000;
 
-export function normalizeCustomProviderConfig(input, { requireModels = true } = {}) {
-  if (!input || typeof input !== 'object') fail('config must be an object');
-  const name = text(input.name);
-  if (!name) fail('name is required');
-  const protocol = text(input.protocol);
-  if (!protocol) fail('protocol is required');
-  if (!CUSTOM_PROVIDER_PROTOCOLS.includes(protocol)) fail(`unsupported protocol: ${protocol}`);
-  return {
-    type: 'custom',
-    name,
-    protocol,
-    baseURL: normalizeBaseURL(input.baseURL),
-    models: normalizeModels(input.models, requireModels),
-    enabled: true,
-  };
+// Discovery error safe to surface: the key is redacted, the HTTP status kept.
+function sanitizeDiscoveryError(error, apiKey) {
+  let message = String(error?.message || error || 'model discovery failed');
+  if (apiKey) message = message.split(apiKey).join('[redacted]');
+  const out = new Error(message);
+  if (Number.isInteger(error?.status)) out.status = error.status;
+  return out;
 }
 
-function modelRow(id, m) {
-  return {
-    id: m.id,
-    name: m.name || m.id,
-    provider: id,
-    contextWindow: m.contextWindow || 0,
-    outputTokens: m.maxOutputTokens || null,
-  };
-}
-
-// Configured models win; an empty list falls back to protocol discovery.
-function withConfiguredModels(Base, discover) {
+// Discovery always runs; overrides layer on top. A failed discovery keeps the
+// last successful discovered rows plus manual rows, and throws only when
+// nothing is usable or the caller asks (`throwOnError`). The sanitized error
+// of the latest attempt is kept in `customDiscoveryError` (null on success).
+function withCustomModels(Base, discover) {
   return class extends Base {
-    _customModels = [];
-    async listModels() {
-      if (!this._customModels.length) return discover(this);
-      if ('_enrichedModels' in this) this._enrichedModels = this._customModels;
-      return this._customModels.map((m) => ({ ...m }));
+    customConfig = null;
+    customDiscoveryError = null;
+    _customDiscovered = null;
+    _customApiKey = '';
+    _customKeyless = false;
+    _customRows() {
+      return effectiveCustomModelRows(this.customConfig, this._customDiscovered || [], { providerId: this.name });
+    }
+    _applyCustomRows(rows) {
+      this._enrichedModels = rows;
+      if (rows.some((row) => row.id === this.defaultModel && !row.hidden)) return;
+      const first = rows.find((row) => !row.hidden);
+      if (first) this.defaultModel = first.id;
+    }
+    async listModels({ signal = null, throwOnError = false } = {}) {
+      let failure = null;
+      try {
+        this._customDiscovered = await discover(this, signal);
+        this.customDiscoveryError = null;
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        failure = sanitizeDiscoveryError(error, this._customApiKey);
+        this.customDiscoveryError = failure;
+      }
+      const rows = this._customRows();
+      this._applyCustomRows(rows);
+      if (failure && (throwOnError || rows.length === 0)) throw failure;
+      return rows.map((row) => structuredClone(row));
     }
     async isAvailable() {
-      return this._customModels.length ? true : super.isAvailable();
+      if (this._enrichedModels?.length) return true;
+      if (this._customKeyless && this.customConfig.protocol === 'anthropic') return true;
+      return super.isAvailable();
     }
     getCachedModelInfo(model) {
-      return this._customModels.find((m) => m.id === model) || super.getCachedModelInfo?.(model) || null;
+      return this._enrichedModels?.find((row) => row.id === model) || null;
     }
   };
 }
 
-async function discoverAnthropicModels(provider) {
+async function discoverAnthropicModels(provider, signal) {
+  const timeout = AbortSignal.timeout(DISCOVERY_TIMEOUT_MS);
   const res = await fetch(`${provider.config.baseURL}/v1/models`, {
     method: 'GET',
-    signal: AbortSignal.timeout(10_000),
-    headers: { 'x-api-key': provider.apiKey || '', 'anthropic-version': ANTHROPIC_VERSION },
+    signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+    headers: {
+      ...(provider._customKeyless ? {} : { 'x-api-key': provider.apiKey || '' }),
+      'anthropic-version': ANTHROPIC_VERSION,
+    },
   });
   if (!res.ok) throw Object.assign(new Error(`${provider.name} models ${res.status}`), { status: res.status });
   const data = await res.json();
   const items = Array.isArray(data?.data) ? data.data : [];
-  return items
+  const rows = items
     .filter((m) => m?.id)
     .map((m) => ({
       id: m.id,
@@ -126,40 +98,51 @@ async function discoverAnthropicModels(provider) {
       contextWindow: Number(m.max_input_tokens) > 0 ? Number(m.max_input_tokens) : 0,
       outputTokens: Number(m.max_tokens) > 0 ? Number(m.max_tokens) : null,
     }));
+  return enrichModels(rows);
 }
 
 export async function createCustomProvider(id, config) {
-  const providerId = text(id);
-  if (!/^custom-.+/.test(providerId)) fail(`invalid custom provider id: ${id}`);
-  const cfg = normalizeCustomProviderConfig(config, { requireModels: false });
+  const providerId = typeof id === 'string' ? id.trim() : '';
+  if (!/^custom-.+/.test(providerId)) throw new Error(`[custom-provider] invalid custom provider id: ${id}`);
+  const cfg = normalizeCustomProviderConfig(config);
+  // `auth: 'none'` is authoritative: a supplied/injected key is ignored and
+  // `keyless` makes the engine omit every credential header.
+  const keyless = cfg.auth === 'none';
+  const apiKey = keyless ? '' : config.apiKey || '';
   const engine = {
     baseURL: cfg.baseURL,
-    apiKey: config.apiKey || undefined,
+    apiKey: apiKey || undefined,
+    ...(keyless ? { keyless: true } : {}),
     ...(config.preconnect === false ? { preconnect: false } : {}),
   };
   let provider;
   if (cfg.protocol === 'anthropic') {
     const { AnthropicProvider } = await import('./anthropic.mjs');
-    const Custom = withConfiguredModels(AnthropicProvider, discoverAnthropicModels);
+    const Custom = withCustomModels(AnthropicProvider, discoverAnthropicModels);
     // The Anthropic SDK appends /v1/messages itself; accept a /v1 base URL.
     provider = new Custom({ ...engine, name: providerId, baseURL: cfg.baseURL.replace(/\/v1$/i, '') });
     // An unknown third-party gateway behind the Anthropic wire: PDFs lower to text.
     provider.nativePdf = false;
   } else {
     const { OpenAICompatProvider } = await import('./openai-compat.mjs');
-    const Base =
-      cfg.protocol === 'openai-responses'
-        ? class extends OpenAICompatProvider {
-            _doSend(messages, model, tools, sendOpts) {
-              return super._doSend(messages, model, tools, { ...(sendOpts || {}), compatWireApi: 'responses' });
-            }
-          }
-        : OpenAICompatProvider;
-    const Custom = withConfiguredModels(Base, (self) => listCompatModels(self, { throwOnError: true }));
+    const responses = cfg.protocol === 'openai-responses';
+    class CompatBase extends OpenAICompatProvider {
+      _fetchModelItems({ signal = null } = {}) {
+        return fetchCompatModelItems(this, { signal, keyless: this._customKeyless });
+      }
+      _doSend(messages, model, tools, sendOpts) {
+        if (!responses) return super._doSend(messages, model, tools, sendOpts);
+        return super._doSend(messages, model, tools, { ...(sendOpts || {}), compatWireApi: 'responses' });
+      }
+    }
+    const Custom = withCustomModels(CompatBase, (self, signal) =>
+      listCompatModels(self, { throwOnError: true, signal })
+    );
     provider = new Custom(providerId, engine);
-    if (cfg.models.length) provider.defaultModel = cfg.models[0].id;
   }
-  provider._customModels = cfg.models.map((m) => modelRow(providerId, m));
   provider.customConfig = cfg;
+  provider._customApiKey = apiKey;
+  provider._customKeyless = keyless;
+  provider._applyCustomRows(provider._customRows());
   return provider;
 }

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

@@ -0,0 +1,107 @@
+// Per-model reasoning settings for user-defined (`custom-*`) providers. Pure:
+// the effective model row (custom-provider getCachedModelInfo) carries the
+// supported levels and the wire mapping; this module snaps the requested
+// effort to a supported level and serializes it for the provider protocol.
+// First-party providers never route through here.
+
+export const CUSTOM_EFFORT_LEVELS = Object.freeze(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
+const RANK = new Map(CUSTOM_EFFORT_LEVELS.map((level, index) => [level, index]));
+
+export function isCustomProviderName(name) {
+  return String(name || '').startsWith('custom-');
+}
+
+/** One effort token in the custom vocabulary (`ultra` → `max`), or null. */
+export function normalizeCustomEffort(value) {
+  const v = String(value ?? '')
+    .trim()
+    .toLowerCase();
+  const level = v === 'ultra' ? 'max' : v;
+  return RANK.has(level) ? level : null;
+}
+
+/**
+ * Supported levels declared on the row, ranked and deduplicated, or null when
+ * the row declares none (unknown). An explicit [] stays [] (no reasoning).
+ */
+export function customEffortLevels(model) {
+  const option = Array.isArray(model?.reasoningOptions)
+    ? model.reasoningOptions.find(
+        (entry) =>
+          String(entry?.type || '')
+            .trim()
+            .toLowerCase() === 'effort'
+      )
+    : null;
+  let raw = null;
+  if (Array.isArray(option?.values)) raw = option.values;
+  else if (Array.isArray(model?.reasoningLevels)) raw = model.reasoningLevels;
+  if (!raw) return null;
+  const levels = new Set(raw.map(normalizeCustomEffort).filter(Boolean));
+  return CUSTOM_EFFORT_LEVELS.filter((level) => levels.has(level));
+}
+
+/**
+ * Snap a requested effort onto `levels`. Exact matches stay; `none` is kept
+ * only when supported; otherwise the strongest supported non-none level not
+ * stronger than the request. Never promotes; no eligible level → null.
+ */
+export function snapCustomEffort(levels, effort) {
+  const requested = normalizeCustomEffort(effort);
+  if (!requested || !Array.isArray(levels) || levels.length === 0) return null;
+  const supported = levels.map(normalizeCustomEffort).filter(Boolean);
+  if (supported.includes(requested)) return requested;
+  if (requested === 'none') return null;
+  const ceiling = RANK.get(requested);
+  let best = null;
+  for (const level of supported) {
+    const rank = RANK.get(level);
+    if (level === 'none' || rank === undefined || rank > ceiling) continue;
+    if (best === null || rank > RANK.get(best)) best = level;
+  }
+  return best;
+}
+
+const EMPTY = Object.freeze({ level: null, fields: {}, thinking: null, replay: false });
+
+/**
+ * @param {{ protocol: 'openai-chat'|'openai-responses'|'anthropic', model: object|null, effort: string|null|undefined }} input
+ * @returns {{ level: string|null, fields: object, thinking: 'on'|'off'|null, replay: boolean }}
+ */
+export function resolveCustomReasoning({ protocol, model, effort } = {}) {
+  const custom = model?.customReasoning || {};
+  const wireFormat = custom.wireFormat === 'deepseek' ? 'deepseek' : 'standard';
+  // DeepSeek's `thinking` extension exists only on the Chat wire.
+  if (wireFormat === 'deepseek' && protocol !== 'openai-chat') return { ...EMPTY, fields: {} };
+  const level = snapCustomEffort(customEffortLevels(model), effort);
+  let thinking = null;
+  if (level !== null) thinking = level === 'none' ? 'off' : 'on';
+  const mapped = level === null ? null : custom.wireValues?.[level];
+  const value = typeof mapped === 'string' && mapped.trim() ? mapped.trim() : level;
+  let fields = {};
+  if (level !== null) {
+    if (protocol === 'openai-chat') {
+      if (wireFormat === 'deepseek') {
+        fields =
+          level === 'none'
+            ? { thinking: { type: 'disabled' } }
+            : { thinking: { type: 'enabled' }, reasoning_effort: value };
+      } else {
+        fields = { reasoning_effort: value };
+      }
+    } else if (protocol === 'openai-responses') {
+      fields = { reasoning: { effort: value } };
+    } else if (protocol === 'anthropic') {
+      fields =
+        level === 'none'
+          ? { thinking: { type: 'disabled' } }
+          : { thinking: { type: 'adaptive' }, output_config: { effort: value } };
+    }
+  }
+  // An explicit replay flag wins over the catalog's reasoning_content field.
+  const replayFlag =
+    typeof custom.replay === 'boolean' ? custom.replay : model?.reasoningContentField === 'reasoning_content';
+  const replay =
+    protocol === 'openai-chat' && replayFlag && thinking !== 'off' && !/reasoner/i.test(String(model?.id || ''));
+  return { level, fields, thinking, replay };
+}

package/src/runtime/agent/orchestrator/providers/effort-configuration.mjs

@@ -1,4 +1,5 @@
 import { normalizeAnthropicEffortInput } from './anthropic-effort.mjs';
+import { CUSTOM_EFFORT_LEVELS, customEffortLevels, isCustomProviderName } from './custom-reasoning.mjs';
 import { codexModelSupportsEffortUpdates } from './openai-oauth-catalog.mjs';
 
 export const EFFORT_CONFIGURATION_BETA = 'mid-conversation-output-config-2026-07-01';
@@ -42,7 +43,10 @@ export function markEffortConfigurationUnsupported(provider, model) {
 
 /** True for a provider error that names the mid-conversation effort update. */
 export function isEffortConfigurationRejection(status, text) {
-  return status === 400 && /output_config|mid-conversation|configuration_update|reasoning_effort_update/i.test(String(text || ''));
+  return (
+    status === 400 &&
+    /output_config|mid-conversation|configuration_update|reasoning_effort_update/i.test(String(text || ''))
+  );
 }
 
 /**
@@ -57,7 +61,9 @@ export async function withEffortConfigurationFallback(provider, model, opts, sen
     const status = error?.status ?? error?.httpStatus;
     if (opts?._effortConfigurationRetry || !isEffortConfigurationRejection(status, error?.message)) throw error;
     markEffortConfigurationUnsupported(provider, model);
-    process.stderr.write(`[${provider}] ${model} rejected the mid-conversation effort update; retrying once without it\n`);
+    process.stderr.write(
+      `[${provider}] ${model} rejected the mid-conversation effort update; retrying once without it\n`
+    );
     return send({ ...opts, effortConfigurationEnabled: false, _effortConfigurationRetry: true });
   }
 }
@@ -116,6 +122,42 @@ export function effortConfigurationMode(provider, model, opts = {}) {
   return null;
 }
 
+// Custom providers on the Chat and Responses wires take a fresh effort with
+// every request, so auto effort sends a turn's or step's effort as that
+// request's own effort: no mid-conversation update, no beta header. A custom
+// Anthropic-wire provider keeps auto effort off.
+const CUSTOM_AUTO_EFFORT_PROTOCOLS = new Set(['openai-chat', 'openai-responses']);
+
+/** Auto effort applies to this custom route: a Chat/Responses protocol and a
+ *  model row declaring a non-empty effort level list. */
+export function customAutoEffortCapable(provider, protocol, model) {
+  return (
+    isCustomProviderName(provider) &&
+    CUSTOM_AUTO_EFFORT_PROTOCOLS.has(protocol) &&
+    (customEffortLevels(model)?.length || 0) > 0
+  );
+}
+
+/** The model auto effort reads its effort options from: a custom provider's
+ *  effective row (its declared levels), the bare id for every other route. */
+export function autoEffortModel(providerName, providerImpl, model) {
+  if (!isCustomProviderName(providerName)) return { id: model };
+  return { ...(providerImpl?.getCachedModelInfo?.(model) || {}), id: model };
+}
+
+/** The effort-change mode of a session's route: 'responses' / 'anthropic'
+ *  (mid-conversation update), 'custom' (per-request effort), or null. */
+export function turnEffortConfigurationMode(session, provider) {
+  const opts = { ...(provider?.config || {}), modelParameters: session.modelParameters || {} };
+  const mode = effortConfigurationMode(session.provider, session.model, opts);
+  if (mode) return mode;
+  const model = autoEffortModel(session.provider, provider, session.model);
+  return customAutoEffortCapable(session.provider, provider?.customConfig?.protocol, model) ? 'custom' : null;
+}
+
+const CUSTOM_EFFORTS = new Set(CUSTOM_EFFORT_LEVELS);
+const effortsFor = (mode) => (mode === 'custom' ? CUSTOM_EFFORTS : EFFORTS);
+
 function normalizedEffort(provider, model, effort) {
   if (ANTHROPIC_PROVIDERS.has(provider)) return normalizeAnthropicEffortInput(effort, model) || null;
   const value = String(effort || 'medium')
@@ -130,19 +172,19 @@ function validSnapshot(value, provider, model, mode) {
     value.provider === provider &&
     value.model === modelKey(model) &&
     value.mode === mode &&
-    EFFORTS.has(value.initialEffort) &&
-    EFFORTS.has(value.effort)
+    effortsFor(mode).has(value.initialEffort) &&
+    effortsFor(mode).has(value.effort)
   );
 }
 
 // `turnEffort` overrides the session's saved effort for this turn only (auto
-// effort); the saved default itself is never changed here.
+// effort); the saved default itself is never changed here. A custom route's
+// snapshot only records the turn's effort (per-request effort, never projected
+// into the history).
 export function prepareTurnEffortConfiguration(session, provider, turnEffort) {
-  const config = provider?.config || {};
-  const opts = { ...config, modelParameters: session.modelParameters || {} };
-  const mode = effortConfigurationMode(session.provider, session.model, opts);
+  const mode = turnEffortConfigurationMode(session, provider);
   const effort = normalizedEffort(session.provider, session.model, turnEffort ?? session.effort);
-  if (!mode || !EFFORTS.has(effort)) return null;
+  if (!mode || !effortsFor(mode).has(effort)) return null;
   const first = (session.messages || []).find((message) =>
     validSnapshot(message?.meta?.[META_KEY], session.provider, session.model, mode)
   )?.meta?.[META_KEY];

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

@@ -76,7 +76,7 @@ export async function exchangeAuthorizationCode({ discovery, pkce, code }) {
   return tokens;
 }
 
-export async function beginOAuthLogin() {
+export async function beginOAuthLogin({ openBrowser = true } = {}) {
   const discovery = await fetchDiscovery();
   const pkce = generatePKCE();
   const state = randomBytes(16).toString('hex');
@@ -138,6 +138,7 @@ export async function beginOAuthLogin() {
       process.stderr.write(
         `\n[grok-oauth] Open this URL to log in (consent shows as "Grok Build"):\n${url.toString()}\n\n`
       );
+      if (!openBrowser) return;
       try {
         const { openInBrowser } = await import('../../../shared/open-url.mjs');
         openInBrowser(url.toString());

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

@@ -528,16 +528,19 @@ function balanceFromCredits(credits, source) {
   if (balance === null) return null;
   return {
     source,
-    remainingUsd: round(balance, 4),
-    currency: cleanString(credits.currency) || 'USD',
+    unit: 'credits',
+    remainingCredits: round(balance, 4),
+    unlimited: credits.unlimited === true,
+    hasCredits: credits.has_credits === true,
   };
 }
 
 function balanceFromExtraUsage(extra) {
   if (!extra || typeof extra !== 'object') return null;
-  const limit = num(extra.monthly_limit, null);
-  const used = num(extra.used_credits, 0);
-  if (limit === null) return null;
+  const limitCents = num(extra.monthly_limit, null);
+  if (limitCents === null) return null;
+  const limit = limitCents / 100;
+  const used = num(extra.used_credits, 0) / 100;
   return {
     source: 'anthropic-oauth-extra',
     period: 'monthly',
@@ -606,7 +609,7 @@ function balanceFromAnthropicSpend(spend) {
   return null;
 }
 
-function normalizeOpenAIWhamUsage(data) {
+export function normalizeOpenAIWhamUsage(data) {
   const rate = data?.rate_limit && typeof data.rate_limit === 'object' ? data.rate_limit : null;
   if (!rate) return null;
   const windows = [
@@ -687,13 +690,15 @@ function anthropicLimitWindows(limits, source) {
 // The extra-usage (pay-as-you-go) window when it is enabled, else null.
 function anthropicExtraUsageWindow(extraUsage) {
   if (extraUsage?.is_enabled !== true) return null;
+  const limitUsd = num(extraUsage.monthly_limit, 0) / 100;
+  const usedUsd = num(extraUsage.used_credits, 0) / 100;
   return windowFromPercent(
     'EXTRA',
     {
       utilization: extraUsage.utilization,
-      limit_dollars: extraUsage.monthly_limit,
-      used_dollars: extraUsage.used_credits,
-      remaining_dollars: Math.max(0, num(extraUsage.monthly_limit, 0) - num(extraUsage.used_credits, 0)),
+      limit_dollars: limitUsd,
+      used_dollars: usedUsd,
+      remaining_dollars: Math.max(0, limitUsd - usedUsd),
     },
     'anthropic-oauth-extra'
   );

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-send.mjs

@@ -22,6 +22,7 @@ import { applyCompatToolChoice, compatStreamRetryReporter } from './compat-reque
 import { ensureChatToolPairs } from './lib/wire-pairing.mjs';
 import { xaiCacheRouting } from './openai-compat-xai.mjs';
 import { preparePdfTextForProvider } from './media-normalization.mjs';
+import { isCustomProviderName, resolveCustomReasoning } from './custom-reasoning.mjs';
 
 export async function sendCompatChat(provider, messages, useModel, tools, opts) {
   const signal = opts.signal || null;
@@ -29,13 +30,31 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
     const reason = signal.reason;
     throw reason instanceof Error ? reason : new Error('OpenAI-compat request aborted by session close');
   }
-  const modelInfo =
-    provider.name === 'opencode-go'
-      ? provider.getCachedModelInfo(useModel) || getModelMetadataSync(useModel, provider.name)
-      : null;
-  const replaysReasoningContent =
-    modelInfo?.reasoningContentField === 'reasoning_content' ||
-    (provider.name === 'deepseek' && deepseekReplaysReasoningContent(useModel));
+  const isCustom = isCustomProviderName(provider.name);
+  // Opt-in per-provider wire profile (config.chatProfile): only a wrapper that
+  // sets it gets the extra hooks below; every other provider is untouched.
+  const profile = provider.config?.chatProfile || null;
+  // Custom providers read only their own model rows: a same-id model in the
+  // global catalog must not shape a user-defined endpoint's request.
+  let modelInfo = null;
+  if (isCustom) modelInfo = provider.getCachedModelInfo(useModel) || null;
+  else if (provider.name === 'opencode-go')
+    modelInfo = provider.getCachedModelInfo(useModel) || getModelMetadataSync(useModel, provider.name);
+  else if (profile?.resolveModelInfo) modelInfo = profile.resolveModelInfo(provider, useModel) || null;
+  // Resolved before lowering: replay eligibility depends on the snapped level
+  // (thinking disabled → nothing to replay).
+  const customReasoning = isCustom
+    ? resolveCustomReasoning({
+        protocol: 'openai-chat',
+        model: modelInfo,
+        effort: opts.effort ?? provider.config?.reasoningEffort,
+      })
+    : null;
+  const replaysReasoningContent = isCustom
+    ? customReasoning.replay
+    : modelInfo?.reasoningContentField === 'reasoning_content' ||
+      profile?.replaysReasoningContent === true ||
+      (provider.name === 'deepseek' && deepseekReplaysReasoningContent(useModel));
   messages = await preparePdfTextForProvider(messages, provider);
   const params = {
     model: useModel,
@@ -43,7 +62,11 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
     // (cancel/abort) is hard-rejected unpaired, so synthesize the
     // missing tool messages here.
     messages: ensureChatToolPairs(
-      toOpenAIMessages(messages, provider.name, { replaysReasoningContent, nativePdf: provider.nativePdf })
+      toOpenAIMessages(messages, provider.name, {
+        replaysReasoningContent,
+        ...(isCustom ? { customReplay: customReasoning.replay } : {}),
+        nativePdf: provider.nativePdf,
+      })
     ),
   };
   const maxOutputTokens = resolveCompatMaxOutputTokens(opts);
@@ -51,6 +74,8 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
   if (tools?.length) params.tools = toOpenAITools(tools);
   applyCompatToolChoice(params, opts);
   applyCompatProviderChatOptions(params, provider.name, opts, provider.config, modelInfo);
+  profile?.applyParams?.(params, { opts, config: provider.config, modelInfo });
+  const firstByteTimeoutMs = profile?.firstByteTimeoutMs || PROVIDER_FIRST_BYTE_TIMEOUT_MS;
   const totalSignal = createPassthroughSignal(signal);
   const cacheRouting = provider.name === 'xai' ? xaiCacheRouting(opts, params, tools || [], useModel) : null;
   const cacheRoutingKey = cacheRouting?.key || null;
@@ -60,7 +85,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
   try {
     try {
       assembled = await withRetry(
-        async ({ signal: attemptSignal }) => {
+        refineAttemptErrors(profile, async ({ signal: attemptSignal }) => {
           try {
             opts.onStageChange?.('requesting');
           } catch {
@@ -79,7 +104,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
               // owned by the outer withRetry — nesting retry loops
               // here multiplied tail latency (5x5).
               maxAttempts: 1,
-              perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+              perAttemptTimeoutMs: firstByteTimeoutMs,
               perAttemptLabel: `${provider.name} first byte`,
             }
           );
@@ -101,6 +126,8 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
               // recovered leaked calls only synthesize when they name
               // a tool actually offered to this request.
               knownToolNames: knownToolNamesFromOpenAITools(params.tools),
+              ...(profile?.firstByteTimeoutMs ? { firstByteTimeoutMs: profile.firstByteTimeoutMs } : {}),
+              ...(profile?.semanticIdleTimeoutMs ? { semanticIdleTimeoutMs: profile.semanticIdleTimeoutMs } : {}),
             });
           } catch (error) {
             // Grok's reference sampler treats content-idle as a
@@ -112,7 +139,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
             }
             throw error;
           }
-        },
+        }),
         {
           signal: totalSignal.signal,
           onRetry: compatStreamRetryReporter(provider.name, opts),
@@ -146,6 +173,19 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
   });
 }
 
+// Opt-in: a provider profile may rewrite an attempt's error (gateway detail,
+// permanent-failure stamps) before the retry classifier sees it.
+function refineAttemptErrors(profile, attempt) {
+  if (typeof profile?.refineError !== 'function') return attempt;
+  return async (ctx) => {
+    try {
+      return await attempt(ctx);
+    } catch (error) {
+      throw profile.refineError(error) || error;
+    }
+  };
+}
+
 export async function recoverCompatNonStreaming(provider, { streamErr, params, opts, signal, useModel }) {
   if (!canFallbackNonStreaming(streamErr, { signal })) return null;
   noteErrorUsage(streamErr);