@oar-sh/oar 0.9.16 → 0.9.18

package/shared/remote-relay-contract.mjs

@@ -29,9 +29,20 @@ import {
   normalizeRelayScheduleAt,
   normalizeRelayScheduleTitle,
 } from './relay-schedules.mjs';
-import { RELAY_ASK_LIMITS, RELAY_ASK_URGENCIES, normalizeRelayAskInput } from './relay-asks.mjs';
-
-export const REMOTE_RELAY_TOOL_NAME = 'remote_relay';
+import {
+  RELAY_ASK_LIMITS,
+  RELAY_ASK_URGENCIES,
+  REMOTE_RELAY_APPROVAL_SOURCE,
+  normalizeRelayAskInput,
+} from './relay-asks.mjs';
+
+// The one name every provider lists the tool under. Up to 0.9.17 it was
+// `remote_relay`; that name is still accepted where a runtime dispatches a
+// call by name without having listed it (the OAR MCP server's tools/call),
+// and recognised in transcripts and holds, but never listed: a second
+// definition would cost every turn its context.
+export const REMOTE_RELAY_TOOL_NAME = 'relay_tool';
+export const REMOTE_RELAY_LEGACY_TOOL_NAME = 'remote_relay';
 
 // Bumped when a relay starts relying on a newer inbound behaviour of its peers.
 // 0 = a relay without this feature (reachable read/prompt only, no pairing).
