clay-server 3.8.1 → 4.0.0-beta.10

package/lib/workspace-assignment-service.js

@@ -0,0 +1,420 @@
+var fs = require("fs");
+var path = require("path");
+var crypto = require("crypto");
+
+var ACTIVE = { proposed: true, starting: true, running: true };
+var MAX_RUNNING = 3;
+
+function clean(value, max) {
+  if (typeof value !== "string") return "";
+  return value.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim().slice(0, max);
+}
+
+function userStorageKey(userId) {
+  return crypto.createHash("sha256").update(String(userId || "_single_user")).digest("hex").slice(0, 24) + ".json";
+}
+
+function attachWorkspaceAssignmentService(ctx) {
+  var storageDir = ctx.storageDir || null;
+  var records = [];
+  var unsubscribers = {};
+  var pendingRestartReplay = {};
+
+  function recordFile(userId) {
+    return storageDir ? path.join(storageDir, userStorageKey(userId)) : null;
+  }
+
+  function saveUser(userId) {
+    var file = recordFile(userId);
+    if (!file) return;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    var owned = records.filter(function (record) { return record.userId === (userId || null); });
+    var temp = file + ".tmp." + process.pid;
+    fs.writeFileSync(temp, JSON.stringify(owned, null, 2), { mode: 0o600 });
+    fs.renameSync(temp, file);
+  }
+
+  function load() {
+    if (!storageDir) return;
+    var files = [];
+    try { files = fs.readdirSync(storageDir); } catch (e) { return; }
+    for (var i = 0; i < files.length; i++) {
+      if (!files[i].endsWith(".json") || files[i].indexOf(".tmp.") !== -1) continue;
+      try {
+        var loaded = JSON.parse(fs.readFileSync(path.join(storageDir, files[i]), "utf8"));
+        if (Array.isArray(loaded)) records = records.concat(loaded);
+      } catch (e) {}
+    }
+    var changedUsers = {};
+    for (var j = 0; j < records.length; j++) {
+      if (records[j].status !== "starting" && records[j].status !== "running") continue;
+      records[j].status = "interrupted";
+      records[j].error = "Clay restarted before this assignment completed.";
+      records[j].updatedAt = Date.now();
+      pendingRestartReplay[records[j].assignmentId] = true;
+      changedUsers[String(records[j].userId || "_single_user")] = records[j].userId || null;
+    }
+    var keys = Object.keys(changedUsers);
+    for (var k = 0; k < keys.length; k++) saveUser(changedUsers[keys[k]]);
+  }
+
+  function sourceKey(principal) {
+    return String(principal.userId || "_single_user") + ":" + principal.sourceProjectSlug + ":" + principal.sourceSessionRef;
+  }
+
+  function normalizePrincipal(principal) {
+    if (!principal || !principal.sourceProjectSlug) return null;
+    var project = ctx.getProjects().get(principal.sourceProjectSlug);
+    var manager = project && project.getSessionManager ? project.getSessionManager() : null;
+    var session = manager && manager.sessions ? manager.sessions.get(principal.sourceSessionId) : null;
+    if (!session && manager && manager.sessions && principal.sourceSessionRef) {
+      manager.sessions.forEach(function (candidate) {
+        if (!session && ctx.sessionRef(principal.sourceProjectSlug, candidate) === principal.sourceSessionRef) session = candidate;
+      });
+    }
+    if (!session) return null;
+    return Object.assign({}, principal, {
+      sourceSessionId: session.localId,
+      sourceSessionRef: ctx.sessionRef(principal.sourceProjectSlug, session),
+    });
+  }
+
+  function publicRecord(record) {
+    return {
+      assignmentId: record.assignmentId,
+      delivery: record.delivery || "new_session",
+      projectSlug: record.targetProjectSlug,
+      projectTitle: record.targetProjectTitle,
+      title: record.title,
+      task: record.task,
+      status: record.status,
+      sourceProjectSlug: record.sourceProjectSlug,
+      sourceSessionRef: record.sourceSessionRef,
+      targetSessionRef: record.targetSessionRef || null,
+      targetSessionTitle: record.targetSessionTitle || null,
+      resultSummary: record.resultSummary || "",
+      error: record.error || "",
+      createdAt: record.createdAt,
+      updatedAt: record.updatedAt,
+    };
+  }
+
+  function ownsProject(record, status) {
+    if (!status || status.isWorktree || status.isMate) return false;
+    if (ctx.isMultiUser()) return !!record.userId && status.projectOwnerId === record.userId;
+    return !status.projectOwnerId || (!!record.singleUserOwnerId && status.projectOwnerId === record.singleUserOwnerId);
+  }
+
+  function exactTarget(record) {
+    var project = ctx.getProjects().get(record.targetProjectSlug);
+    if (!project || !ownsProject(record, project.getStatus())) return null;
+    return project;
+  }
+
+  function exactSource(record) {
+    var project = ctx.getProjects().get(record.sourceProjectSlug);
+    if (!project) return null;
+    var status = project.getStatus();
+    if (!status || status.isMate !== true || status.mateId !== record.sourceMateId) return null;
+    if (ctx.isMultiUser() && status.projectOwnerId !== record.userId) return null;
+    var manager = project.getSessionManager();
+    var session = null;
+    if (manager && manager.sessions) {
+      manager.sessions.forEach(function (candidate) {
+        if (!session && ctx.sessionRef(record.sourceProjectSlug, candidate) === record.sourceSessionRef) session = candidate;
+      });
+    }
+    if (!session) return null;
+    if (ctx.isMultiUser() && session.ownerId !== record.userId) return null;
+    if (!ctx.isMultiUser() && session.ownerId && session.ownerId !== record.singleUserOwnerId) return null;
+    return { project: project, manager: manager, session: session };
+  }
+
+  function emit(record, eventType) {
+    var source = exactSource(record);
+    if (!source) return;
+    source.manager.sendAndRecord(source.session, {
+      type: eventType || "project_assignment_status",
+      assignment: publicRecord(record),
+      requestId: record.sourceRequestId || null,
+    });
+  }
+
+  function reconcileProject(projectSlug) {
+    for (var i = 0; i < records.length; i++) {
+      if (!pendingRestartReplay[records[i].assignmentId] || records[i].sourceProjectSlug !== projectSlug) continue;
+      if (!exactSource(records[i])) continue;
+      emit(records[i]);
+      delete pendingRestartReplay[records[i].assignmentId];
+    }
+  }
+
+  function propose(principal, args) {
+    principal = normalizePrincipal(principal);
+    if (!principal || !principal.sourceSessionRef) throw new Error("Project assignments require an exact session-bound Mate query.");
+    var projectSlug = clean(args.projectSlug, 120);
+    var title = clean(args.title, 160);
+    var task = clean(args.task, 12000);
+    if (!projectSlug || !title || !task) throw new Error("projectSlug, title, and task are required.");
+    var candidate = {
+      userId: principal.userId || null,
+      singleUserOwnerId: principal.singleUserOwnerId || null,
+      targetProjectSlug: projectSlug,
+    };
+    var target = exactTarget(candidate);
+    if (!target) throw new Error("Target project not found in the owned workspace.");
+    var key = sourceKey(principal);
+    var idempotency = crypto.createHash("sha256").update(key + "\u0000" + projectSlug + "\u0000" + title + "\u0000" + task).digest("hex");
+    for (var i = 0; i < records.length; i++) {
+      if (records[i].idempotencyKey === idempotency) return publicRecord(records[i]);
+      if (records[i].sourceKey === key && ACTIVE[records[i].status]) throw new Error("This conversation already has an active assignment.");
+    }
+    var now = Date.now();
+    var targetStatus = target.getStatus();
+    var record = {
+      assignmentId: "assignment_" + crypto.randomUUID(),
+      idempotencyKey: idempotency,
+      sourceKey: key,
+      userId: principal.userId || null,
+      singleUserOwnerId: principal.singleUserOwnerId || null,
+      sourceMateId: principal.mateId,
+      sourceProjectSlug: principal.sourceProjectSlug,
+      sourceSessionRef: principal.sourceSessionRef,
+      sourceRequestId: principal.sourceRequestId || null,
+      targetProjectSlug: projectSlug,
+      targetProjectTitle: clean(targetStatus.title || targetStatus.project || projectSlug, 160),
+      title: title,
+      task: task,
+      delivery: "new_session",
+      status: "proposed",
+      createdAt: now,
+      updatedAt: now,
+    };
+    if (!exactSource(record)) throw new Error("Source conversation is no longer available.");
+    records.push(record);
+    saveUser(record.userId);
+    emit(record, "project_assignment_proposal");
+    return publicRecord(record);
+  }
+
+  function proposeFollowUp(principal, args) {
+    principal = normalizePrincipal(principal);
+    if (!principal || !principal.sourceSessionRef) throw new Error("Project follow-ups require an exact session-bound Mate query.");
+    var projectSlug = clean(args.projectSlug, 120);
+    var targetSessionRef = clean(args.targetSessionRef, 100);
+    var title = clean(args.title, 160);
+    var task = clean(args.task, 12000);
+    if (!projectSlug || !targetSessionRef || !title || !task) throw new Error("projectSlug, targetSessionRef, title, and task are required.");
+    var key = sourceKey(principal);
+    var idempotency = crypto.createHash("sha256").update(key + "\u0000follow_up\u0000" + projectSlug + "\u0000" + targetSessionRef + "\u0000" + title + "\u0000" + task).digest("hex");
+    for (var i = 0; i < records.length; i++) {
+      if (records[i].idempotencyKey === idempotency) return publicRecord(records[i]);
+      if (records[i].sourceKey === key && ACTIVE[records[i].status]) throw new Error("This conversation already has an active assignment.");
+    }
+    var candidate = { userId: principal.userId || null, singleUserOwnerId: principal.singleUserOwnerId || null, targetProjectSlug: projectSlug };
+    var target = exactTarget(candidate);
+    if (!target || typeof target.inspectDelegatedFollowUp !== "function") throw new Error("Target project is unavailable for follow-ups.");
+    var inspected = target.inspectDelegatedFollowUp({ userId: principal.userId }, targetSessionRef);
+    var now = Date.now();
+    var targetStatus = target.getStatus();
+    var record = {
+      assignmentId: "assignment_" + crypto.randomUUID(), idempotencyKey: idempotency, sourceKey: key,
+      userId: principal.userId || null, singleUserOwnerId: principal.singleUserOwnerId || null,
+      sourceMateId: principal.mateId, sourceProjectSlug: principal.sourceProjectSlug,
+      sourceSessionRef: principal.sourceSessionRef, sourceRequestId: principal.sourceRequestId || null,
+      targetProjectSlug: projectSlug, targetProjectTitle: clean(targetStatus.title || targetStatus.project || projectSlug, 160),
+      targetSessionRef: inspected.sessionRef, targetSessionTitle: clean(inspected.title || "Existing session", 160),
+      title: title, task: task, delivery: "follow_up", status: "proposed", createdAt: now, updatedAt: now,
+    };
+    if (!exactSource(record)) throw new Error("Source conversation is no longer available.");
+    records.push(record);
+    saveUser(record.userId);
+    emit(record, "project_assignment_proposal");
+    return publicRecord(record);
+  }
+
+  function findOwned(userId, assignmentId) {
+    for (var i = 0; i < records.length; i++) {
+      if (records[i].assignmentId === assignmentId && records[i].userId === (userId || null)) return records[i];
+    }
+    return null;
+  }
+
+  function responseUserId(ws) {
+    return ctx.isMultiUser() && ws && ws._clayUser ? ws._clayUser.id : null;
+  }
+
+  function summarize(session) {
+    var text = "";
+    for (var i = (session && session.history || []).length - 1; i >= 0; i--) {
+      if (session.history[i].type === "delta") text = session.history[i].text + text;
+      else if (text && (session.history[i].type === "user_message" || session.history[i].type === "delegated_work" || session.history[i].type === "delegated_follow_up")) break;
+    }
+    return clean(text, 1200);
+  }
+
+  function settle(record, status, session, error) {
+    if (!ACTIVE[record.status]) return publicRecord(record);
+    record.status = status;
+    record.resultSummary = status === "completed" ? summarize(session) : "";
+    record.error = clean(error || "", 800);
+    record.updatedAt = Date.now();
+    if (unsubscribers[record.assignmentId]) unsubscribers[record.assignmentId]();
+    delete unsubscribers[record.assignmentId];
+    saveUser(record.userId);
+    emit(record);
+    return publicRecord(record);
+  }
+
+  function watch(record, manager, session) {
+    var unsubscribe = manager.subscribeSession(session.localId, function (event) {
+      if (event.type === "session_id") {
+        record.targetSessionRef = ctx.sessionRef(record.targetProjectSlug, session);
+        record.updatedAt = Date.now();
+        saveUser(record.userId);
+        emit(record);
+      } else if (event.type === "error") {
+        settle(record, "failed", session, event.text || "Assignment failed.");
+      } else if (event.type === "done" || event.type === "result") {
+        settle(record, session._lastTurnInterrupted ? "interrupted" : "completed", session, "");
+      }
+    });
+    if (unsubscribe) unsubscribers[record.assignmentId] = unsubscribe;
+  }
+
+  async function approve(record) {
+    if (record.status !== "proposed") return publicRecord(record);
+    var running = records.filter(function (item) {
+      return item.userId === record.userId && (item.status === "starting" || item.status === "running");
+    }).length;
+    if (running >= MAX_RUNNING) throw new Error("Too many assignments are already running.");
+    if (!exactSource(record)) throw new Error("Source conversation is no longer available.");
+    var target = exactTarget(record);
+    var followUp = record.delivery === "follow_up";
+    if (!target || (followUp ? typeof target.dispatchDelegatedFollowUp !== "function" : typeof target.createDelegatedSession !== "function")) throw new Error("Target project is no longer available.");
+    record.decision = "approve";
+    record.status = "starting";
+    record.updatedAt = Date.now();
+    saveUser(record.userId);
+    emit(record);
+    try {
+      var metadata = {
+        assignmentId: record.assignmentId,
+        title: record.title,
+        sourceMateId: record.sourceMateId,
+        sourceProjectSlug: record.sourceProjectSlug,
+        sourceSessionRef: record.sourceSessionRef,
+      };
+      var session;
+      if (followUp) {
+        session = await target.dispatchDelegatedFollowUp({ userId: record.userId }, record.targetSessionRef, record.task, metadata, function (existing) { watch(record, target.getSessionManager(), existing); });
+      } else {
+        session = await target.createDelegatedSession({ userId: record.userId }, record.task, metadata, function (created) { watch(record, target.getSessionManager(), created); });
+      }
+      if (record.status !== "starting") return publicRecord(record);
+      record.targetSessionRef = ctx.sessionRef(record.targetProjectSlug, session);
+      record.targetSessionId = session.localId;
+      record.status = "running";
+      record.updatedAt = Date.now();
+      saveUser(record.userId);
+      emit(record);
+    } catch (e) {
+      settle(record, "failed", null, e.message || String(e));
+    }
+    return publicRecord(record);
+  }
+
+  function cancel(record) {
+    if (record.status !== "proposed") return publicRecord(record);
+    record.decision = "cancel";
+    record.status = "cancelled";
+    record.updatedAt = Date.now();
+    saveUser(record.userId);
+    emit(record);
+    return publicRecord(record);
+  }
+
+  function getStatus(principal, assignmentId) {
+    principal = normalizePrincipal(principal);
+    if (!principal) throw new Error("Assignment not found for this conversation.");
+    var record = findOwned(principal.userId, assignmentId);
+    if (!record || record.sourceKey !== sourceKey(principal)) throw new Error("Assignment not found for this conversation.");
+    return publicRecord(record);
+  }
+
+  function validateResponseSource(ws, msg, record, routedProjectSlug) {
+    var source = exactSource(record);
+    if (!source) throw new Error("Source conversation is no longer available.");
+    var userId = responseUserId(ws);
+    if (record.userId !== (userId || null)) throw new Error("Assignment access denied.");
+    if (msg.sourceProjectSlug !== record.sourceProjectSlug || msg.sourceSessionRef !== record.sourceSessionRef) {
+      throw new Error("Assignment response does not match its source conversation.");
+    }
+    if (msg.surface === "home") {
+      var tap = ws && ws._homeChatTap;
+      if (!tap || tap.mateSlug !== record.sourceProjectSlug || tap.sessionId !== source.session.localId) {
+        throw new Error("Open the exact Home conversation before responding.");
+      }
+      if (msg.mateId !== tap.mateId || msg.sessionId !== tap.sessionReference || msg.requestId !== tap.requestId) {
+        throw new Error("Assignment response is stale for this Home conversation.");
+      }
+    } else if (routedProjectSlug !== record.sourceProjectSlug || !ws || ws._clayActiveSession !== source.session.localId) {
+      throw new Error("Open the exact project conversation before responding.");
+    }
+    return source;
+  }
+
+  async function respond(ws, msg, routedProjectSlug) {
+    var userId = responseUserId(ws);
+    var record = findOwned(userId, clean(msg.assignmentId, 100));
+    if (!record) throw new Error("Assignment proposal is stale or unavailable.");
+    validateResponseSource(ws, msg, record, routedProjectSlug);
+    var action = msg.action === "approve" ? "approve" : (msg.action === "cancel" ? "cancel" : "");
+    if (!action) throw new Error("Choose approve or cancel.");
+    if (record.status !== "proposed") {
+      if (record.decision === action) return publicRecord(record);
+      throw new Error("Assignment proposal has already been resolved.");
+    }
+    return action === "approve" ? approve(record) : cancel(record);
+  }
+
+  function handleMessage(ws, msg, routedProjectSlug) {
+    if (!msg || msg.type !== "project_assignment_response") return false;
+    respond(ws, msg, routedProjectSlug).then(function (assignment) {
+      if (ws.readyState !== 1) return;
+      if (msg.surface === "home") {
+        ws.send(JSON.stringify({ type: "home_project_assignment_status", assignment: assignment, mateId: msg.mateId, sessionId: msg.sessionId, requestId: msg.requestId }));
+      } else {
+        ws.send(JSON.stringify({ type: "project_assignment_status", assignment: assignment }));
+      }
+    }).catch(function (error) {
+      if (ws.readyState !== 1) return;
+      if (msg.surface === "home") {
+        var userId = responseUserId(ws);
+        var record = findOwned(userId, msg.assignmentId);
+        var assignment = record ? publicRecord(record) : { assignmentId: msg.assignmentId || null, status: "proposed" };
+        assignment.error = error.message || String(error);
+        ws.send(JSON.stringify({ type: "home_project_assignment_status", assignment: assignment, mateId: msg.mateId, sessionId: msg.sessionId, requestId: msg.requestId }));
+      } else {
+        ws.send(JSON.stringify({ type: "project_assignment_error", assignmentId: msg.assignmentId || null, error: error.message || String(error) }));
+      }
+    });
+    return true;
+  }
+
+  load();
+  return {
+    propose: propose,
+    proposeFollowUp: proposeFollowUp,
+    getStatus: getStatus,
+    respond: respond,
+    handleMessage: handleMessage,
+    reconcileProject: reconcileProject,
+    records: records,
+  };
+}
+
+module.exports = {
+  attachWorkspaceAssignmentService: attachWorkspaceAssignmentService,
+  userStorageKey: userStorageKey,
+};

