clay-server 5.2.0-beta.4 → 5.2.0-beta.6

package/lib/yoke/muse-input.js

@@ -0,0 +1,64 @@
+var userInput = require("./user-input");
+function createRouter(runtime, queryOpts, signal) {
+  var pending = new Map();
+  function route(request) {
+    if (pending.has(request.userInputId)) return pending.get(request.userInputId).operation;
+    if (pending.size >= 1000) return Promise.reject(new Error("Muse input request capacity exceeded"));
+    var controller = new AbortController();
+    var entry = { controller: controller, retired: false };
+    function abort() { controller.abort(); }
+    if (signal.aborted) abort(); else signal.addEventListener("abort", abort, { once: true });
+    var operation = Promise.resolve().then(async function() {
+      runtime.check();
+      var input = { id: request.userInputId, questions: (request.questions || []).map(function(question) {
+        return { id: question.id, header: question.header, question: question.question,
+          options: question.options, multiSelect: question.selection && question.selection.mode === "multiple", allowOther: true };
+      }) };
+      if (typeof queryOpts.validateUserInputRequest === "function") {
+        var reason = queryOpts.validateUserInputRequest(input);
+        if (reason) throw new Error(reason);
+      }
+      var result = await runtime.wait(userInput.dispatchUserInput(queryOpts.onUserInputRequest, input,
+        { source: "muse", native: true, provider: "muse", signal: controller.signal }));
+      runtime.check();
+      if (entry.retired) return;
+      if (result.status !== "submitted") return runtime.waitRequest(runtime.connection.command("userInput/cancel", {
+        sessionId: request.sessionId, userInputId: request.userInputId,
+      }));
+      var answers = request.questions.map(function(question) {
+        var values = result.answers[question.id] || [];
+        var selection = question.selection || {};
+        if (values.length < (selection.minSelections || 1) || selection.maxSelections != null && values.length > selection.maxSelections) throw new Error("Muse answer violates selection bounds");
+        var known = values.every(function(value) { return (question.options || []).some(function(option) { return option.label === value; }); });
+        var answer = { questionId: question.id };
+        if (!known || !question.options.length) {
+          var text = values.join(", ");
+          if (text.length > 500) throw new Error("Muse free-text answer exceeds 500 characters");
+          answer.freeText = text;
+        } else if (selection.mode === "multiple") answer.selectedLabels = values;
+        else answer.selectedLabel = values[0];
+        return answer;
+      });
+      return runtime.waitRequest(runtime.connection.command("userInput/answer", {
+        sessionId: request.sessionId, userInputId: request.userInputId, answers: answers,
+      }));
+    });
+    entry.operation = operation.finally(function() { signal.removeEventListener("abort", abort); });
+    pending.set(request.userInputId, entry);
+    return entry.operation;
+  }
+  route.settle = function(id) {
+    var entry = pending.get(id);
+    if (entry) { entry.retired = true; entry.controller.abort(); }
+  };
+  return route;
+}
+function inputParts(text, images) {
+  var parts = [{ type: "text", text: text }];
+  (images || []).forEach(function(image) {
+    if (!image || typeof image.data !== "string" || !image.data || !/^image\/[a-z0-9.+-]+$/i.test(image.mediaType || "") || !/^[A-Za-z0-9+/]+={0,2}$/.test(image.data)) throw new Error("Invalid Muse image attachment");
+    parts.push({ type: "image", mediaType: image.mediaType, base64Data: image.data });
+  });
+  return parts;
+}
+module.exports = { createRouter: createRouter, inputParts: inputParts };

package/lib/yoke/muse-items.js

