clay-server 3.8.1 → 4.0.0-beta.2

package/lib/project-worker-proposal.js

@@ -167,16 +167,16 @@ function attachWorkerProposal(ctx) {
   }
 
   async function propose(args, session) {
-    if (!isEligible(session)) return toolResult({ error: "Worker suggestions are only available in an unpaired Fable session." });
-    if (hasPendingProposal(session)) return toolResult({ error: "A Worker suggestion is already awaiting a decision." });
+    if (!isEligible(session)) return toolResult({ error: "Split Worker suggestions are only available in an unpaired Fable session." });
+    if (hasPendingProposal(session)) return toolResult({ error: "A Split Worker suggestion is already awaiting a decision." });
     var summary = typeof args.summary === "string" ? args.summary.trim() : "";
     var plan = typeof args.plan === "string" ? args.plan.trim() : "";
     var task = typeof args.message === "string" ? args.message.trim() : "";
     if (!summary || !plan || !task) return toolResult({ error: "summary, plan, and message are required." });
-    if (task.length > MAX_TASK_CHARS) return toolResult({ error: "The Worker task is too long." });
+    if (task.length > MAX_TASK_CHARS) return toolResult({ error: "The Split Worker task is too long." });
     await ensureModelCatalogs();
     var options = proposalOptions();
-    if (options.installedVendors.length === 0) return toolResult({ error: "No coding agent is installed for a Worker session." });
+    if (options.installedVendors.length === 0) return toolResult({ error: "No coding agent is installed for a Split Worker session." });
     var recommendation = chooseRecommendation(args, session, options);
     var autoApprove = skipPermissionsEnabled(session);
     var proposal = {
@@ -200,17 +200,17 @@ function attachWorkerProposal(ctx) {
         effort: recommendation.effort,
         autoApproved: true,
       }, autoApprovalWs(session));
-      if (!accepted.ok) return toolResult({ error: accepted.error || "Could not start the Worker." });
+      if (!accepted.ok) return toolResult({ error: accepted.error || "Could not start the Split Worker." });
       return toolResult({
         status: "running",
         proposalId: proposal.proposalId,
-        instruction: "The Worker was auto-approved and started because skip permissions is enabled. Its result will return for review.",
+        instruction: "The Split Worker was auto-approved and started because skip permissions is enabled. Its result will return for review.",
       });
     }
     return toolResult({
       status: "posted",
       proposalId: proposal.proposalId,
-      instruction: "The Worker suggestion is visible in the chat. End this turn now and wait for the user's decision.",
+      instruction: "The Split Worker suggestion is visible in the chat. End this turn now and wait for the user's decision.",
     });
   }
 
@@ -231,10 +231,10 @@ function attachWorkerProposal(ctx) {
 
   function parsePartnerResult(result) {
     if (!result || result.isError || !result.content || !result.content[0]) {
-      return { status: "error", error: "Worker execution failed." };
+      return { status: "error", error: "Split Worker execution failed." };
     }
     try { return JSON.parse(result.content[0].text); }
-    catch (e) { return { status: "error", error: result.content[0].text || "Worker execution failed." }; }
+    catch (e) { return { status: "error", error: result.content[0].text || "Split Worker execution failed." }; }
   }
 
   async function runWorker(session, proposal) {
@@ -247,13 +247,13 @@ function attachWorkerProposal(ctx) {
     });
     var followup;
     if (result.status === "complete") {
-      followup = "[Worker execution completed]\nReview and verify the Worker's result. The Worker session remains available: if the implementation needs corrections or additional edits, send a follow-up with send_to_partner instead of taking over the Worker-owned files yourself. If that Worker is no longer available, keep the work in the visible Worker flow and use send_to_partner again after the stale pair is removed; never substitute a background session.\n\n" + (result.response || "The Worker completed without a text summary.");
+      followup = "[Split Worker execution completed]\nReview and verify the Split Worker's result. The Split Worker session remains available: if the implementation needs corrections or additional edits, send a follow-up with send_to_partner instead of taking over the Split Worker-owned files yourself. If that Split Worker is no longer available, keep the work in the visible Split Worker flow and use send_to_partner again after the stale pair is removed; never substitute a background Sub-agent.\n\n" + (result.response || "The Split Worker completed without a text summary.");
     } else if (result.status === "interrupted") {
-      followup = "[Worker execution interrupted]\nThe user interrupted the Worker mid-turn. Its work is PARTIAL and unverified — do not treat it as finished. Review what was done and decide next steps with the user.";
+      followup = "[Split Worker execution interrupted]\nThe user interrupted the Split Worker mid-turn. Its work is PARTIAL and unverified — do not treat it as finished. Review what was done and decide next steps with the user.";
     } else if (result.status === "running") {
-      followup = "[Worker execution is still running]\nUse read_partner to inspect progress before completing the task.";
+      followup = "[Split Worker execution is still running]\nUse read_partner to inspect progress before completing the task.";
     } else {
-      followup = "[Worker execution failed]\nInspect the failure and delegate a narrower follow-up to the Worker when implementation work remains.\n\n" + (result.error || result.response || "Unknown Worker error.");
+      followup = "[Split Worker execution failed]\nInspect the failure and delegate a narrower follow-up to the Split Worker when implementation work remains.\n\n" + (result.error || result.response || "Unknown Split Worker error.");
     }
     await resumeDriver(session, followup);
   }
