clay-server 5.2.0-beta.5 → 5.2.0-beta.6

package/lib/sdk-foreground-admission.js

@@ -0,0 +1,16 @@
+// One next-message admission window, bound to the exact live provider query.
+// This is not turn completion: processing and pending terminal counts survive.
+function available(session) {
+  var credit = session && session._foregroundAdmission;
+  return !!(credit && session.queryInstance === credit.query
+    && Number(session._sdkQueryGeneration || 0) === credit.generation
+    && !session.taskStopRequested && !session._pendingMessageDrainPaused
+    && !(session.abortController && session.abortController.signal.aborted));
+}
+function offer(session) {
+  if (!session.queryInstance || session.taskStopRequested || session.abortController && session.abortController.signal.aborted) return false;
+  session._foregroundAdmission = { query: session.queryInstance, generation: Number(session._sdkQueryGeneration || 0) };
+  return true;
+}
+function take(session) { delete session._foregroundAdmission; }
+module.exports = { available: available, offer: offer, take: take };

package/lib/sdk-mcp-descriptors.js

@@ -1,37 +1,2 @@
-// Extract serializable tool descriptors from MCP server instances.
-// Used for IPC to worker processes (McpSdkServerConfigWithInstance is not serializable).
-function extractMcpDescriptors(mcpServers) {
-  if (!mcpServers) return null;
-  // Claude's adapter uses Zod v3 for JSON Schema tools; other servers use v4.
-  // Use the MCP SDK's version-aware converter for both kinds of registered tool.
-  var toJSONSchema = require("@modelcontextprotocol/sdk/server/zod-json-schema-compat.js").toJsonSchemaCompat;
-  var descriptors = [];
-  var names = Object.keys(mcpServers);
-  for (var i = 0; i < names.length; i++) {
-    var serverName = names[i];
-    var server = mcpServers[serverName];
-    if (!server || !server.instance || !server.instance._registeredTools) continue;
-    var tools = [];
-    var toolNames = Object.keys(server.instance._registeredTools);
-    for (var j = 0; j < toolNames.length; j++) {
-      var toolName = toolNames[j];
-      var toolDef = server.instance._registeredTools[toolName];
-      var inputSchema = { type: "object", properties: {} };
-      try {
-        if (toolDef._clayInputSchema) inputSchema = toolDef._clayInputSchema;
-        else if (toolDef.inputSchema) inputSchema = toJSONSchema(toolDef.inputSchema);
-      } catch (e) {
-        throw new Error("Cannot serialize MCP tool schema " + serverName + "/" + toolName + ": " + e.message);
-      }
-      tools.push({
-        name: toolName,
-        description: toolDef.description || toolName,
-        inputSchema: inputSchema,
-      });
-    }
-    if (tools.length > 0) descriptors.push({ serverName: serverName, tools: tools });
-  }
-  return descriptors.length > 0 ? descriptors : null;
-}
-
-module.exports = { extractMcpDescriptors: extractMcpDescriptors };
+// Compatibility export; SDK serialization is owned by YOKE.
+module.exports = require("./yoke/sdk-mcp-descriptors");

package/lib/sdk-message-processor.js

@@ -42,9 +42,20 @@ function attachMessageProcessor(ctx) {
   }
 
   function sendAndRecord(session, obj, clientObj) {
+    obj = require("./yoke/usage").clientEvent(obj, session.vendor || "claude");
     sm.sendAndRecord(session, obj, clientObj);
   }
 