@@ -0,0 +1,157 @@
+function itemInput(item) {
+  if (!item || typeof item.args !== "string") return {};
+  try {
+    return JSON.parse(item.args);
+  } catch (e) {
+    return {
+      rawArgs: item.args
+    };
+  }
+}
+
+function toolName(item) {
+  var name = String(item && (item.tool || item.toolName) || "Tool").toLowerCase();
+  if (name.indexOf("shell") !== -1 || name.indexOf("command") !== -1) return "Bash";
+  if (name.indexOf("read") !== -1) return "Read";
+  if (name.indexOf("write") !== -1 || name.indexOf("create") !== -1) return "Write";
+  if (name.indexOf("edit") !== -1 || name.indexOf("delete") !== -1) return "Edit";
+  if (name.indexOf("search") !== -1 || name.indexOf("grep") !== -1) return "Grep";
+  return item && (item.tool || item.toolName) || "Tool";
+}
+
+function createRenderer(state, push) {
+  var streamedItems = {};
+  var openBlocks = {};
+  var notices = {};
+  function closeBlocks(turnId) {
+    Object.keys(openBlocks).forEach(function(id) {
+      if (turnId && openBlocks[id] !== turnId) return;
+      push({
+        yokeType: "block_stop",
+        blockId: id
+      });
+      delete openBlocks[id];
+    });
+    if (!turnId) { state.thinkingBlocks = {}; state.textBlocks = {}; state.toolBlocks = {}; }
+  }
+  function emitNotice(item, id) {
+    if (item.status === "inProgress" || item.kind === "userMessage") return;
+    var failed = ["failed", "rejected", "timedOut"].includes(item.status)
+      || (item.kind === "compaction" && item.outcome === "failed")
+      || (item.kind === "hookRun" && ["failed", "blocked", "timedOut"].includes(item.runStatus))
+      || (item.kind === "subagent" && item.result && item.result.errorKind);
+    var text = "";
+    if (failed) {
+      var labels = { reminderChild: "A background task", hookRun: "A hook", compaction: "Context maintenance", sideChat: "A side conversation", subagent: "A task", workflow: "A workflow", userShell: "A command", webSearch: "A search" };
+      var label = labels[item.kind] || "A Muse operation";
+      // Unknown kinds have no established human-facing fields. Do not dump them.
+      var detail = labels[item.kind] ? (item.failureReason || item.reason || item.message || "") : "";
+      if (item.kind === "subagent" && !detail && item.result) detail = item.result.summary || "";
+      text = label + " failed" + (detail ? ": " + detail : ".");
+    } else if (item.status === "completed") {
+      // Only documented action results belong in chat. Reminder/hook/compaction/
+      // side-chat bookkeeping and unknown protocol fallback text stay silent.
+      if (item.kind === "subagent" && item.result) text = item.result.text || item.result.summary || "";
+      else if (item.kind === "workflow") text = item.finalSummary || item.message || "";
+      else if (item.kind === "userShell") text = item.visibleOutput || "";
+      else if (item.kind === "webSearch") text = item.fallbackText || "";
+    }
+    var key = id + (failed ? ":failure" : ":summary");
+    if (typeof text !== "string" || !text.trim() || notices[key]) return;
+    notices[key] = true;
+    push({ yokeType: "informational", level: failed ? "warning" : "info", content: text });
+  }
+  function emitItem(item) {
+    if (!item || state.stopped) return;
+    var id = item.itemId || "muse-item";
+    if (item.kind === "agentMessage" || item.kind === "reasoning") {
+      var previous = state.textBlocks[id] || "";
+      var value = item.kind === "reasoning" && Array.isArray(item.summary) ? item.summary.join("\n") : item.text || "";
+      var blockId = state.thinkingBlocks[id] || id;
+      if (item.kind === "reasoning") state.thinkingBlocks[id] = blockId;
+      if (!previous && value) {
+        openBlocks[blockId] = item.turnId;
+        push({
+          yokeType: item.kind === "reasoning" ? "thinking_start" : "text_start",
+          blockId: blockId
+        });
+      }
+      if (value.length > previous.length) push({
+        yokeType: item.kind === "reasoning" ? "thinking_delta" : "text_delta",
+        blockId: blockId,
+        text: value.substring(previous.length)
+      });
+      if (value.length >= previous.length) state.textBlocks[id] = value;
+      if (item.status !== "inProgress" && openBlocks[blockId]) {
+        push({
+          yokeType: "block_stop",
+          blockId: blockId
+        });
+        delete openBlocks[blockId];
+      }
+      return;
+    }
+    if (item.kind === "toolCall") {
+      if (!state.toolBlocks[id]) {
+        state.toolBlocks[id] = true;
+        push({
+          yokeType: "tool_start",
+          blockId: id,
+          toolId: id,
+          toolName: toolName(item)
+        });
+        push({
+          yokeType: "tool_executing",
+          blockId: id,
+          toolId: id,
+          toolName: toolName(item),
+          input: itemInput(item)
+        });
+      }
+      if (item.status && item.status !== "inProgress" && state.toolBlocks[id] !== "completed") {
+        state.toolBlocks[id] = "completed";
+        push({
+          yokeType: "tool_result",
+          blockId: id,
+          toolId: id,
+          content: item.visibleOutput || item.message || item.failureReason || "",
+          isError: item.status !== "completed"
+        });
+      }
+      return;
+    }
+    emitNotice(item, id);
+  }
+  function renderFrame(frame) {
+    var params = frame.params || {};
+    var item = params.item;
+    var owner = item && item.turnId || streamedItems[params.itemId] && streamedItems[params.itemId].turnId;
+    if (!(state.liveTurnIds && state.liveTurnIds.has(owner) || state.activeTurn && owner === state.activeTurn.turnId)) return false;
+    if (item) streamedItems[item.itemId] = Object.assign({}, item); else if (frame.method === "item/delta") {
+      item = streamedItems[params.itemId];
+      if (item) {
+        var field = params.field || "text";
+        if (field.indexOf("summary.") === 0) {
+          var index = Number(field.split(".")[1]);
+          item.summary = (item.summary || []).slice();
+          item.summary[index] = (item.summary[index] || "") + params.delta;
+        } else if (field === "text") item.text = (item.text || "") + params.delta; else if (field === "output") item.visibleOutput = (item.visibleOutput || "") + params.delta;
+      }
+    }
+    if (item) emitItem(item);
+    return true;
+  }
+  return {
+    emitItem: emitItem,
+    renderFrame: renderFrame,
+    closeBlocks: closeBlocks,
+    hasItem: function(id) {
+      return !!streamedItems[id];
+    }
+  };
+}
+
+module.exports = {
+  createRenderer: createRenderer,
+  itemInput: itemInput
+};