@@ -272,8 +272,8 @@ function attachWorkerProposal(ctx) {
     var options = proposal.options || proposalOptions();
     var vendor = msg.vendor || proposal.recommendedVendor;
     var model = msg.model || "";
-    if (options.installedVendors.indexOf(vendor) === -1) throw new Error("Selected Worker vendor is not installed");
-    if (!modelIsAvailable(options, vendor, model)) throw new Error("Selected Worker model is unavailable");
+    if (options.installedVendors.indexOf(vendor) === -1) throw new Error("Selected Split Worker vendor is not installed");
+    if (!modelIsAvailable(options, vendor, model)) throw new Error("Selected Split Worker model is unavailable");
     var effort = yoke.clampEffort(vendor, msg.effort || proposal.recommendedEffort || "medium") || "";
     var startingPatch = { status: "starting", selectedVendor: vendor, selectedModel: model, selectedEffort: effort };
     if (msg.autoApproved) startingPatch.autoApproved = true;
@@ -288,7 +288,7 @@ function attachWorkerProposal(ctx) {
       else ctx.sendTo(ws, { type: "pair_session_created", ok: true, group: created.group });
       runWorker(session, proposal).catch(function (err) {
         updateProposal(session, proposal, { status: "error", error: err.message || String(err) });
-        resumeDriver(session, "[Worker execution failed]\n" + (err.message || String(err))).catch(function () {});
+        resumeDriver(session, "[Split Worker execution failed]\n" + (err.message || String(err))).catch(function () {});
       });
       return { ok: true, status: "running", group: created.group };
     } catch (err) {
@@ -300,11 +300,11 @@ function attachWorkerProposal(ctx) {
   async function respondToProposal(ws, msg) {
     var session = sessionForResponse(ws);
     var proposal = findProposal(session, msg.proposalId);
-    if (!proposal) throw new Error("Worker suggestion not found");
-    if (proposal.status !== "pending") throw new Error("Worker suggestion has already been resolved");
+    if (!proposal) throw new Error("Split Worker suggestion not found");
+    if (proposal.status !== "pending") throw new Error("Split Worker suggestion has already been resolved");
     if (!msg.accepted) {
       updateProposal(session, proposal, { status: "declined" });
-      await resumeDriver(session, "[Worker suggestion declined]\nContinue this task in the current session using the plan you already prepared.");
+      await resumeDriver(session, "[Split Worker suggestion declined]\nContinue this task in the current session using the plan you already prepared.");
       return { ok: true, status: "declined" };
     }
     return acceptProposal(session, proposal, msg, ws);
@@ -322,13 +322,13 @@ function attachWorkerProposal(ctx) {
     if (!isEligible(session)) return [];
     return [{
       name: "propose_worker",
-      description: "After making a concise plan for an implementation-heavy task, suggest that the user run the execution with another model in a visible Worker session. Use this only before substantial execution begins, never for small edits, explanations, or tasks the user asked you to keep in this session.",
+      description: "After making a concise plan for an implementation-heavy task, suggest that the user run the execution with another model in a visible Split Worker session. Use this only before substantial execution begins, never for small edits, explanations, or tasks the user asked you to keep in this session.",
       inputSchema: buildShape({
-        summary: { type: "string", description: "One short sentence explaining why a Worker is useful for this task." },
+        summary: { type: "string", description: "One short sentence explaining why a Split Worker is useful for this task." },
         plan: { type: "string", description: "A concise numbered implementation plan to show in the approval card." },
-        message: { type: "string", description: "Complete execution instructions for the Worker, including scope, constraints, validation, and expected result." },
-        recommendedVendor: { type: "string", description: "Optional installed vendor id for the Worker." },
-        recommendedModel: { type: "string", description: "Optional exact Worker model id. Omit when uncertain." },
+        message: { type: "string", description: "Complete execution instructions for the Split Worker, including scope, constraints, validation, and expected result." },
+        recommendedVendor: { type: "string", description: "Optional installed vendor id for the Split Worker." },
+        recommendedModel: { type: "string", description: "Optional exact Split Worker model id. Omit when uncertain." },
         recommendedEffort: { type: "string", description: "Optional reasoning effort: minimal, low, medium, high, xhigh, or max." },
       }, ["summary", "plan", "message"]),
       handler: function (args) { return propose(args || {}, session); },
@@ -337,7 +337,7 @@ function attachWorkerProposal(ctx) {
 
   function getSystemPrompt(session) {
     if (!isEligible(session)) return "";
-    return "You can introduce Clay's Driver/Worker workflow with propose_worker. For an implementation-heavy task that is likely to consume substantial execution time, first reason about the work and form a concise plan. Before editing files or running substantial execution, call propose_worker once with that plan and a complete Worker instruction, recommending another suitable execution model. Use it conservatively: do not suggest a Worker for questions, investigations, tiny fixes, or when the user explicitly wants you to execute here. After posting a proposal, end the turn and wait. If accepted, the Worker runs visibly and its result returns to you for review.";
+    return "You can introduce Clay's Driver/Split Worker workflow with propose_worker. For an implementation-heavy task that is likely to consume substantial execution time, first reason about the work and form a concise plan. Before editing files or running substantial execution, call propose_worker once with that plan and a complete Split Worker instruction, recommending another suitable execution model. Use it conservatively: do not suggest a Split Worker for questions, investigations, tiny fixes, or when the user explicitly wants you to execute here. After posting a proposal, end the turn and wait. If accepted, the Split Worker runs visibly and its result returns to you for review.";
   }
 
   return {

package/lib/project-workspace-query.js

@@ -0,0 +1,144 @@
+var workspaceMcp = require("./workspace-query-mcp-server");
+var clayHistoryMcp = require("./clay-history-mcp-server");
+
+function attachProjectWorkspaceQuery(ctx) {
+  var service = ctx.service;
+  var sm = ctx.sm;
+  var projectSlug = ctx.projectSlug;
+  var getProjectOwnerId = ctx.getProjectOwnerId || function () { return null; };
+  var isMate = ctx.isMate;
+  var mateId = ctx.mateId;
+
+  function binding(session) {
+    if (!service || isMate !== true || !mateId) return null;
+    if (session && (!sm || !sm.sessions || sm.sessions.get(session.localId) !== session)) return null;
+    if (session && (session.homeDebatePlanning === true || session.debateSetupMode === true || session._mentionInProgress === true || session.spawn)) return null;
+    return service.bindSource({
+      projectSlug: projectSlug,
+      projectOwnerId: getProjectOwnerId(),
+      isMate: true,
+      mateId: mateId,
+      session: session || null,
+    });
+  }
+
+  function getToolDefs(session) {
+    var bound = session ? binding(session) : null;
+    if (session && !bound) return [];
+    return workspaceMcp.getToolDefs(bound, !!(bound && bound.isClay));
+  }
+
+  function createMcpServer(adapter, session) {
+    if (!service || isMate !== true) return null;
+    var bound = session ? binding(session) : null;
+    var projectBound = binding(null);
+    if (!projectBound) return null;
+    return workspaceMcp.createMcpServer(adapter, bound, projectBound.isClay);
+  }
+
+  function createHistoryMcpServer(adapter, session) {
+    if (!adapter || typeof adapter.createToolServer !== "function") return null;
+    var bound = session ? binding(session) : null;
+    var projectBound = binding(null);
+    if (!projectBound || projectBound.isClay !== true) return null;
+    return adapter.createToolServer({
+      name: "clay-history",
+      version: "2.0.0",
+      tools: clayHistoryMcp.getToolDefs({ workspace: bound }),
+    });
+  }
+
+  function isAuthoritativeClay() {
+    var bound = binding(null);
+    return !!(bound && bound.isClay === true);
+  }
+
+  function getBridgeTools(session, normalizeSchema) {
+    if (!session) return [];
+    var defs = getToolDefs(session);
+    var tools = [];
+    for (var i = 0; i < defs.length; i++) {
+      tools.push({
+        server: "clay-workspace",
+        name: defs[i].name,
+        description: defs[i].description || defs[i].name,
+        inputSchema: normalizeSchema(defs[i].inputSchema),
+      });
+    }
+    return tools;
+  }
+
+  function getDynamicToolDefs(session) {
+    return getToolDefs(session).map(function (tool) {
+      tool.permissionName = "mcp__clay-workspace__" + tool.name;
+      return tool;
+    });
+  }
+
+  function getHistoryDynamicToolDefs(session) {
+    var bound = session ? binding(session) : null;
+    if (!bound || bound.isClay !== true) return [];
+    return clayHistoryMcp.getToolDefs({ workspace: bound }).map(function (tool) {
+      tool.permissionName = "mcp__clay-history__" + tool.name;
+      return tool;
+    });
+  }
+
+  function getHistoryBridgeTools(session, normalizeSchema) {
+    if (!session) return [];
+    var bound = binding(session);
+    if (!bound || bound.isClay !== true) return [];
+    var defs = clayHistoryMcp.getToolDefs({ workspace: bound });
+    var tools = [];
+    for (var i = 0; i < defs.length; i++) {
+      tools.push({
+        server: "clay-history",
+        name: defs[i].name,
+        description: defs[i].description || defs[i].name,
+        inputSchema: normalizeSchema(defs[i].inputSchema),
+      });
+    }
+    return tools;
+  }
+
+  function callBridgeTool(session, toolName, args) {
+    if (!session) return Promise.reject(new Error("Workspace tools require a valid Clay session."));
+    var defs = getToolDefs(session);
+    for (var i = 0; i < defs.length; i++) {
+      if (defs[i].name === toolName) return Promise.resolve(defs[i].handler(args || {}));
+    }
+    return Promise.reject(new Error("Workspace tool not found: " + toolName));
+  }
+
+  function callHistoryBridgeTool(session, toolName, args) {
+    var bound = session ? binding(session) : null;
+    if (!bound || bound.isClay !== true) return Promise.reject(new Error("Clay history requires a valid builtin Clay session."));
+    var defs = clayHistoryMcp.getToolDefs({ workspace: bound });
+    for (var i = 0; i < defs.length; i++) {
+      if (defs[i].name === toolName) return Promise.resolve(defs[i].handler(args || {}));
+    }
+    return Promise.reject(new Error("Clay history tool not found: " + toolName));
+  }
+
+  function getMemorySessions(session, excludeSource) {
+    var bound = session && service && typeof service.bindProjectSession === "function"
+      ? service.bindProjectSession({ projectSlug: projectSlug, session: session })
+      : binding(null);
+    return bound ? bound.getMemorySessions(excludeSource) : [];
+  }
+
+  return {
+    createMcpServer: createMcpServer,
+    createHistoryMcpServer: createHistoryMcpServer,
+    isAuthoritativeClay: isAuthoritativeClay,
+    getBridgeTools: getBridgeTools,
+    getHistoryBridgeTools: getHistoryBridgeTools,
+    getDynamicToolDefs: getDynamicToolDefs,
+    getHistoryDynamicToolDefs: getHistoryDynamicToolDefs,
+    callBridgeTool: callBridgeTool,
+    callHistoryBridgeTool: callHistoryBridgeTool,
+    getMemorySessions: getMemorySessions,
+  };
+}
+
+module.exports = { attachProjectWorkspaceQuery: attachProjectWorkspaceQuery };