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

package/lib/project-elicitation-response.js

@@ -0,0 +1,42 @@
+// Browser elicitation_response handling: action mapping and server-side form
+// validation before the provider callback settles.
+
+var elicitationSchema = require("./yoke/elicitation-schema");
+
+// "reject" is the legacy browser spelling of an explicit refusal.
+function normalizeAction(action) {
+  if (action === "accept") return "accept";
+  if (action === "decline" || action === "reject") return "decline";
+  return "cancel";
+}
+
+// Returns true when handled. Invalid accepted forms stay pending so the user
+// can correct them; only the submitting socket receives the error.
+function handleElicitationResponse(session, ws, msg, deps) {
+  var pending = session.pendingElicitations && session.pendingElicitations[msg.requestId];
+  if (!pending) {
+    deps.sendTo(ws, { type: "elicitation_error", requestId: msg.requestId, error: "This request is no longer active.", expired: true });
+    return true;
+  }
+  var action = normalizeAction(msg.action);
+  var result = { action: action };
+  if (action === "accept") {
+    var request = pending.request || {};
+    var content = msg.content && typeof msg.content === "object" && !Array.isArray(msg.content) ? msg.content : {};
+    if (request.mode !== "url") {
+      try {
+        content = elicitationSchema.validateContent(content, request.requestedSchema);
+      } catch (error) {
+        deps.sendTo(ws, { type: "elicitation_error", requestId: msg.requestId, error: error.message });
+        return true;
+      }
+    }
+    result.content = content;
+  }
+  delete session.pendingElicitations[msg.requestId];
+  pending.resolve(result);
+  deps.sendAndRecord(session, { type: "elicitation_resolved", requestId: msg.requestId, action: action });
+  return true;
+}
+
+module.exports = { handleElicitationResponse: handleElicitationResponse, normalizeAction: normalizeAction };

package/lib/project-sessions.js

@@ -8,6 +8,7 @@ var yoke = require("./yoke");
 var sessionVisibility = require("./session-visibility");
 var contextUsageModule = require("./context-usage");
 var sessionDeleteModule = require("./project-session-delete");