package/lib/yoke/muse-policy.js

@@ -0,0 +1,52 @@
+var itemInput = require("./muse-items").itemInput;
+
+function normalizeMcpServers(servers) {
+  var config = {};
+  if (servers == null) return config;
+  if (!Array.isArray(servers)) throw new Error("Invalid Muse session MCP servers");
+  for (var i = 0; i < servers.length; i++) {
+    var server = servers[i] || {};
+    if (!server.name || !server.command || typeof server.name !== "string" || typeof server.command !== "string" || !Array.isArray(server.args || [])) throw new Error("Invalid Muse session MCP server");
+    if (["__proto__", "constructor", "prototype"].includes(server.name) || Object.prototype.hasOwnProperty.call(config, server.name)) throw new Error("Invalid or duplicate Muse MCP server name");
+    var env = {};
+    var entries = Array.isArray(server.env) ? server.env : [];
+    for (var j = 0; j < entries.length; j++) if (entries[j] && entries[j].name) env[entries[j].name] = String(entries[j].value == null ? "" : entries[j].value);
+    config[server.name] = {
+      transport: "stdio",
+      command: server.command,
+      args: server.args || [],
+      env: env,
+      mode: "required"
+    };
+  }
+  return config;
+}
+
+function chooseApprovalDecision(request, canUseTool, signal) {
+  var choices = Array.isArray(request && request.availableChoices) ? request.availableChoices : [];
+  if (!choices.length || typeof canUseTool !== "function") return Promise.reject(new Error("Muse approval cannot be decided safely"));
+  if (signal && signal.aborted) return Promise.reject(new Error("Muse approval cancelled"));
+  return Promise.resolve(canUseTool(request.toolName || "Tool", itemInput({
+    args: request.rawArgs
+  }), {
+    request: request,
+    signal: signal
+  })).then(function(result) {
+    if (signal && signal.aborted) throw new Error("Muse approval cancelled");
+    var allowed = result && result.behavior === "allow";
+    if (!allowed && !(result && result.behavior === "deny")) throw new Error("Muse approval returned an unsupported decision");
+    for (var i = 0; i < choices.length; i++) if (choices[i].scope === "once" && (choices[i].decision === (allowed ? "approved" : "denied") || !allowed && choices[i].decision === "abort")) {
+      var decision = {
+        choiceId: choices[i].choiceId
+      };
+      if (choices[i].acceptsFeedback && result.message) decision.feedback = result.message;
+      return decision;
+    }
+    throw new Error("Muse approval has no matching safe choice");
+  });
+}
+
+module.exports = {
+  normalizeMcpServers: normalizeMcpServers,
+  chooseApprovalDecision: chooseApprovalDecision
+};