clay-server 4.7.1-beta.2 → 4.7.1-beta.4

package/lib/yoke/adapters/antigravity.js

@@ -74,6 +74,23 @@ function toolName(name) {
   return name || "Tool";
 }
 
+var USAGE_FIELDS = ["input_tokens", "output_tokens", "cache_read_tokens"];
+var ZERO_USAGE = { input_tokens: 0, output_tokens: 0, cache_read_tokens: 0 };
+
+// Result counters are cumulative for the conversation. A per-turn delta is
+// trustworthy only against a known baseline that has not gone backwards.
+function usageDelta(current, baseline) {
+  if (!current || !baseline) return null;
+  var result = {};
+  for (var i = 0; i < USAGE_FIELDS.length; i++) {
+    var field = USAGE_FIELDS[i];
+    var delta = (current[field] || 0) - (baseline[field] || 0);
+    if (delta < 0) return null;
+    result[field] = delta;
+  }
+  return result;
+}
+
 function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
   var processHandle = null;
   var removeAbort = function () {};
@@ -97,6 +114,14 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
   var textBlockId = null;
   var toolBlocks = {};
   var latestUsage = null;
+  // Trusted cumulative counters from the previous result. A fresh conversation
+  // starts at zero; a resumed one has no trustworthy baseline until its first
+  // result, and a result without counters invalidates the baseline again.
+  var usageBaseline = queryOpts.resumeSessionId ? null : ZERO_USAGE;
+  var durationBaseline = queryOpts.resumeSessionId ? null : 0;
+  var turnUsage = null;
+  var turnDurationSeconds = null;
+  var countedStepIndexes = {};
   var firstMessage = true;
 
   function notifyFinished() {
@@ -146,6 +171,9 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
     activeTurn = true;
     textBlockId = null;
     toolBlocks = {};
+    turnUsage = null;
+    turnDurationSeconds = null;
+    countedStepIndexes = {};
     pushEvent({ yokeType: "turn_start", messageType: "user" });
     processHandle.stdin.write(JSON.stringify({
       event: "user",
@@ -156,7 +184,17 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
   function finishTurn(result) {
     result = result || {};
     if (result.conversation_id) sessionId = result.conversation_id;
-    if (result.usage) latestUsage = result.usage;
+    // Prefer the cumulative counter delta; otherwise fall back to this turn's
+    // completed-step totals, or leave the turn unknown.
+    var resultUsage = result.usage || null;
+    var emittedUsage = usageDelta(resultUsage, usageBaseline) || turnUsage;
+    usageBaseline = resultUsage;
+    if (resultUsage) latestUsage = resultUsage;
+    var totalSeconds = typeof result.duration_seconds === "number" ? result.duration_seconds : null;
+    var durationSeconds = totalSeconds != null && durationBaseline != null && totalSeconds >= durationBaseline
+      ? totalSeconds - durationBaseline
+      : turnDurationSeconds;
+    durationBaseline = totalSeconds;
     var status = result.status || "SUCCESS";
     if (status !== "SUCCESS") {
       if (status === "CANCELED" || status === "INTERRUPTED") {
@@ -172,11 +210,11 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
       yokeType: "result",
       messageType: "assistant",
       cost: null,
-      duration: typeof result.duration_seconds === "number" ? result.duration_seconds * 1000 : null,
-      usage: latestUsage ? {
-        input_tokens: latestUsage.input_tokens || 0,
-        output_tokens: latestUsage.output_tokens || 0,
-        cache_read_input_tokens: latestUsage.cache_read_tokens || 0,
+      duration: typeof durationSeconds === "number" ? durationSeconds * 1000 : null,
+      usage: emittedUsage ? {
+        input_tokens: emittedUsage.input_tokens || 0,
+        output_tokens: emittedUsage.output_tokens || 0,
+        cache_read_input_tokens: emittedUsage.cache_read_tokens || 0,
         cache_creation_input_tokens: 0,
       } : null,
       sessionId: sessionId,
@@ -189,6 +227,17 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
 
   function handleStep(step) {
     if (!step) return;
+    var stepKey = step.step_index == null ? null : String(step.step_index);
+    if (step.state === "DONE" && (stepKey == null || !countedStepIndexes[stepKey])) {
+      if (stepKey != null) countedStepIndexes[stepKey] = true;
+      if (step.usage) {
+        if (!turnUsage) turnUsage = {};
+        USAGE_FIELDS.forEach(function(field) {
+          turnUsage[field] = (turnUsage[field] || 0) + (step.usage[field] || 0);
+        });
+      }
+      if (typeof step.duration_seconds === "number") turnDurationSeconds = (turnDurationSeconds || 0) + step.duration_seconds;
+    }
     if (step.step_type === "agent_response") {
       if (!textBlockId) {
         textBlockId = "agy_blk_" + (++blockCounter);

package/lib/yoke/adapters/claude-worker.js

@@ -370,7 +370,7 @@ function onElicitation(request, opts) {
     if (opts.signal) {
       opts.signal.addEventListener("abort", function() {
         delete pendingElicitations[requestId];
-        resolve({ action: "reject" });
+        resolve({ action: "cancel" });
       });
     }
   });

package/lib/yoke/adapters/codex.js

@@ -1079,10 +1079,13 @@ function createCodexQueryHandle(appServer, queryOpts) {
         onElicitation(request, {
           signal: { addEventListener: function() {} },
         }).then(function(result) {
-          appServer.respond(msg.id, result || { action: "reject" });
+          var resultAction = result && result.action === "reject" ? "decline" : result && result.action;
+          appServer.respond(msg.id, resultAction === "accept" || resultAction === "decline"
+            ? Object.assign({}, result, { action: resultAction })
+            : { action: "cancel" });
         }).catch(function(err) {
           console.error("[yoke/codex] elicitation_response send failed:", err.message || err);
-          appServer.respond(msg.id, { action: "reject" });
+          appServer.respond(msg.id, { action: "cancel" });
         });
       } else if (canUseTool) {
         canUseTool("mcp__" + (mcpParams.serverName || "unknown") + "__" + (mcpMeta.tool || "call"), mcpParams, {}).then(function(decision) {

package/lib/yoke/adapters/kiro.js

@@ -204,12 +204,12 @@ function flattenUpdate(update, state) {
   // Tool call announced
   if (type === "tool_call") {
     var callId = update.toolCallId;
-    var toolName = toolNameForKind(update.kind, update.title);
+    var toolName = update.name || toolNameForKind(update.kind, update.title);
     // Cache kind/rawInput so the permission handler (whose request payload only
     // carries { toolCallId, title }) can pass a canonical tool name + input to
     // canUseTool. Clay's permission whitelist keys on canonical names.
     if (callId) {
-      state.toolMeta[callId] = { kind: update.kind, title: update.title, rawInput: update.rawInput || {} };
+      state.toolMeta[callId] = { kind: update.kind, name: update.name, title: update.title, rawInput: update.rawInput || {} };
     }
     if (callId && !state.toolBlocks[callId]) {
       state.blockCounter++;
@@ -501,8 +501,13 @@ function createKiroQueryHandle(acp, queryOpts) {
         }
         return null;
       }
-      var allowId = pickOption(["allow_once", "allow_always"]) || (options[0] && options[0].optionId);
-      var rejectId = pickOption(["reject_once", "reject_always"]) || (options[options.length - 1] && options[options.length - 1].optionId);
+      var allowId = pickOption(["allow_once", "allow_always"]);
+      var rejectId = pickOption(["reject_once", "reject_always"]);
+      function permissionResponse(optionId) {
+        return optionId
+          ? { outcome: { outcome: "selected", optionId: optionId } }
+          : { outcome: { outcome: "cancelled" } };
+      }
 
       if (isCancelled()) {
         acp.respond(msg.id, { outcome: { outcome: "cancelled" } });
@@ -512,21 +517,21 @@ function createKiroQueryHandle(acp, queryOpts) {
         // The permission request payload carries only { toolCallId, title }.
         // Recover kind + rawInput from the tool_call notification we cached.
         var meta = (tc.toolCallId && state.toolMeta[tc.toolCallId]) || {};
-        var toolName = toolNameForKind(tc.kind || meta.kind, tc.title || meta.title);
+        var toolName = tc.name || meta.name || toolNameForKind(tc.kind || meta.kind, tc.title || meta.title);
         var toolInput = tc.rawInput || meta.rawInput || { title: tc.title || meta.title };
         cancellation.wait(Promise.resolve().then(function () { cancellation.check(); return canUseTool(toolName, toolInput, { signal: cancellation.signal }); })).then(function(decision) {
-          acp.respond(msg.id, isCancelled() ? { outcome: { outcome: "cancelled" } } : { outcome: { outcome: "selected", optionId: isApproved(decision) ? allowId : rejectId } });
+          acp.respond(msg.id, isCancelled() ? { outcome: { outcome: "cancelled" } } : permissionResponse(isApproved(decision) ? allowId : rejectId));
         }).catch(function(err) {
           if (isCancelled()) { acp.respond(msg.id, { outcome: { outcome: "cancelled" } }); return; }
           console.error("[yoke/kiro] canUseTool error:", err.message);
-          acp.respond(msg.id, { outcome: { outcome: "selected", optionId: rejectId } });
+          acp.respond(msg.id, permissionResponse(rejectId));
         });
       } else {
         // No approver wired up. Deny: Clay is the only thing standing between
         // the agent and the user's filesystem, so absence of an approver must
         // never mean approval.
         console.warn("[yoke/kiro] permission request with no canUseTool callback, denying");
-        acp.respond(msg.id, { outcome: { outcome: "selected", optionId: rejectId } });
+        acp.respond(msg.id, permissionResponse(rejectId));
       }
       return;
     }
@@ -652,12 +657,6 @@ function createKiroQueryHandle(acp, queryOpts) {
             cwd: queryOpts.cwd,
             mcpServers: queryOpts.mcpServers || [],
           }, 60000);
-        } catch (e) {
-          if (isCancelled()) throw e;
-          // If load fails (unknown session), fall back to a fresh session.
-          console.warn("[yoke/kiro] session/load failed, starting fresh:", e.message);
-          state.sessionId = null;
-          handlerEntry.sessionId = null;
         } finally {
           state.loadingSession = false;
         }
@@ -681,12 +680,12 @@ function createKiroQueryHandle(acp, queryOpts) {
         }, 15000);
       }
 
-      // Select model + mode for the session (best-effort; failures are non-fatal).
+      // Select the requested model and mode before the prompt is sent.
       if (queryOpts.model) {
-        await setSessionModel(queryOpts.model).catch(function() {});
+        await setSessionModel(queryOpts.model);
       }
       if (queryOpts.mode) {
-        await send("session/set_mode", { sessionId: state.sessionId, modeId: queryOpts.mode }, 15000).catch(function() {});
+        await send("session/set_mode", { sessionId: state.sessionId, modeId: queryOpts.mode }, 15000);
       }
 
       while (!isCancelled()) {

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

@@ -14,15 +14,13 @@ function ask(handler, input, opts) {
 
 function elicitation(handler, request, opts) {
   opts = opts || {};
-  return userInput.dispatchUserInput(handler, userInput.questionsFromElicitation(request), {
+  return userInput.dispatchElicitation(handler, request, {
     requestId: opts.requestId || request.elicitationId,
     signal: opts.signal,
     source: "claude_elicitation",
     native: true,
     provider: "claude",
-    presentation: "elicitation",
-    diagnostics: { elicitation: request },
-  }).then(userInput.elicitationResponse);
+  }).then(function (result) { return userInput.elicitationResponse(result, request.requestedSchema); });
 }
 
 function canUseTool(queryOpts) {

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

@@ -45,8 +45,7 @@ function handleElicitation(appServer, msg, handler, signal) {
     elicitationId: params.elicitationId || null,
     requestedSchema: params.requestedSchema || null,
   };
-  var input = Array.isArray(params.questions) ? nativeInput(params) : userInput.questionsFromElicitation(request);
-  userInput.dispatchUserInput(handler, input, {
+  var dispatchOpts = {
     requestId: request.elicitationId || String(msg.id),
     signal: signal,
     source: "codex_mcp_elicitation",
@@ -54,8 +53,12 @@ function handleElicitation(appServer, msg, handler, signal) {
     provider: "codex",
     presentation: "elicitation",
     diagnostics: { threadId: params.threadId || null, elicitation: request },
-  }).then(function (result) {
-    appServer.respond(msg.id, userInput.elicitationResponse(result));
+  };
+  var pending = Array.isArray(params.questions)
+    ? userInput.dispatchUserInput(handler, nativeInput(params), dispatchOpts)
+    : userInput.dispatchElicitation(handler, request, dispatchOpts);
+  pending.then(function (result) {
+    appServer.respond(msg.id, userInput.elicitationResponse(result, request.requestedSchema));
   }).catch(function (error) {
     appServer.respondError(msg.id, -32602, error.message);
   });

package/lib/yoke/elicitation-schema.js

@@ -0,0 +1,204 @@
+// Restricted elicitation schema handling shared by ACP, Claude and Codex.
+// Mirrors lib/public/modules/elicitation-schema.js; keep both in sync
+// (test/elicitation-schema-parity.test.js runs one fixture table on both).
+
+var PATTERN_MAX_LENGTH = 200;
+var PATTERN_MAX_VARIABLE_QUANTIFIERS = 2;
+var PATTERN_MAX_INPUT_LENGTH = 256;
+
+function hasOwn(object, key) {
+  return !!object && Object.prototype.hasOwnProperty.call(object, key);
+}
+
+function constChoices(list) {
+  if (!Array.isArray(list)) return null;
+  var values = [];
+  for (var i = 0; i < list.length; i++) {
+    if (!hasOwn(list[i], "const")) return null;
+    values.push({ value: list[i].const, label: String(list[i].title || list[i].const), description: list[i].description || "" });
+  }
+  return values.length ? values : null;
+}
+
+function enumChoices(list) {
+  if (!Array.isArray(list) || !list.length) return null;
+  return list.map(function (value) { return { value: value, label: String(value), description: "" }; });
+}
+
+// Returns { kind, multi, choices } where kind is one of string, number,
+// integer, boolean, array or unsupported. Unknown types are never rendered
+// or validated as a known control.
+function fieldInfo(property) {
+  property = property || {};
+  var type = property.type || (Array.isArray(property.enum) || Array.isArray(property.oneOf) ? "string" : null);
+  if (type === "array") {
+    var items = property.items || {};
+    var itemType = items.type || "string";
+    var itemChoices = itemType === "string" ? (enumChoices(items.enum) || constChoices(items.anyOf)) : null;
+    return itemChoices ? { kind: "array", multi: true, choices: itemChoices } : { kind: "unsupported", multi: false, choices: null };
+  }
+  if (type === "string") return { kind: "string", multi: false, choices: enumChoices(property.enum) || constChoices(property.oneOf) };
+  if (type === "number" || type === "integer" || type === "boolean") return { kind: type, multi: false, choices: null };
+  return { kind: "unsupported", multi: false, choices: null };
+}
+
+// Agent-supplied patterns are evaluated only inside a subset whose backtracking
+// cost is bounded: no backreferences, lookaround or quantified groups, at most
+// two variable quantifiers, and short inputs. Anything else is an unenforced hint.
+function patternIsBounded(pattern) {
+  if (typeof pattern !== "string" || !pattern || pattern.length > PATTERN_MAX_LENGTH) return false;
+  var variable = 0;
+  var inClass = false;
+  for (var i = 0; i < pattern.length; i++) {
+    var ch = pattern[i];
+    if (ch === "\\") {
+      var next = pattern[i + 1];
+      if (next === undefined || /[1-9k]/.test(next)) return false;
+      i++;
+      continue;
+    }
+    if (inClass) { if (ch === "]") inClass = false; continue; }
+    if (ch === "[") { inClass = true; continue; }
+    if (ch === "(" && pattern[i + 1] === "?") {
+      if (pattern[i + 2] !== ":") return false;
+      i += 2;
+      continue;
+    }
+    if (ch === "*" || ch === "+" || ch === "?" || ch === "{") {
+      if (pattern[i - 1] === ")") return false;
+      if (ch === "{") {
+        var close = pattern.indexOf("}", i);
+        if (close === -1) return false;
+        var body = pattern.slice(i + 1, close);
+        if (!/^\d+(,\d*)?$/.test(body)) return false;
+        if (body.indexOf(",") !== -1) variable++;
+        i = close;
+      } else {
+        variable++;
+      }
+      if (pattern[i + 1] === "?") i++;
+    }
+  }
+  if (inClass || variable > PATTERN_MAX_VARIABLE_QUANTIFIERS) return false;
+  try { new RegExp(pattern, "u"); } catch (e) { return false; }
+  return true;
+}
+
+// true or false when evaluated; null when the pattern is left as a hint.
+function patternMatches(pattern, value) {
+  if (!patternIsBounded(pattern) || value.length > PATTERN_MAX_INPUT_LENGTH) return null;
+  return new RegExp(pattern, "u").test(value);
+}
+
+function sameValue(left, right) {
+  return left === right;
+}
+
+function inChoices(choices, value) {
+  return choices.some(function (choice) { return sameValue(choice.value, value); });
+}
+
+// Returns an error message or null. `value` must already be typed.
+function valueError(value, property) {
+  property = property || {};
+  var info = fieldInfo(property);
+  if (info.kind === "unsupported") return null;
+  if (info.kind === "boolean") return typeof value === "boolean" ? null : "Choose yes or no.";
+  if (info.kind === "number" || info.kind === "integer") {
+    if (typeof value !== "number" || !Number.isFinite(value)) return "Enter a number.";
+    if (info.kind === "integer" && !Number.isInteger(value)) return "Enter a whole number.";
+    if (typeof property.minimum === "number" && value < property.minimum) return "Must be at least " + property.minimum + ".";
+    if (typeof property.maximum === "number" && value > property.maximum) return "Must be at most " + property.maximum + ".";
+    return null;
+  }
+  if (info.kind === "array") {
+    if (!Array.isArray(value)) return "Choose from the listed options.";
+    for (var i = 0; i < value.length; i++) {
+      if (!inChoices(info.choices, value[i])) return "Choose only listed options.";
+      if (value.indexOf(value[i]) !== i) return "Choose each option once.";
+    }
+    if (typeof property.minItems === "number" && value.length < property.minItems) return "Choose at least " + property.minItems + ".";
+    if (typeof property.maxItems === "number" && value.length > property.maxItems) return "Choose at most " + property.maxItems + ".";
+    return null;
+  }
+  if (typeof value !== "string") return "Enter text.";
+  if (info.choices) return inChoices(info.choices, value) ? null : "Choose one of the listed options.";
+  var length = Array.from(value).length;
+  if (typeof property.minLength === "number" && length < property.minLength) return "Must be at least " + property.minLength + " characters.";
+  if (typeof property.maxLength === "number" && length > property.maxLength) return "Must be at most " + property.maxLength + " characters.";
+  if (patternMatches(property.pattern, value) === false) return "Does not match the required format.";
+  return null;
+}
+
+// Accepts string answers from the question-card path and returns a typed value.
+function coerceValue(value, property) {
+  var info = fieldInfo(property);
+  if (info.kind === "boolean" && (value === "true" || value === "false")) return value === "true";
+  if ((info.kind === "number" || info.kind === "integer") && typeof value === "string" && value.trim()) return Number(value);
+  if (info.kind === "array" && !Array.isArray(value)) return value == null ? [] : [value];
+  return value;
+}
+
+// Required means presence only. Throws on the first invalid property.
+function validateContent(content, schema) {
+  if (!content || typeof content !== "object" || Array.isArray(content)) throw new Error("Elicitation content must be an object.");
+  var properties = schema && schema.properties && typeof schema.properties === "object" ? schema.properties : {};
+  var required = schema && Array.isArray(schema.required) ? schema.required : [];
+  var validated = Object.assign({}, content);
+  for (var i = 0; i < required.length; i++) {
+    if (hasOwn(properties, required[i]) && !hasOwn(content, required[i])) throw new Error("An answer is required for " + required[i] + ".");
+  }
+  Object.keys(properties).forEach(function (id) {
+    if (!hasOwn(content, id)) return;
+    var value = coerceValue(content[id], properties[id]);
+    var error = valueError(value, properties[id]);
+    if (error) throw new Error("Invalid elicitation answer for " + id + ": " + error);
+    validated[id] = value;
+  });
+  return validated;
+}
+
+function clip(text, max) {
+  text = typeof text === "string" ? text.trim() : "";
+  return text.length > max ? text.slice(0, max - 1) + "…" : text;
+}
+
+// Provider-neutral question view of a form. Unlike structured question tools,
+// forms have no property-count or text-length limits; text is only clipped.
+function questionsFromSchema(request) {
+  var schema = request && request.requestedSchema;
+  var properties = schema && schema.properties && typeof schema.properties === "object" ? schema.properties : null;
+  var required = schema && Array.isArray(schema.required) ? schema.required : [];
+  var header = clip(request && request.serverName, 40) || "Input";
+  var questions = [];
+  Object.keys(properties || {}).forEach(function (id) {
+    var property = properties[id] || {};
+    var info = fieldInfo(property);
+    var choices = info.choices || (info.kind === "boolean" ? [{ value: true, label: "true", description: "Yes" }, { value: false, label: "false", description: "No" }] : []);
+    questions.push({
+      id: id,
+      header: header,
+      question: clip(property.description || property.title || (request && request.message) || id, 2000) || id,
+      multiSelect: info.multi,
+      allowOther: !info.choices && info.kind !== "boolean",
+      required: required.indexOf(id) !== -1,
+      secret: false,
+      options: choices.map(function (choice) { return { label: clip(String(choice.value), 60) || "(empty)", description: clip(choice.description || (choice.label !== String(choice.value) ? choice.label : ""), 160) }; }),
+    });
+  });
+  if (!questions.length) {
+    questions.push({ id: "response", header: header, question: clip(request && request.message, 2000) || "What should the tool use?", multiSelect: false, allowOther: true, required: true, secret: false, options: [] });
+  }
+  return questions;
+}
+
+module.exports = {
+  PATTERN_MAX_INPUT_LENGTH: PATTERN_MAX_INPUT_LENGTH,
+  fieldInfo: fieldInfo,
+  patternIsBounded: patternIsBounded,
+  patternMatches: patternMatches,
+  valueError: valueError,
+  coerceValue: coerceValue,
+  validateContent: validateContent,
+  questionsFromSchema: questionsFromSchema,
+};

package/lib/yoke/interface.js

@@ -47,17 +47,22 @@ var INITIALIZE_TIMEOUT_MS = 90000;
  *     this method may only use completeOnce's explicit unknown-persistence path.
  *
  * Optional structured user-input capability:
- *   .userInputCapability: { mode: "native"|"fallback", native: boolean, transport: string }
+ *   .userInputCapability: { mode: "native"|"fallback", native: boolean,
+ *                           nativeElicitation?: 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,
+ *     question requests 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.
+ *     { label, description } entries. Elicitation requests carry the raw
+ *     form in request.diagnostics.elicitation and have no question limit.
+ *     respond(answerMap), respond.submitContent(typedMap),
+ *     respond.decline(reason) and respond.cancel(reason) settle exactly once.
+ *     submitContent preserves typed MCP elicitation forms.
+ *     mode governs structured questions only: "native" adapters translate
+ *     their provider question protocol, others use createFallbackServer() /
+ *     fallbackToolDefs() from yoke/user-input. nativeElicitation marks
+ *     adapters that also forward agent-initiated forms on fallback mode.
  *
  * Lightweight utilities:
  *   .generateTitle(messages, opts) : Promise<string> - generate a short session title

package/lib/yoke/user-input.js

@@ -1,6 +1,7 @@
 // Provider-neutral structured user-input lifecycle for YOKE queries.
 
 var crypto = require("crypto");
+var elicitationSchema = require("./elicitation-schema");
 var z;
 try { z = require("zod"); } catch (e) { z = null; }
 
@@ -46,6 +47,7 @@ function normalizeQuestions(input) {
       question: cleanText(item.question || item.prompt, "Question", 2000),
       multiSelect: item.multiSelect === true,
       allowOther: item.allowOther !== false && item.isOther !== false,
+      required: item.required !== false,
       secret: item.secret === true || item.isSecret === true,
       options: normalizeOptions(item.options, i),
     });
@@ -54,23 +56,7 @@ function normalizeQuestions(input) {
 }
 
 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 };
+  return { questions: elicitationSchema.questionsFromSchema(request) };
 }
 
 function answerValues(value) {
@@ -86,6 +72,7 @@ function normalizeAnswers(questions, raw) {
     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 && question.required === false) continue;
     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;
@@ -98,18 +85,33 @@ function normalizeAnswers(questions, raw) {
  *
  * handler receives:
  *   request: { id, questions, source, native, provider, diagnostics }
- *   respond(answers): submits once; respond.cancel(reason) cancels once.
+ *   respond(answers): submits once; respond.cancel(reason) cancels once;
+ *   respond.decline(reason) records an explicit refusal 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); }
+  return startRequest(handler, questions, opts || {}, input && input.id);
+}
+
+/**
+ * Start one form elicitation. Forms keep their raw schema in
+ * diagnostics.elicitation and are not subject to the 1-3 question limit of
+ * structured question tools.
+ */
+function dispatchElicitation(handler, request, opts) {
+  opts = Object.assign({}, opts || {}, { presentation: "elicitation" });
+  opts.diagnostics = Object.assign({}, opts.diagnostics || {}, { elicitation: (opts.diagnostics && opts.diagnostics.elicitation) || request });
+  return startRequest(handler, elicitationSchema.questionsFromSchema(request), opts, null);
+}
+
+function startRequest(handler, questions, opts, inputId) {
   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 id = opts.requestId || inputId || "yoke_input_" + crypto.randomUUID();
   var settled = false;
   var abortHandler = null;
   var settleListeners = [];
@@ -143,6 +145,7 @@ function dispatchUserInput(handler, input, opts) {
       return finish({ status: "submitted", answers: {}, content: content });
     };
     respond.cancel = function (reason) { return finish({ status: "cancelled", reason: reason || "Cancelled" }); };
+    respond.decline = function (reason) { return finish({ status: "declined", reason: reason || "Declined" }); };
     respond.isPending = function () { return !settled; };
     respond.onSettle = function (listener) {
       if (typeof listener === "function" && !settled) settleListeners.push(listener);
@@ -187,12 +190,17 @@ function codexResponse(result) {
   return { answers: answers };
 }
 
-function elicitationResponse(result) {
-  if (!result || result.status !== "submitted") return { action: "reject" };
-  if (result.content) return { action: "accept", content: result.content };
+function elicitationResponse(result, schema) {
+  if (!result || result.status !== "submitted") return { action: result && result.status === "declined" ? "decline" : "cancel" };
+  if (result.content) return { action: "accept", content: elicitationSchema.validateContent(result.content, schema) };
   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 };
+  var properties = schema && schema.properties ? schema.properties : {};
+  Object.keys(result.answers).forEach(function (id) {
+    var values = result.answers[id];
+    var multi = elicitationSchema.fieldInfo(properties[id]).multi;
+    content[id] = multi ? values : (values.length === 1 ? values[0] : values);
+  });
+  return { action: "accept", content: elicitationSchema.validateContent(content, schema) };
 }
 
 function buildQuestionShape(maxQuestions) {
@@ -258,6 +266,7 @@ module.exports = {
   questionsFromElicitation: questionsFromElicitation,
   normalizeAnswers: normalizeAnswers,
   dispatchUserInput: dispatchUserInput,
+  dispatchElicitation: dispatchElicitation,
   claudePermissionResult: claudePermissionResult,
   codexResponse: codexResponse,
   elicitationResponse: elicitationResponse,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "4.7.1-beta.2",
+  "version": "4.7.1-beta.4",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js"