clay-server 3.8.1 → 4.0.0-beta.2

package/lib/project-connection.js

@@ -78,6 +78,7 @@ function attachConnection(ctx) {
   var _mcp = ctx._mcp;
   var _notifications = ctx._notifications;
   var _splitGroups = ctx._splitGroups;
+  var _vendorLogin = ctx._vendorLogin;
   var hydrateImageRefs = ctx.hydrateImageRefs;
   var resolveSessionForView = ctx.resolveSessionForView;
   var broadcastClientCount = ctx.broadcastClientCount;
@@ -191,6 +192,9 @@ function attachConnection(ctx) {
     sendTo(ws, { type: "last_vendor", vendor: sm.lastVendor || "" });
     sendTo(ws, Object.assign({ type: "codex_config" }, getCodexConfig(sm)));
     sendTo(ws, { type: "term_list", terminals: tm.list() });
+    // Any login flow already running in this project, so a reconnecting client
+    // re-attaches to the existing login terminal instead of starting another.
+    if (_vendorLogin) _vendorLogin.sendStateTo(ws);
     // Context sources sent after session is resolved (per-session storage)
     // Send email accounts list for context sources picker
     var emailUserId = (wsUser && wsUser.id) || "default";

package/lib/project-debate-proposal.js

@@ -1,28 +1,84 @@
 var path = require("path");
 var debateMcp = require("./debate-mcp-server");
+var debateModels = require("./debate-model-selection");
 
 function attachDebateProposal(ctx) {
   var pendingProposals = {};
 
-  function createMcpServer(adapter, boundSession) {
-    var toolDefs = debateMcp.getToolDefs(function onPropose(briefData) {
+  function hasHomeDebateTopicAnswer(session) {
+    if (session && typeof session.homeDebateInitialTopic === "string" && session.homeDebateInitialTopic.trim()) return true;
+    var history = session && Array.isArray(session.history) ? session.history : [];
+    var firstQuestionId = null;
+    for (var i = 0; i < history.length; i++) {
+      var event = history[i];
+      if (!firstQuestionId && event && event.type === "tool_executing" && event.name === "AskUserQuestion") firstQuestionId = event.id || null;
+      if (firstQuestionId && event && event.type === "ask_user_answered" && event.toolId === firstQuestionId) return true;
+    }
+    return false;
+  }
+
+  function publicProposal(briefData) {
+    return {
+      proposalId: briefData.proposalId,
+      topic: briefData.topic || "Untitled debate",
+      format: briefData.format || "free_discussion",
+      context: briefData.context || "",
+      specialRequests: briefData.specialRequests || null,
+      moderatorId: briefData.moderatorId || null,
+      modelSelections: Array.isArray(briefData.modelSelections) ? briefData.modelSelections : [],
+      panelists: Array.isArray(briefData.panelists) ? briefData.panelists.map(function (panelist) {
+        return { mateId: panelist.mateId, role: panelist.role || "", brief: panelist.brief || "" };
+      }) : [],
+    };
+  }
+
+  function record(session, event) {
+    if (typeof ctx.recordSessionEvent === "function") ctx.recordSessionEvent(session, event);
+  }
+
+  function getToolDefs(boundSession) {
+    return debateMcp.getToolDefs(function onPropose(briefData) {
       if (!boundSession) {
         return Promise.resolve({
           action: "error",
           error: "Debate proposals require an active Clay session.",
         });
       }
-
+      var projectOwnerId = typeof ctx.getProjectOwnerId === "function" ? ctx.getProjectOwnerId() : null;
+      if (boundSession.homeDebatePlanning === true
+          && (ctx.isHostAgent !== true || ctx.isMate !== true || boundSession.debateSetupMode !== true
+            || !boundSession.ownerId || (projectOwnerId && boundSession.ownerId !== projectOwnerId))) {
+        return Promise.resolve({
+          action: "error",
+          error: "This Home debate proposal is not bound to an owned Clay planning session.",
+        });
+      }
+      if (boundSession.homeDebatePlanning === true && !hasHomeDebateTopicAnswer(boundSession)) {
+        return Promise.resolve({ action: "error", error: "Ask the user for a debate topic before proposing a debate." });
+      }
       return new Promise(function (resolve) {
         var proposalId = "dp_" + Date.now() + "_" + Math.random().toString(36).slice(2, 8);
         briefData.proposalId = proposalId;
-        pendingProposals[proposalId] = {
-          resolve: resolve,
-          briefData: briefData,
-          session: boundSession,
-        };
+        var moderatorId = ctx.isMate ? path.basename(ctx.cwd) : briefData.moderatorId;
+        var userId = boundSession.ownerId || (typeof ctx.getProjectOwnerId === "function" ? ctx.getProjectOwnerId() : null);
+        var mateCtx = ctx.buildMateCtx(userId);
+        function register(selections) {
+          briefData.modelSelections = selections;
+          pendingProposals[proposalId] = {
+            resolve: resolve,
+            briefData: briefData,
+            session: boundSession,
+          };
+          record(boundSession, { type: "debate_proposal", proposal: publicProposal(briefData) });
+        }
+        if (typeof ctx.getVendorModelCatalog !== "function" && typeof ctx.getVendorModelCatalogForSession !== "function") register([]);
+        else debateModels.loadSelections(ctx, null, mateCtx, moderatorId, briefData.panelists || [], boundSession).then(register).catch(function () { register([]); });
       });
     });
+  }
+
+  function createMcpServer(adapter, boundSession) {
+    var toolDefs = getToolDefs(boundSession);
 
     return adapter.createToolServer({
       name: "clay-debate",
@@ -31,6 +87,30 @@ function attachDebateProposal(ctx) {
     });
   }
 
+  function getBridgeTools(boundSession, normalizeSchema) {
+    if (!boundSession) return [];
+    var toolDefs = getToolDefs(boundSession);
+    return toolDefs.map(function (tool) {
+      return {
+        server: "clay-debate",
+        name: tool.name,
+        description: tool.description || tool.name,
+        inputSchema: normalizeSchema(tool.inputSchema),
+      };
+    });
+  }
+
+  function callBridgeTool(boundSession, toolName, args) {
+    if (!boundSession) return Promise.reject(new Error("Debate proposals require a valid Clay session."));
+    var toolDefs = getToolDefs(boundSession);
+    for (var i = 0; i < toolDefs.length; i++) {
+      if (toolDefs[i].name === toolName && typeof toolDefs[i].handler === "function") {
+        return Promise.resolve(toolDefs[i].handler(args || {}));
+      }
+    }
+    return Promise.reject(new Error("Session tool not found: clay-debate/" + toolName));
+  }
+
   function findPendingProposal(ws, msg) {
     var keys = Object.keys(pendingProposals);
     if (keys.length === 0) return null;
@@ -47,8 +127,7 @@ function attachDebateProposal(ctx) {
     if (!key) key = keys[keys.length - 1];
     var pending = pendingProposals[key];
     if (!pending) return null;
-    delete pendingProposals[key];
-    return pending;
+    return { key: key, pending: pending };
   }
 
   function rejectProposal(ws, pending, error) {
@@ -57,6 +136,7 @@ function attachDebateProposal(ctx) {
     } catch (sendErr) {
       console.error("[debate] Failed to send proposal error:", sendErr && sendErr.message ? sendErr.message : sendErr);
     }
+    record(pending.session, { type: "debate_proposal_resolved", proposalId: pending.briefData.proposalId, action: "error", error: error });
     pending.resolve({ action: "error", error: error });
   }
 
@@ -98,40 +178,76 @@ function attachDebateProposal(ctx) {
     return { moderatorId: moderatorId };
   }
 
-  function handleMessage(ws, msg) {
-    if (msg.type !== "debate_proposal_response") return false;
-
-    var pending = findPendingProposal(ws, msg);
-    if (!pending) return true;
+  async function startApprovedProposal(ws, msg, found) {
+    var pending = found.pending;
+    if (pending.responding) return;
+    pending.responding = true;
     if (msg.action !== "start") {
+      delete pendingProposals[found.key];
+      record(pending.session, { type: "debate_proposal_resolved", proposalId: pending.briefData.proposalId, action: "cancel" });
       pending.resolve({ action: "cancel" });
-      return true;
+      return;
     }
 
     var validated = validateProposal(ws, pending);
     if (validated.error) {
+      delete pendingProposals[found.key];
       rejectProposal(ws, pending, validated.error);
-      return true;
+      return;
     }
 
+    var userId = ws && ws._clayUser ? ws._clayUser.id : (pending.session.ownerId || ctx.getProjectOwnerId() || null);
+    var mateCtx = ctx.buildMateCtx(userId);
+    var modelResult = await debateModels.validateSelections(ctx, ws, mateCtx, validated.moderatorId, pending.briefData.panelists, msg.modelOverrides, pending.session);
+    if (modelResult.error) {
+      delete pendingProposals[found.key];
+      rejectProposal(ws, pending, modelResult.error);
+      return;
+    }
+    pending.briefData.participantModels = modelResult.selections;
+    delete pendingProposals[found.key];
+
     try {
       var result = ctx.startDebate(pending.session, pending.briefData, validated.moderatorId, ws);
       if (result && result.error) {
         rejectProposal(ws, pending, result.error);
         return true;
       }
+      record(pending.session, { type: "debate_proposal_resolved", proposalId: pending.briefData.proposalId, action: "start" });
       pending.resolve({ action: "start" });
     } catch (err) {
       var detail = err && err.message ? err.message : String(err);
       console.error("[debate] Failed to start approved proposal:", detail);
       rejectProposal(ws, pending, "The debate could not be started. Check the server logs for details.");
     }
+  }
+
+  function handleMessage(ws, msg) {
+    if (msg.type !== "debate_proposal_response") return false;
+
+    var found = findPendingProposal(ws, msg);
+    if (!found) return true;
+    startApprovedProposal(ws, msg, found).catch(function (error) {
+      delete pendingProposals[found.key];
+      rejectProposal(ws, found.pending, error && error.message ? error.message : "The selected debate models could not be verified.");
+    });
     return true;
   }
 
+  function handleHomeMessage(ws, msg, expectedSession) {
+    var found = findPendingProposal(ws, msg);
+    if (!found || found.pending.session !== expectedSession) return false;
+    if (expectedSession.ownerId && (!ws || !ws._clayUser || ws._clayUser.id !== expectedSession.ownerId)) return false;
+    return handleMessage(ws, msg);
+  }
+
   return {
     createMcpServer: createMcpServer,
+    getToolDefs: getToolDefs,
+    getBridgeTools: getBridgeTools,
+    callBridgeTool: callBridgeTool,
     handleMessage: handleMessage,
+    handleHomeMessage: handleHomeMessage,
   };
 }