@@ -154,8 +165,11 @@ export const REMOTE_RELAY_PROMPT_ACTIONS = Object.freeze(['send', 'create_sessio
 export const REMOTE_RELAY_APPROVAL_MODES = Object.freeze(['ask', 'plan']);
 
 export const REMOTE_RELAY_SESSION_SCOPES = Object.freeze(['active', 'recent', 'all']);
-export const REMOTE_RELAY_PROVIDERS = Object.freeze(['github', 'openai', 'claude', 'cursor', 'grok', 'claude-cloud']);
+export const REMOTE_RELAY_PROVIDERS = Object.freeze(['github', 'openai', 'claude', 'cursor', 'grok', 'claude-cloud', 'deepseek', 'claude-api']);
 export const REMOTE_RELAY_MODES = Object.freeze(['plan', 'ask', 'agent', 'autopilot']);
+// What `send` may name as `provider`: a Claude session's billing, the
+// subscription or the API key. Naming the other one switches the session.
+export const REMOTE_RELAY_SEND_PROVIDERS = Object.freeze(['claude', 'claude-api']);
 export const REMOTE_RELAY_IF_BUSY = Object.freeze(['queue', 'fail']);
 // Reasoning efforts differ per provider and model (none, low, medium, high,
 // xhigh, max, ultracode, ...), so the contract only checks the shape of the
@@ -447,13 +461,15 @@ export const REMOTE_RELAY_TOOL_INPUT_SCHEMA = Object.freeze({
     provider: {
       type: 'string',
       enum: [...REMOTE_RELAY_PROVIDERS],
-      description: 'create_session: provider (default: the same provider as this session).',
+      description: 'create_session: provider (default: the same provider as this session). '
+        + 'send to a Claude session: "claude" (the subscription) or "claude-api" (the API key) switches its billing from the next turn, '
+        + 'together with this message; the other billing must be set up there. Omit it to keep the session\'s billing.',
     },
     model: {
       type: 'string',
       description: 'create_session: model id (default: this session\'s model when the remote offers it, else the remote\'s default). '
         + 'send: switch the remote session to this model (default: it keeps its own). update_session: the session\'s model from now on. '
-        + 'Must be an id relay_info lists for the provider (Claude also takes "opus", "sonnet", "haiku"): '
+        + 'Must be an id relay_info lists for the provider (Claude and Claude API also take "opus", "sonnet", "haiku"): '
         + 'an unknown id is refused with the close matches, nothing created or sent.',
     },
     cwd: {
@@ -660,7 +676,7 @@ export const REMOTE_RELAY_ACTION_ARGUMENTS = Object.freeze({
   read_session: Object.freeze(['session', 'last', 'before', 'include_activity', 'max_chars']),
   read_task_output: Object.freeze(['session', 'task_id', 'lines']),
   wait: Object.freeze(['session', 'message_id', 'wait_seconds']),
-  send: Object.freeze(['session', 'text', 'wait_seconds', 'model', 'mode', 'effort', 'if_busy']),
+  send: Object.freeze(['session', 'text', 'wait_seconds', 'model', 'mode', 'effort', 'if_busy', 'provider']),
   create_session: Object.freeze(['text', 'provider', 'model', 'cwd', 'repo', 'branch', 'mode', 'effort', 'title', 'group', 'wait_seconds']),
   update_session: Object.freeze(['session', ...REMOTE_RELAY_SESSION_SETTINGS]),
   answer_question: Object.freeze(['question_id', 'answer', 'choices']),
@@ -867,6 +883,10 @@ function validateToolInput(input, { maxWaitSeconds, now } = {}) {
       const busyCheck = optionalEnum('if_busy', REMOTE_RELAY_IF_BUSY);
       if (!busyCheck.ok) return busyCheck;
       args.if_busy = args.if_busy || 'queue';
+      const providerCheck = optionalEnum('provider', REMOTE_RELAY_SEND_PROVIDERS);
+      if (!providerCheck.ok) {
+        return invalid('send takes provider "claude" (the subscription) or "claude-api" (the API key), for a Claude session only');
+      }
     } else {
       const providerCheck = optionalEnum('provider', REMOTE_RELAY_PROVIDERS);
       if (!providerCheck.ok) return providerCheck;
@@ -1222,8 +1242,8 @@ export function formatSessionGroupList(groups, max = REMOTE_RELAY_GROUP_LIMITS.r
 // another relay (ask / plan mode) is an ordinary relay question whose
 // `context.source` is this. Only that relay's user may answer it: its question
 // routes hide the card from other relays' agents and refuse their answers, and
-// a dispatcher never offers one to its agent.
-export const REMOTE_RELAY_APPROVAL_SOURCE = 'remote_relay';
+// a dispatcher never offers one to its agent. Defined in relay-asks.mjs.
+export { REMOTE_RELAY_APPROVAL_SOURCE };
 
 /** True for such a card: a formatted question, or a stored request envelope (both carry `context`). */
 export function isRemoteRelayApprovalQuestion(question) {

package/shared/remote-relay-tool-core.mjs

@@ -1,4 +1,4 @@
-// The provider-facing side of the `remote_relay` tool, in one place.
+// The provider-facing side of the `relay_tool` tool, in one place.
 //
 // Every adapter (Claude's in-process MCP server, Cursor's customTools, the
 // Copilot SDK engine's session tools, and the OAR stdio MCP server that Grok
@@ -16,12 +16,14 @@ import {
   REMOTE_RELAY_TOOL_DESCRIPTION,
   REMOTE_RELAY_TOOL_ENDPOINT,
   REMOTE_RELAY_TOOL_INPUT_SCHEMA,
+  REMOTE_RELAY_LEGACY_TOOL_NAME,
   REMOTE_RELAY_TOOL_NAME,
   summarizeRemoteRelayCall,
   validateRemoteRelayToolInput,
 } from './remote-relay-contract.mjs';
 
 export {
+  REMOTE_RELAY_LEGACY_TOOL_NAME,
   REMOTE_RELAY_TOOL_DESCRIPTION,
   REMOTE_RELAY_TOOL_ENDPOINT,
   REMOTE_RELAY_TOOL_INPUT_SCHEMA,
@@ -141,7 +143,7 @@ export function remoteRelayCancelledResult() {
 }
 
 /**
- * Executes one `remote_relay` call: validate, then forward
+ * Executes one `relay_tool` call: validate, then forward
  * `{ conversationId, action, args }` to the local relay and hand back its JSON.
  * Never throws — a refusal reads as an answer the model can act on, the same
  * contract as executePreviewTool.
@@ -256,7 +258,7 @@ export function createRemoteRelayToolGate({
 }
 
 /**
- * How many remote_relay calls of this conversation the relay is still working
+ * How many relay_tool calls of this conversation the relay is still working
  * on. 0 on any failure: the caller's watchdog then does what it would have
  * done without the question.
  */
@@ -292,14 +294,29 @@ export function formatRemoteRelayToolResult(result) {
 // ─── Activity lines ──────────────────────────────────────────────────────────
 
 // A provider may report the tool under its bare name or namespaced by the MCP
-// server that carries it (`mcp__relay__remote_relay`, `oar__remote_relay`,
-// `oar/remote_relay`, `oar-remote_relay`); all of them are this tool.
-const REMOTE_RELAY_NAME_PATTERN = new RegExp(`(?:^|__|[^A-Za-z0-9_])${REMOTE_RELAY_TOOL_NAME}$`, 'i');
+// server that carries it (`mcp__relay__relay_tool`, `oar__relay_tool`,
+// `oar/relay_tool`, `oar-relay_tool`); all of them are this tool. So is the
+// name it had before, `remote_relay`, in every spelling: transcripts and
+// sessions from before the rename still render and hold the same way.
+const REMOTE_RELAY_NAME_PATTERN = new RegExp(
+  `(?:^|__|[^A-Za-z0-9_])(?:${REMOTE_RELAY_TOOL_NAME}|${REMOTE_RELAY_LEGACY_TOOL_NAME})$`,
+  'i',
+);
 
 export function isRemoteRelayToolName(name) {
   return REMOTE_RELAY_NAME_PATTERN.test(toText(name));
 }
 
+/**
+ * The tool's listed name for a bare call name that means it: `relay_tool`
+ * itself, or the legacy `remote_relay` a dispatcher still accepts without
+ * listing it. Any other name comes back unchanged.
+ */
+export function canonicalRemoteRelayToolCallName(name) {
+  const text = toText(name);
+  return text === REMOTE_RELAY_LEGACY_TOOL_NAME ? REMOTE_RELAY_TOOL_NAME : text;
+}
+
 /**
  * The arguments of a tool call as an object, whether the provider delivered
  * them parsed or as a JSON string. Null when there is nothing usable.

package/shared/steer-settle-failure.mjs

@@ -85,6 +85,8 @@ export function steerAgentLabelForProvider(providerType) {
     case 'cursor': return 'Cursor';
     case 'grok': return 'Grok';
     case 'claude-cloud': return 'Claude Cloud';
+    case 'deepseek': return 'DeepSeek';
+    case 'claude-api': return 'Claude API';
     default: return DEFAULT_STEER_AGENT_LABEL;
   }
 }

package/shared/worker-runtime/api-client.mjs

@@ -19,7 +19,7 @@ function httpError(status, routePath, text) {
   error.status = status;
   error.detail = detail;
   // The parsed error body, for callers that pass the relay's answer on as
-  // is (a refused remote_relay call carries its code there).
+  // is (a refused relay_tool call carries its code there).
   error.body = payload && typeof payload === "object" ? payload : null;
   return error;
 }
@@ -89,7 +89,7 @@ function requestWithoutTimeout({ url, method, headers, payload, signal }) {
 export function createApiClient({ serverUrl, token, getHeaders }) {
   /**
    * `options.longCall`: a call the relay may legitimately hold open for many
-   * minutes (the remote_relay tool) — it goes over node:http without any
+   * minutes (the relay_tool) — it goes over node:http without any
    * timeout instead of fetch. `options.signal` aborts either kind; an aborted
    * call rejects with an AbortError.
    */

package/shared/worker-runtime/direct-openai-image.mjs

@@ -0,0 +1,128 @@
+// A turn on an OpenAI image model (`gpt-image-*`, `dall-e-*`) is no chat
+// turn: no chat runtime can serve it, and one that is handed it fails ("No
+// available capacity was found for the model", or a request rejected as
+// invalid). Both Copilot engines therefore send it straight to the relay's
+// image routes instead, and this module is the one copy of that path.
+//
+// With image continuity on (the default) the relay created an image operation
+// when the message was sent, and `POST /api/image-operations/:id/execute` does
+// everything: the provider call, the generated-image reply, and on a failure
+// the failure note or the requeue. The caller only reports the outcome. Without
+// an operation the worker calls `POST /api/openai/images/generate` and
+// publishes the reply itself.
+
+export const DIRECT_IMAGE_OUTCOMES = Object.freeze(['completed', 'executing', 'terminal', 'uncertain', 'retryable']);
+
+// The code of the error thrown when the provider refused the request outright:
+// a retry would be refused the same way, so the turn fails instead of being
+// requeued.
+export const OPENAI_IMAGE_TERMINAL_CODE = 'RELAY_OPENAI_IMAGE_TERMINAL';
+
+export function shouldUseDirectOpenAIImageApi(message = {}) {
+  const providerType = String(message?.providerType || '').trim().toLowerCase();
+  if (providerType !== 'openai') return false;
+  const model = String(message?.providerModel || message?.model || '').trim().toLowerCase();
+  return model.startsWith('gpt-image-') || model.startsWith('dall-e-');
+}
+
+export function isDirectOpenAIImageTerminalStatus(status) {
+  const numeric = Number(status);
+  if (!Number.isFinite(numeric)) return false;
+  return [400, 401, 403, 404, 409, 422, 429, 503].includes(numeric);
+}
+
+export function isOpenAIImageTerminalError(error) {
+  return String(error?.code || '').trim() === OPENAI_IMAGE_TERMINAL_CODE;
+}
+
+const isAutoModel = (value) => String(value || '').trim().toLowerCase() === 'auto';
+
+/**
+ * Run one image turn. `requestOptions` goes to every `api` call that may wait
+ * on the provider (a worker passes `{ longCall: true }`: an edit can take
+ * minutes); `responseFields` is merged into the reply the worker publishes
+ * itself (the attempt fence).
+ *
+ * Resolves `{ via: 'operation', outcome }` or `{ via: 'direct', outcome:
+ * 'completed', imageCount, model }`. Throws an error with `code`
+ * `OPENAI_IMAGE_TERMINAL_CODE` when the provider refused the direct request,
+ * and a plain error for anything else (the caller requeues).
+ */
+export async function runDirectOpenAIImageTurn({
+  api,
+  message,
+  requestOptions = {},
+  responseFields = {},
+} = {}) {
+  if (message?.imageOperationId) {
+    const result = await api(
+      'POST',
+      `/api/image-operations/${encodeURIComponent(message.imageOperationId)}/execute`,
+      { messageId: message.id },
+      requestOptions,
+    ).catch((error) => {
+      // The route answers a failure it already handled (published or
+      // requeued) with 409 or 503 and the outcome in the body.
+      if (error?.status === 409 || error?.status === 503) {
+        return error?.body || error?.payload || { outcome: error?.status === 503 ? 'retryable' : 'terminal' };
+      }
+      throw error;
+    });
+    const outcome = String(result?.outcome || '').trim().toLowerCase();
+    if (!DIRECT_IMAGE_OUTCOMES.includes(outcome)) {
+      throw new Error('Image operation returned an invalid outcome');
+    }
+    return { via: 'operation', outcome };
+  }
+
+  const requestedModel = isAutoModel(message?.model) ? '' : String(message?.model || '').trim();
+  const directModel = String(message?.providerModel || requestedModel || message?.model || '').trim();
+  const prompt = String(message?.text || '').trim();
+  if (!directModel) throw new Error('OpenAI image request is missing model');
+  if (!prompt) throw new Error('OpenAI image request is missing prompt');
+  await api('POST', '/api/activity', {
+    messageId: message.id,
+    conversationId: message.conversationId,
+    mode: message.relayMode || 'agent',
+    text: `Calling OpenAI image API directly (${directModel})`,
+  }).catch(() => {});
+  let directResult;
+  try {
+    directResult = await api('POST', '/api/openai/images/generate', {
+      messageId: message.id,
+      conversationId: message.conversationId,
+      model: directModel,
+      prompt,
+      n: message?.n,
+      size: message?.size || message?.contextTier,
+      quality: message?.quality || message?.reasoningEffort,
+      attachments: Array.isArray(message?.attachments) ? message.attachments : [],
+    }, requestOptions);
+  } catch (error) {
+    if (isDirectOpenAIImageTerminalStatus(error?.status)) {
+      const terminalError = new Error(
+        `OpenAI image request failed: ${error?.detail || `HTTP ${error?.status || 'error'}`}`,
+      );
+      terminalError.code = OPENAI_IMAGE_TERMINAL_CODE;
+      terminalError.status = error?.status;
+      terminalError.detail = error?.detail || null;
+      throw terminalError;
+    }
+    throw error;
+  }
+  const generatedImages = Array.isArray(directResult?.generatedImages) ? directResult.generatedImages : [];
+  if (!generatedImages.length) {
+    throw new Error('OpenAI image API returned no images');
+  }
+  const model = String(directResult?.model || directModel).trim() || directModel;
+  await api('POST', '/api/response', {
+    messageId: message.id,
+    conversationId: message.conversationId,
+    text: '',
+    generatedImages,
+    model,
+    modelOrigin: isAutoModel(message?.model) ? 'auto' : 'manual',
+    ...responseFields,
+  });
+  return { via: 'direct', outcome: 'completed', imageCount: generatedImages.length, model };
+}

package/shared/worker-runtime/heartbeat.mjs

@@ -33,6 +33,10 @@ export function createHeartbeatController({
   // Optional: called after every beat the relay answered, for work that
   // waits for a reachable relay (posts kept after a failure).
   onAnswered = () => {},
+  // Optional: the kind of worker this is ("claude", "claude-api", ...). The
+  // relay hands a Claude chat's row only to a worker of the row's billing,
+  // and knows a worker's kind from what it says here and in its hello.
+  workerKind = null,
   // requestPulse's window: one turn transition can flip the steering
   // snapshot several times in quick succession, and each flip only needs to
   // reach the relay once.
@@ -66,6 +70,7 @@ export function createHeartbeatController({
         ...(steering && typeof steering === "object" ? { steering } : {}),
         ...(settleFailed.length ? { settleFailed } : {}),
         ...(Array.isArray(backgroundTaskIds) ? { backgroundTasks: backgroundTaskDigest(backgroundTaskIds) } : {}),
+        ...(workerKind ? { workerKind: String(workerKind) } : {}),
       };
       const response = await api("POST", "/api/heartbeat", body);
       // Failed by the relay, or skipped because this worker has no claim on

package/shared/worker-runtime/worker-log-file.mjs

@@ -95,3 +95,63 @@ export function installWorkerLogFile({
     },
   };
 }
+
+const REDACTED_SECRET_TEXT = '[redacted]';
+// As the relay's redaction of worker posts (server/services/worker-secret-redaction.mjs):
+// a shorter value would mangle ordinary text.
+const MIN_REDACTED_SECRET_LENGTH = 8;
+
+/**
+ * Replaces each secret's exact text with `[redacted]` in what the worker
+ * writes to stdout/stderr, on every platform: the console, the Linux
+ * launcher's redirect into the worker log, and the Windows copy above (install
+ * this after installWorkerLogFile so the copy gets the redacted text). A
+ * secret split across two writes is not caught; the worker logs whole lines.
+ * Returns null when there is no secret of at least 8 characters.
+ */
+export function installWorkerLogRedaction({
+  secrets = [],
+  processImpl = process,
+} = {}) {
+  const values = [...new Set((Array.isArray(secrets) ? secrets : [])
+    .map((value) => String(value ?? '').trim())
+    .filter((value) => value.length >= MIN_REDACTED_SECRET_LENGTH))]
+    .sort((a, b) => b.length - a.length);
+  if (!values.length) return null;
+
+  const redact = (text) => {
+    let output = text;
+    for (const value of values) {
+      if (output.includes(value)) output = output.split(value).join(REDACTED_SECRET_TEXT);
+    }
+    return output;
+  };
+
+  const restores = [];
+  for (const stream of [processImpl.stdout, processImpl.stderr]) {
+    if (!stream || typeof stream.write !== 'function') continue;
+    const originalWrite = stream.write;
+    const redactingWrite = function redactingWrite(chunk, encoding, callback) {
+      if (typeof chunk === 'string') {
+        return originalWrite.call(this, redact(chunk), encoding, callback);
+      }
+      if (chunk instanceof Uint8Array) {
+        const bytes = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+        if (values.some((value) => bytes.includes(value))) {
+          const done = typeof encoding === 'function' ? encoding : callback;
+          return originalWrite.call(this, redact(bytes.toString('utf8')), 'utf8', done);
+        }
+      }
+      return originalWrite.call(this, chunk, encoding, callback);
+    };
+    stream.write = redactingWrite;
+    restores.push(() => {
+      if (stream.write === redactingWrite) stream.write = originalWrite;
+    });
+  }
+  return {
+    uninstall() {
+      for (const restore of restores) restore();
+    },
+  };
+}

package/shared/worker-runtime/worker-websocket-link.mjs

@@ -66,6 +66,10 @@ export function createWorkerWebSocketLink({
   onServerHello = () => {},
   getSessionId = () => null,
   getPid = () => null,
+  // The kind of worker this is ("claude", "claude-api", ...), stated in
+  // every hello and ready: the relay hands a Claude chat's row only to a
+  // worker of the row's billing.
+  workerKind = null,
   minBackoffMs = 1000,
   maxBackoffMs = 8_000,
   jitterMs = 250,
@@ -170,6 +174,7 @@ export function createWorkerWebSocketLink({
       reason,
       sessionId: normalizeText(getSessionId()),
       pid: normalizePositiveInt(getPid()),
+      ...(normalizeText(workerKind) ? { kind: normalizeText(workerKind) } : {}),
       ...(held ? { ready: false } : {}),
     });
     if (sent) lastHelloSentAt = getNowMs();
@@ -197,6 +202,7 @@ export function createWorkerWebSocketLink({
       reason,
       sessionId: normalizeText(getSessionId()),
       pid: normalizePositiveInt(getPid()),
+      ...(normalizeText(workerKind) ? { kind: normalizeText(workerKind) } : {}),
     });
     if (sent) lastReadySentAt = getNowMs();
     return sent;