mixdog 0.7.17 → 0.7.18

package/server-main.mjs

@@ -237,26 +237,46 @@ process.once('exit', () => {
 globalThis.__tribFastEntry = true
 
 // ── Module enable flags (B6 General toggles) ──────────────────────
-// Snapshotted once at boot — toggling in the setup UI requires a full
-// plugin restart to take effect. All four default to enabled:true when
-// the `modules` section is absent (backcompat for pre-B6 configs).
-const MODULE_NAMES = ['channels', 'memory', 'search', 'agent']
+// Tool-facing modules are snapshotted once at boot because their advertised
+// tool list is static for the MCP session. `gateway` is special: it has no MCP
+// tools and is an owned HTTP child, so server-main reconciles its runtime
+// process when modules.gateway.enabled changes below.
+const MODULE_NAMES = ['channels', 'memory', 'search', 'agent', 'gateway']
+const MIXDOG_CONFIG_PATH = join(PLUGIN_DATA, 'mixdog-config.json')
 const MODULE_ENABLED = (() => {
-  const out = { channels: true, memory: true, search: true, agent: true }
+  // channels/memory/search/agent are opt-OUT (enabled unless explicitly
+  // disabled) for pre-B6 backcompat. `gateway` is opt-IN: OFF unless the
+  // user explicitly sets modules.gateway.enabled === true, so existing
+  // installs that never heard of the gateway are completely unaffected.
+  const out = { channels: true, memory: true, search: true, agent: true, gateway: false }
   try {
-    const raw = JSON.parse(readFileSync(join(PLUGIN_DATA, 'mixdog-config.json'), 'utf8'))
+    const raw = JSON.parse(readFileSync(MIXDOG_CONFIG_PATH, 'utf8'))
     const mods = raw && typeof raw === 'object' ? raw.modules : null
     if (mods && typeof mods === 'object') {
       for (const name of MODULE_NAMES) {
         const entry = mods[name]
-        if (entry && typeof entry === 'object' && entry.enabled === false) out[name] = false
+        if (!entry || typeof entry !== 'object') continue
+        if (name === 'gateway') {
+          if (entry.enabled === true) out[name] = true
+        } else if (entry.enabled === false) {
+          out[name] = false
+        }
       }
     }
-  } catch { /* missing / malformed — keep all enabled */ }
+  } catch { /* missing / malformed — keep opt-out modules enabled, gateway off */ }
   return out
 })()
 const isModuleEnabled = (name) => MODULE_ENABLED[name] !== false
 
+function readGatewayModuleEnabled() {
+  try {
+    const raw = JSON.parse(readFileSync(MIXDOG_CONFIG_PATH, 'utf8'))
+    return raw?.modules?.gateway?.enabled === true
+  } catch {
+    return false
+  }
+}
+
 // ── Static manifest ─────────────────────────────────────────────────
 // Dev-only self-heal: if a TOOL_DEFS source was edited after the last
 // tools.json build, regenerate before loading so boot never serves a stale
@@ -636,6 +656,195 @@ function spawnStatusServer() {
 }
 spawnStatusServer()
 
+// ── Gateway HTTP server (forked child) ─────────────────────────────
+// Anthropic-compatible local gateway: routes an external Claude Code's MAIN
+// model to a mixdog provider. OFF by default (modules.gateway.enabled !==
+// true) so existing installs are unaffected. Lives in its OWN forked process
+// (like the status server) so the HTTP request loop can't starve the MCP
+// parent's event loop. The child reads gateway.defaultProvider /
+// gateway.defaultModel / gateway.port from config (+ MIXDOG_GATEWAY_* env),
+// binds a fixed port (default 3468), and advertises gateway_port into
+// active-instance.json — mirroring the memory worker's port advertisement.
+let gatewayServerChild = null
+let gatewayServerRestartTimer = null
+let gatewayServerStopping = false
+let gatewayServerFinalShutdown = false
+let gatewayServerDesiredEnabled = isModuleEnabled('gateway')
+let gatewayServerReconcileChain = Promise.resolve()
+const GATEWAY_STOP_TIMEOUT_MS = 3000
+
+function scheduleGatewayServerRestart() {
+  if (gatewayServerFinalShutdown) return
+  if (gatewayServerStopping) return
+  if (!gatewayServerDesiredEnabled) return
+  if (gatewayServerChild) return
+  if (gatewayServerRestartTimer) return
+  gatewayServerRestartTimer = setTimeout(() => {
+    gatewayServerRestartTimer = null
+    spawnGatewayServer()
+  }, 1000)
+  gatewayServerRestartTimer.unref?.()
+}
+
+function spawnGatewayServer() {
+  if (gatewayServerFinalShutdown) return
+  if (gatewayServerStopping) return
+  if (!gatewayServerDesiredEnabled) return
+  if (gatewayServerChild) return
+  if (gatewayServerRestartTimer) {
+    clearTimeout(gatewayServerRestartTimer)
+    gatewayServerRestartTimer = null
+  }
+  try {
+    gatewayServerChild = fork(
+      join(PLUGIN_ROOT, 'src/gateway/server.mjs'),
+      [],
+      {
+        env: {
+          ...process.env,
+          CLAUDE_PLUGIN_ROOT: PLUGIN_ROOT,
+          CLAUDE_PLUGIN_DATA: PLUGIN_DATA,
+          MIXDOG_SESSION_ID: SESSION_ID,
+          MIXDOG_OWNER_SESSION_ID: SESSION_ID,
+          MIXDOG_SERVER_PID: String(process.pid),
+          MIXDOG_OWNER_LEAD_PID: process.env.MIXDOG_SUPERVISOR_PID || '',
+        },
+        stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+        windowsHide: true,
+      }
+    )
+    const _emitGatewayLines = (prefix, chunk) => {
+      const text = String(chunk)
+      if (!text) return
+      const lines = text.split(/\r?\n/)
+      if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop()
+      for (const line of lines) {
+        if (!line) continue
+        log(prefix ? `${prefix}${line}` : line)
+      }
+    }
+    gatewayServerChild.stdout?.on('data', (d) => _emitGatewayLines('', d))
+    gatewayServerChild.stderr?.on('data', (d) => _emitGatewayLines('[gateway] stderr: ', d))
+    gatewayServerChild.on('message', (msg) => {
+      if (msg && msg.type === 'gateway_ready' && Number.isFinite(msg.port)) {
+        log(`[gateway] ready on port ${msg.port}`)
+      }
+    })
+    gatewayServerChild.on('error', (e) => {
+      log(`[gateway] child error: ${(e && (e.stack || e.message)) || e}`)
+      gatewayServerChild = null
+      scheduleGatewayServerRestart()
+    })
+    gatewayServerChild.on('exit', (code, signal) => {
+      log(`[gateway] child exited code=${code} signal=${signal}`)
+      gatewayServerChild = null
+      // A clean exit (code 0) means the gateway intentionally went idle
+      // (enabled but no provider/model configured, or provider not enabled).
+      // Don't respawn-loop in that case — only restart on a crash.
+      if (code === 0) return
+      scheduleGatewayServerRestart()
+    })
+  } catch (e) {
+    log(`[gateway] failed to fork: ${(e && (e.stack || e.message)) || e}`)
+    scheduleGatewayServerRestart()
+  }
+}
+
+async function stopGatewayServer(reason = 'runtime', { final = false } = {}) {
+  if (final) gatewayServerFinalShutdown = true
+  if (gatewayServerRestartTimer) {
+    clearTimeout(gatewayServerRestartTimer)
+    gatewayServerRestartTimer = null
+  }
+  const child = gatewayServerChild
+  if (!child) return
+  gatewayServerStopping = true
+  const pid = child.pid
+  try {
+    const exited = new Promise(resolve => child.once('exit', () => resolve(false)))
+    let requested = false
+    try {
+      if (child.connected) {
+        child.send({ type: 'shutdown', reason })
+        requested = true
+      }
+    } catch {}
+    if (!requested) {
+      try { child.kill('SIGTERM') } catch {}
+    }
+    const timedOut = await Promise.race([
+      exited,
+      new Promise(resolve => setTimeout(() => resolve(true), GATEWAY_STOP_TIMEOUT_MS)),
+    ])
+    if (timedOut) {
+      try {
+        if (process.platform === 'win32' && pid) {
+          const { execSync: _execSync } = await import('node:child_process')
+          _execSync(`taskkill /F /T /PID ${pid}`, { stdio: 'ignore', windowsHide: true, timeout: GATEWAY_STOP_TIMEOUT_MS })
+        } else {
+          child.kill('SIGKILL')
+        }
+      } catch {}
+    }
+  } catch (e) {
+    log(`[gateway] stop failed (${reason}): ${(e && (e.stack || e.message)) || e}`)
+  } finally {
+    if (gatewayServerChild === child) gatewayServerChild = null
+    if (!gatewayServerFinalShutdown) gatewayServerStopping = false
+  }
+}
+
+async function reconcileGatewayServer(reason = 'config') {
+  const nextEnabled = readGatewayModuleEnabled()
+  const changed = gatewayServerDesiredEnabled !== nextEnabled
+  gatewayServerDesiredEnabled = nextEnabled
+
+  if (gatewayServerDesiredEnabled) {
+    if (changed) log(`[gateway] module enabled after ${reason} — starting gateway server`)
+    spawnGatewayServer()
+    return
+  }
+
+  if (gatewayServerChild || gatewayServerRestartTimer) {
+    log(`[gateway] module disabled after ${reason} — stopping gateway server`)
+    await stopGatewayServer(reason)
+  } else if (reason === 'boot') {
+    log(`module 'gateway' disabled — skipping gateway server`)
+  }
+}
+
+function queueGatewayServerReconcile(reason = 'config') {
+  gatewayServerReconcileChain = gatewayServerReconcileChain
+    .catch(() => {})
+    .then(() => reconcileGatewayServer(reason))
+    .catch(e => log(`[gateway] reconcile failed after ${reason}: ${(e && (e.stack || e.message)) || e}`))
+}
+
+function watchGatewayModuleConfig() {
+  let debounceTimer = null
+  const trigger = (reason) => {
+    if (debounceTimer) clearTimeout(debounceTimer)
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null
+      queueGatewayServerReconcile(reason)
+    }, 250)
+    debounceTimer.unref?.()
+  }
+  try {
+    fsWatch(PLUGIN_DATA, { recursive: false, persistent: true }, (_eventType, filename) => {
+      if (!filename) return
+      const norm = String(filename).replace(/\\/g, '/')
+      if (norm.split('/').pop() !== 'mixdog-config.json') return
+      trigger('mixdog-config.json')
+    })
+    log(`[gateway-watcher] watching ${MIXDOG_CONFIG_PATH}`)
+  } catch (e) {
+    log(`[gateway-watcher] failed to watch ${PLUGIN_DATA}: ${(e && (e.stack || e.message)) || e}`)
+  }
+}
+watchGatewayModuleConfig()
+queueGatewayServerReconcile('boot')
+
 // ── Crash handlers ──────────────────────────────────────────────────
 // Leave a trace on silent hangs. Previously only child workers
 // (channels/memory) installed these; the main MCP entry had none, so