+  function recordTurnActivity(session, activity) {
+    // An authoritative input card owns progress until its request settles.
+    var awaitingInput = ["pendingPermissions", "pendingAskUser", "pendingElicitations", "pendingUserDialogs"].some(function (key) {
+      return Object.keys(session[key] || {}).length > 0;
+    });
+    if (!awaitingInput && ["waiting", "running", "background"].indexOf(activity.phase) !== -1) sendAndRecord(session, {
+      type: "turn_activity", phase: activity.phase, turnId: activity.turnId || null, disposition: activity.disposition || null
+    });
+  }
+
   function parseGeneratedImage(parsed) {
     var data = parsed.data || "";
     var mediaType = parsed.mediaType || "image/png";
@@ -77,8 +88,8 @@ function attachMessageProcessor(ctx) {
       || !!authLinuxUser
       || (authUser && authUser.role === "admin");
     var vendorInfo = yoke.getVendorInfo(session.vendor);
-    var authTitle = ((vendorInfo && vendorInfo.displayName) || "Claude Code") + " is not logged in.";
-    var loginCommand = (vendorInfo && vendorInfo.loginCommand) || "claude login";
+    var authTitle = ((vendorInfo && vendorInfo.displayName) || "The provider") + " is not logged in.";
+    var loginCommand = (vendorInfo && vendorInfo.loginCommand) || "";
     var _nmLogin = getNotificationsModule();
     // Authentication recovery is transient UI state, not transcript content.
     // Recording it makes history replay look like a fresh auth failure and
@@ -163,6 +174,7 @@ function attachMessageProcessor(ctx) {
   }
 
   function processSDKMessage(session, parsed) {
+    parsed = require("./yoke/auth-events").normalize(parsed, session.responsePreview, session.vendor || "claude");
     // Timing: log key SDK milestones relative to query start
     if (session._queryStartTs) {
       var _elapsed = Date.now() - session._queryStartTs;
@@ -378,7 +390,7 @@ function attachMessageProcessor(ctx) {
       }) : [];
       sendAndRecord(session, {
         type: "tool_executing",
-        id: parsed.turnId || "codex-plan",
+        id: parsed.turnId || "provider-plan",
         name: "TodoWrite",
         input: {
           todos: todos,
@@ -546,7 +558,32 @@ function attachMessageProcessor(ctx) {
         }
       }
 
+    } else if (parsed.yokeType === "turn_activity") {
+      recordTurnActivity(session, parsed);
+    } else if (parsed.yokeType === "foreground_available") {
+      // A provider observed an admission boundary while background work still
+      // owns its terminal. Do not synthesize success or clear processing/tasks.
+      // Persist the presentation boundary before a synchronous next admission.
+      sendAndRecord(session, { type: "assistant_boundary" });
+      recordTurnActivity(session, { phase: "background" });
+      if (require('./sdk-foreground-admission').offer(session) && opts && typeof opts.onSessionAvailable === 'function') opts.onSessionAvailable(session);
     } else if (parsed.yokeType === "result") {
+      if (parsed.backgroundOnly === true) {
+        // Observed terminal of an older foreground turn. Account for the
+        // outstanding send without settling a newer turn's reviews/callbacks.
+        session._queuedTurnCount = turnQueue.pendingSends(session, parsed);
+        if (session._queuedTurnCount > 0) session._queuedTurnCount--;
+        else {
+          session.isProcessing = false;
+          session._awaitingTurnResult = false;
+          onProcessingChanged();
+          sendAndRecord(session, { type: "done", code: 0 });
+        }
+        sendAndRecord(session, { type: "background_result", usage: require('./yoke/usage').accounting(parsed.usage), cost: parsed.cost, duration: parsed.duration });
+        sm.broadcastSessionList();
+        if (opts && typeof opts.onSessionAvailable === 'function') opts.onSessionAvailable(session);
+        return;
+      }
       // SDK 0.3.274 batches queued background-task completion wakes into one
       // model call. Every wake still emits a result, but all results before
       // the final wake are successful task-notification-origin placeholders
@@ -616,7 +653,7 @@ function attachMessageProcessor(ctx) {
         session._queuedTurnCount = 0;
         taskLifecycle.clearAll(session);
         onProcessingChanged();
-        sendAndRecord(session, { type: "error", text: "Claude failed to start: " + parsed.startupFailureReason });
+        sendAndRecord(session, { type: "error", text: "The provider failed to start: " + parsed.startupFailureReason });
         sendAndRecord(session, { type: "done", code: 1 });
         sm.broadcastSessionList();
         return;
@@ -657,12 +694,6 @@ function attachMessageProcessor(ctx) {
         onProcessingChanged();
       }
       // Recognize only short, zero-cost CLI login responses, not ordinary prose.
-      var previewTrimmed = (session.responsePreview || "").trim();
-      var isZeroCost = !parsed.cost || parsed.cost === 0;
-      var isLoginPrompt = isZeroCost && previewTrimmed.length < 100
-        && ((/not logged in/i.test(previewTrimmed) && /\/login/i.test(previewTrimmed))
-          || ((session.vendor || "claude") === "claude"
-            && /^Failed to authenticate: OAuth session expired and could not be refreshed\.?$/i.test(previewTrimmed)));
       // Fetch rich context usage breakdown (fire-and-forget, non-blocking)
       if (session.queryInstance && typeof session.queryInstance.getContextUsage === "function") {
         var contextQuery = session.queryInstance;
@@ -684,7 +715,8 @@ function attachMessageProcessor(ctx) {
         type: "result",
         cost: parsed.cost,
         duration: parsed.duration,
-        usage: parsed.usage || null,
+        usage: require("./yoke/usage").accounting(parsed.usage),
+        context: require("./yoke/usage").turnContext(Object.assign({}, parsed, { lastStreamInputTokens: lastStreamInput })),
         modelUsage: parsed.modelUsage || null,
         sessionId: parsed.sessionId,
         lastStreamInputTokens: lastStreamInput,
@@ -699,7 +731,7 @@ function attachMessageProcessor(ctx) {
       }
       // Recover both missing login and expired OAuth sessions from the SDK.
       // This is a short canned response with zero cost, not actual AI output.
-      if (isLoginPrompt) {
+      if (parsed.authenticationRequired === true) {
         emitAuthRequired(session);
       }
       sendAndRecord(session, { type: "done", code: 0 });
@@ -887,7 +919,7 @@ function attachMessageProcessor(ctx) {
           resetsAt: info.resetsAt ? info.resetsAt * 1000 : null,
           rateLimitType: info.rateLimitType || null,
           utilization: info.utilization || null,
-          isUsingOverage: info.isUsingOverage === true || info.overageInUse === true,
+          isUsingOverage: info.isUsingOverage === true,
           overageEnabled: typeof info.overageEnabled === "boolean" ? info.overageEnabled : null,
           overageStatus: info.overageStatus || null,
           overageResetsAt: info.overageResetsAt ? info.overageResetsAt * 1000 : null,
@@ -979,6 +1011,7 @@ function attachMessageProcessor(ctx) {
       }
 
     } else if (parsed.yokeType === "commands_changed") {
+      if (Array.isArray(parsed.skills)) session.skillNames = parsed.skills.slice();
       // Mid-session command list change: rebuild the union with skills (same as
       // init) and push a full replacement to the client.
       var cmdSeen = new Set();
@@ -1053,12 +1086,12 @@ function attachMessageProcessor(ctx) {
       // processQueryStream can finish the turn when the iterator closes.
       var adapterErrorText = parsed.text || parsed.message || parsed.error || "Agent runtime error";
       session._lastAdapterError = adapterErrorText;
-      var isSessionWriterConflict = /thread-store conflict|already has an active writer/i.test(adapterErrorText);
-      if (isSessionWriterConflict) {
+      var classifiedError = require("./yoke/errors").classify(session.vendor || "claude", adapterErrorText);
+      if (classifiedError && classifiedError.kind === "session_writer_conflict") {
         sendAndRecord(session, {
           type: "session_writer_conflict",
-          vendor: session.vendor || "codex",
-          text: "This Codex session is already open in another Clay or Codex process. Stop the other server or close the other session, then try again.",
+          vendor: session.vendor || "claude",
+          text: classifiedError.text,
         });
       } else {
         sendAndRecord(session, { type: "error", text: adapterErrorText });

package/lib/sdk-quota-snapshot.js

@@ -9,6 +9,7 @@ function recordQuotaSnapshot(session, info, sendAndRecord) {
       return Object.assign({}, window, { resetsAt: window.resetsAt ? window.resetsAt * 1000 : null });
     }),
   };
+  if (Number.isFinite(info.observedAtMs)) message.observedAtMs = info.observedAtMs;
   var snapshots = session._quotaSnapshots || (session._quotaSnapshots = Object.create(null));
   var key = JSON.stringify([session.ownerId, session.vendor, info.limitId]);
   var serialized = JSON.stringify(message);
@@ -20,7 +21,6 @@ function recordQuotaSnapshot(session, info, sendAndRecord) {
 function attachQuotaSnapshots(sm) {
   if (typeof sm.addOnSessionViewed !== "function") return;
   sm.addOnSessionViewed(function (session, ws, send) {
-    if (session.vendor !== "codex") return;
     var seen = Object.create(null);
     var history = session.history || [];
     // A deduplicated snapshot may precede the initial page of chat history.

package/lib/sdk-response-recovery.js

@@ -1,155 +1 @@
-// Claude delivery watchdog. Only an unanswered foreground turn is replayable.
-function attachResponseRecovery(ctx) {
-  var states = new Map();
-  var schedule = ctx.setTimeout || setTimeout;
-  var unschedule = ctx.clearTimeout || clearTimeout;
-  var waitMs = ctx.waitMs || 180000;
-  var stopMs = ctx.stopMs || 10000;
-
-  function live(session, state) {
-    return states.get(session) === state && !session.destroying && !session.taskStopRequested
-      && state.ownerId === session.ownerId && state.vendor === session.vendor
-      && (!ctx.sessions || ctx.sessions.get(session.localId) === session);
-  }
-  function clearTimer(state) {
-    if (state.timer) unschedule(state.timer);
-    state.timer = null;
-  }
-  function cancel(session, expected) {
-    var state = states.get(session);
-    if (expected && state !== expected) return;
-    if (state) clearTimer(state);
-    states.delete(session);
-  }
-  function protectedWait(session) {
-    return [session.pendingPermissions, session.pendingAskUser, session.pendingElicitations,
-      session.pendingUserDialogs, session.activeTaskToolIds].some(function(map) {
-      return map && Object.keys(map).length > 0;
-    }) || (session.activeBackgroundTasks && session.activeBackgroundTasks.length > 0);
-  }
-  function arm(session, state) {
-    clearTimer(state);
-    if (!state.turns.length || state.turns[0].progress || state.stopping) return;
-    state.timer = schedule(function() { expire(session, state); }, waitMs);
-    if (state.timer && state.timer.unref) state.timer.unref();
-  }
-  function snapshot(payload) {
-    return Object.assign({}, payload, { images: payload.images ? JSON.parse(JSON.stringify(payload.images)) : payload.images });
-  }
-  function begin(session, payload, retryState) {
-    if (retryState) return retryState;
-    cancel(session);
-    var state = { turns: [snapshot(payload)], timer: null, stopping: false, retried: false, ownerId: session.ownerId, vendor: session.vendor };
-    states.set(session, state);
-    arm(session, state);
-    return state;
-  }
-  function enqueue(session, payload) {
-    var state = states.get(session);
-    if (!state) return begin(session, payload);
-    state.turns.push(snapshot(payload));
-    return state;
-  }
-  function progress(session) {
-    var state = states.get(session);
-    if (!state || state.stopping || !state.turns.length) return;
-    state.turns[0].progress = true;
-    clearTimer(state);
-  }
-  function event(session, msg) {
-    var state = states.get(session);
-    if (!state || state.stopping || !msg) return;
-    var type = msg.yokeType;
-    if (type === 'error' || type === 'interrupted') { cancel(session); return; }
-    if (type === 'result') {
-      if (msg.subtype === 'success' && !msg.is_error && msg.numTurns === 0
-          && msg.origin && msg.origin.kind === 'task-notification'
-          && !msg.localCommand && msg.resultText === '') return;
-      var remaining = require('./sdk-turn-queue').pendingSends(session, msg);
-      state.turns = remaining ? state.turns.slice(-remaining) : [];
-      state.retried = false;
-      arm(session, state);
-      if (!state.turns.length) cancel(session);
-    } else if ((type === 'text_delta' || type === 'thinking_delta') && (msg.text || msg.delta)
-        || type === 'tool_start' || type === 'tool_input_delta' || type === 'tool_progress'
-        || type === 'task_started' || type === 'task_progress' || type === 'subagent_message'
-        || type === 'message' && msg.messageRole === 'assistant' && msg.content && msg.content.length) {
-      progress(session);
-    }
-  }
-  function finish(session, state, text) {
-    if (!live(session, state)) { cancel(session, state); return; }
-    cancel(session);
-    // Fence late output when a transport cannot confirm termination.
-    session._sdkQueryGeneration = Number(session._sdkQueryGeneration || 0) + 1;
-    session.isProcessing = false;
-    session._awaitingTurnResult = false;
-    session._queuedTurnCount = 0;
-    ctx.changed();
-    ctx.record(session, { type: 'thinking_stop' });
-    ctx.record(session, { type: 'error', text: text });
-    ctx.record(session, { type: 'done', code: 1 });
-    ctx.broadcast();
-  }
-  async function expire(session, state) {
-    clearTimer(state);
-    if (!live(session, state)) { cancel(session, state); return; }
-    // Never stop a known tool or a human decision because prose is absent.
-    if (protectedWait(session)) { progress(session); return; }
-    state.stopping = true;
-    ctx.record(session, { type: 'info', text: 'Claude has not responded for three minutes. Stopping this attempt safely before retrying.' });
-    var timeout;
-    var stopped = false;
-    try {
-      var stopAttempt = (async function() {
-        var handle = session.queryInstance || state.handle;
-        if (!handle && session.abortController) session.abortController.abort();
-        if (!handle && state.starting) await state.starting;
-        handle = handle || session.queryInstance || state.handle;
-        if (handle) {
-          if (typeof handle.stopAndWait !== 'function') return false;
-          await handle.stopAndWait();
-          if (session.streamPromise) await session.streamPromise;
-        }
-        return true;
-      })();
-      session._responseRecoveryStopPending = stopAttempt;
-      stopAttempt.then(function(confirmed) {
-        if (confirmed && session._responseRecoveryStopPending === stopAttempt) session._responseRecoveryStopPending = null;
-      }, function() {});
-      stopped = await Promise.race([
-        stopAttempt,
-        new Promise(function(resolve) { timeout = schedule(function() { resolve(false); }, stopMs); }),
-      ]);
-    } catch (e) { stopped = false; }
-    if (timeout) unschedule(timeout);
-    if (!live(session, state)) { cancel(session, state); return; }
-    if (!stopped) {
-      finish(session, state, 'Claude could not be confirmed stopped. Automatic retry was cancelled to avoid running your request twice. Check your Claude connection before trying again.');
-      return;
-    }
-    if (state.retried || state.turns.length !== 1) {
-      finish(session, state, state.retried
-        ? 'Claude still has not responded after one automatic retry. Please send your message again or check your Claude connection.'
-        : 'Claude did not respond. Several messages were queued, so automatic replay was cancelled to avoid duplicating work. Please send the unanswered messages again.');
-      return;
-    }
-    state.retried = true;
-    state.stopping = false;
-    session.isProcessing = true;
-    ctx.changed();
-    ctx.record(session, { type: 'info', text: 'The previous attempt has stopped. Retrying your original message once.' });
-    ctx.send(session, { type: 'status', status: 'processing' });
-    arm(session, state);
-    var payload = state.turns[0];
-    await ctx.restart(session, payload, state);
-  }
-  return {
-    begin: begin, enqueue: enqueue, event: event, progress: progress, cancel: cancel,
-    current: function(session) { return states.get(session); },
-    valid: live,
-    stopping: function(session) { var state = states.get(session); return !!(state && state.stopping); },
-    dispose: function() { states.forEach(function(state) { clearTimer(state); }); states.clear(); },
-  };
-}
-module.exports = { attachResponseRecovery: attachResponseRecovery };
+module.exports = require("./yoke/claude-response-recovery");