@oar-sh/oar 0.9.16 → 0.9.18

package/server/claude-worker/sdk-message-normalizer.mjs

@@ -135,7 +135,7 @@ export function isBackgroundLaunch(block, toolUseResult = null) {
 
 export function summarizeToolInput(toolName, input) {
   if (!input || typeof input !== 'object') return '';
-  // `mcp__relay__remote_relay` reads as what it does on which relay
+  // `mcp__relay__relay_tool` reads as what it does on which relay
   // (`send → linux-test session 01234567: “…”`), not as its first argument.
   if (isRemoteRelayToolName(toolName)) {
     const summary = remoteRelayActivitySummary(input);
@@ -198,6 +198,57 @@ export function createSdkMessageNormalizer() {
   // The `error` of the turn's last main-thread assistant message: the SDK's
   // name for the failure a refused turn ended on.
   let lastAssistantError = '';
+  // The turn's web searches and fetches, per API message id: the API counts
+  // them in each message's `usage.server_tool_use`, and the SDK repeats a
+  // message's usage with every content block it delivers, so a message is
+  // counted once. Summed per model on the result; DeepSeek bills them per
+  // request (shared/deepseek-pricing.mjs).
+  const serverToolUse = new Map(); // message id -> { model, webSearchRequests, webFetchRequests }
+  let unnamedServerToolUseMessages = 0;
+
+  function requestCount(value) {
+    const number = Number(value ?? 0);
+    return Number.isFinite(number) && number > 0 ? Math.round(number) : 0;
+  }
+
+  function noteServerToolUse(messageId, message) {
+    const use = message?.usage?.server_tool_use;
+    if (!use || typeof use !== 'object') return;
+    const webSearchRequests = requestCount(use.web_search_requests);
+    const webFetchRequests = requestCount(use.web_fetch_requests);
+    if (!webSearchRequests && !webFetchRequests) return;
+    const key = messageId || `unnamed-${++unnamedServerToolUseMessages}`;
+    const current = serverToolUse.get(key)
+      || { model: String(message?.model || '').trim() || initModel, webSearchRequests: 0, webFetchRequests: 0 };
+    // A message's usage is the message's total, so repeats do not add up.
+    current.webSearchRequests = Math.max(current.webSearchRequests, webSearchRequests);
+    current.webFetchRequests = Math.max(current.webFetchRequests, webFetchRequests);
+    serverToolUse.set(key, current);
+  }
+
+  /** The turn's `[{ model, webSearchRequests, webFetchRequests }]`, and the count starts over. */
+  function takeServerToolUse(resultUsage) {
+    const byModel = new Map();
+    const add = (model, webSearchRequests, webFetchRequests) => {
+      const key = String(model || '').trim() || initModel;
+      const current = byModel.get(key) || { model: key, webSearchRequests: 0, webFetchRequests: 0 };
+      current.webSearchRequests += webSearchRequests;
+      current.webFetchRequests += webFetchRequests;
+      byModel.set(key, current);
+    };
+    for (const entry of serverToolUse.values()) add(entry.model, entry.webSearchRequests, entry.webFetchRequests);
+    serverToolUse.clear();
+    unnamedServerToolUseMessages = 0;
+    // A result without assistant messages seen still carries the turn's
+    // counts in its own usage, under the turn's model.
+    const use = resultUsage?.server_tool_use;
+    if (!byModel.size && use && typeof use === 'object') {
+      const webSearchRequests = requestCount(use.web_search_requests);
+      const webFetchRequests = requestCount(use.web_fetch_requests);
+      if (webSearchRequests || webFetchRequests) add(initModel, webSearchRequests, webFetchRequests);
+    }
+    return [...byModel.values()];
+  }
 
   function threadKeyFor(parentToolUseId) {
     return String(parentToolUseId || '').trim() || 'main';
@@ -592,6 +643,7 @@ export function createSdkMessageNormalizer() {
       const content = Array.isArray(sdkMessage?.message?.content) ? sdkMessage.message.content : [];
       const messageId = String(sdkMessage?.message?.id || '').trim();
       if (!parentToolUseId) lastAssistantError = String(sdkMessage?.error || '').trim();
+      noteServerToolUse(messageId, sdkMessage?.message);
       return actionsForAssistantMessage(content, parentToolUseId, messageId);
     }
 
@@ -683,6 +735,9 @@ export function createSdkMessageNormalizer() {
           totalCostUsd: Number.isFinite(Number(sdkMessage.total_cost_usd))
             ? Number(sdkMessage.total_cost_usd)
             : null,
+          // This turn's web searches and fetches per model (not running
+          // totals): `[{ model, webSearchRequests, webFetchRequests }]`.
+          serverToolUse: takeServerToolUse(sdkMessage.usage),
         },
       }];
     }

package/server/copilot-worker/copilot-remote-relay-tool.mjs

@@ -1,4 +1,4 @@
-// The relay's `remote_relay` tool for Copilot SDK sessions: a plain SDK
+// The relay's `relay_tool` tool for Copilot SDK sessions: a plain SDK
 // `Tool` (`{ name, description, parameters, skipPermission, handler }`) built
 // from the shared contract and forwarded through the shared tool core. The
 // module never imports the SDK; the session process hands the definition to
@@ -50,7 +50,7 @@ export function buildCopilotRemoteRelayTool({
         }));
       } catch (error) {
         const message = error?.message || String(error);
-        dbg('remote_relay tool failed', message);
+        dbg('relay_tool failed', message);
         result = { ok: false, code: REMOTE_RELAY_CALL_FAILED, error: message };
       }
       return formatRemoteRelayToolResult(result);

