@oar-sh/oar 0.9.17 → 0.9.18

package/server/claude-worker/claude-usage-totals.mjs

@@ -106,3 +106,56 @@ export function claudeToolRequests(serverToolUse, { modelKey = (value) => String
   }
   return [...requests.values()].filter((entry) => entry.searchRequests + entry.fetchRequests > 0);
 }
+
+function costOf(value) {
+  const number = Number(value ?? 0);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+
+/**
+ * The CLI's totals per model with Claude Code's own cost estimate, for the
+ * Claude API booking (claude-api-usage-service.mjs): `[{ model, hitTokens,
+ * missTokens, outputTokens, costUsd, costUnknown }]`. From `modelUsage` (the
+ * session's running totals, sub-agents and helper calls included; `costUSD`
+ * per model, `costBasis: 'unknown'` for a model the CLI has no price for), or
+ * from `usage` alone under the turn's model (pass `modelUsage` as null): the
+ * turn's main agent loop, which carries no cost. Model ids keep Claude's
+ * `[1m]` tier; the relay books them under the base id.
+ */
+export function claudeBillingTotals(modelUsage, { usage = null, model = '' } = {}) {
+  const totals = new Map();
+  const add = (name, hit, miss, output, costUsd, costUnknown) => {
+    const key = String(name ?? '').trim().toLowerCase();
+    if (!key) return;
+    const current = totals.get(key) || { model: key, hitTokens: 0, missTokens: 0, outputTokens: 0, costUsd: 0, costUnknown: false };
+    current.hitTokens += hit;
+    current.missTokens += miss;
+    current.outputTokens += output;
+    current.costUsd += costUsd;
+    current.costUnknown = current.costUnknown || costUnknown;
+    totals.set(key, current);
+  };
+  if (modelUsage && typeof modelUsage === 'object' && !Array.isArray(modelUsage)) {
+    for (const [name, entry] of Object.entries(modelUsage)) {
+      if (!entry || typeof entry !== 'object') continue;
+      add(
+        name,
+        count(entry.cacheReadInputTokens),
+        count(entry.inputTokens) + count(entry.cacheCreationInputTokens),
+        count(entry.outputTokens),
+        costOf(entry.costUSD),
+        entry.costBasis === 'unknown',
+      );
+    }
+  } else if (usage && typeof usage === 'object') {
+    add(
+      model,
+      count(usage.cache_read_input_tokens),
+      count(usage.input_tokens) + count(usage.cache_creation_input_tokens),
+      count(usage.output_tokens),
+      0,
+      false,
+    );
+  }
+  return [...totals.values()].filter((entry) => entry.hitTokens + entry.missTokens + entry.outputTokens > 0 || entry.costUsd > 0);
+}

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);

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-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

