clay-server 3.8.1 → 4.0.0-beta.1

package/lib/yoke/claude-user-input.js

@@ -0,0 +1,38 @@
+// Claude SDK mappings for YOKE structured user input.
+var userInput = require("./user-input");
+
+function ask(handler, input, opts) {
+  opts = opts || {};
+  return userInput.dispatchUserInput(handler, input, {
+    requestId: opts.toolUseID || opts.requestId,
+    signal: opts.signal,
+    source: "claude_ask_user_question",
+    native: true,
+    provider: "claude",
+  }).then(function (result) { return userInput.claudePermissionResult(input, result); });
+}
+
+function elicitation(handler, request, opts) {
+  opts = opts || {};
+  return userInput.dispatchUserInput(handler, userInput.questionsFromElicitation(request), {
+    requestId: opts.requestId || request.elicitationId,
+    signal: opts.signal,
+    source: "claude_elicitation",
+    native: true,
+    provider: "claude",
+    presentation: "elicitation",
+    diagnostics: { elicitation: request },
+  }).then(userInput.elicitationResponse);
+}
+
+function canUseTool(queryOpts) {
+  var original = queryOpts.canUseTool;
+  return function (toolName, input, opts) {
+    if (toolName === "AskUserQuestion" && typeof queryOpts.onUserInputRequest === "function") return ask(queryOpts.onUserInputRequest, input, opts);
+    if (toolName === "AskUserQuestion") return Promise.resolve({ behavior: "deny", message: "Use the query's structured input fallback tool." });
+    if (original) return original(toolName, input, opts);
+    return Promise.resolve({ behavior: "deny", message: "No tool permission handler is available." });
+  };
+}
+
+module.exports = { ask: ask, elicitation: elicitation, canUseTool: canUseTool };

package/lib/yoke/codex-user-input.js

@@ -0,0 +1,64 @@
+// Codex app-server 0.147 structured user-input protocol mapping.
+var userInput = require("./user-input");
+
+function nativeInput(params) {
+  return {
+    questions: (params.questions || []).map(function (question) {
+      return {
+        id: question.id,
+        header: question.header || "",
+        question: question.question,
+        allowOther: question.isOther !== false,
+        secret: question.isSecret === true,
+        options: Array.isArray(question.options) ? question.options : [],
+      };
+    }),
+  };
+}
+
+function handleNative(appServer, msg, handler, expectedThreadId, signal) {
+  var params = msg.params || {};
+  if (!params.threadId || (expectedThreadId && params.threadId !== expectedThreadId)) {
+    appServer.respondError(msg.id, -32001, "Structured input request does not belong to this query thread.");
+    return;
+  }
+  userInput.dispatchUserInput(handler, nativeInput(params), {
+    requestId: params.itemId || String(msg.id),
+    signal: signal,
+    source: "codex_request_user_input",
+    native: true,
+    provider: "codex",
+    diagnostics: { threadId: params.threadId, turnId: params.turnId || null, itemId: params.itemId || null },
+  }).then(function (result) {
+    appServer.respond(msg.id, userInput.codexResponse(result));
+  }).catch(function (error) {
+    appServer.respondError(msg.id, -32602, error.message);
+  });
+}
+
+function handleElicitation(appServer, msg, handler, signal) {
+  var params = msg.params || {};
+  var request = {
+    serverName: params.serverName || (params._meta && params._meta.tool) || "Tool",
+    message: params.message || params.prompt || "",
+    url: params.url || null,
+    elicitationId: params.elicitationId || null,
+    requestedSchema: params.requestedSchema || null,
+  };
+  var input = Array.isArray(params.questions) ? nativeInput(params) : userInput.questionsFromElicitation(request);
+  userInput.dispatchUserInput(handler, input, {
+    requestId: request.elicitationId || String(msg.id),
+    signal: signal,
+    source: "codex_mcp_elicitation",
+    native: true,
+    provider: "codex",
+    presentation: "elicitation",
+    diagnostics: { threadId: params.threadId || null, elicitation: request },
+  }).then(function (result) {
+    appServer.respond(msg.id, userInput.elicitationResponse(result));
+  }).catch(function (error) {
+    appServer.respondError(msg.id, -32602, error.message);
+  });
+}
+
+module.exports = { nativeInput: nativeInput, handleNative: handleNative, handleElicitation: handleElicitation };

