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

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

package/lib/yoke/muse-runtime.js

@@ -0,0 +1,211 @@
+var queryAbort = require("./query-abort");
+
+var initializeTimeoutMs = require("./interface").INITIALIZE_TIMEOUT_MS;
+
+function isAuthError(error) {
+  var kind = error && (error.kind || error.data && error.data.kind);
+  return kind === "authRequired" || /authentication|not authenticated|sign[ -]?in|log[ -]?in|credential|unauthorized|forbidden|api.?key|401/i.test(String(error && error.message || error || ""));
+}
+
+function closeResource(resource) {
+  if (!resource || typeof resource.close !== "function") return Promise.resolve();
+  return Promise.resolve().then(function() {
+    return resource.close();
+  });
+}
+// Own the process before initialize starts, including callers still opening a session.
+
+function createRuntime(adapter, sdk, options) {
+  var scope = queryAbort.createAbortScope();
+  var handshake = sdk.spawnMspConnection(Object.assign({}, options, {
+    shutdownTimeoutMs: adapter.shutdownTimeoutMs
+  }));
+  var closing = null;
+  var runtime = {
+    handshake: handshake,
+    spawned: null,
+    connection: null,
+    session: null,
+    held: [],
+    opening: true,
+    dead: false,
+    wait: scope.wait,
+    check: scope.check,
+    waitRequest: async function(promise, timeoutMs) {
+      var timer;
+      try {
+        return await scope.wait(Promise.race([ promise, new Promise(function(resolve, reject) {
+          timer = setTimeout(function() {
+            reject(new Error("Muse Code request timed out"));
+          }, timeoutMs || adapter.requestTimeoutMs);
+        }) ]));
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+    fail: function(error) {},
+    onFrame: function(frame) {},
+    apply: function(frame) {
+      if (!runtime.session || scope.stopped()) return;
+      var named = frame.params && frame.params.sessionId;
+      if (named !== runtime.session.sessionId) return;
+      if (frame.method === "view/gap") {
+        runtime.fail(new Error("Muse view stream has a gap; Stop retired this attempt. Resume explicitly to reconcile the session."));
+        return;
+      }
+      try {
+        var applied = runtime.session.apply(frame);
+        if (applied.fold.kind !== "item" || applied.fold.outcome.kind !== "ignoredStaleRevision") runtime.onFrame(frame);
+      } catch (error) {
+        runtime.fail(error);
+      }
+    },
+    close: function() {
+      if (closing) return closing;
+      scope.stop();
+      if (runtime.session) runtime.session.hostExited({
+        kind: "transportEof"
+      });
+      closing = closeResource(handshake).finally(function() {
+        adapter.clients.delete(runtime);
+      });
+      return closing;
+    },
+    initialize: async function() {
+      try {
+        runtime.spawned = await runtime.waitRequest(handshake.initialize({
+          clientInfo: {
+            name: "clay",
+            title: "Clay",
+            version: "1.0.0"
+          },
+          capabilities: {
+            requestedCapabilities: [ "sessionMcp" ],
+            userInputDialogs: options.userInputDialogs === true
+          }
+        }), initializeTimeoutMs);
+        runtime.connection = runtime.spawned.connection;
+        runtime.connection.onProtocolError(function(error) {
+          runtime.fail(error);
+        });
+        runtime.connection.closed.then(function() {
+          if (scope.stopped()) return;
+          runtime.dead = true;
+          if (runtime.session) runtime.session.hostExited({
+            kind: "transportEof"
+          });
+          runtime.fail(new Error("Muse Code transport closed unexpectedly"));
+        });
+        return runtime.spawned;
+      } catch (error) {
+        await runtime.close();
+        throw error;
+      }
+    }
+  };
+  function route(frame) {
+    if (scope.stopped()) return;
+    if (frame.method === "usage/changed") { runtime.onFrame(frame); return; }
+    if (runtime.opening) runtime.held.push(frame); else runtime.apply(frame);
+  }
+  handshake.onServerRequest(async function(request) {
+    if (request.method === "approval/request") {
+      route({
+        method: "approval/requested",
+        params: request.params
+      });
+      return {};
+    }
+    if (request.method === "userInput/request" && typeof runtime.onUserInput === "function") {
+      route({ method: "userInput/requested", params: request.params });
+      return {};
+    }
+    var error = new Error("Muse host requested an unsupported client dialog: " + request.method);
+    runtime.fail(error);
+    throw error;
+  });
+  adapter.clients.add(runtime);
+  handshake.onNotification(route);
+  if (typeof handshake.onProtocolError === "function") handshake.onProtocolError(function(error) {
+    runtime.fail(error);
+  });
+  if (handshake.child && handshake.child.exit) handshake.child.exit.then(function(exit) {
+    runtime.dead = true;
+    if (runtime.session) runtime.session.hostExited(exit);
+    if (!scope.stopped()) runtime.fail(new Error("Muse Code host exited: " + exit.kind));
+  }, function(error) {
+    if (!scope.stopped()) runtime.fail(error);
+  });
+  return runtime;
+}
+
+function normalizeCatalog(result) {
+  return (result.models || []).map(function(model) {
+    return {
+      value: model.modelId,
+      displayName: model.displayLabel || model.modelId,
+      description: model.description || "",
+      supportedEffortLevels: Array.isArray(model.variants) ? model.variants.filter(function(tier) {
+        return ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"].includes(tier);
+      }) : [],
+      providerId: model.providerId || result.providerId,
+      profileId: model.profileId == null ? result.profileId : model.profileId,
+      defaultReasoningEffort: model.defaultReasoningEffort,
+      isDefault: model.isDefault === true,
+      effortUnknown: !Array.isArray(model.variants),
+      catalogSource: result.source
+    };
+  });
+}
+
+function modelSelection(catalog, model) {
+  for (var i = 0; i < catalog.length; i++) {
+    if (catalog[i].value !== model) continue;
+    var selection = {
+      modelId: model,
+      displayLabel: catalog[i].displayName
+    };
+    if (catalog[i].providerId) selection.providerId = catalog[i].providerId;
+    if (catalog[i].profileId != null) selection.profileId = catalog[i].profileId;
+    return selection;
+  }
+  throw new Error("Muse model is not in the live model catalog: " + model);
+}
+// SDK 1.4.7 retains opening metadata but does not ingest its history. Seed once,
+// before the buffered live suffix; pending pointers await the host's full reissue.
+
+function seedHistory(session, opening, onFrame) {
+  if (opening.verb !== "session/resume") return;
+  var history = opening.result.history || {};
+  var snapshot = history.snapshot;
+  if (snapshot && snapshot.schemaVersion !== 1) throw new Error("Unsupported Muse snapshot schema version");
+  var items = history.items || snapshot && snapshot.state.items || [];
+  for (var i = 0; i < items.length; i++) {
+    var frame = {
+      method: "item/updated",
+      params: {
+        sessionId: session.sessionId,
+        item: items[i],
+        viewCursor: opening.result.viewCursor
+      }
+    };
+    session.apply(frame);
+    if (onFrame) onFrame(frame);
+  }
+  var active = snapshot && snapshot.state.activeTurn;
+  if (active) session.apply({
+    method: "turn/started",
+    params: Object.assign({}, active, {
+      sessionId: session.sessionId,
+      viewCursor: snapshot.viewCursor
+    })
+  });
+}
+
+module.exports = {
+  isAuthError: isAuthError,
+  createRuntime: createRuntime,
+  normalizeCatalog: normalizeCatalog,
+  modelSelection: modelSelection,
+  seedHistory: seedHistory
+};