@oar-sh/oar 0.9.6 → 0.9.8

package/server/routes/messages-routes.mjs

@@ -43,6 +43,8 @@ import { ANSWERED_ELSEWHERE_KIND, STEER_FOLDED_TEXT } from '../../shared/steer-s
 import { isLiveResend } from '../services/steer-resend.mjs';
 import { resolveProviderModelSelection } from '../services/provider-model-selection.mjs';
 import { stripRemotePromptHeader } from '../../shared/remote-relay-contract.mjs';
+import { stripModelTierSuffix } from '../../shared/claude-cloud/repo-url.mjs';
+import { buildClaudeCloudDelivery, isClaudeCloudProviderType } from '../services/claude-cloud-session-service.mjs';
 import {
   admitRemoteRelayRequest,
   findMentionedRemoteRelays,
@@ -114,6 +116,8 @@ function normalizeRequestedProviderType(value = '') {
   // "no provider stated" and the guards below could never fire.
   if (normalized === 'grok' || normalized === 'xai' || normalized === 'xai-grok') return 'grok';
   if (normalized === 'claude' || normalized === 'anthropic') return 'claude';
+  // Its own provider, never read as `claude`.
+  if (normalized === 'claude-cloud') return 'claude-cloud';
   return '';
 }
 
@@ -121,6 +125,7 @@ const BOOTSTRAP_ONLY_PROVIDER_LABELS = Object.freeze({
   cursor: 'Cursor',
   grok: 'Grok',
   claude: 'Claude',
+  'claude-cloud': 'Claude Cloud',
 });
 
 function deriveModelOrigin(model) {
@@ -589,9 +594,17 @@ async function resolveRelayResponseText({
   }
 }
 
-export function resolveTerminalFailurePayload(payload = {}, { fallbackText = null } = {}) {
+/**
+ * `inferFromText`: whether a text shaped like a failure note counts as one
+ * when no record came with it. A session worker always sends the record
+ * (`terminalError`), so for its publishes (an `attemptId` names the attempt)
+ * the text is a reply whatever it says — a reply that names a code after
+ * fixing a failed test is a reply. Senders without an attempt (the Copilot
+ * extension, a note read from another relay) still report as text.
+ */
+export function resolveTerminalFailurePayload(payload = {}, { fallbackText = null, inferFromText = true } = {}) {
   const body = payload && typeof payload === 'object' ? payload : {};
-  const parsedTextFailure = parseTerminalFailureText(body.text);
+  const parsedTextFailure = inferFromText ? parseTerminalFailureText(body.text) : null;
   const direct = body.terminalError && typeof body.terminalError === 'object'
     ? body.terminalError
     : null;
@@ -1121,6 +1134,7 @@ export function buildDequeuedRelayMessage({
   defaultRelayMode,
   defaultModel,
   getCursorProviderSettings = () => null,
+  getClaudeCloudProviderSettings = () => null,
 } = {}) {
   if (!msg) return null;
   const attachments = parseAttachments(msg.attachments).map(hydrateAttachment).filter(Boolean);
@@ -1150,6 +1164,17 @@ export function buildDequeuedRelayMessage({
       .map((value) => String(value || '').trim())
       .filter(Boolean);
   }
+  // A Claude Cloud worker creates its session from the first delivered
+  // message and sends into it afterwards: the repository, the branch and the
+  // binding it reported ride on every message, so a restarted worker needs
+  // nothing but the delivery. Other providers never get the field.
+  const claudeCloud = isClaudeCloudProviderType(providerType)
+    ? buildClaudeCloudDelivery({
+        conversation: stmts.getConvAnyStatus?.get?.(msg.conversation_id) || null,
+        runtimeSession,
+        fallbackEnvironmentId: getClaudeCloudProviderSettings()?.environmentId || '',
+      })
+    : null;
   return {
     id: msg.id,
     conversationId: msg.conversation_id,
@@ -1163,6 +1188,7 @@ export function buildDequeuedRelayMessage({
     cursorAgentId: String(runtimeSession?.cursor_agent_id || '').trim() || null,
     cursorSubagentModels,
     grokNativeSessionId: String(runtimeSession?.grok_native_session_id || '').trim() || null,
+    ...(isClaudeCloudProviderType(providerType) ? { claudeCloud } : {}),
     reasoningEffort: String(msg.reasoning_effort || '').trim() || null,
     contextTier: String(msg.context_tier || '').trim() || 'default',
     quality: normalizeOpenAIImageQuality(msg.reasoning_effort),
@@ -1783,6 +1809,7 @@ export function registerMessagesRoutes(app, deps) {
     getClaudeProviderSettings = () => ({ enabled: false, model: '', models: [] }),
     getCursorProviderSettings = () => ({ enabled: false, model: '', models: [] }),
     getGrokProviderSettings = () => ({ enabled: false, model: '', models: [] }),
+    getClaudeCloudProviderSettings = () => ({ enabled: false, defaultModel: '', environmentId: '', models: [] }),
     rebindUnstartedOpenAIConversationModel = null,
     normalizeRelayMode,
     DEFAULT_RELAY_MODE,
@@ -4166,7 +4193,8 @@ export function registerMessagesRoutes(app, deps) {
     const runtimeBoundToExplicitProvider = runtimeProviderType === 'openai'
       || runtimeProviderType === 'claude'
       || runtimeProviderType === 'cursor'
-      || runtimeProviderType === 'grok';
+      || runtimeProviderType === 'grok'
+      || runtimeProviderType === 'claude-cloud';
     const configuredOpenAIModel = String(configuredOpenAI?.model || '').trim();
     const availableOpenAIModels = new Set(
       (Array.isArray(configuredOpenAI?.models) ? configuredOpenAI.models : [])
@@ -4290,6 +4318,17 @@ export function registerMessagesRoutes(app, deps) {
         });
       }
     }
+    // Claude Cloud conversations are bootstrap-created only as well: each
+    // carries the repository its cloud session clones. Only an explicit
+    // provider counts here — the cloud's model ids are the Claude provider's
+    // own, so an id alone never means "cloud".
+    const runtimeUsesClaudeCloud = runtimeProviderType === 'claude-cloud';
+    if (!shouldCreateConversation && !runtimeUsesClaudeCloud && requestedProviderType === 'claude-cloud') {
+      return res.status(409).json({
+        error: 'Claude Cloud requires creating a new Claude Cloud conversation',
+        code: 'CLAUDE_CLOUD_REQUIRES_NEW_CONVERSATION',
+      });
+    }
     if (
       useOpenAIProvider
       && requestedOpenAIModel
@@ -4422,6 +4461,32 @@ export function registerMessagesRoutes(app, deps) {
     const grokModel = runtimeUsesGrok
       ? (pinnedGrokModel || String(configuredGrok?.model || '').trim())
       : '';
+    // Claude Cloud conversations resolve models against the cloud provider's
+    // own list (plain ids, no "[1m]" tier). The model is part of the cloud
+    // session's configuration: it can still change before the first message
+    // creates that session, and is locked afterwards.
+    const configuredClaudeCloud = runtimeUsesClaudeCloud ? getClaudeCloudProviderSettings() : null;
+    const pinnedClaudeCloudModel = runtimeUsesClaudeCloud
+      ? stripModelTierSuffix(existingRuntimeSession?.provider_model)
+      : '';
+    const claudeCloudModelSelection = runtimeUsesClaudeCloud
+      ? resolveProviderModelSelection({
+          requestedModel: stripModelTierSuffix(model),
+          configuredModel: pinnedClaudeCloudModel || String(configuredClaudeCloud?.defaultModel || '').trim(),
+          availableModels: Array.isArray(configuredClaudeCloud?.models) ? configuredClaudeCloud.models : [],
+        })
+      : null;
+    if (claudeCloudModelSelection && !claudeCloudModelSelection.ok) {
+      return res.status(400).json({
+        error: `Claude Cloud model "${claudeCloudModelSelection.requestedModel}" is not available`,
+        code: 'CLAUDE_CLOUD_MODEL_UNAVAILABLE',
+        supportedModels: claudeCloudModelSelection.availableModels || [],
+      });
+    }
+    // A cloud session's model can be switched between turns (the worker
+    // sends set_model before the message), so a changed model is taken as
+    // for a local Claude chat.
+    const claudeCloudModel = claudeCloudModelSelection ? claudeCloudModelSelection.model : '';
     const modelResolution = useOpenAIProvider
       ? {
           ok: !!openAIModel,
@@ -4454,7 +4519,15 @@ export function registerMessagesRoutes(app, deps) {
                 reasoningEffort: null,
                 error: grokModel ? null : 'Grok model is not configured',
               }
-            : resolveRequestedModel(model))));
+            : (runtimeUsesClaudeCloud
+              ? {
+                  ok: !!claudeCloudModel,
+                  model: claudeCloudModel,
+                  modelVariantId: claudeCloudModel,
+                  reasoningEffort: null,
+                  error: claudeCloudModel ? null : 'Claude Cloud model is not configured',
+                }
+              : resolveRequestedModel(model)))));
     if (!modelResolution.ok) return res.status(400).json({ error: modelResolution.error, supportedModels: modelResolution.available || [] });
     const requestedModel = String(modelResolution.model || '').trim();
     const requestedAutoModel = requestedModel.toLowerCase() === AUTO_MODEL_SENTINEL;
@@ -4523,10 +4596,13 @@ export function registerMessagesRoutes(app, deps) {
           ? resolveCursorReasoningEffort()
           : (runtimeUsesGrok
             ? resolveGrokReasoningEffort()
-            : resolveRequestedReasoningEffort(
-                requestedModel,
-                explicitReasoningEffort || modelResolution.reasoningEffort || null,
-              ))));
+            // A cloud session takes no effort: whatever was asked, it is none.
+            : (runtimeUsesClaudeCloud
+              ? { ok: true, effort: 'none', supported: ['none'] }
+              : resolveRequestedReasoningEffort(
+                  requestedModel,
+                  explicitReasoningEffort || modelResolution.reasoningEffort || null,
+                )))));
     if (!reasoningResolution?.ok && !explicitReasoningEffort) {
       const supportedEfforts = Array.isArray(reasoningResolution?.supported)
         ? reasoningResolution.supported.map((value) => String(value || '').trim().toLowerCase()).filter(Boolean)
@@ -4553,6 +4629,9 @@ export function registerMessagesRoutes(app, deps) {
       }
     } else if (!['default', 'long_context'].includes(requestedContextTier)) {
       return res.status(400).json({ error: 'Unsupported context tier' });
+    } else if (runtimeUsesClaudeCloud) {
+      // The cloud has no long-context tier to pick.
+      normalizedContextTier = 'default';
     }
     if (!requestedRelayMode) return res.status(400).json({ error: 'Unsupported relay mode' });
     const conversationWorkspaceState = (!shouldCreateConversation && typeof resolveConversationWorkspaceState === 'function')
@@ -4784,6 +4863,17 @@ export function registerMessagesRoutes(app, deps) {
       ) {
         stmts.updateRuntimeSessionProvider.run('claude', claudeModel, claudeModel, now, runtimeSession.id);
       }
+      // A cloud conversation follows the composer like a Claude one: the
+      // worker switches the sandbox's model before the message.
+      if (
+        runtimeUsesClaudeCloud
+        && claudeCloudModel
+        && runtimeSession?.id
+        && claudeCloudModel !== String(existingRuntimeSession?.provider_model || '').trim()
+        && typeof stmts.updateRuntimeSessionProvider?.run === 'function'
+      ) {
+        stmts.updateRuntimeSessionProvider.run('claude-cloud', claudeCloudModel, claudeCloudModel, now, runtimeSession.id);
+      }
       // Another relay's agent picks the model and mode of its own turn; the
       // composer keeps restoring the user's choice for this conversation.
       conversationPreferences = remoteRequest.remote && !shouldCreateConversation
@@ -5057,7 +5147,9 @@ export function registerMessagesRoutes(app, deps) {
           // in either must reach the status payload (composer gate, bubble
           // Cancel), so it counts as a change like the hold fields do.
           || (stored.supported === true) !== (steering.supported === true)
-          || storedCancellableIds.join('\n') !== steering.cancellableIds.join('\n');
+          || storedCancellableIds.join('\n') !== steering.cancellableIds.join('\n')
+          // The running CLI's compaction window (context-usage modal).
+          || JSON.stringify(stored.autoCompactWindow ?? null) !== JSON.stringify(steering.autoCompactWindow ?? null);
         if (workerForSteering && changed) {
           sessionWorkerRegistry?.upsertWorker?.({ ...workerForSteering, steering });
           // Pushed rather than left for the clients' status poll: the
@@ -5285,7 +5377,10 @@ export function registerMessagesRoutes(app, deps) {
     if (!runtimeSession) {
       return res.status(404).json({ error: 'Runtime session not found for conversation' });
     }
-    if (String(runtimeSession.provider_type || 'github').trim().toLowerCase() !== 'claude') {
+    // The Claude Cloud worker reports the same shape (the cloud session's
+    // context and token usage), so both providers are taken here.
+    const contextUsageProvider = String(runtimeSession.provider_type || 'github').trim().toLowerCase();
+    if (contextUsageProvider !== 'claude' && contextUsageProvider !== 'claude-cloud') {
       return res.status(409).json({ error: 'Conversation is not bound to the Claude provider' });
     }
     if (typeof stmts.updateRuntimeSessionContextUsage?.run !== 'function') {
@@ -5345,13 +5440,17 @@ export function registerMessagesRoutes(app, deps) {
     // Claude-bound conversation's worker may write the Claude card. The
     // snapshot itself is global, so a misrouted poster would corrupt it for
     // everyone.
+    // A Claude Cloud worker posts here too; its report is kept under its own
+    // snapshot key, so the Claude card stays what the Claude workers wrote.
     const conversationId = String(req.body?.conversationId || '').trim();
+    let snapshotProvider = 'claude';
     if (conversationId) {
       const runtimeSession = stmts.getRuntimeSessionByConversation?.get?.(conversationId) || null;
       const boundProvider = String(runtimeSession?.provider_type || 'github').trim().toLowerCase();
-      if (runtimeSession && boundProvider !== 'claude') {
+      if (runtimeSession && boundProvider !== 'claude' && boundProvider !== 'claude-cloud') {
         return res.status(409).json({ error: 'Conversation is not bound to the Claude provider' });
       }
+      if (runtimeSession && boundProvider === 'claude-cloud') snapshotProvider = 'claude-cloud';
     }
     const usage = normalizeClaudePlanUsage(req.body?.usage)
       || claudePlanUsageFromResult({
@@ -5359,7 +5458,7 @@ export function registerMessagesRoutes(app, deps) {
         totalCostUsd: req.body?.totalCostUsd,
       });
     if (!usage) return res.status(400).json({ error: 'Missing usable usage payload' });
-    planUsageService.saveSnapshot('claude', usage, {
+    planUsageService.saveSnapshot(snapshotProvider, usage, {
       source: 'worker',
       error: String(req.body?.error || '').trim() || null,
     });
@@ -5373,12 +5472,13 @@ export function registerMessagesRoutes(app, deps) {
     touchCli();
     if (!usageLimitPauseService) return res.status(501).json({ error: 'Usage limit handling is unavailable' });
     // The report is the account's, so only a Claude-bound conversation's
-    // worker may write it (same validation as the plan usage card).
+    // worker may write it (same validation as the plan usage card); a Claude
+    // Cloud chat runs on the same account and reports the same limit.
     const conversationId = String(req.body?.conversationId || '').trim();
     if (conversationId) {
       const runtimeSession = stmts.getRuntimeSessionByConversation?.get?.(conversationId) || null;
       const boundProvider = String(runtimeSession?.provider_type || 'github').trim().toLowerCase();
-      if (runtimeSession && boundProvider !== 'claude') {
+      if (runtimeSession && boundProvider !== 'claude' && boundProvider !== 'claude-cloud') {
         return res.status(409).json({ error: 'Conversation is not bound to the Claude provider' });
       }
     }
@@ -5982,6 +6082,7 @@ export function registerMessagesRoutes(app, deps) {
         defaultRelayMode: DEFAULT_RELAY_MODE,
         defaultModel: DEFAULT_MODEL,
         getCursorProviderSettings,
+        getClaudeCloudProviderSettings,
       });
       
       if (out.attachments.length) {
@@ -6576,7 +6677,10 @@ export function registerMessagesRoutes(app, deps) {
       }
     };
     let trimmedText = String(text || '').trim();
-    let terminalFailure = resolveTerminalFailurePayload(req.body, { fallbackText: trimmedText });
+    let terminalFailure = resolveTerminalFailurePayload(req.body, {
+      fallbackText: trimmedText,
+      inferFromText: !String(req.body?.attemptId || '').trim(),
+    });
     // Final digests of background workflows that settled during this turn —
     // the transcript's "Finished background task" cards. Same structural
     // sanitizer as the live panel rows; junk entries drop silently (this
@@ -7106,7 +7210,10 @@ export function registerMessagesRoutes(app, deps) {
   // Providers whose workers turn runtime-initiated activity into continuation
   // rows: the Claude worker (background tasks/agents) and the Copilot SDK
   // worker (detached background shells) serving both Copilot-CLI providers.
-  const CONTINUATION_PROVIDER_TYPES = new Set(['claude', 'github', 'openai']);
+  // A Claude Cloud session can take a turn of its own too: one the agent
+  // starts when its background work reports back, or one started on
+  // claude.ai; the cloud worker follows it and registers it here.
+  const CONTINUATION_PROVIDER_TYPES = new Set(['claude', 'github', 'openai', 'claude-cloud']);
 
   // POST /api/continuation-turn — a session worker's CLI started a turn on its
   // own (a background task's notification). The synthetic queue row gives that

package/server/routes/remote-relay-routes.mjs

@@ -42,12 +42,15 @@ export function registerRemoteRelayRoutes(app, deps) {
     });
   });
 
-  // Workers ask at start whether to register the remote_relay tool at all.
+  // Workers ask at start whether to register the remote_relay tool at all:
+  // when a relay is paired (`count`), or when this relay's own sessions are
+  // open to its agents (`localEnabled`, the local target).
   app.get('/api/remote-relays/summary', auth, (_req, res) => {
     const relays = registry.listPublic();
     res.json({
       count: relays.length,
       online: relays.filter((relay) => relay.lastStatus === 'online').length,
+      localEnabled: registry.getAgentSessionsSettings?.().enabled === true,
     });
   });
 
@@ -111,6 +114,17 @@ export function registerRemoteRelayRoutes(app, deps) {
     sendResult(res, registry.setSelfSettings(req.body || {}));
   });
 
+  // Agent sessions: whether this relay's agents may start and use sessions on
+  // it, and the longest wait of one tool call. POST takes
+  // `{ enabled?, maxWaitSeconds? }` and answers the GET shape plus `ok`.
+  app.get('/api/settings/agent-sessions', auth, (_req, res) => {
+    res.json(registry.getAgentSessionsSettings());
+  });
+
+  app.post('/api/settings/agent-sessions', auth, (req, res) => {
+    sendResult(res, registry.setAgentSessionsSettings(req.body || {}));
+  });
+
   // PATCH /api/remote-relays/:id — { permission, url, token, tokenMode }.
   app.patch('/api/remote-relays/:id', auth, (req, res) => {
     sendResult(res, registry.update(req.params?.id, req.body || {}));