package/lib/workspace-query-mcp-server.js

@@ -0,0 +1,154 @@
+var z;
+try { z = require("zod"); } catch (e) { z = null; }
+
+function field(type, description, optional) {
+  if (!z) return {};
+  var value = type === "number" ? z.number() : z.string();
+  if (description) value = value.describe(description);
+  return optional ? value.optional() : value;
+}
+
+function shape(fields) {
+  if (!z) return {};
+  return fields;
+}
+
+function textResult(value) {
+  return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] });
+}
+
+function errorResult(error) {
+  return Promise.resolve({
+    content: [{ type: "text", text: "Error: " + (error && error.message ? error.message : String(error)) }],
+    isError: true,
+  });
+}
+
+function handler(bound, method) {
+  return function (args) {
+    if (!bound || typeof bound[method] !== "function") return errorResult(new Error("Workspace tools require an exact session-bound Mate query."));
+    try { return textResult(bound[method](args || {})); }
+    catch (e) { return errorResult(e); }
+  };
+}
+
+var SESSION_CITATION = " When citing a returned session in user-visible text, write [clayos/<sessionRef> — short label] so Clay Studio renders an owner-validated session control.";
+
+function commonTools(bound) {
+  return [
+    {
+      name: "list_projects",
+      description: "List projects owned by the current user. Returns sanitized summaries only; use a project-specific tool to inspect sessions or history.",
+      inputSchema: shape({
+        query: field("string", "Optional project title or slug filter.", true),
+        cursor: field("string", "Opaque pagination cursor from a previous response.", true),
+        limit: field("number", "Page size, from 1 to 50.", true),
+      }),
+      handler: handler(bound, "listProjects"),
+    },
+    {
+      name: "list_project_sessions",
+      description: "List sanitized session summaries for one owned project, newest activity first." + SESSION_CITATION,
+      inputSchema: shape({
+        projectSlug: field("string", "Exact project slug."),
+        cursor: field("string", "Opaque pagination cursor from a previous response.", true),
+        limit: field("number", "Page size, from 1 to 50.", true),
+      }),
+      handler: handler(bound, "listProjectSessions"),
+    },
+    {
+      name: "search_project_history",
+      description: "Search canonical user and assistant text in one owned project. Tool inputs, tool results, hidden prompts, and internal paths are excluded." + SESSION_CITATION,
+      inputSchema: shape({
+        projectSlug: field("string", "Exact project slug."),
+        query: field("string", "Search query."),
+        cursor: field("string", "Opaque pagination cursor from a previous response.", true),
+        limit: field("number", "Page size, from 1 to 50.", true),
+      }),
+      handler: handler(bound, "searchProjectHistory"),
+    },
+    {
+      name: "read_project_session",
+      description: "Read a bounded page of canonical user and assistant turns from one owned session using the opaque session reference returned by list or search." + SESSION_CITATION,
+      inputSchema: shape({
+        projectSlug: field("string", "Exact project slug."),
+        sessionRef: field("string", "Opaque session reference returned by a workspace list or search tool."),
+        cursor: field("string", "Opaque pagination cursor from a previous response.", true),
+        limit: field("number", "Page size, from 1 to 50.", true),
+      }),
+      handler: handler(bound, "readProjectSession"),
+    },
+    {
+      name: "propose_project_assignment",
+      description: "Propose a new delegated session in an owned project. This posts a user-visible approval card and performs no target work until explicit approval.",
+      inputSchema: shape({
+        projectSlug: field("string", "Exact owned target project slug."),
+        title: field("string", "Short delegated session title."),
+        task: field("string", "Standalone bounded task without hidden source transcript."),
+      }),
+      handler: handler(bound, "proposeProjectAssignment"),
+    },
+    {
+      name: "propose_project_follow_up",
+      description: "Propose a bounded follow-up in an existing durable private session. This posts a user-visible approval card and performs no target work until explicit approval.",
+      inputSchema: shape({
+        projectSlug: field("string", "Exact owned target project slug."),
+        targetSessionRef: field("string", "Durable opaque session reference returned by list_project_sessions."),
+        title: field("string", "Short follow-up title."),
+        task: field("string", "Standalone bounded follow-up without hidden source transcript."),
+      }),
+      handler: handler(bound, "proposeProjectFollowUp"),
+    },
+    {
+      name: "get_assignment_status",
+      description: "Read a new-session or follow-up assignment status for this exact Mate conversation.",
+      inputSchema: shape({ assignmentId: field("string", "Assignment ID returned by propose_project_assignment.") }),
+      handler: handler(bound, "getAssignmentStatus"),
+    },
+  ];
+}
+
+function globalTools(bound) {
+  return [
+    {
+      name: "search_workspace_history",
+      description: "Search canonical user and assistant text across every project owned by the current user. Available only to authoritative builtin Clay." + SESSION_CITATION,
+      inputSchema: shape({
+        query: field("string", "Search query."),
+        cursor: field("string", "Opaque pagination cursor from a previous response.", true),
+        limit: field("number", "Page size, from 1 to 50.", true),
+      }),
+      handler: handler(bound, "searchWorkspaceHistory"),
+    },
+    {
+      name: "list_workspace_activity",
+      description: "List recent session activity across every project owned by the current user. Available only to authoritative builtin Clay." + SESSION_CITATION,
+      inputSchema: shape({
+        status: field("string", "Optional status: idle, processing, or waiting_for_approval.", true),
+        cursor: field("string", "Opaque pagination cursor from a previous response.", true),
+        limit: field("number", "Page size, from 1 to 50.", true),
+      }),
+      handler: handler(bound, "listWorkspaceActivity"),
+    },
+  ];
+}
+
+function getToolDefs(bound, includeGlobal) {
+  var tools = commonTools(bound);
+  if (includeGlobal === true) tools = tools.concat(globalTools(bound));
+  return tools;
+}
+
+function createMcpServer(adapter, bound, includeGlobal) {
+  if (!adapter || typeof adapter.createToolServer !== "function") return null;
+  return adapter.createToolServer({
+    name: "clay-workspace",
+    version: "1.0.0",
+    tools: getToolDefs(bound, includeGlobal),
+  });
+}
+
+module.exports = {
+  createMcpServer: createMcpServer,
+  getToolDefs: getToolDefs,
+};