package/server/copilot-worker/copilot-sdk-adapter.mjs

@@ -392,8 +392,11 @@ export function isCopilotQuotaError(data) {
  * "Open Check Usage" pointer shipped in 37d2899. The structured quota verdict
  * is passed to that classifier as a hint rather than smuggled in as forged
  * prose, so a quota error is non-retryable however GitHub worded it.
+ *
+ * `provider` is the worker's provider (`openai` for a BYOK worker): the note
+ * names it, so an OpenAI turn does not read as a Copilot one.
  */
-export function classifyCopilotSessionError(data) {
+export function classifyCopilotSessionError(data, { provider = '' } = {}) {
   const detail = String(data?.message || '').trim() || 'the Copilot runtime reported a session error';
   const quota = isCopilotQuotaError(data);
   const probe = new Error(detail);
@@ -420,7 +423,7 @@ export function classifyCopilotSessionError(data) {
   return {
     code,
     stableCode: `copilot.${code}`,
-    text: `System note: the Copilot turn failed (${detail}). Retry or send a new message.`,
+    text: turnFailedText(detail, provider),
     // Without one the relay adds its default, which advises a retry.
     guidance: COPILOT_TURN_FAILURE_GUIDANCE,
     detail,
@@ -490,6 +493,17 @@ export function isCopilotAuthError(error) {
   return AUTH_ERROR_RE.test(String(error?.message || error || ''));
 }
 
+/**
+ * The generic failure note. On the SDK engine the provider is GitHub Copilot or,
+ * for a BYOK worker, OpenAI; the note names the one the turn ran on.
+ */
+function turnFailedText(detail, provider) {
+  const subject = String(provider || '').trim().toLowerCase() === 'openai'
+    ? 'the OpenAI turn on the Copilot SDK engine'
+    : 'the Copilot turn';
+  return `System note: ${subject} failed (${detail}). Retry or send a new message.`;
+}
+
 /**
  * What the relay appends to a failed Copilot turn in place of its own default
  * (which advises a retry). The worker deals with its runtime itself: a delivered
@@ -509,7 +523,7 @@ export const COPILOT_TURN_CONTINUE_GUIDANCE =
  * than a `session.error` event. Auth gets its own branch because the fix is a
  * user action on the relay host, not a retry.
  */
-export function classifyCopilotTurnException(error) {
+export function classifyCopilotTurnException(error, { provider = '' } = {}) {
   const detail = String(error?.message || error || '').trim() || 'unknown error';
   // The conversation's folder is gone; the message names it.
   if (isWorkingDirectoryMissingError(error)) {
@@ -563,7 +577,7 @@ export function classifyCopilotTurnException(error) {
   return {
     code: 'turn-error',
     stableCode: 'copilot.turn-error',
-    text: `System note: the Copilot turn failed (${detail}). Retry or send a new message.`,
+    text: turnFailedText(detail, provider),
     guidance: COPILOT_TURN_FAILURE_GUIDANCE,
     detail,
   };

package/server/copilot-worker/copilot-sdk-event-normalizer.mjs

@@ -84,7 +84,7 @@ export function summarizeToolInput(input) {
 
 export function formatToolActivityText(toolName, input) {
   const rawName = String(toolName || '').trim() || 'tool';
-  // `remote_relay` (bare, or namespaced by an MCP server) reads as what it
+  // `relay_tool` (bare, or namespaced by an MCP server) reads as what it
   // does on which relay (`send → linux-test session 01234567: “…”`); its
   // arguments may arrive as a JSON string.
   const isRemoteRelay = isRemoteRelayToolName(rawName);

package/server/copilot-worker/copilot-sdk-session-process.mjs

@@ -114,6 +114,11 @@ import { shouldEmitStreamUpdate } from '../../shared/stream-emit-gating.mjs';
 import { withSteerNote } from '../../shared/steer-note.mjs';
 import { isRelayAutomatedDelivery } from '../../shared/relay-events.mjs';
 import { isTransientRelayError } from '../../shared/worker-runtime/relay-errors.mjs';
+import {
+  isOpenAIImageTerminalError,
+  runDirectOpenAIImageTurn,
+  shouldUseDirectOpenAIImageApi,
+} from '../../shared/worker-runtime/direct-openai-image.mjs';
 import {
   createTurnLiveness,
   createTurnStalledError,
@@ -451,7 +456,7 @@ export function createCopilotSdkSessionRunner({
   // runtime's built-in one. A runtime that refuses the override falls back
   // to the built-in for the rest of this worker's life.
   relayAskUserTool = true,
-  // Whether sessions carry the relay's `remote_relay` tool
+  // Whether sessions carry the relay's `relay_tool` tool
   // (shared/remote-relay-tool-core.mjs). Default: ask the relay.
   remoteRelayToolGate = null,
   taskRefreshMs = DEFAULT_TASK_REFRESH_MS,
@@ -556,6 +561,12 @@ export function createCopilotSdkSessionRunner({
   // terminal error until the publish lands, so recovery can never re-run them
   // (see publishSettleMarker).
   const settlingMessages = new Map();
+  // Image-model rows running on the relay's image routes (id → message). They
+  // never reach the runtime, so no turn owns them; the heartbeat and the crash
+  // guard still have to.
+  const directImageMessages = new Map();
+  // `openai` on a BYOK worker; the failure notes name the provider.
+  const workerProvider = String(env.COPILOT_PROVIDER_TYPE || '').trim().toLowerCase();
   // Settle markers that could not be posted even terminally; the heartbeat
   // hands them to the relay to fail (id → terminalError).
   const settleFailedTerminals = new Map();
@@ -685,12 +696,12 @@ export function createCopilotSdkSessionRunner({
   // the human's eventual answer to a runtime whose row is already settled.
   // Same guard the Cursor worker's `hasPendingClientWork` provides.
   let pendingHumanRequests = 0;
-  // Running `remote_relay` calls. The runtime is just as silent while one
+  // Running `relay_tool` calls. The runtime is just as silent while one
   // runs (the relay may wait up to 600 s for a remote turn, plus an approval
   // card), so they hold the stall watchdog and the idle shutdown too — but
   // not steering: nobody is answering a card here.
   let pendingRelayToolCalls = 0;
-  // `remote_relay` is registered only while this relay has paired remotes.
+  // `relay_tool` is registered only while this relay has paired remotes.
   // Asked once when the worker starts; a session build waits for that first
   // answer (it is async anyway), and every runtime stop asks again so the
   // next session picks up a remote paired in the meantime.
@@ -2295,7 +2306,7 @@ export function createCopilotSdkSessionRunner({
   }
 
   /**
-   * The relay's `remote_relay` tool (copilot-remote-relay-tool.mjs). Every call
+   * The relay's `relay_tool` tool (copilot-remote-relay-tool.mjs). Every call
    * is counted while it runs: the stall watchdog re-arms instead of failing the
    * row, and the lifecycle keeps the runtime up. The clock restarts from the
    * answer, like after a card. A call is cancelled by the runtime (its
@@ -2338,7 +2349,7 @@ export function createCopilotSdkSessionRunner({
    * runtime refuses the override (an older runtime). The refusal is
    * remembered until the runtime is stopped — the next runtime (possibly
    * auto-updated under the relay) gets another try. Only the override goes:
-   * the relay's other tools (`remote_relay`) override nothing and stay.
+   * the relay's other tools (`relay_tool`) override nothing and stay.
    */
   async function openSession(open, config) {
     try {
@@ -3187,7 +3198,7 @@ export function createCopilotSdkSessionRunner({
       // Cancels any relay question card this turn is blocked on, so an aborted
       // turn does not leave a human answering into the void.
       abortController: new AbortController(),
-      // Cancels the `remote_relay` calls that started under this turn — on the
+      // Cancels the `relay_tool` calls that started under this turn — on the
       // user's Stop only. Not `abortController`: that one also fires when the
       // turn settles normally, and a background agent's call must outlive that.
       remoteRelayStop: new AbortController(),
@@ -3358,7 +3369,7 @@ export function createCopilotSdkSessionRunner({
     if (turn.settled) return;
     // A human staring at a question card is not a stalled runtime: the card
     // has its own (much longer) timeout, and failing the row here would
-    // settle it while the answer is still coming. A remote_relay call waiting
+    // settle it while the answer is still coming. A relay_tool call waiting
     // on another relay is the same kind of silence; the relay bounds that
     // wait itself. So is a compaction, bounded by its stale cap, and the wait
     // for the previous runtime to stop, bounded by the teardown's own limits.
@@ -3728,7 +3739,7 @@ export function createCopilotSdkSessionRunner({
     // afterwards: a runtime that died or went silent under a Stop used to put
     // the watchdog's failure on every row instead.
     if (failure && !turn.aborted) {
-      const classified = classifyCopilotTurnException(failure);
+      const classified = classifyCopilotTurnException(failure, { provider: workerProvider });
       dbg('copilot turn failed', turn.message?.id || '(continuation)', classified.detail);
       const running = turn.currentOwner || turn.primaryEntry;
       for (const entry of pending) {
@@ -3747,7 +3758,7 @@ export function createCopilotSdkSessionRunner({
       return;
     }
     if (result?.isError) {
-      const classified = classifyCopilotSessionError(result.errorData || { message: result.errorMessage });
+      const classified = classifyCopilotSessionError(result.errorData || { message: result.errorMessage }, { provider: workerProvider });
       dbg('turn failed', turn.message?.id || '(continuation)', classified.stableCode);
       const running = turn.currentOwner || turn.primaryEntry;
       for (const entry of pending) {
@@ -3901,7 +3912,7 @@ export function createCopilotSdkSessionRunner({
     }
     turn.aborted = true;
     turn.abortedRowId = rowId;
-    // A pending `remote_relay` call ends now rather than when the runtime gets
+    // A pending `relay_tool` call ends now rather than when the runtime gets
     // round to it: the relay drops the request, withdraws its approval card
     // and stops waiting on the remote, and the watchdog hold is released.
     turn.remoteRelayStop?.abort();
@@ -4117,6 +4128,7 @@ export function createCopilotSdkSessionRunner({
           dbg('continuation output dropped (no relay row)');
           const classified = classifyCopilotTurnException(
             turn.failure || new Error('the relay refused a continuation row for this turn'),
+            { provider: workerProvider },
           );
           for (const entry of turn.entries) {
             if (entry.settled || entry.turn !== turn) continue;
@@ -4552,7 +4564,7 @@ export function createCopilotSdkSessionRunner({
    *    is not waiting for its tools, so a steer interrupts nothing. A
    *    subagent the main agent runs in the foreground is covered by the main
    *    agent's own tool call that started it.
-   *  - `remote_relay`, which holds the stall watchdog but never held steering
+   *  - `relay_tool`, which holds the stall watchdog but never held steering
    *    (see `pendingRelayToolCalls`).
    */
   function mainToolsInFlight(turn = activeTurn) {
@@ -4821,6 +4833,9 @@ export function createCopilotSdkSessionRunner({
   async function handlePendingPayload(pending) {
     const message = pending?.message || null;
     if (!message) return false;
+    // An image model is no chat model: its row goes to the relay's image
+    // routes, whatever the runtime is doing, and never into the runtime.
+    if (shouldUseDirectOpenAIImageApi(message)) return runDirectImageTurn(message);
     // Held (a card is open, a compaction is running, a tool of the main agent
     // is running, the turn-opening prompt is not sent yet): hand the row back
     // with no retry penalty; the relay re-delivers it when the hold ends. An
@@ -4850,7 +4865,7 @@ export function createCopilotSdkSessionRunner({
         if (outcome !== NOT_STEERED) return outcome;
       } catch (error) {
         dbg('steering failed', message.id, error?.message || String(error));
-        const classified = classifyCopilotTurnException(error);
+        const classified = classifyCopilotTurnException(error, { provider: workerProvider });
         await publishResponse(message, {
           text: classified.text,
           model: null,
@@ -4863,6 +4878,54 @@ export function createCopilotSdkSessionRunner({
     return runTurn(turn);
   }
 
+  /**
+   * One image-model row (shared/worker-runtime/direct-openai-image.mjs). With
+   * an image operation the relay's execute route publishes the reply, the
+   * failure or the requeue itself; without one the shared helper publishes
+   * the reply, and a refusal by the provider is published here as the row's
+   * failure. Anything else requeues the row, as on the extension engine.
+   */
+  async function runDirectImageTurn(message) {
+    const id = String(message.id || '');
+    directImageMessages.set(id, message);
+    touch();
+    try {
+      const result = await runDirectOpenAIImageTurn({
+        api,
+        message,
+        // An edit can take minutes, longer than fetch waits for headers.
+        requestOptions: { longCall: true },
+        responseFields: attemptFields(message),
+      });
+      dbg('image turn', message.id, result.via, result.outcome);
+    } catch (error) {
+      if (isOpenAIImageTerminalError(error)) {
+        dbg('image turn refused by OpenAI', message.id, error.message);
+        await publishResponse(message, {
+          text: error.message,
+          model: null,
+          terminalError: {
+            kind: 'openai-image-failed',
+            // The code the relay's image operation uses for the same refusal.
+            code: 'image-provider-rejected',
+            stableCode: 'image-provider-rejected',
+            message: error.message,
+            ...(error.detail ? { detail: String(error.detail) } : {}),
+            failedAt: new Date().toISOString(),
+            queueMessageId: id || null,
+          },
+        });
+      } else {
+        dbg('image turn failed; requeueing', message.id, error?.message || String(error));
+        await api('POST', '/api/requeue', { messageId: message.id, ...attemptFields(message) }).catch(() => {});
+      }
+    } finally {
+      directImageMessages.delete(id);
+      touch();
+    }
+    return true;
+  }
+
   // --------------------------------------------------------------- teardown --
 
   function getActiveQueueMessageId() {
@@ -4872,6 +4935,7 @@ export function createCopilotSdkSessionRunner({
       const id = String(entry.message?.id || '');
       if (id && !entry.released) return id;
     }
+    for (const id of directImageMessages.keys()) return id;
     return '';
   }
 
@@ -4911,6 +4975,7 @@ export function createCopilotSdkSessionRunner({
     for (const { message, variant } of settlingMessages.values()) {
       push(message, buildSteerSettleFailure(message, { variant, agentLabel: SETTLE_AGENT_LABEL }));
     }
+    for (const message of directImageMessages.values()) push(message);
     return entries;
   }
 
@@ -4949,8 +5014,9 @@ export function createCopilotSdkSessionRunner({
     // registry and refuses ids it does not know.
     stopBackgroundTask,
     // "Active" spans both ownerships: a settled turn still publishing must
-    // keep the worker's idle/shutdown gates closed just like a running one.
-    isTurnActive: () => !!activeTurn || publishingTurns.size > 0,
+    // keep the worker's idle/shutdown gates closed just like a running one,
+    // and so must an image row on the relay's image routes.
+    isTurnActive: () => !!activeTurn || publishingTurns.size > 0 || directImageMessages.size > 0,
     dispose,
     // The turn's tokens/cost/TTFT, as posted to `/api/copilot-plan-usage`.
     getLastTurnUsage: () => lastTurnUsage,

package/server/cursor-worker/cursor-remote-relay-tool.mjs

@@ -1,7 +1,7 @@
 /**
- * The relay's `remote_relay` custom tool for the Cursor worker. SDK-free: the
+ * The relay's `relay_tool` custom tool for the Cursor worker. SDK-free: the
  * turn runner passes the returned `{ description, inputSchema, execute }` into
- * `customTools.remote_relay`, and every call goes through the shared tool core
+ * `customTools.relay_tool`, and every call goes through the shared tool core
  * to the local relay endpoint.
  *
  * A call can legitimately run for many minutes (a remote turn plus an approval
@@ -46,7 +46,7 @@ export function createRemoteRelayTool({
     } catch (error) {
       // A tool exception must never kill the run.
       const message = error?.message || String(error);
-      dbg('remote_relay tool failed', message);
+      dbg('relay_tool failed', message);
       const result = { ok: false, code: REMOTE_RELAY_CALL_FAILED, error: message };
       return {
         structuredContent: result,

package/server/cursor-worker/cursor-turn-runner.mjs

@@ -126,7 +126,7 @@ export function createCursorTurnRunner({
   // The error an agent started in `cwd` fails with up front, or null
   // (shared/worker-runtime/working-directory.mjs).
   checkWorkingDirectoryImpl = missingWorkingDirectoryError,
-  // Whether agent handles carry the relay's `remote_relay` tool
+  // Whether agent handles carry the relay's `relay_tool` tool
   // (shared/remote-relay-tool-core.mjs). Default: ask the relay.
   remoteRelayToolGate = null,
   dbg = () => {},
@@ -149,7 +149,7 @@ export function createCursorTurnRunner({
   // Open ask_user round-trips: the merged-stream stall watchdog defers while
   // a human is thinking about a question card.
   let pendingAskUserCalls = 0;
-  // Running remote_relay calls, same family: the relay may be waiting up to
+  // Running relay_tool calls, same family: the relay may be waiting up to
   // 600 s for a remote turn (plus an approval card) with no SDK traffic.
   let pendingRemoteRelayCalls = 0;
   // Mirrors the Copilot extension's lastPromptedRelayMode: full mode
@@ -178,7 +178,7 @@ export function createCursorTurnRunner({
   // plain refusal the model can relay instead of a failed turn.
   const previewTool = createPreviewTool({
     api,
-    // Between turns, the worker's own session (as remote_relay below): list
+    // Between turns, the worker's own session (as relay_tool below): list
     // and close are scoped to a conversation and refused without one.
     getConversationId: () => activeMessage?.conversationId || sdkSessionId || '',
     dbg,
@@ -202,7 +202,7 @@ export function createCursorTurnRunner({
       execute: previewTool.execute,
     },
   };
-  // `remote_relay` joins the set only while this relay has paired remotes.
+  // `relay_tool` joins the set only while this relay has paired remotes.
   // Asked once when the worker starts; the first handle waits for the answer
   // (it is created asynchronously anyway), and every handle creation refreshes
   // it so a later rebuild picks up a remote paired in the meantime.

package/server/cursor-worker/sdk-message-normalizer.mjs

@@ -47,8 +47,8 @@ export function summarizeToolInput(toolName, input) {
 /**
  * The relay's custom tools reach the stream as the SDK's generic MCP call
  * (`name: 'mcp'`, args `{ providerIdentifier: 'custom-user-tools', toolName,
- * args }`). `remote_relay` is shown as itself with the contract's one-line
- * summary, so the transcript reads `Tool (remote_relay): send → …` like every
+ * args }`). `relay_tool` is shown as itself with the contract's one-line
+ * summary, so the transcript reads `Tool (relay_tool): send → …` like every
  * other provider's; null for any other tool.
  */
 function remoteRelayCallArgs(toolName, input) {

package/server/db-schema.mjs

@@ -29,6 +29,17 @@ import { migrateConversationMayCreateSessions } from './migrations/0020-conversa
 import { migrateConversationGroupAgentMarks } from './migrations/0021-conversation-group-agent-marks.mjs';
 import { migrateRelaySchedules } from './migrations/0022-relay-schedules.mjs';
 import { migrateRelayAsks } from './migrations/0023-relay-asks.mjs';
+import { migrateDeepSeekUsageTotals } from './migrations/0024-deepseek-usage-totals.mjs';
+import { migrateDeepSeekUsageRequestsDaily } from './migrations/0025-deepseek-usage-requests-daily.mjs';
+import { migrateDeepSeekUsageServedModels } from './migrations/0026-deepseek-usage-served-models.mjs';
+import { migrateDeepSeekUsageCheckpointRuns } from './migrations/0027-deepseek-usage-checkpoint-runs.mjs';
+import { migrateDeepSeekUsageCheckpointRequestRuns } from './migrations/0028-deepseek-usage-checkpoint-request-runs.mjs';
+import { migrateDeepSeekBalanceRises } from './migrations/0029-deepseek-balance-rises.mjs';
+import { migrateDeepSeekUsageActuals } from './migrations/0030-deepseek-usage-actuals.mjs';
+import { migrateQueueProvider } from './migrations/0031-queue-provider.mjs';
+import { migrateRuntimeSessionBillingSwitch } from './migrations/0032-runtime-session-billing-switch.mjs';
+import { migrateClaudeApiUsageCheckpoints } from './migrations/0033-claude-api-usage-checkpoints.mjs';
+import { migrateClaudeApiUsageTotals } from './migrations/0034-claude-api-usage-totals.mjs';
 import { migrateImageConversationSchema } from './repositories/image-conversation-repository.mjs';
 
 // Mirrors DEFAULT_RELAY_MODE in server-runtime.mjs; used only by the one-time
@@ -898,7 +909,7 @@ try {
   console.warn(`[relay-schedules] migration 0022 failed; retrying on next boot: ${error?.message || error}`);
 }
 
-// Questions that don't block (remote_relay ask): one new table. The ask
+// Questions that don't block (relay_tool ask): one new table. The ask
 // service checks for it and refuses the ask actions without it, so a failure
 // is logged and retried next boot like 0022.
 try {
@@ -907,6 +918,62 @@ try {
   console.warn(`[relay-asks] migration 0023 failed; retrying on next boot: ${error?.message || error}`);
 }
 
+// DeepSeek usage totals: one new table. The plan usage service creates it
+// itself as well, so a failure here is logged and retried next boot like 0023.
+try {
+  migrateDeepSeekUsageTotals(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0024 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// DeepSeek search/fetch counts, daily spend and balance reference: four
+// columns on 0024's table and two tables, handled like 0024.
+try {
+  migrateDeepSeekUsageRequestsDaily(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0025 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// DeepSeek usage booked under a Claude model name is folded into the DeepSeek
+// model that served it, handled like 0024.
+try {
+  migrateDeepSeekUsageServedModels(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0026 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// The DeepSeek usage checkpoint learns the worker process's run id and its
+// search and fetch counts: three columns on 0024's table, handled like 0024.
+try {
+  migrateDeepSeekUsageCheckpointRuns(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0027 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// The checkpoint's search and fetch counts get a run id of their own: one
+// column on 0024's table, handled like 0024.
+try {
+  migrateDeepSeekUsageCheckpointRequestRuns(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0028 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// The balance reference notes when the balance last rose: one column on
+// 0025's table, handled like 0025.
+try {
+  migrateDeepSeekBalanceRises(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0029 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// The imported figures of DeepSeek's usage export: a table of its own, handled
+// like 0024.
+try {
+  migrateDeepSeekUsageActuals(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0030 failed; retrying on next boot: ${error?.message || error}`);
+}
+
 const runtimeSessionColumns = db.prepare(`PRAGMA table_info(runtime_sessions)`).all().map((c) => c.name);
 if (runtimeSessionColumns.length) {
   if (!runtimeSessionColumns.includes('strategy')) {
@@ -964,6 +1031,34 @@ if (runtimeSessionColumns.length) {
   }
 }
 
+// The Claude billing switch: the billing a queue row runs on, and the chat's
+// last switch. After runtime_sessions has provider_type: 0031's back-fill
+// reads it. Every reader and writer of these columns checks for them, so a
+// failure is logged and retried next boot like 0004.
+try {
+  migrateQueueProvider(db);
+} catch (error) {
+  console.warn(`[claude-billing] migration 0031 failed; retrying on next boot: ${error?.message || error}`);
+}
+try {
+  migrateRuntimeSessionBillingSwitch(db);
+} catch (error) {
+  console.warn(`[claude-billing] migration 0032 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// Claude API usage: the checkpoints across both Claude billings and the
+// booked totals per day and model, handled like 0024.
+try {
+  migrateClaudeApiUsageCheckpoints(db);
+} catch (error) {
+  console.warn(`[claude-api-usage] migration 0033 failed; retrying on next boot: ${error?.message || error}`);
+}
+try {
+  migrateClaudeApiUsageTotals(db);
+} catch (error) {
+  console.warn(`[claude-api-usage] migration 0034 failed; retrying on next boot: ${error?.message || error}`);
+}
+
 const conversationColumns = db.prepare(`PRAGMA table_info(conversations)`).all().map((c) => c.name);
 if (!conversationColumns.includes('archived')) {
   db.exec(`ALTER TABLE conversations ADD COLUMN archived INTEGER NOT NULL DEFAULT 0`);