package/lib/yoke/complete-once.js

@@ -0,0 +1,164 @@
+// Canonical single-turn completion lifecycle for YOKE adapters.
+
+function assistantMessageText(event) {
+  if (!event || event.yokeType !== "message" || event.messageRole !== "assistant") return "";
+  if (!Array.isArray(event.content)) return "";
+  var text = "";
+  for (var i = 0; i < event.content.length; i++) {
+    if (event.content[i] && event.content[i].type === "text" && event.content[i].text) {
+      text += event.content[i].text;
+    }
+  }
+  return text;
+}
+
+function normalizedText(streamedText, finalText) {
+  if (!streamedText) return finalText;
+  if (!finalText) return streamedText;
+  if (finalText.indexOf(streamedText) === 0) return finalText;
+  if (streamedText.indexOf(finalText) === 0) return streamedText;
+  return streamedText;
+}
+
+function oneShotError(event) {
+  if (!event) return null;
+  if (event.yokeType === "error") return new Error(event.text || "One-shot completion failed.");
+  if (event.yokeType === "auth_required") {
+    return new Error("The " + (event.vendor || "selected") + " provider requires sign-in.");
+  }
+  return null;
+}
+
+async function createOneShot(adapter, queryOpts, allowUnknownPersistence) {
+  if (typeof adapter.createOneShotQuery === "function") {
+    var created = await adapter.createOneShotQuery(queryOpts);
+    if (!created || !created.handle) throw new Error("YOKE adapter returned an invalid one-shot query.");
+    if (created.backendPersistence !== "ephemeral") {
+      if (!allowUnknownPersistence) {
+        if (typeof created.handle.abort === "function") created.handle.abort();
+        if (typeof created.handle.close === "function") created.handle.close();
+        throw new Error("The " + adapter.vendor + " adapter did not confirm ephemeral one-shot execution.");
+      }
+      created.backendPersistence = "unknown";
+    }
+    return created;
+  }
+  if (!allowUnknownPersistence) {
+    throw new Error("The " + adapter.vendor + " adapter does not guarantee ephemeral one-shot execution.");
+  }
+  return {
+    handle: await adapter.createQuery(Object.assign({}, queryOpts, { persistSession: false })),
+    backendPersistence: "unknown",
+  };
+}
+
+async function completeOnce(adapter, opts) {
+  opts = opts || {};
+  if (!adapter || typeof adapter.createQuery !== "function") throw new Error("A YOKE adapter is required.");
+  if (typeof opts.prompt !== "string" || !opts.prompt.trim()) throw new Error("A one-shot prompt is required.");
+
+  var timeoutMs = opts.timeoutMs || 60000;
+  var controller = new AbortController();
+  var handle = null;
+  var timedOut = false;
+  var externallyAborted = false;
+  var timer = null;
+  var externalSignal = opts.signal || null;
+  var abortHandle = function() {
+    controller.abort();
+    if (handle && typeof handle.abort === "function") handle.abort();
+  };
+  var onExternalAbort = function() {
+    externallyAborted = true;
+    abortHandle();
+  };
+
+  if (externalSignal) {
+    if (externalSignal.aborted) onExternalAbort();
+    else externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  timer = setTimeout(function() {
+    timedOut = true;
+    abortHandle();
+  }, timeoutMs);
+
+  var streamedText = "";
+  var finalText = "";
+  var resultEvent = null;
+  var interactiveRequested = false;
+  var created;
+  try {
+    var queryOpts = Object.assign({}, opts.query || {}, {
+      cwd: opts.cwd,
+      model: opts.model,
+      systemPrompt: opts.systemPrompt,
+      abortController: controller,
+      onUserInputRequest: function (request, respond) {
+        interactiveRequested = true;
+        respond.cancel("One-shot completions cannot request interactive user input.");
+      },
+    });
+    var creationFinished = false;
+    var rejectCreation;
+    var creationAbort = new Promise(function(resolve, reject) { rejectCreation = reject; });
+    var onCreationAbort = function() { rejectCreation(new Error("One-shot completion aborted.")); };
+    controller.signal.addEventListener("abort", onCreationAbort, { once: true });
+    var creation = createOneShot(adapter, queryOpts, !!opts.allowUnknownBackendPersistence);
+    creation.then(function(lateCreated) {
+      if (!creationFinished && controller.signal.aborted && lateCreated && lateCreated.handle) {
+        if (typeof lateCreated.handle.abort === "function") lateCreated.handle.abort();
+        if (typeof lateCreated.handle.close === "function") lateCreated.handle.close();
+      }
+    }).catch(function() {});
+    try {
+      created = await Promise.race([creation, creationAbort]);
+      creationFinished = true;
+    } finally {
+      controller.signal.removeEventListener("abort", onCreationAbort);
+    }
+    handle = created.handle;
+    if (controller.signal.aborted) {
+      if (typeof handle.abort === "function") handle.abort();
+      throw new Error("One-shot completion aborted.");
+    }
+    if (handle.pushMessage(opts.prompt) !== true) {
+      throw new Error("YOKE one-shot query rejected its prompt.");
+    }
+    handle.endInput();
+
+    for await (var event of handle) {
+      var eventError = oneShotError(event);
+      if (eventError) throw eventError;
+      if (event.yokeType === "text_delta" && event.text) streamedText += event.text;
+      var messageText = assistantMessageText(event);
+      if (messageText) finalText = messageText;
+      if (event.yokeType === "result") {
+        resultEvent = event;
+        break;
+      }
+    }
+    if (timedOut) throw new Error("YOKE one-shot timed out after " + timeoutMs + " ms.");
+    if (externallyAborted) throw new Error("YOKE one-shot was aborted.");
+    if (interactiveRequested) throw new Error("YOKE one-shot completion requested interactive user input.");
+    return {
+      text: normalizedText(streamedText, finalText).trim(),
+      backendPersistence: created.backendPersistence || "unknown",
+      vendor: adapter.vendor,
+      model: opts.model || null,
+      result: resultEvent,
+    };
+  } catch (error) {
+    if (timedOut) throw new Error("YOKE one-shot timed out after " + timeoutMs + " ms.");
+    if (externallyAborted) throw new Error("YOKE one-shot was aborted.");
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    if (externalSignal) externalSignal.removeEventListener("abort", onExternalAbort);
+    if (handle && typeof handle.close === "function") handle.close();
+  }
+}
+
+module.exports = {
+  completeOnce: completeOnce,
+  normalizedText: normalizedText,
+};

package/lib/yoke/index.js

@@ -4,6 +4,8 @@
 var iface = require("./interface");
 var instructions = require("./instructions");
 var vendorRegistry = require("./vendor-registry");
+var completeOnce = require("./complete-once").completeOnce;
+var userInput = require("./user-input");
 var createClaudeAdapter = require("./adapters/claude").createClaudeAdapter;
 var createCodexAdapter = require("./adapters/codex").createCodexAdapter;
 var createAntigravityAdapter = require("./adapters/antigravity").createAntigravityAdapter;
@@ -47,7 +49,7 @@ function wrapCreateQuery(adapter, defaultCwd) {
   adapter.createQuery = function(queryOpts) {
     queryOpts = queryOpts || {};
     var projectDir = (queryOpts && queryOpts.cwd) || defaultCwd;
-    var merged = instructions.scanAndMerge(projectDir, adapter.vendor);
+    var merged = queryOpts.skipProjectInstructions ? "" : instructions.scanAndMerge(projectDir, adapter.vendor);
 
     if (merged) {
       var parts = [];
@@ -473,4 +475,6 @@ module.exports = {
   TOOL_POLICIES: iface.TOOL_POLICIES,
   validateAdapter: iface.validateAdapter,
   validateQueryHandle: iface.validateQueryHandle,
+  completeOnce: completeOnce,
+  userInput: userInput,
 };

package/lib/yoke/interface.js

@@ -40,6 +40,25 @@ var INITIALIZE_TIMEOUT_MS = 90000;
  *   .createToolServer(def): ToolServer (opaque)
  *   .createQuery(opts): QueryHandle
  *
+ * Optional one-shot capability:
+ *   .createOneShotQuery(opts): Promise<{ handle, backendPersistence }>
+ *     backendPersistence is "ephemeral" only when the adapter can verify the
+ *     provider does not materialize the backend conversation. Adapters without
+ *     this method may only use completeOnce's explicit unknown-persistence path.
+ *
+ * Optional structured user-input capability:
+ *   .userInputCapability: { mode: "native"|"fallback", native: boolean, transport: string }
+ *   createQuery({ userInputMode: "auto"|"native"|"fallback",
+ *                 onUserInputRequest(request, respond) })
+ *     request.presentation is "questions" or "elicitation";
+ *     request.questions contain 1-3 { id, header, question, multiSelect,
+ *     allowOther, secret, options }; options contain zero or 2-6 safe
+ *     { label, description } entries. respond(answerMap),
+ *     respond.submitContent(typedMap), and respond.cancel(reason) settle
+ *     exactly once. submitContent preserves typed MCP elicitation forms.
+ *     Adapters with mode "native" translate their provider protocol directly.
+ *     Other adapters use createFallbackServer() from yoke/user-input.
+ *
  * Lightweight utilities:
  *   .generateTitle(messages, opts) : Promise<string> - generate a short session title
  *     messages: string[] - user messages to derive the title from

package/lib/yoke/mcp-bridge-server.js

@@ -102,12 +102,8 @@ function postJson(urlPath, body) {
       reject(err);
     });
 
-    // 10 min safety ceiling. ask_user_questions is stateless (returns
-    // immediately; the user's answer arrives on the next turn as a new
-    // user message), so no tool call should legitimately block long.
-    // The generous ceiling is just a belt-and-suspenders against slow
-    // browser automation or external MCP servers, not the primary
-    // mechanism for human-in-the-loop tools.
+    // 10 min safety ceiling. Structured user input may legitimately wait
+    // for a person, while other tools normally return much sooner.
     req.setTimeout(600000, function () {
       req.destroy(new Error("Request timed out"));
     });

package/lib/yoke/user-input.js

@@ -0,0 +1,254 @@
+// Provider-neutral structured user-input lifecycle for YOKE queries.
+
+var crypto = require("crypto");
+var z;
+try { z = require("zod"); } catch (e) { z = null; }
+
+var TOOL_NAME = "ask_user_questions";
+
+function cleanText(value, field, max) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(field + " must be a non-empty string.");
+  var text = value.trim();
+  if (text.length > max) throw new Error(field + " must be at most " + max + " characters.");
+  return text;
+}
+
+function normalizeOptions(options, questionIndex) {
+  if (options == null) return [];
+  if (!Array.isArray(options)) throw new Error("Question " + (questionIndex + 1) + " options must be an array.");
+  if (options.length === 1 || options.length > 6) {
+    throw new Error("Question " + (questionIndex + 1) + " must use zero options or 2-6 options.");
+  }
+  var result = [];
+  for (var i = 0; i < options.length; i++) {
+    var option = options[i] || {};
+    result.push({
+      label: cleanText(option.label || option.value, "Option label", 60),
+      description: typeof option.description === "string" ? option.description.trim().substring(0, 160) : "",
+    });
+  }
+  return result;
+}
+
+function normalizeQuestions(input) {
+  var source = input && Array.isArray(input.questions) ? input.questions : null;
+  if (!source || source.length < 1 || source.length > 3) throw new Error("Structured input requires 1-3 questions.");
+  var ids = {};
+  var questions = [];
+  for (var i = 0; i < source.length; i++) {
+    var item = source[i] || {};
+    var id = typeof item.id === "string" && item.id.trim() ? item.id.trim() : "question_" + (i + 1);
+    if (id.length > 128 || ids[id]) throw new Error("Question IDs must be unique strings of at most 128 characters.");
+    ids[id] = true;
+    questions.push({
+      id: id,
+      header: typeof item.header === "string" ? item.header.trim().substring(0, 40) : "",
+      question: cleanText(item.question || item.prompt, "Question", 2000),
+      multiSelect: item.multiSelect === true,
+      allowOther: item.allowOther !== false && item.isOther !== false,
+      secret: item.secret === true || item.isSecret === true,
+      options: normalizeOptions(item.options, i),
+    });
+  }
+  return questions;
+}
+
+function questionsFromElicitation(request) {
+  var schema = request && request.requestedSchema;
+  var properties = schema && schema.properties && typeof schema.properties === "object" ? schema.properties : null;
+  var questions = [];
+  if (properties) {
+    Object.keys(properties).forEach(function (id) {
+      var property = properties[id] || {};
+      var values = Array.isArray(property.enum) ? property.enum : [];
+      questions.push({
+        id: id,
+        header: request.serverName || "Input",
+        question: property.description || request.message || id,
+        options: values.map(function (value) { return { label: String(value), description: "" }; }),
+      });
+    });
+  }
+  if (!questions.length) questions.push({ id: "response", header: request.serverName || "Input", question: request.message || "What should the tool use?", options: [] });
+  return { questions: questions };
+}
+
+function answerValues(value) {
+  if (value && Array.isArray(value.answers)) value = value.answers;
+  if (!Array.isArray(value)) value = value == null ? [] : [value];
+  return value.map(function (entry) { return String(entry).trim(); }).filter(Boolean);
+}
+
+function normalizeAnswers(questions, raw) {
+  raw = raw || {};
+  var answers = {};
+  for (var i = 0; i < questions.length; i++) {
+    var question = questions[i];
+    var value = Object.prototype.hasOwnProperty.call(raw, question.id) ? raw[question.id] : raw[i];
+    var values = answerValues(value);
+    if (!values.length) throw new Error("An answer is required for " + question.id + ".");
+    if (!question.multiSelect && values.length > 1) throw new Error("Only one answer is allowed for " + question.id + ".");
+    answers[question.id] = values;
+  }
+  return answers;
+}
+
+/**
+ * Start one provider-neutral structured-input request.
+ *
+ * handler receives:
+ *   request: { id, questions, source, native, provider, diagnostics }
+ *   respond(answers): submits once; respond.cancel(reason) cancels once.
+ *
+ * The returned promise resolves to { status, answers|reason }. Provider
+ * adapters translate that result back to their own wire protocol. Nothing in
+ * this lifecycle is persisted; Clay callers may persist sanitized events.
+ */
+function dispatchUserInput(handler, input, opts) {
+  opts = opts || {};
+  var questions;
+  try { questions = normalizeQuestions(input); } catch (e) { return Promise.reject(e); }
+  if (typeof handler !== "function") return Promise.reject(new Error("This query cannot request structured user input."));
+  var id = opts.requestId || (input && input.id) || "yoke_input_" + crypto.randomUUID();
+  var settled = false;
+  var abortHandler = null;
+  var settleListeners = [];
+  return new Promise(function (resolve, reject) {
+    function cleanup(result) {
+      if (opts.signal && abortHandler && typeof opts.signal.removeEventListener === "function") opts.signal.removeEventListener("abort", abortHandler);
+      for (var li = 0; li < settleListeners.length; li++) {
+        try { settleListeners[li](result); } catch (e) {}
+      }
+    }
+    function finish(result) {
+      if (settled) return false;
+      settled = true;
+      cleanup(result);
+      resolve(result);
+      return true;
+    }
+    function fail(error) {
+      if (settled) return false;
+      settled = true;
+      cleanup({ status: "error", error: error.message || String(error) });
+      reject(error);
+      return true;
+    }
+    var respond = function (answers) {
+      try { return finish({ status: "submitted", answers: normalizeAnswers(questions, answers) }); }
+      catch (e) { return fail(e); }
+    };
+    respond.submitContent = function (content) {
+      if (!content || typeof content !== "object" || Array.isArray(content)) return fail(new Error("Structured elicitation content must be an object."));
+      return finish({ status: "submitted", answers: {}, content: content });
+    };
+    respond.cancel = function (reason) { return finish({ status: "cancelled", reason: reason || "Cancelled" }); };
+    respond.isPending = function () { return !settled; };
+    respond.onSettle = function (listener) {
+      if (typeof listener === "function" && !settled) settleListeners.push(listener);
+      return respond;
+    };
+    abortHandler = function () { respond.cancel("Aborted"); };
+    if (opts.signal) {
+      if (opts.signal.aborted) return abortHandler();
+      opts.signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    var request = {
+      id: String(id),
+      questions: questions,
+      presentation: opts.presentation || "questions",
+      source: opts.source || "unknown",
+      native: opts.native === true,
+      provider: opts.provider || null,
+      diagnostics: opts.diagnostics || null,
+    };
+    try {
+      var returned = handler(request, respond);
+      if (returned && typeof returned.then === "function") returned.catch(fail);
+    } catch (error) {
+      fail(error);
+    }
+  });
+}
+
+function claudePermissionResult(input, result) {
+  if (!result || result.status !== "submitted") return { behavior: "deny", message: (result && result.reason) || "Cancelled" };
+  var questions = normalizeQuestions(input);
+  var byText = {};
+  for (var i = 0; i < questions.length; i++) byText[questions[i].question] = result.answers[questions[i].id].join(", ");
+  return { behavior: "allow", updatedInput: Object.assign({}, input, { answers: byText }) };
+}
+
+function codexResponse(result) {
+  var answers = {};
+  if (result && result.status === "submitted") {
+    Object.keys(result.answers).forEach(function (id) { answers[id] = { answers: result.answers[id] }; });
+  }
+  return { answers: answers };
+}
+
+function elicitationResponse(result) {
+  if (!result || result.status !== "submitted") return { action: "reject" };
+  if (result.content) return { action: "accept", content: result.content };
+  var content = {};
+  Object.keys(result.answers).forEach(function (id) { content[id] = result.answers[id].length === 1 ? result.answers[id][0] : result.answers[id]; });
+  return { action: "accept", content: content };
+}
+
+function buildQuestionShape() {
+  if (!z) return {};
+  var option = z.object({ label: z.string().min(1).max(60), description: z.string().max(160).optional() }).passthrough();
+  var question = z.object({
+    id: z.string().max(128).optional(), header: z.string().max(40).optional(), question: z.string().min(1),
+    multiSelect: z.boolean().optional(), options: z.array(option).max(6).refine(function (items) { return items.length === 0 || items.length >= 2; }),
+  }).passthrough();
+  return { questions: z.array(question).min(1).max(3) };
+}
+
+function fallbackToolDefs(handler) {
+  return [{
+    name: TOOL_NAME,
+    description: "Ask the user 1-3 structured questions. Use zero options for freeform or 2-6 options for choices; never one option.",
+    inputSchema: buildQuestionShape(),
+    handler: function (input) {
+      return dispatchUserInput(handler, input, { source: "mcp_fallback", native: false }).then(function (result) {
+        if (result.status !== "submitted") return { content: [{ type: "text", text: "The user cancelled this question." }], isError: true };
+        return { content: [{ type: "text", text: JSON.stringify(result.answers) }] };
+      }).catch(function (error) { return { content: [{ type: "text", text: "Error: " + error.message }], isError: true }; });
+    },
+  }];
+}
+
+function capability(adapter) {
+  return adapter && adapter.userInputCapability ? adapter.userInputCapability : { mode: "fallback", native: false };
+}
+
+function selectMode(adapter, requestedMode) {
+  if (requestedMode === "fallback") return "fallback";
+  if (requestedMode === "native" && capability(adapter).mode !== "native") {
+    throw new Error("This provider does not support native structured user input.");
+  }
+  return capability(adapter).mode === "native" ? "native" : "fallback";
+}
+
+function createFallbackServer(adapter, handler) {
+  var opts = arguments.length > 2 && arguments[2] ? arguments[2] : {};
+  if (!adapter || typeof adapter.createToolServer !== "function") return null;
+  if (capability(adapter).mode === "native" && opts.force !== true) return null;
+  return adapter.createToolServer({ name: "yoke-user-input", version: "1.0.0", tools: fallbackToolDefs(handler) });
+}
+
+module.exports = {
+  TOOL_NAME: TOOL_NAME,
+  normalizeQuestions: normalizeQuestions,
+  questionsFromElicitation: questionsFromElicitation,
+  normalizeAnswers: normalizeAnswers,
+  dispatchUserInput: dispatchUserInput,
+  claudePermissionResult: claudePermissionResult,
+  codexResponse: codexResponse,
+  elicitationResponse: elicitationResponse,
+  fallbackToolDefs: fallbackToolDefs,
+  createFallbackServer: createFallbackServer,
+  capability: capability,
+  selectMode: selectMode,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "3.8.1",
+  "version": "4.0.0-beta.1",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js",
@@ -52,6 +52,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.241",
     "@lydell/node-pty": "^1.2.0-beta.3",
     "@openai/codex": "^0.147.0",
+    "@seald-io/nedb": "^4.1.2",
     "imapflow": "^1.3.1",
     "nodemailer": "^9.0.5",
     "qrcode-terminal": "^0.12.0",