+var elicitationResponse = require("./project-elicitation-response");
 
 function vendorSupportsTui(vendor) {
   var info = yoke.getVendorInfo(vendor);
@@ -1805,20 +1806,7 @@ function attachSessions(ctx) {
     if (msg.type === "elicitation_response") {
       var session = getSessionForWs(ws);
       if (!session) return true;
-      var pending = session.pendingElicitations && session.pendingElicitations[msg.requestId];
-      if (!pending) return true;
-      delete session.pendingElicitations[msg.requestId];
-      if (msg.action === "accept") {
-        pending.resolve({ action: "accept", content: msg.content || {} });
-      } else {
-        pending.resolve({ action: "reject" });
-      }
-      sm.sendAndRecord(session, {
-        type: "elicitation_resolved",
-        requestId: msg.requestId,
-        action: msg.action,
-      });
-      return true;
+      return elicitationResponse.handleElicitationResponse(session, ws, msg, { sendTo: sendTo, sendAndRecord: sm.sendAndRecord });
     }
 
     // --- Host user dialog response (SDK request_user_dialog) ---

package/lib/public/css/elicitation-form.css

@@ -0,0 +1,33 @@
+/* Elicitation request form (lib/public/modules/elicitation-form.js) */
+
+.elicitation-form { margin-top: 8px; display: flex; flex-direction: column; gap: 10px; }
+.elicitation-field { display: flex; flex-direction: column; gap: 3px; }
+.elicitation-label { font-size: 12px; font-weight: 500; color: var(--text-secondary); }
+.elicitation-help { font-size: 11px; color: var(--text-dimmer); overflow-wrap: anywhere; }
+
+.elicitation-input {
+  padding: 4px 8px;
+  border-radius: 4px;
+  border: 1px solid var(--border);
+  background: var(--input-bg);
+  color: var(--text-primary, var(--text));
+  font-size: 13px;
+  font-family: inherit;
+}
+.elicitation-checkbox { align-self: flex-start; }
+
+.elicitation-choice-group { display: flex; flex-wrap: wrap; gap: 6px 14px; }
+.elicitation-choice { display: inline-flex; align-items: center; gap: 5px; font-size: 13px; color: var(--text-secondary); cursor: pointer; }
+
+.elicitation-unsupported { font-size: 12px; color: var(--text-dimmer); font-style: italic; }
+.elicitation-url-info { margin-top: 8px; font-size: 12px; color: var(--text-muted); overflow-wrap: anywhere; }
+
+.elicitation-field-error,
+.elicitation-form-error { font-size: 12px; color: var(--error); }
+.elicitation-field-error:empty,
+.elicitation-form-error:empty { display: none; }
+.elicitation-form-error { margin-top: 8px; }
+.elicitation-field.invalid .elicitation-input,
+.elicitation-field.invalid .elicitation-choice-group { border-color: var(--error); outline: 1px solid var(--error-15); }
+
+.elicitation-container.submitting .permission-actions button { opacity: 0.6; cursor: progress; }

package/lib/public/modules/app-messages.js

@@ -34,7 +34,7 @@ import { handleSessionActionMessage } from './session-actions.js';
 import { renderWorkerProposal, updateWorkerProposal } from './worker-proposal.js';
 import { renderDriverContinuation, updateDriverContinuation, renderDriverContinuationContext } from './driver-continuation.js';
 import { handleInputSync, autoResize, builtinCommands, setScheduleBtnDisabled, sendShellResultToAgent, handleAcceptedOrdinaryMessage, handleScheduleMessageResult } from './input.js';
-import { startThinking, appendThinking, stopThinking, resetThinkingGroup, createToolItem, updateToolExecuting, updateToolResult, markAllToolsDone, closeToolGroup, removeToolFromGroup, resetToolState, getTools, getPlanContent, setPlanContent, renderPlanBanner, renderPlanCard, getTodoTools, handleTodoWrite, handleTaskCreate, handleTaskUpdate, applyDeadSessionTodoCompaction, isPlanFilePath, enableMainInput, addTurnMeta, updateSubagentActivity, addSubagentToolEntry, markSubagentDone, initSubagentStop, updateSubagentProgress, updateSubagentTaskStatus, renderAskUserQuestion, markAskUserAnswered, renderPermissionRequest, markPermissionCancelled, markPermissionResolved, renderElicitationRequest, markElicitationResolved, renderUserDialogRequest, markUserDialogResolved, updateThinkingTokens } from './tools.js';
+import { startThinking, appendThinking, stopThinking, resetThinkingGroup, createToolItem, updateToolExecuting, updateToolResult, markAllToolsDone, closeToolGroup, removeToolFromGroup, resetToolState, getTools, getPlanContent, setPlanContent, renderPlanBanner, renderPlanCard, getTodoTools, handleTodoWrite, handleTaskCreate, handleTaskUpdate, applyDeadSessionTodoCompaction, isPlanFilePath, enableMainInput, addTurnMeta, updateSubagentActivity, addSubagentToolEntry, markSubagentDone, initSubagentStop, updateSubagentProgress, updateSubagentTaskStatus, renderAskUserQuestion, markAskUserAnswered, renderPermissionRequest, markPermissionCancelled, markPermissionResolved, renderElicitationRequest, markElicitationResolved, markElicitationError, renderUserDialogRequest, markUserDialogResolved, updateThinkingTokens } from './tools.js';
 import { isInterimToolResult } from './tool-result-lifecycle.js';
 import { finishThinkingTurn, resumeThinkingAfterReplay } from './thinking-lifecycle.js';
 import { showDoneNotification, playDoneSound, isNotifAlertEnabled, isNotifSoundEnabled } from './notifications.js';
@@ -1257,6 +1257,10 @@ export function processMessage(msg) {
         stopUrgentBlink();
         break;
 
+      case "elicitation_error":
+        markElicitationError(msg.requestId, msg.error, msg.expired === true);
+        break;
+
       case "user_dialog_request":
         renderUserDialogRequest(msg);
         startUrgentBlink();

package/lib/public/modules/elicitation-form.js

@@ -0,0 +1,260 @@
+// Elicitation request card: renders a restricted-schema form, keeps omitted
+// optional values distinct from explicit false/0/"", validates before sending,
+// and stays editable until the server confirms the response.
+import { escapeHtml } from './utils.js';
+import { iconHtml } from './icons.js';
+import { getWs } from './ws-ref.js';
+import { fieldInfo, patternIsBounded, validateForm } from './elicitation-schema.js';
+
+var UNSET = "__clay_unset__";
+var FORMAT_INPUT_TYPES = { email: "email", uri: "url", date: "date" };
+
+function el(tag, className, text) {
+  var node = document.createElement(tag);
+  if (className) node.className = className;
+  if (text != null) node.textContent = text;
+  return node;
+}
+
+function hasDefault(prop) {
+  return Object.prototype.hasOwnProperty.call(prop, "default");
+}
+
+function choiceSelect(name, choices, prop, required, labels) {
+  var select = el("select", "elicitation-input");
+  var defaultIndex = -1;
+  for (var i = 0; i < choices.length; i++) {
+    if (hasDefault(prop) && choices[i].value === prop.default) defaultIndex = i;
+  }
+  if (!required || defaultIndex === -1) {
+    var unset = el("option", null, required ? labels.required : labels.optional);
+    unset.value = UNSET;
+    select.appendChild(unset);
+  }
+  choices.forEach(function (choice, index) {
+    var option = el("option", null, choice.label);
+    option.value = String(index);
+    if (choice.description) option.title = choice.description;
+    select.appendChild(option);
+  });
+  select.value = defaultIndex === -1 ? UNSET : String(defaultIndex);
+  select.name = name;
+  return select;
+}
+
+// Each builder returns { node, read } where read() yields { present, value }
+// or { present: true, raw } for unparsable text.
+function buildControl(name, prop, info, required) {
+  if (info.kind === "boolean") {
+    if (required) {
+      var box = el("input", "elicitation-checkbox");
+      box.type = "checkbox";
+      box.name = name;
+      box.checked = prop.default === true;
+      return { node: box, read: function () { return { present: true, value: box.checked }; } };
+    }
+    var boolSelect = choiceSelect(name, [{ value: true, label: "Yes" }, { value: false, label: "No" }], prop, false, { optional: "Not set" });
+    return { node: boolSelect, read: function () {
+      return boolSelect.value === UNSET ? { present: false } : { present: true, value: boolSelect.value === "0" };
+    } };
+  }
+  if (info.kind === "array") {
+    var group = el("div", "elicitation-choice-group");
+    group.setAttribute("role", "group");
+    var defaults = Array.isArray(prop.default) ? prop.default : [];
+    var boxes = info.choices.map(function (choice, index) {
+      var label = el("label", "elicitation-choice");
+      var input = el("input");
+      input.type = "checkbox";
+      input.name = name;
+      input.value = String(index);
+      input.checked = defaults.indexOf(choice.value) !== -1;
+      label.appendChild(input);
+      label.appendChild(el("span", null, choice.label));
+      if (choice.description) label.title = choice.description;
+      group.appendChild(label);
+      return input;
+    });
+    return { node: group, read: function () {
+      var values = [];
+      boxes.forEach(function (input, index) { if (input.checked) values.push(info.choices[index].value); });
+      return values.length || required ? { present: true, value: values } : { present: false };
+    } };
+  }
+  if (info.choices) {
+    var select = choiceSelect(name, info.choices, prop, required, { optional: "Not set", required: "Select…" });
+    return { node: select, read: function () {
+      return select.value === UNSET ? { present: false } : { present: true, value: info.choices[Number(select.value)].value };
+    } };
+  }
+  if (info.kind === "unsupported") {
+    return { node: el("div", "elicitation-unsupported", "This field type is not supported here."), read: function () { return { present: false }; } };
+  }
+  var input = el("input", "elicitation-input");
+  input.name = name;
+  if (info.kind === "number" || info.kind === "integer") {
+    input.type = "number";
+    input.step = info.kind === "integer" ? "1" : "any";
+    if (typeof prop.minimum === "number") input.min = String(prop.minimum);
+    if (typeof prop.maximum === "number") input.max = String(prop.maximum);
+    if (typeof prop.default === "number") input.value = String(prop.default);
+    return { node: input, read: function () {
+      if (input.value === "") return input.validity && input.validity.badInput ? { present: true, raw: true } : { present: false };
+      return { present: true, value: Number(input.value) };
+    } };
+  }
+  input.type = FORMAT_INPUT_TYPES[prop.format] || "text";
+  if (typeof prop.default === "string") input.value = prop.default;
+  if (prop.description) input.placeholder = prop.description;
+  return { node: input, read: function () {
+    if (input.value === "" && !required) return { present: false };
+    return { present: true, value: input.value };
+  } };
+}
+
+function buildField(name, prop, required) {
+  var info = fieldInfo(prop);
+  var wrapper = el("div", "elicitation-field");
+  wrapper.dataset.propName = name;
+  var label = el("label", "elicitation-label", (prop.title || name) + (required ? " *" : ""));
+  wrapper.appendChild(label);
+  var control = buildControl(name, prop, info, required);
+  wrapper.appendChild(control.node);
+  if (prop.description && prop.title) wrapper.appendChild(el("div", "elicitation-help", prop.description));
+  if (typeof prop.pattern === "string" && !patternIsBounded(prop.pattern)) {
+    wrapper.appendChild(el("div", "elicitation-help", "Expected pattern (checked by the agent): " + prop.pattern));
+  }
+  var error = el("div", "elicitation-field-error");
+  error.setAttribute("role", "alert");
+  wrapper.appendChild(error);
+  return { name: name, wrapper: wrapper, control: control, error: error };
+}
+
+function collect(fields, schema) {
+  var content = {};
+  var errors = {};
+  fields.forEach(function (field) {
+    var read = field.control.read();
+    if (read.raw) errors[field.name] = "Enter a number.";
+    else if (read.present) content[field.name] = read.value;
+  });
+  var validation = validateForm(content, schema);
+  Object.keys(validation.errors).forEach(function (name) { if (!errors[name]) errors[name] = validation.errors[name]; });
+  return { content: content, errors: errors };
+}
+
+function setBusy(container, busy) {
+  container.classList.toggle("submitting", busy);
+  container.querySelectorAll(".permission-actions button").forEach(function (button) { button.disabled = busy; });
+}
+
+function showFormError(container, message) {
+  var summary = container.querySelector(".elicitation-form-error");
+  if (summary) summary.textContent = message || "";
+}
+
+function send(container, action, content, onSent) {
+  var ws = getWs();
+  if (!ws || ws.readyState !== 1) {
+    showFormError(container, "Not connected. Try again when the connection is restored.");
+    return false;
+  }
+  var msg = { type: "elicitation_response", requestId: container.dataset.requestId, action: action };
+  if (action === "accept") msg.content = content;
+  ws.send(JSON.stringify(msg));
+  setBusy(container, true);
+  showFormError(container, "");
+  if (onSent) onSent();
+  return true;
+}
+
+function actionButton(label, className, handler) {
+  var button = el("button", "permission-btn " + className, label);
+  button.type = "button";
+  button.addEventListener("click", handler);
+  return button;
+}
+
+export function buildElicitationCard(msg, onSent) {
+  var container = el("div", "permission-container elicitation-container");
+  container.dataset.requestId = msg.requestId;
+  var header = el("div", "permission-header");
+  header.innerHTML = '<span class="permission-icon">' + iconHtml("key") + '</span>' +
+    '<span class="permission-title">' + escapeHtml(msg.serverName || "MCP Server") + ' requests input</span>';
+  var body = el("div", "permission-body");
+  if (msg.message) body.appendChild(el("div", "permission-reason", msg.message));
+  var isUrl = msg.mode === "url" && msg.url;
+  var schema = msg.requestedSchema || null;
+  var fields = [];
+  if (isUrl) {
+    body.appendChild(el("div", "elicitation-url-info", "Opens: " + msg.url));
+  } else if (schema && schema.properties) {
+    var form = el("div", "elicitation-form");
+    var required = Array.isArray(schema.required) ? schema.required : [];
+    Object.keys(schema.properties).forEach(function (name) {
+      var field = buildField(name, schema.properties[name] || {}, required.indexOf(name) !== -1);
+      fields.push(field);
+      form.appendChild(field.wrapper);
+    });
+    body.appendChild(form);
+  }
+  var summary = el("div", "elicitation-form-error");
+  summary.setAttribute("role", "alert");
+  body.appendChild(summary);
+
+  var actions = el("div", "permission-actions");
+  actions.appendChild(actionButton(isUrl ? "Open & Approve" : "Submit", "permission-allow elicitation-submit", function () {
+    if (isUrl) {
+      if (send(container, "accept", {}, onSent)) window.open(msg.url, "_blank");
+      return;
+    }
+    var result = collect(fields, schema);
+    var invalid = false;
+    fields.forEach(function (field) {
+      var message = result.errors[field.name] || "";
+      field.error.textContent = message;
+      field.wrapper.classList.toggle("invalid", !!message);
+      if (message) invalid = true;
+    });
+    if (invalid) {
+      showFormError(container, "Fix the highlighted fields before submitting.");
+      return;
+    }
+    send(container, "accept", result.content, onSent);
+  }));
+  actions.appendChild(actionButton("Decline", "permission-deny elicitation-decline", function () { send(container, "decline", null, onSent); }));
+  actions.appendChild(actionButton("Cancel", "permission-allow-session elicitation-cancel", function () { send(container, "cancel", null, onSent); }));
+  container.appendChild(header);
+  container.appendChild(body);
+  container.appendChild(actions);
+  return container;
+}
+
+var RESOLVED = {
+  accept: { label: "Submitted", className: "resolved-allowed" },
+  decline: { label: "Declined", className: "resolved-denied" },
+  reject: { label: "Declined", className: "resolved-denied" },
+  cancel: { label: "Cancelled", className: "resolved-cancelled" },
+  expired: { label: "No longer active", className: "resolved-cancelled" },
+};
+
+export function markElicitationCard(container, action) {
+  if (!container || container.classList.contains("resolved")) return;
+  var state = RESOLVED[action] || RESOLVED.cancel;
+  container.classList.remove("submitting");
+  container.classList.add("resolved", state.className);
+  container.querySelectorAll("input, select, button").forEach(function (control) { control.disabled = true; });
+  var actions = container.querySelector(".permission-actions");
+  if (actions) actions.innerHTML = '<span class="permission-decision-label">' + state.label + '</span>';
+}
+
+// Server-side rejection keeps the form editable; an expired request resolves.
+export function showElicitationError(container, message, expired) {
+  if (!container || container.classList.contains("resolved")) return;
+  if (expired) {
+    markElicitationCard(container, "expired");
+    return;
+  }
+  setBusy(container, false);
+  showFormError(container, message || "The response was not accepted.");
+}

package/lib/public/modules/elicitation-schema.js

@@ -0,0 +1,139 @@
+// Restricted elicitation schema handling for the browser form.
+// Mirrors lib/yoke/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: "" }; });
+}
+
+export 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; anything else stays a visible, unenforced hint.
+export 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;
+}
+
+export function patternMatches(pattern, value) {
+  if (!patternIsBounded(pattern) || value.length > PATTERN_MAX_INPUT_LENGTH) return null;
+  return new RegExp(pattern, "u").test(value);
+}
+
+function inChoices(choices, value) {
+  return choices.some(function (choice) { return choice.value === value; });
+}
+
+// Returns an error message or null. `value` must already be typed.
+export 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;
+}
+
+// Required means presence only. Returns { content, errors } where errors maps
+// property name to message; content holds only present properties.
+export function validateForm(content, schema) {
+  var properties = schema && schema.properties && typeof schema.properties === "object" ? schema.properties : {};
+  var required = schema && Array.isArray(schema.required) ? schema.required : [];
+  var errors = {};
+  Object.keys(properties).forEach(function (id) {
+    if (!hasOwn(content, id)) {
+      if (required.indexOf(id) !== -1) errors[id] = fieldInfo(properties[id]).kind === "unsupported" ? "This field type is not supported here." : "A value is required.";
+      return;
+    }
+    var error = valueError(content[id], properties[id]);
+    if (error) errors[id] = error;
+  });
+  return { content: content, errors: errors };
+}