@@ -1758,7 +1967,11 @@ function pushChannelNotification(content, extraMeta) {
 function agentContext() {
   return {
     notifyFn: (text, extraMeta) => pushChannelNotification(text, extraMeta),
-    elicitFn: opts => server.elicitInput(opts),
+    // Default (stdio) elicitFn — capability-gated so it returns null when the
+    // client cannot do elicitation (tools degrade gracefully instead of the SDK
+    // throwing "Client does not support elicitation"). The daemon path overrides
+    // this with a per-connection elicitFn via callerCtx in _dispatchByModule.
+    elicitFn: _buildElicitFn(server),
     // In-process tool bridge. External LLMs see the plugin's non-agent tools
     // (search, search_memories, channels actions, etc.) and their tool_calls
     // land back in dispatchTool, which routes to the same worker IPC /
@@ -2351,6 +2564,10 @@ async function _dispatchByModule(name, args, callerCtx, def) {
     const ctx = agentContext()
     if (callerCtx?.requestSignal) ctx.requestSignal = callerCtx.requestSignal
     if (callerCtx?.callerCwd) ctx.callerCwd = callerCtx.callerCwd
+    // Prefer the connection-scoped elicitFn (daemon-correct, capability-gated)
+    // threaded from runToolCall; null when the client lacks elicitation, so the
+    // tool degrades gracefully. Overrides agentContext()'s module-global default.
+    if ('elicitFn' in callerCtx) ctx.elicitFn = callerCtx.elicitFn
     // Tag the dispatching MCP session so a detached bridge worker's result
     // routes back to THIS terminal (daemon router), not the Lead connection.
     if (callerCtx?.callerSession?.sessionId) ctx.routingSessionId = callerCtx.callerSession.sessionId
@@ -2484,7 +2701,22 @@ function _buildProgressReporter(progressCtx) {
   }
 }
 
-async function runToolCall(session, name, rawArgs, requestSignal, progressCtx = null) {
+// Build a connection-scoped elicitFn for the active MCP server, or null when
+// the client did not declare the `elicitation` capability (graceful
+// degradation — the gateway_select_model tool then falls back to listing).
+// connServer is the SDK Server actually connected to THIS client (module-global
+// `server` for stdio, the per-connection `perConn` in daemon mode), so the
+// elicitation/create request reaches the right transport. elicitFn returns the
+// raw SDK ElicitResult { action: 'accept'|'decline'|'cancel', content? }.
+function _buildElicitFn(connServer) {
+  let caps = null;
+  try { caps = connServer?.getClientCapabilities?.() || null; } catch { caps = null; }
+  if (!caps || !caps.elicitation) return null;
+  return ({ message, requestedSchema }) =>
+    connServer.elicitInput({ message, requestedSchema, mode: 'form' });
+}
+
+async function runToolCall(session, name, rawArgs, requestSignal, progressCtx = null, connServer = server) {
   const _entryT = Date.now()
   const args = MEMORY_FAMILY_TOOLS.has(name) && rawArgs && typeof rawArgs === 'object'
     ? { ...rawArgs, sessionId: rawArgs.sessionId ?? session.sessionId }
@@ -2512,12 +2744,17 @@ async function runToolCall(session, name, rawArgs, requestSignal, progressCtx =
   // build a monotonic-progress reporter ONLY when a token is present, so a
   // client that did not subscribe sees byte-identical behaviour (no emits).
   const _progressReporter = _buildProgressReporter(progressCtx)
+  // Connection-scoped interactive elicitation (null when the client lacks the
+  // capability → tools degrade to non-interactive). Threaded through callerCtx
+  // so agentContext() prefers it over the module-global stdio fallback.
+  const _elicitFn = _buildElicitFn(connServer)
   const _postT0 = Date.now()
   const result = await dispatchTool(name, args, {
     requestSignal,
     callerSession: session,
     callerCwd: session.resolveCwd(),
     progress: _progressReporter,
+    elicitFn: _elicitFn,
   })
   const _postT1 = Date.now()
   // Apply the same chained safe-compression + trim passes the bridge role loop
@@ -2595,7 +2832,7 @@ async function serveDaemon(dataDir) {
       )
       perConn.setRequestHandler(ListToolsRequestSchema, async () => LIST_TOOLS_RESPONSE)
       perConn.setRequestHandler(CallToolRequestSchema, async (req, extra) =>
-        runToolCall(session, req.params.name, req.params.arguments, extra?.signal, extra))
+        runToolCall(session, req.params.name, req.params.arguments, extra?.signal, extra, perConn))
       // Channel permission requests: forward to the shared channels worker and
       // record request_id → this connection so the worker's response routes back
       // here (the daemon notify router). Each connection registers its own.
@@ -3051,6 +3288,10 @@ async function shutdown(reason) {
     // Belt-and-braces: unlink the advertisement file if child didn't.
     try { unlinkSync(STATUS_ADVERTISE_PATH) } catch {}
   }
+  // Stop gateway HTTP server child — IPC shutdown retracts gateway_port from
+  // active-instance.json before the process exits. Reuse the runtime toggle
+  // helper so /mixdog:model off and process shutdown stay consistent.
+  await stopGatewayServer('shutdown', { final: true })
   // Graceful worker shutdown: IPC/SIGTERM → wait → force kill only as last resort.
   // Avoids taskkill /F /T which may corrupt pgdata.
   for (const [name, entry] of workers) {

package/src/agent/index.mjs

@@ -5,6 +5,13 @@ import { publishHeartbeat as publishSessionHeartbeat } from './orchestrator/sess
 import { StreamStalledAbortError, startWatchdog as startStreamWatchdog } from './orchestrator/session/stream-watchdog.mjs';
 import { startBridgeStallWatchdog } from './bridge-stall-watchdog.mjs';
 import { loadConfig, getPluginData, listPresets, getDefaultPreset, resolveRuntimeSpec } from './orchestrator/config.mjs';
+import { updateSection } from '../shared/config.mjs';
+import { readGatewayRouteInfo } from '../gateway/route-meta.mjs';
+import { CLAUDE_CURRENT_MODE } from '../gateway/claude-current.mjs';
+// Shared gateway inventory/target helpers — SAME module scripts/gateway-model.mjs
+// uses, so the interactive gateway_select_model tool and the CLI build the model
+// list and persist the routing target through one code path.
+import { buildInventory as buildGatewayInventory, inventoryChoices as gatewayInventoryChoices, parseChoiceId as parseGatewayChoiceId, resolveTargetChoice as resolveGatewayTargetChoice, writeGatewayTarget } from '../../scripts/lib/gateway-inventory.mjs';
 import { connectMcpServers, disconnectAll } from './orchestrator/mcp/client.mjs';
 import { setInternalToolsProvider, awaitBootReady } from './orchestrator/internal-tools.mjs';
 import { listWorkflows, getWorkflow, seedDefaults } from './orchestrator/workflow-store.mjs';
@@ -1219,6 +1226,10 @@ export async function handleToolCall(name, args, opts = {}) {
         const current = getDefaultPreset(cfg);
         if (presets.length === 0) return ok('No presets configured.');
         const currentLabel = current ? `${current.model}${current.effort ? ' · ' + current.effort : ''}${current.fast ? ' · fast' : ''}` : 'none';
+        const routeInfo = readGatewayRouteInfo();
+        const gatewayRoute = routeInfo?.provider && routeInfo?.model
+          ? `${routeInfo.provider} / ${routeInfo.model}${routeInfo.effort ? ' · ' + routeInfo.effort : ''}${routeInfo.fast ? ' · fast' : ''}`
+          : 'none';
         // list_models is read-only; default-preset changes go through
         // mixdog-config.json or the config UI, not interactive elicit.
         const lines = presets.map((p, i) => {
@@ -1228,7 +1239,84 @@ export async function handleToolCall(name, args, opts = {}) {
           const mark = current && p.name === current.name ? '  ← active' : '';
           return `[${i}] ${parts.join(' · ')}${mark}`;
         });
-        return ok({ current: currentLabel, presets: lines });
+        return ok({ current: currentLabel, defaultPreset: currentLabel, gatewayRoute, presets: lines });
+      }
+
+      case 'gateway_select_model': {
+        // Interactive gateway routing-target picker via MCP elicitation.
+        // Opt-in (only on explicit invocation). Builds the model inventory from
+        // the SAME shared helper the CLI uses, then asks the client to render a
+        // dropdown. Degrades gracefully when elicitation is unavailable.
+        const cfg = loadConfig();
+        const inventory = buildGatewayInventory(cfg);
+        const choices = gatewayInventoryChoices(inventory);
+        if (choices.length === 0) {
+          return fail('No enabled agent providers found. Enable a provider in /mixdog:config first.');
+        }
+        const elicitFn = typeof opts.elicitFn === 'function' ? opts.elicitFn : null;
+        // Graceful degradation: no elicitation support → list + point at the
+        // slash command instead of opening a dropdown.
+        if (!elicitFn) {
+          const listing = choices.map((c) => `  • ${c.label}`).join('\n');
+          return ok(
+            'Interactive selection is unavailable (this client does not support MCP elicitation).\n'
+            + `Available gateway targets:\n${listing}\n\n`
+            + 'Run /mixdog:model (or: bun scripts/gateway-model.mjs --set <provider> [model]) to choose one.',
+          );
+        }
+        const ids = choices.map((c) => c.id);
+        const labels = choices.map((c) => c.label);
+        const listing = choices.map((c, i) => `  ${i + 1}. ${c.label}`).join('\n');
+        let res;
+        try {
+          res = await elicitFn({
+            message:
+              'Select how the mixdog gateway should route Claude Code\'s main model:\n\n'
+              + `${listing}\n\n`
+              + 'The first option follows Claude Code\'s native /model setting on future requests.',
+            requestedSchema: {
+              type: 'object',
+              properties: {
+                model: { type: 'string', title: 'Gateway model', enum: ids, enumNames: labels },
+              },
+              required: ['model'],
+            },
+          });
+        } catch (e) {
+          // elicitInput throws if the client capability is missing despite the
+          // hook being present — fall back to the listing rather than erroring.
+          const listing = choices.map((c) => `  • ${c.label}`).join('\n');
+          return ok(
+            `Interactive selection failed (${errText(e)}).\n`
+            + `Available gateway targets:\n${listing}\n\n`
+            + 'Run /mixdog:model to choose one.',
+          );
+        }
+        if (!res || res.action !== 'accept') {
+          return ok(`Selection ${res?.action || 'cancelled'} — gateway routing unchanged.`);
+        }
+        const chosenId = res.content && typeof res.content.model === 'string' ? res.content.model : null;
+        const choice = choices.find((c) => c.id === chosenId) || null;
+        const parsed = choice || parseGatewayChoiceId(chosenId);
+        const provider = parsed?.provider || null;
+        let model = parsed?.model || null;
+        if (!provider) return fail(`Invalid selection: ${chosenId}`);
+        // A provider-only choice (no concrete model) resolves to its first
+        // candidate model from the inventory.
+        if (!model) {
+          const inv = inventory.find((e) => e.provider === provider);
+          model = inv && inv.models.length ? inv.models[0] : null;
+        }
+        if (!model) return fail(`No model available for "${provider}".`);
+        const meta = choice || resolveGatewayTargetChoice(inventory, provider, model, false);
+        writeGatewayTarget(updateSection, provider, model, meta);
+        const label = meta?.mode === CLAUDE_CURRENT_MODE
+          ? `Claude Code current (${meta.modelDisplay || model}) — follows Claude Code /model`
+          : `${provider} / ${model}${meta?.effort ? ` · ${String(meta.effort).toUpperCase()}` : ''}${meta?.fast ? ' · fast' : ''}`;
+        return ok(
+          `Gateway routing set: ${label}\n`
+          + 'modules.gateway.enabled = true — live on the next gateway request (no restart needed if the gateway is running).',
+        );
       }
 
       case 'get_workflows': {
@@ -1564,8 +1652,7 @@ export async function handleToolCall(name, args, opts = {}) {
         // --- spawn (default): dispatch a detached worker ---
         // Enforce exactly-one-of: prompt | file | ref. Schema is the first
         // gate; _resolveBridgePrompt is the second defence for clients that
-        // bypass JSON Schema validation. `message` is the unified alias for
-        // `prompt` on spawn — fold it in before resolution. Resolve the bridge
+        // bypass JSON Schema validation. Resolve the bridge
         // worker's cwd BEFORE reading args.file so a relative path is resolved
         // against the worker's effective workspace (args.cwd > callerCwd), not
         // the agent host process cwd.
@@ -1580,7 +1667,6 @@ export async function handleToolCall(name, args, opts = {}) {
         if (isCurrentDaemonDoomed()) {
           return fail('bridge spawn deferred: this daemon (server_pid) is being recycled by dev-sync — retry; the next call reconnects to the fresh daemon');
         }
-        if (args.message != null && args.prompt == null) args = { ...args, prompt: args.message };
         // Allocate the tag up front so a duplicate-live-tag request fails fast
         // before any session is created.
         const _tagAlloc = _allocateBridgeTag(args.tag, args.role);
@@ -1588,7 +1674,12 @@ export async function handleToolCall(name, args, opts = {}) {
         const bridgeTag = _tagAlloc.tag;
         const { _rawBridgeCwd, _safeBridgeCwd } = _buildBridgeCwds(args, callerCwd);
         const _promptResolution = await _resolveBridgePrompt(args, _rawBridgeCwd);
-        if (_promptResolution.error) return fail(_promptResolution.error);
+        if (_promptResolution.error) {
+          const _messageOnly = args.message != null && args.prompt == null && args.file == null && args.ref == null;
+          return fail(_messageOnly
+            ? 'bridge spawn requires prompt (or file/ref). message is only for send.'
+            : _promptResolution.error);
+        }
         let prompt = _promptResolution.prompt;
 
         // Bench escape hatch — when both provider and model are supplied,

package/src/agent/orchestrator/bridge-trace.mjs

@@ -270,6 +270,7 @@ function messagePrefixHash(messages) {
 function traceBridgeTrim({
     sessionId,
     iteration,
+    stage,
     prune_count,
     trim_changed,
     input_prefix_hash,
@@ -277,12 +278,21 @@ function traceBridgeTrim({
     after_count,
     before_bytes,
     after_bytes,
+    context_window,
+    budget_tokens,
+    reserve_tokens,
+    message_tokens_est,
+    provider,
+    model,
+    error,
+    error_code,
 }) {
     if (process.env.MIXDOG_BRIDGE_TRACE_VERBOSE !== '1') return;
     appendBridgeTrace({
         sessionId,
         iteration,
         kind: 'trim_meta',
+        stage: stage || null,
         prune_count: prune_count ?? 0,
         trim_changed: !!trim_changed,
         input_prefix_hash: input_prefix_hash || null,
@@ -290,6 +300,14 @@ function traceBridgeTrim({
         after_count: after_count ?? null,
         before_bytes: before_bytes ?? null,
         after_bytes: after_bytes ?? null,
+        context_window: context_window ?? null,
+        budget_tokens: budget_tokens ?? null,
+        reserve_tokens: reserve_tokens ?? null,
+        message_tokens_est: message_tokens_est ?? null,
+        provider: provider || null,
+        model: model || null,
+        error: error || null,
+        error_code: error_code || null,
     });
 }
 

package/src/agent/orchestrator/providers/anthropic-oauth.mjs

@@ -1187,7 +1187,10 @@ function buildRequestBody(messages, model, tools, sendOpts) {
         body.tools = toAnthropicTools(tools);
     }
 
-    if (opts.effort) {
+    const thinkingBudgetTokens = Number(opts.thinkingBudgetTokens);
+    if (Number.isFinite(thinkingBudgetTokens) && thinkingBudgetTokens > 0) {
+        body.thinking = { type: 'enabled', budget_tokens: Math.floor(thinkingBudgetTokens) };
+    } else if (opts.effort) {
         if (EFFORT_BUDGET[opts.effort]) {
             body.thinking = { type: 'enabled', budget_tokens: EFFORT_BUDGET[opts.effort] };
         } else if (!_LOGGED_UNKNOWN_EFFORT.has(opts.effort)) {

package/src/agent/orchestrator/providers/anthropic.mjs

@@ -320,8 +320,12 @@ export class AnthropicProvider {
             // Anthropic prefix semantics (order: tools → system → messages).
             params.tools = toAnthropicTools(tools);
         }
-        // Effort → extended thinking budget
-        if (opts.effort && EFFORT_BUDGET[opts.effort]) {
+        // Effort → extended thinking budget. Gateway inherit mode may pass the
+        // exact Claude Code budget from the incoming Anthropic request.
+        const thinkingBudgetTokens = Number(opts.thinkingBudgetTokens);
+        if (Number.isFinite(thinkingBudgetTokens) && thinkingBudgetTokens > 0) {
+            params.thinking = { type: 'enabled', budget_tokens: Math.floor(thinkingBudgetTokens) };
+        } else if (opts.effort && EFFORT_BUDGET[opts.effort]) {
             params.thinking = { type: 'enabled', budget_tokens: EFFORT_BUDGET[opts.effort] };
         }
         // Fast mode → speed: "fast" on models Anthropic marks as speed-capable.