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

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
+};

package/lib/yoke/muse-query.js

@@ -0,0 +1,428 @@
+var queryAbort = require("./query-abort");
+
+var runtimeTools = require("./muse-runtime");
+
+var policy = require("./muse-policy");
+
+function createMuseQueryHandle(adapter, queryOpts) {
+  var state = {
+    client: null,
+    connection: null,
+    session: null,
+    sessionId: queryOpts.resumeSessionId || null,
+    model: queryOpts.model || null,
+    effort: queryOpts.effort || null,
+    toolPolicy: "ask",
+    messages: [],
+    messageSequence: 0,
+    active: false,
+    ended: false,
+    inputEnded: false,
+    stopped: false,
+    events: [],
+    waiter: null,
+    textBlocks: {},
+    thinkingBlocks: {},
+    toolBlocks: {},
+    activeTurn: null,
+    liveTurnIds: new Set(),
+    abortController: queryOpts.abortController || new AbortController(),
+    started: false
+  };
+  var removeAbort = function() {};
+  var handle;
+  var failure = null;
+  var cleanup = null;
+  var runtime = null;
+  var itemFrames = [];
+  var skillDelivery = require("./muse-skills").create(Object.assign({}, queryOpts, { cwd: queryOpts.cwd || adapter.cwd }), function() { return runtime; }, push, assertLive);
+  var emitArtifact = require("./muse-artifacts").create(function() { return runtime; }, push);
+  var renderer = require("./muse-items").createRenderer(state, push);
+  var turns = require("./muse-turns").create({ state: state, renderer: renderer, emitArtifact: emitArtifact,
+    runtime: function() { return runtime; }, ready: flushFrames, push: push, outcomeEvent: outcomeEvent, fail: fail, close: function() { return handle.close(); } });
+  function push(event) {
+    if (state.stopped || state.ended) return;
+    if (state.waiter) {
+      var resolve = state.waiter;
+      state.waiter = null;
+      resolve({
+        value: event,
+        done: false
+      });
+    } else state.events.push(event);
+  }
+  function finish() {
+    if (state.waiter) {
+      var resolve = state.waiter;
+      state.waiter = null;
+      resolve({
+        value: undefined,
+        done: true
+      });
+    }
+  }
+  function assertLive() {
+    if (state.stopped || state.ended || adapter.shuttingDown) throw new Error("Muse Code query was stopped");
+  }
+  function activateTurn(turn) {
+    state.activeTurn = turn;
+  }
+  function flushFrames() {
+    var frames = itemFrames.splice(0);
+    for (var i = 0; i < frames.length; i++) renderer.renderFrame(frames[i]);
+  }
+  function chooseApproval(request) {
+    if (state.stopped || state.abortController.signal.aborted) return Promise.reject(new Error("Muse approval cancelled"));
+    return runtime.wait(policy.chooseApprovalDecision(request, queryOpts.canUseTool, state.abortController.signal));
+  }
+  function fail(error) {
+    if (state.stopped || failure) return;
+    failure = error;
+    state.messages = [];
+    push(runtimeTools.isAuthError(error) ? {
+      yokeType: "auth_required",
+      vendor: "muse"
+    } : {
+      yokeType: "error",
+      text: error.message || String(error)
+    });
+    handle.close().catch(function(closeError) {
+      adapter.lastCloseError = closeError;
+    });
+  }
+  async function selectModel(model) {
+    if (!model) return null;
+    if (!adapter.catalog.some(function(row) {
+      return row.value === model;
+    })) {
+      var result = await runtime.waitRequest(state.connection.request("model/list", {}));
+      adapter.catalog = runtimeTools.normalizeCatalog(result);
+    }
+    assertLive();
+    return runtimeTools.modelSelection(adapter.catalog, model);
+  }
+  function validateEffort(effort) {
+    var vocabulary = [ "none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra" ];
+    if (!vocabulary.includes(effort)) throw new Error("Unsupported Muse reasoning effort: " + effort);
+    var row = adapter.catalog.find(function(model) {
+      return model.value === state.model;
+    });
+    if (row && !row.effortUnknown && !row.supportedEffortLevels.includes(effort)) {
+      throw new Error("Muse model does not support reasoning effort: " + effort);
+    }
+  }
+  async function ensureSession() {
+    assertLive();
+    if (state.session) return state.session;
+    var sdk = await adapter.loadSdk();
+    assertLive();
+    runtime = runtimeTools.createRuntime(adapter, sdk, {
+      command: adapter.binaryPath,
+      args: [ "serve" ],
+      cwd: queryOpts.cwd || adapter.cwd,
+      userInputDialogs: queryOpts.userInputMode !== "fallback" && typeof queryOpts.onUserInputRequest === "function",
+      env: Object.assign({}, process.env, queryOpts.env || {})
+    });
+    runtime.fail = fail;
+    runtime.onUserInput = require("./muse-input").createRouter(runtime, queryOpts, state.abortController.signal);
+    runtime.onFrame = function(frame) {
+      turns.onFrame(frame);
+      if (frame.method.indexOf("item/") === 0) {
+        if (!renderer.renderFrame(frame)) itemFrames.push(frame);
+      }
+      if (frame.method === "session/modelChanged") {
+        var previousModel = state.model;
+        state.model = frame.params.modelId;
+        if (typeof queryOpts.onModelSwitch === "function" && previousModel && previousModel !== state.model) queryOpts.onModelSwitch({ fromModel: previousModel, toModel: state.model, source: frame.params.source });
+      }
+      if (frame.method === "userInput/settled") runtime.onUserInput.settle(frame.params.userInputId);
+      if (frame.method === "userInput/requested") runtime.onUserInput(frame.params).catch(fail);
+      if (frame.method === "usage/changed") {
+        var quota = require("./muse-services").quotaEvent(frame.params);
+        if (quota) push(quota);
+      }
+      if (frame.method === "session/contextUsage") state.contextUsage = frame.params;
+      if (frame.method === "approval/requested" && queryOpts.resumeSessionId && !state.started) {
+        state.resumedTurnId = state.resumedTurnId || frame.params.turnId;
+      }
+    };
+    var spawned = await runtime.initialize();
+    assertLive();
+    state.connection = spawned.connection;
+    var museOpts = queryOpts.adapterOptions && queryOpts.adapterOptions.MUSE || {};
+    var mcpServers = policy.normalizeMcpServers(museOpts.mcpServers);
+    var hasMcp = Object.keys(mcpServers).length > 0;
+    var config = hasMcp ? {
+      mcpServers: mcpServers
+    } : undefined;
+    if (hasMcp && !(spawned.initializeResult.grantedCapabilities || []).includes("sessionMcp")) {
+      throw new Error("Muse host does not support the required sessionMcp capability");
+    }
+    var selection = await selectModel(state.model);
+    if (state.effort) validateEffort(state.effort);
+    var verb = state.sessionId ? "session/resume" : "session/start";
+    var params = state.sessionId ? {
+      sessionId: state.sessionId,
+      config: config,
+      history: "inline"
+    } : {
+      workspaceRoot: queryOpts.cwd || adapter.cwd,
+      config: config,
+      approvalMode: museOpts.readOnly ? "denyUnmatched" : "onRequest"
+    };
+    if (selection && verb === "session/start") {
+      params.modelId = selection.modelId;
+      if (selection.providerId) params.providerId = selection.providerId;
+    }
+    var result = await runtime.waitRequest(state.connection.command(verb, params));
+    assertLive();
+    state.sessionId = result.session.sessionId;
+    var opening = {
+      verb: verb,
+      result: result
+    };
+    state.session = new sdk.Session({
+      connection: state.connection,
+      durability: sdk.readSessionDurability(spawned.initializeResult),
+      opening: opening,
+      sessionId: state.sessionId
+    });
+    runtime.session = state.session;
+    state.session.onApproval(chooseApproval);
+    state.session.onApprovalError(function(problem) {
+      fail(problem.error || new Error("Muse approval failed: " + problem.kind));
+    });
+    state.session.onGapError(function(problem) {
+      fail(problem.error || new Error("Muse view gap could not be filled"));
+    });
+    runtimeTools.seedHistory(state.session, opening, runtime.onFrame);
+    state.resumedTurnId = state.session.fold.activeTurnId;
+    state.contextUsage = result.history && result.history.snapshot && result.history.snapshot.state.contextUsage || null;
+    runtime.opening = false;
+    var held = runtime.held.splice(0);
+    for (var i = 0; i < held.length; i++) runtime.apply(held[i]);
+    assertLive();
+    if (runtime.dead) throw new Error("Muse host exited while opening the session");
+    if (verb === "session/resume") {
+      await runtime.waitRequest(state.connection.command("session/setApprovalMode", {
+        sessionId: state.sessionId,
+        mode: museOpts.readOnly ? "denyUnmatched" : "onRequest"
+      }));
+      if (selection) await runtime.waitRequest(state.connection.command("session/setModel", {
+        sessionId: state.sessionId,
+        model: selection
+      }));
+    }
+    assertLive();
+    if (verb === "session/resume") {
+      state.resumedTurnId = state.resumedTurnId || result.session.activeTurnId || state.session.fold.activeTurnId;
+      if ((result.pendingRequests || []).length) {
+        var pending = await runtime.waitRequest(state.connection.request("approval/listPending", {
+          sessionId: state.sessionId
+        }));
+        for (var promptIndex = 0; promptIndex < (pending.userInputs || []).length; promptIndex++) {
+          var promptRequest = pending.userInputs[promptIndex];
+          state.resumedTurnId = state.resumedTurnId || promptRequest.turnId;
+          runtime.onUserInput(promptRequest).catch(fail);
+        }
+        for (var pendingIndex = 0; pendingIndex < (pending.approvals || []).length; pendingIndex++) {
+          var approval = pending.approvals[pendingIndex];
+          state.resumedTurnId = state.resumedTurnId || approval.turnId;
+          runtime.apply({
+            method: "approval/requested",
+            params: approval
+          });
+        }
+      }
+    }
+    assertLive();
+    push({
+      yokeType: "session_started",
+      sessionId: state.sessionId
+    });
+    return state.session;
+  }
+  function outcomeEvent(outcome) {
+    if (!outcome || outcome.kind === "unqueued" || outcome.kind === "completed" && outcome.params && (outcome.params.terminal === "cancelled" || outcome.params.terminal === "cancelledByUser")) return {
+      yokeType: "interrupted"
+    };
+    if (outcome.kind === "terminalUnknown") return {
+      yokeType: "error",
+      text: "Muse host exited before the turn outcome was known"
+    };
+    var params = outcome.params || {};
+    if (params.terminal === "failed") return params.error && params.error.kind === "authRequired" ? {
+      yokeType: "auth_required",
+      vendor: "muse"
+    } : {
+      yokeType: "error",
+      text: params.error && params.error.message || params.reason || "Muse Code turn failed."
+    };
+    if (params.terminal !== "completed") return {
+      yokeType: "error",
+      text: "Unknown Muse turn outcome: " + params.terminal
+    };
+    return {
+      yokeType: "result",
+      messageType: "assistant",
+      sessionId: state.sessionId,
+      usage: params.usage ? {
+        input_tokens: params.usage.inputTokens,
+        output_tokens: params.usage.outputTokens,
+        cache_read_input_tokens: params.usage.cacheReadTokens == null ? params.usage.cachedTokens : params.usage.cacheReadTokens,
+        cache_creation_input_tokens: params.usage.cacheWriteTokens || 0
+      } : null,
+      cost: null,
+      duration: params.durationMs || null
+    };
+  }
+  async function runMessage(text, images, skill, sequence) {
+    state.active = true;
+    try {
+      var session = await ensureSession();
+      assertLive();
+      if (state.resumedTurnId) {
+        var resumed = session.turn(state.resumedTurnId);
+        state.resumedTurnId = null;
+        activateTurn(resumed);
+        var resumedBoundary = await turns.follow(resumed, false);
+        assertLive();
+        if (resumedBoundary.kind === "failed" || resumedBoundary.event && resumedBoundary.event.yokeType !== "result") return;
+        push({ yokeType: "runtime_specific", vendor: "muse",
+          eventType: resumedBoundary.kind === "foreground" ? "resumed_foreground_completed" : "resumed_turn_completed", raw: resumedBoundary.outcome });
+      }
+      var prepared = await skillDelivery.prepare(text || "", skill);
+      assertLive();
+      skill = prepared.skill;
+      var prompt = prepared.text;
+      if (!state.started) {
+        state.started = true;
+        prompt = [ queryOpts.systemPrompt, queryOpts.appendSystemPrompt, prompt ].filter(function(part) {
+          return !!part;
+        }).join("\n\n");
+      }
+      state.activeTurn = null;
+      if (prepared.scoped) skillDelivery.check();
+      push({ yokeType: "turn_activity", phase: "waiting" });
+      var turn = await runtime.wait(session.sendUserTurn({
+        input: require("./muse-input").inputParts(prompt, images).concat(skill ? [{ type: "skill", selector: skill.selector, arguments: skill.arguments }] : []),
+        reasoningEffort: state.effort || undefined
+      }));
+      assertLive();
+      activateTurn(turn);
+      await turns.follow(turn, true, sequence);
+    } catch (e) {
+      fail(e);
+    } finally {
+      state.active = false;
+      state.activeTurn = null;
+      if (state.messages.length && !state.stopped) {
+        var next = state.messages.shift();
+        runMessage(next.text, next.images, next.skill, next.sequence).catch(function(error) {
+          adapter.lastCloseError = error;
+        });
+      } else if (state.inputEnded && !turns.pending()) await handle.close();
+      else if (!state.stopped && turns.background()) push({ yokeType: "foreground_available" });
+    }
+  }
+  handle = {
+    [Symbol.asyncIterator]: function() {
+      return {
+        next: function() {
+          if (state.events.length) return Promise.resolve({
+            value: state.events.shift(),
+            done: false
+          });
+          if (state.ended) return Promise.resolve({
+            value: undefined,
+            done: true
+          });
+          return new Promise(function(resolve) {
+            state.waiter = resolve;
+          });
+        }
+      };
+    },
+    pushMessage: function(text, images, skill) {
+      if (state.stopped || state.ended || state.inputEnded) return false;
+      state.messages.push({
+        text: text, sequence: ++state.messageSequence,
+        images: images, skill: skill
+      });
+      if (!state.active) {
+        var next = state.messages.shift();
+        runMessage(next.text, next.images, next.skill, next.sequence).catch(function(error) {
+          adapter.lastCloseError = error;
+        });
+      }
+      return true;
+    },
+    // Clay's callback remains the authority even when its UI permits all tools.
+    setToolPolicy: async function(value) {
+      assertLive();
+      if (["ask", "allow-all"].indexOf(value) < 0) throw new Error("Unsupported Muse tool policy: " + value);
+      state.toolPolicy = value;
+      return { policy: value, nativeApprovalMode: "onRequest", authority: "canUseTool" };
+    },
+    stopTask: async function(taskId) {
+      assertLive();
+      if (!taskId) return handle.abort();
+      if (!state.connection || !state.session) throw new Error("Muse task stop requires an opened session");
+      await runtime.waitRequest(state.connection.command("task/stop", {
+        sessionId: state.sessionId,
+        taskId: taskId
+      }));
+    },
+    getContextUsage: function() {
+      var context = state.contextUsage;
+      return Promise.resolve(context ? {
+        input_tokens: context.usedTokens,
+        contextWindow: context.windowTokens
+      } : null);
+    },
+    endInput: function() {
+      state.inputEnded = true;
+      if (!state.active && !state.messages.length && !turns.pending()) handle.close().catch(function(error) {
+        adapter.lastCloseError = error;
+      });
+    },
+    abort: function() {
+      if (state.ended || state.stopped) return cleanup;
+      state.events = [];
+      var liveTurns = new Set(state.liveTurnIds);
+      if (state.activeTurn) liveTurns.add(state.activeTurn.turnId);
+      if (state.connection) liveTurns.forEach(function(turnId) {
+        state.connection.command("turn/cancel", { sessionId: state.sessionId, turnId: turnId }).catch(function(error) {
+          adapter.lastCancelError = error;
+        });
+      });
+      push({
+        yokeType: "interrupted"
+      });
+      return handle.close();
+    },
+    close: function() {
+      if (cleanup) return cleanup;
+      state.stopped = true;
+      state.inputEnded = true;
+      state.messages = [];
+      state.ended = true;
+      removeAbort();
+      state.abortController.abort();
+      finish();
+      adapter.handles.delete(handle);
+      cleanup = runtime ? runtime.close() : Promise.resolve();
+      return cleanup;
+    }
+  };
+  Object.assign(handle, require("./muse-controls").create({ state: state, assertLive: assertLive, selectModel: selectModel, validateEffort: validateEffort, skills: skillDelivery, runtime: function() { return runtime; }, handle: handle }));
+  adapter.handles.add(handle);
+  removeAbort = queryAbort.bindAbort(state.abortController, function() {
+    handle.abort();
+  });
+  return handle;
+}
+
+module.exports = {
+  createMuseQueryHandle: createMuseQueryHandle
+};