@@ -456,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,
@@ -696,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.
@@ -2306,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
@@ -2349,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 {
@@ -3198,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(),
@@ -3369,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.
@@ -3912,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();
@@ -4564,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) {

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

@@ -36,6 +36,10 @@ import { migrateDeepSeekUsageCheckpointRuns } from './migrations/0027-deepseek-u
 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
@@ -905,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 {
@@ -1027,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`);

package/server/deepseek-worker/deepseek-claude-backend.mjs

@@ -7,9 +7,11 @@
 //   directory of its own, no nonessential traffic, and nothing of the host's
 //   Claude login or of another Anthropic configuration. The endpoint, the
 //   key and everything else that routes the CLI's requests or decides whom
-//   it trusts (DEEPSEEK_CLI_PINNED_ENV: provider switches, credentials,
+//   it trusts (CLAUDE_CLI_PINNED_ENV: provider switches, credentials,
 //   proxies, TLS) are pinned again in the CLI's flag settings
 //   (liveFlagSettings), over the settings of the chat's folder.
+// - Hooks: none run, neither the user's nor the chat folder's, and no
+//   statusLine command (CLAUDE_CLI_KEY_CHAT_SETTINGS, on the command line).
 // - The model: DeepSeek's ids, with Claude Code's `[1m]` suffix so the CLI
 //   plans with the 1M window; helper calls (titles, summaries) go to flash.
 //   Claude Code's model aliases are pinned to the session's model
@@ -34,6 +36,7 @@
 
 import { deepseekAnthropicBaseUrl } from '../../shared/deepseek-api.mjs';
 import { isHostClaudeSessionVariable } from '../../shared/host-claude-session-env.mjs';
+import { CLAUDE_CLI_KEY_CHAT_SETTINGS, claudeCliPinnedEnv } from '../claude-worker/claude-cli-pinned-env.mjs';
 import {
   DEEPSEEK_PROVIDER_TYPE,
   DEFAULT_DEEPSEEK_MODEL,
@@ -120,133 +123,6 @@ const FOREIGN_CLI_VARIABLES = Object.freeze([
 // ANTHROPIC_AUTH_TOKEN) and the relay's own OAR_* switches.
 const FOREIGN_CLI_PREFIXES = Object.freeze(['ANTHROPIC_', 'COPILOT_WEB_RELAY_', 'COPILOT_PROVIDER_', 'DEEPSEEK_', 'OAR_']);
 
-/**
- * Every variable through which the env of the chat folder's settings
- * (.claude/settings.json, settings.local.json) could send the CLI's requests,
- * and with them the key, somewhere else, or change whom the CLI trusts on the
- * way: the endpoints, the provider switches, the credentials, the proxies and
- * the TLS trust. liveFlagSettings pins each one in the flag settings layer,
- * which the CLI applies over the folder's, to the value the CLI was spawned
- * with: the worker's own, else the other case's for a proxy variable, else ''.
- * '' is unset to the CLI for each of these (truthy or trimmed reads), except
- * SSL_CERT_FILE and SSL_CERT_DIR: '' empties OpenSSL's and Node's system
- * store, so those two are pinned only when the worker sets them.
- *
- * Source: the names Claude Code 2.1.304 (the bundled CLI) reads, by a grep
- * of the binary; the CLI's own lists of endpoints (with their selection
- * switches and companions) and credentials are in it as they are there. A
- * deny-list, because a settings layer can only pin names known in advance.
- * Left out, each for its reason: the model variables (same endpoint, same
- * key), what the CLI already drops from a folder's settings or from all
- * settings (CLAUDE_CONFIG_DIR, CLAUDE_CODE_CUSTOM_OAUTH_URL, the OTEL
- * exporter endpoints, ANTHROPIC_UNIX_SOCKET, the host-managed provider
- * switches, the file-descriptor credentials), a provider's own SDK settings
- * (AWS_*, GOOGLE_*, AZURE_*, read only for the provider the switches here
- * turn off), NODE_OPTIONS (at runtime the CLI reads only its system-CA
- * flags, which add no CA), and what routes only other programs' traffic
- * (NPM_CONFIG_*, GIT_*, the resolver's variables).
- */
-export const DEEPSEEK_CLI_PINNED_ENV = Object.freeze([
-  // Endpoints: the CLI's list, its fallback and the headers sent with them.
-  'ANTHROPIC_BASE_URL',
-  '_CLAUDE_CODE_ASSUME_FIRST_PARTY_BASE_URL',
-  'ANTHROPIC_CUSTOM_HEADERS',
-  'ANTHROPIC_BEDROCK_BASE_URL',
-  'ANTHROPIC_VERTEX_BASE_URL',
-  'ANTHROPIC_FOUNDRY_BASE_URL',
-  'ANTHROPIC_AWS_BASE_URL',
-  'ANTHROPIC_GOOGLE_CLOUD_BASE_URL',
-  'ANTHROPIC_BEDROCK_MANTLE_BASE_URL',
-  'CLAUDE_CODE_API_BASE_URL',
-  'CLAUDE_CODE_ARTIFACTS_API_BASE_URL',
-  'CLAUDE_CODE_ARTIFACTS_API_TOKEN',
-  'CLAUDE_CODE_ARTIFACT_ASSET_BASE_URL',
-  'CLAUDE_CODE_ARTIFACT_LIVE_BASE_URL',
-  'CLAUDE_CODE_ARTIFACT_SYNC_BASE_URL',
-  'CLAUDE_CODE_ARTIFACT_VIEWER_BASE_URL',
-  'CLAUDE_CODE_MEMORY_API_BASE_URL',
-  'CLAUDE_CODE_MEMORY_API_TOKEN',
-  // Provider switches.
-  'CLAUDE_CODE_USE_BEDROCK',
-  'CLAUDE_CODE_USE_VERTEX',
-  'CLAUDE_CODE_USE_FOUNDRY',
-  'CLAUDE_CODE_USE_ANTHROPIC_AWS',
-  'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
-  'CLAUDE_CODE_USE_MANTLE',
-  'CLAUDE_CODE_USE_GATEWAY',
-  'CLAUDE_CODE_SKIP_BEDROCK_AUTH',
-  'CLAUDE_CODE_SKIP_VERTEX_AUTH',
-  'CLAUDE_CODE_SKIP_FOUNDRY_AUTH',
-  'CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH',
-  'CLAUDE_CODE_SKIP_ANTHROPIC_GOOGLE_CLOUD_AUTH',
-  'CLAUDE_CODE_SKIP_MANTLE_AUTH',
-  // Credentials: the CLI's list, the OAuth login, the federation profile and
-  // the proxy credential helper.
-  'ANTHROPIC_API_KEY',
-  'ANTHROPIC_AUTH_TOKEN',
-  'CLAUDE_CODE_OAUTH_TOKEN',
-  'AWS_BEARER_TOKEN_BEDROCK',
-  'ANTHROPIC_FOUNDRY_API_KEY',
-  'ANTHROPIC_FOUNDRY_AUTH_TOKEN',
-  'ANTHROPIC_AWS_API_KEY',
-  'CLAUDE_CODE_OAUTH_REFRESH_TOKEN',
-  'CLAUDE_CODE_OAUTH_SCOPES',
-  'CLAUDE_CODE_OAUTH_CLIENT_ID',
-  'ANTHROPIC_PROFILE',
-  'ANTHROPIC_IDENTITY_TOKEN',
-  'ANTHROPIC_IDENTITY_TOKEN_FILE',
-  'ANTHROPIC_FEDERATION_RULE_ID',
-  'ANTHROPIC_ORGANIZATION_ID',
-  'ANTHROPIC_SERVICE_ACCOUNT_ID',
-  'ANTHROPIC_SCOPE',
-  'ANTHROPIC_WORKSPACE_ID',
-  'CLAUDE_CODE_ENABLE_PROXY_AUTH_HELPER',
-  // Proxies: the CLI reads both cases, the lower one first.
-  'HTTPS_PROXY',
-  'https_proxy',
-  'HTTP_PROXY',
-  'http_proxy',
-  'ALL_PROXY',
-  'all_proxy',
-  'NO_PROXY',
-  'no_proxy',
-  'CLAUDE_CODE_HTTPS_PROXY',
-  'CLAUDE_CODE_HTTP_PROXY',
-  // TLS trust and the client certificate.
-  'NODE_TLS_REJECT_UNAUTHORIZED',
-  'NODE_EXTRA_CA_CERTS',
-  'CLAUDE_CODE_CERT_STORE',
-  'CLAUDE_CODE_CLIENT_CERT',
-  'CLAUDE_CODE_CLIENT_KEY',
-  'CLAUDE_CODE_CLIENT_KEY_PASSPHRASE',
-  'SSL_CERT_FILE',
-  'SSL_CERT_DIR',
-]);
-// The two of DEEPSEEK_CLI_PINNED_ENV for which '' is not unset (see there).
-const PINNED_ONLY_WHEN_SET = new Set(['SSL_CERT_FILE', 'SSL_CERT_DIR']);
-// The proxy variables the CLI and the tools it runs read in either case.
-const OTHER_CASE = new Map(
-  ['HTTPS_PROXY', 'HTTP_PROXY', 'ALL_PROXY', 'NO_PROXY'].flatMap((name) => [
-    [name, name.toLowerCase()],
-    [name.toLowerCase(), name],
-  ]),
-);
-
-/**
- * The pins of DEEPSEEK_CLI_PINNED_ENV for a CLI spawned with `cliEnv`: the
- * value it was spawned with, else the other case's (a proxy the worker sets
- * as https_proxy holds for HTTPS_PROXY as well), else ''.
- */
-export function deepseekPinnedEnv(cliEnv = {}) {
-  const pins = {};
-  for (const name of DEEPSEEK_CLI_PINNED_ENV) {
-    const own = cliEnv[name] ?? cliEnv[OTHER_CASE.get(name)];
-    if (own !== undefined) pins[name] = String(own);
-    else if (!PINNED_ONLY_WHEN_SET.has(name)) pins[name] = '';
-  }
-  return pins;
-}
-
 /**
  * Whether a variable of the worker's stays out of the CLI's environment:
  * another Anthropic configuration or credential, the relay's settings for
@@ -410,13 +286,21 @@ export function createDeepSeekClaudeBackend({ env = process.env } = {}) {
 
     spawnEnv,
 
+    /**
+     * The settings layer every CLI of this backend is spawned with, on its
+     * command line (no key in it): no hooks and no statusLine command, from
+     * the user's settings or the chat folder's. They would run with the key
+     * in their environment, a folder's SessionStart hook before the pins.
+     */
+    flagSettings: () => ({ ...CLAUDE_CLI_KEY_CHAT_SETTINGS }),
+
     /**
      * The CLI's routing, trust and credentials once more, in its flag
      * settings layer, which outranks the settings of the chat's folder: a
      * .claude/settings.json or settings.local.json there whose
      * env.ANTHROPIC_BASE_URL, proxy or CA points elsewhere would otherwise
      * get the DeepSeek key as its bearer token (scripts/deepseek-cli-proof.mjs).
-     * Every variable of DEEPSEEK_CLI_PINNED_ENV holds the value of `cliEnv`,
+     * Every variable of CLAUDE_CLI_PINNED_ENV holds the value of `cliEnv`,
      * the environment the CLI was spawned with (spawnEnv), or is blanked, and
      * so is an apiKeyHelper of the folder's. The key may not go on the
      * command line, so the adapter sends these over the control channel
@@ -425,7 +309,7 @@ export function createDeepSeekClaudeBackend({ env = process.env } = {}) {
     liveFlagSettings(cliEnv = spawnEnv(env)) {
       if (!apiKey) throw new Error('deepseek-api-key-not-configured');
       return {
-        env: { ...deepseekPinnedEnv(cliEnv), ANTHROPIC_BASE_URL: anthropicBaseUrl, ANTHROPIC_AUTH_TOKEN: apiKey },
+        env: { ...claudeCliPinnedEnv(cliEnv), ANTHROPIC_BASE_URL: anthropicBaseUrl, ANTHROPIC_AUTH_TOKEN: apiKey },
         apiKeyHelper: '',
       };
     },

package/server/grok-worker/acp-client.mjs

@@ -358,7 +358,7 @@ export class AcpClient extends EventEmitter {
    * `holdStall` (async, optional) is asked once the inactivity window has run
    * out: `true` re-arms the full window instead of failing the prompt. It is
    * for work the agent is blocked on that this client cannot see — a
-   * remote_relay call the agent runs through its MCP server, which the relay
+   * relay_tool call the agent runs through its MCP server, which the relay
    * reports as in flight. A question that fails or takes longer than
    * `holdCheckTimeoutMs` counts as `false`.
    *

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

@@ -134,7 +134,7 @@ export function createGrokTurnRunner({
 } = {}) {
   const terminalTasks = taskPublisher;
   // The OAR MCP server gives Grok the relay's real tools — `preview`, and
-  // `remote_relay` when remotes are paired — bound to this conversation.
+  // `relay_tool` when remotes are paired — bound to this conversation.
   // `OAR_MCP_SERVER=0` is the operator's way back to the preview instruction
   // block, should an agent build turn out to ignore ACP `mcpServers`.
   const oarMcpLaunch = oarMcpServer !== undefined
@@ -238,7 +238,7 @@ export function createGrokTurnRunner({
   }
 
   /**
-   * The inactivity hold. A remote_relay call runs inside the MCP server, which
+   * The inactivity hold. A relay_tool call runs inside the MCP server, which
    * this worker cannot see: Grok just goes quiet for as long as the relay
    * waits on the remote turn. Before the ACP watchdog calls that a stall, the
    * relay is asked whether a call of this conversation is still in flight.
@@ -247,7 +247,7 @@ export function createGrokTurnRunner({
    */
   async function remoteRelayCallInFlight() {
     const inflight = await fetchRemoteRelayInflight({ api, conversationId: sdkSessionId });
-    if (inflight > 0) dbg('remote_relay call in flight; holding the inactivity watchdog', String(inflight));
+    if (inflight > 0) dbg('relay_tool call in flight; holding the inactivity watchdog', String(inflight));
     return inflight > 0;
   }
 
@@ -447,7 +447,7 @@ export function createGrokTurnRunner({
     // absolute cap: "No limit" (0) must not be silently trimmed to the
     // 30-minute default. The inactivity watchdog stays — it detects a dead
     // transport, not a long turn — but asks the relay before it fires while
-    // Grok may be blocked on a remote_relay call.
+    // Grok may be blocked on a relay_tool call.
     const watchdog = {
       ...(turnCeilingMs !== null ? { maxTurnMs: turnCeilingMs > 0 ? turnCeilingMs : 0 } : {}),
       ...(acpMcpServers.length ? { holdStall: remoteRelayCallInFlight } : {}),

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

@@ -64,7 +64,7 @@ export function summarizeToolInput(input) {
 }
 
 export function formatToolActivityText(toolName, input, title = '') {
-  // The OAR MCP server's `remote_relay`, however the agent labels it (bare,
+  // The OAR MCP server's `relay_tool`, however the agent labels it (bare,
   // or namespaced by the server), reads as what it does on which relay.
   if (isRemoteRelayToolName(toolName) || isRemoteRelayToolName(title)) {
     const remoteSummary = remoteRelayActivitySummary(input);

package/server/mcp/oar-mcp-server.mjs

@@ -2,7 +2,7 @@
 // OAR's own stdio MCP server. It gives the agents OAR launches without an
 // in-process tool surface — Grok (ACP `mcpServers`) and the Copilot CLI
 // extension engine (`--additional-mcp-config`) — the relay's real tools:
-// `remote_relay` and `preview`, bound to the one conversation it was started
+// `relay_tool` and `preview`, bound to the one conversation it was started
 // for, so the relay's mention gate and approval apply exactly as they do for
 // the Claude, Cursor and Copilot SDK workers.
 //
@@ -34,6 +34,7 @@ import {
   REMOTE_RELAY_TOOL_CALL_TIMEOUT_MS,
   REMOTE_RELAY_TOOL_DESCRIPTION,
   REMOTE_RELAY_TOOL_NAME,
+  canonicalRemoteRelayToolCallName,
   cloneRemoteRelayToolInputSchema,
   executeRemoteRelayTool,
   formatRemoteRelayToolResult,
@@ -216,10 +217,15 @@ export function createOarMcpServer({
   }
 
   async function callTool(id, params) {
-    const name = toText(params?.name);
+    // `remote_relay`, the tool's name up to 0.9.17, still dispatches while
+    // the tool is on, but is never listed: a second definition would only
+    // cost context. The hosts in use (Grok, the Copilot CLI) call only what
+    // tools/list gave them, so for them the old name is gone; a client that
+    // kept it still works.
+    const name = canonicalRemoteRelayToolCallName(params?.name);
     const tools = await listTools();
     if (!tools.some((tool) => tool.name === name)) {
-      return fail(id, JSON_RPC.invalidParams, `Unknown tool: ${name || '(none)'}`);
+      return fail(id, JSON_RPC.invalidParams, `Unknown tool: ${toText(params?.name) || '(none)'}`);
     }
     const args = params?.arguments && typeof params.arguments === 'object' && !Array.isArray(params.arguments)
       ? params.arguments
@@ -348,7 +354,7 @@ export function createOarMcpServer({
 
 /**
  * The stdio process: parse the arguments, reach the relay like a worker does,
- * decide whether `remote_relay` is listed (asked once, at startup), then serve
+ * decide whether `relay_tool` is listed (asked once, at startup), then serve
  * until stdin closes. Returns the server, or null after a startup failure.
  */
 export async function runOarMcpServer({
@@ -413,7 +419,7 @@ export async function runOarMcpServer({
     remoteRelay: Promise.resolve()
       .then(() => shouldRegisterRemoteRelayToolImpl({ api }))
       .then((enabled) => {
-        log(`serving conversation ${conversationId.slice(0, 8)}; remote_relay ${enabled ? 'on' : 'off'}`);
+        log(`serving conversation ${conversationId.slice(0, 8)}; relay_tool ${enabled ? 'on' : 'off'}`);
         return enabled;
       }),
     version: readPackageVersion(),