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

package/lib/project-session-github.js

@@ -8,11 +8,24 @@ function attachSessionGithub(ctx) {
   var attempts = new Map();
   var statusCache = new Map();
   var statusQueue = Promise.resolve();
-  function readStatus(session, link, stillAllowed) {
+  var viewerCache = new Map();
+  async function readViewerLogin(identity, viewerKey) {
+    var key = JSON.stringify([viewerKey || null, identity || null]);
+    var cached = viewerCache.get(key);
+    if (cached && cached.until > Date.now()) return cached.value;
+    var pending = (ctx.run || github.runGh)(ctx.cwd, ["api", "user"], identity).then(function (value) {
+      var login = String(value && value.login || "").trim().toLowerCase();
+      viewerCache.set(key, { value: login, until: Date.now() + 300000 });
+      return login;
+    });
+    viewerCache.set(key, { value: pending, until: Date.now() + 30000 });
+    try { return await pending; } catch (error) { viewerCache.delete(key); throw error; }
+  }
+  function readStatus(session, link, stillAllowed, viewerKey, allowPersonalReview) {
     var identity = authorize(session);
-    var key = JSON.stringify([session.ownerId || null, identity && identity.uid, identity && identity.home, link.url.toLowerCase()]);
+    var key = JSON.stringify([session.ownerId || null, viewerKey || null, !!allowPersonalReview, identity && identity.uid, identity && identity.home, link.url.toLowerCase()]);
     var cached = statusCache.get(key);
-    if (cached && (cached.pending || cached.until > Date.now())) return cached.pending || (cached.error ? Promise.reject(cached.error) : Promise.resolve(cached.value));
+    if (cached && (cached.pending || cached.until > Date.now())) return cached.pending || (cached.error ? Promise.reject(cached.error) : Promise.resolve({ value: cached.value, personalReviewState: cached.personalReviewState || "unknown" }));
     var entry = { failures: cached ? cached.failures : 0 };
     statusCache.set(key, entry);
     entry.pending = statusQueue.then(async function () {
@@ -20,9 +33,17 @@ function attachSessionGithub(ctx) {
         var currentIdentity = authorize(session);
         if (JSON.stringify(currentIdentity) !== JSON.stringify(identity) || (stillAllowed && !stillAllowed())) throw new Error("Session access changed.");
         entry.value = await github.readReference(ctx.cwd, link.url, identity, ctx.run, true);
+        entry.personalReviewState = "clear";
+        if (allowPersonalReview && entry.value.reviewRequests && entry.value.reviewRequests.length) {
+          try {
+            entry.personalReviewState = entry.value.reviewRequests.indexOf(await readViewerLogin(identity, viewerKey)) >= 0 ? "requested" : "clear";
+          } catch (viewerError) { entry.personalReviewState = "unknown"; }
+        }
+        if (!allowPersonalReview) entry.personalReviewState = "unknown";
+        delete entry.value.reviewRequests;
         entry.failures = 0;
         entry.until = Date.now() + (entry.value.state === "closed" || entry.value.state === "merged" ? 300000 : 45000);
-        return entry.value;
+        return { value: entry.value, personalReviewState: entry.personalReviewState };
       } catch (error) {
         entry.error = error;
         entry.failures++;
@@ -51,21 +72,29 @@ function attachSessionGithub(ctx) {
     if (ctx.sm.saveSessionFile(session) === false) throw new Error("Could not save GitHub links.");
     ctx.sm.broadcastSessionList();
   }
-  async function refresh(session, force, statusOnly, stillAllowed) {
+  async function refresh(session, force, statusOnly, stillAllowed, viewerKey, allowPersonalReview) {
     var identity = authorize(session);
-    var id = session.localId + (statusOnly ? ":status" : ":full");
+    var id = session.localId + (statusOnly ? ":status:" + (viewerKey || "anonymous") : ":full");
     if (inflight.has(id)) return inflight.get(id);
-    if (!force && Date.now() - (attempts.get(id) || 0) < (statusOnly ? 30000 : 60000)) return session.githubLinks || [];
+    if (!force && Date.now() - (attempts.get(id) || 0) < (statusOnly ? 30000 : 60000)) return { links: session.githubLinks || [], viewerReviewRequests: {} };
     attempts.set(id, Date.now());
     var pending = (async function () {
       var links = (session.githubLinks || []).slice();
       var updated = [];
+      var viewerReviewRequests = {};
       for (var link of links) {
         try {
           if (stillAllowed && !stillAllowed()) throw new Error("Session access changed.");
-          updated.push(statusOnly ? Object.assign({}, link, await readStatus(session, link, stillAllowed), { stale: false }) : await github.readReference(ctx.cwd, link.url, identity, ctx.run));
+          if (statusOnly) {
+            var status = await readStatus(session, link, stillAllowed, viewerKey, allowPersonalReview);
+            updated.push(Object.assign({}, link, status.value, { stale: false }));
+            if (status.personalReviewState !== "unknown") viewerReviewRequests[link.url.toLowerCase()] = status.personalReviewState;
+          } else updated.push(await github.readReference(ctx.cwd, link.url, identity, ctx.run));
+        }
+        catch (error) {
+          updated.push(Object.assign({}, link, { stale: true }));
+          if (statusOnly) viewerReviewRequests[link.url.toLowerCase()] = "unknown";
         }
-        catch (error) { updated.push(Object.assign({}, link, { stale: true })); }
       }
       authorize(session);
       if (stillAllowed && !stillAllowed()) throw new Error("Session access changed.");
@@ -81,7 +110,7 @@ function attachSessionGithub(ctx) {
         return next;
       });
       if (changed) persist(session);
-      return session.githubLinks || [];
+      return { links: session.githubLinks || [], viewerReviewRequests: viewerReviewRequests };
     })();
     inflight.set(id, pending);
     try { return await pending; } finally { inflight.delete(id); }
@@ -89,7 +118,8 @@ function attachSessionGithub(ctx) {
   async function invoke(session, name, args) {
     var identity = authorize(session);
     if (name === "get_session_github") {
-      var links = await refresh(session, false);
+      var refreshed = await refresh(session, false);
+      var links = refreshed.links;
       var matches = [];
       if (args.url) {
         var url = github.parseReference(args.url).url.toLowerCase();
@@ -140,7 +170,12 @@ function attachSessionGithub(ctx) {
       Array.from(new Set(ids)).forEach(function (id) {
         var session = ctx.sm.sessions.get(id);
         if (!session || !ctx.canRefresh(ws, session) || !(session.githubLinks || []).length) return;
-        refresh(session, false, true, function () { return ctx.canRefresh(ws, session); }).catch(function () {});
+        var viewerId = ws._clayUser && ws._clayUser.id;
+        var allowPersonalReview = !session.ownerId || !viewerId || viewerId === session.ownerId;
+        refresh(session, false, true, function () { return ctx.canRefresh(ws, session); }, viewerId, allowPersonalReview).then(function (result) {
+          if (!allowPersonalReview || typeof ctx.sendTo !== "function" || !result.viewerReviewRequests || !ctx.canRefresh(ws, session)) return;
+          ctx.sendTo(ws, { type: "session_github_status", projectSlug: ctx.projectSlug || null, accountId: viewerId || null, requestId: msg.requestId || null, sessionId: session.localId, personalReview: result.viewerReviewRequests });
+        }).catch(function () {});
       });
       return true;
     },

package/lib/project-session-history-actions.js

@@ -0,0 +1,167 @@
+var sessionVisibility = require("./session-visibility");
+function attachSessionHistoryActions(ctx) {
+  var sm = ctx.sm, sdk = ctx.sdk, cwd = ctx.cwd, hydrateImageRefs = ctx.hydrateImageRefs;
+  var resolveSessionHome = ctx.resolveSessionHome, cancelPendingAskUser = ctx.cancelPendingAskUser;
+  var onProcessingChanged = ctx.onProcessingChanged;
+  async function rewind(session, uuid, mode, ws, revalidate) {
+    if (session._rewindInProgress) throw new Error("Rewind already in progress.");
+    session._rewindInProgress = true;
+    try {
+      // File restoration (delegated to adapter via sdk-bridge)
+      if (mode !== "chat") {
+        await sdk.rewindExecuteFiles(session, uuid);
+        revalidate();
+      }
+
+      // Conversation rollback (skip for files-only mode)
+      if (mode !== "files") {
+        var targetIdx = -1;
+        for (var i = 0; i < session.messageUUIDs.length; i++) {
+          if (session.messageUUIDs[i].uuid === uuid) {
+            targetIdx = i;
+            break;
+          }
+        }
+
+        // Codex's thread/revert cuts at a turn id, not a count. Read the
+        // target entry's turnId BEFORE trimming local history below.
+        var hasTurnsToRollBack = false;
+        var targetTurnId = null;
+        if (targetIdx >= 0) {
+          targetTurnId = session.messageUUIDs[targetIdx].turnId || null;
+          for (var ri = targetIdx; ri < session.messageUUIDs.length; ri++) {
+            if (session.messageUUIDs[ri].type === "user") { hasTurnsToRollBack = true; break; }
+          }
+        }
+
+        // Notify adapter of conversation rollback (e.g. Codex thread/revert)
+        // BEFORE trimming local history below. Deliberately not caught
+        // here: a failed or impossible (missing turnId) provider-side
+        // rollback must abort the whole rewind via the outer catch, never
+        // leave local history trimmed ahead of the real provider thread.
+        if (hasTurnsToRollBack) {
+          await sdk.rollbackConversation(session, targetTurnId);
+          revalidate();
+        }
+
+        if (targetIdx >= 0) {
+          var trimTo = session.messageUUIDs[targetIdx].historyIndex;
+          for (var k = trimTo - 1; k >= 0; k--) {
+            if (session.history[k].type === "user_message") {
+              trimTo = k;
+              break;
+            }
+          }
+          session.history = session.history.slice(0, trimTo);
+          session.messageUUIDs = session.messageUUIDs.slice(0, targetIdx);
+          // Reset digest checkpoint if it points past the trimmed history
+          if (typeof session._dmLastDigestedIndex === "number" && session._dmLastDigestedIndex > trimTo) {
+            session._dmLastDigestedIndex = trimTo;
+          }
+        }
+
+        var kept = session.messageUUIDs;
+        session.lastRewindUuid = kept.length > 0 ? kept[kept.length - 1].uuid : null;
+      }
+
+      if (session.abortController) {
+        try { session.abortController.abort(); } catch (e) {}
+      }
+      if (session.messageQueue) {
+        try { session.messageQueue.end(); } catch (e) {}
+      }
+      session.queryInstance = null;
+      session.messageQueue = null;
+      session.abortController = null;
+      session.blocks = {};
+      session.sentToolResults = {};
+      session.pendingPermissions = {};
+      cancelPendingAskUser(session, "Conversation rewound");
+      session.isProcessing = false;
+      onProcessingChanged();
+
+      if (sm.saveSessionFile(session) === false) throw new Error("The conversation was rewound but could not be saved.");
+      if (ws) sm.switchSession(session.localId, ws, hydrateImageRefs);
+      sm.sendAndRecord(session, { type: "rewind_complete", mode: mode });
+      sm.broadcastSessionList();
+    } finally { session._rewindInProgress = false; }
+    return { mode: mode };
+  }
+  function saveFork(forked, ws) {
+    if (sm.saveSessionFile(forked) !== false) return;
+    var error = new Error("The provider fork exists and its local session is retained in memory, but the fork could not be saved. Do not create another fork to retry this save.");
+    if (!ws) error.productControlResult = { status: "failed", outcome: "partial", persisted: false, runtimeEffect: "applied", retrySafe: false,
+      retainedSession: true, forkedSessionRef: require("./workspace-query-service").sessionRef(ctx.slug, forked), error: error.message };
+    throw error;
+  }
+  async function fork(session, uuid, ws, revalidate) {
+    var forkTitle = (session.title || "New Session") + " (fork)";
+    var result = await sdk.forkSession(session, uuid);
+    revalidate();
+    if (result.useLocalHistory) {
+      // Copy local history up to the target UUID
+      var targetIdx = -1;
+      for (var fi = 0; fi < session.messageUUIDs.length; fi++) {
+        if (session.messageUUIDs[fi].uuid === uuid) { targetIdx = fi; break; }
+      }
+      var forkHistory = [];
+      if (result.localHistoryEndIndex !== undefined) {
+        if (!Number.isInteger(result.localHistoryEndIndex) || result.localHistoryEndIndex < 0 || result.localHistoryEndIndex > session.history.length) throw new Error("The provider fork exists but its local history boundary is unavailable; inspect before retrying");
+        forkHistory = session.history.slice(0, result.localHistoryEndIndex);
+      } else if (targetIdx >= 0) {
+        var trimTo = session.messageUUIDs[targetIdx].historyIndex;
+        forkHistory = session.history.slice(0, trimTo);
+      } else {
+        forkHistory = session.history.slice();
+      }
+      var create = ws ? sm.createSession : sm.createSessionRaw;
+      var forked = create({
+        vendor: session.vendor,
+        ownerId: session.ownerId || null,
+        userKnowledgeOwnerId: session.userKnowledgeOwnerId || null,
+        sessionVisibility: sessionVisibility.normalize(session.sessionVisibility),
+      }, ws);
+      forked.cliSessionId = result.sessionId;
+      forked.title = forkTitle;
+      forked.history = forkHistory;
+      forked.messageUUIDs = [];
+      for (var hi = 0; hi < forkHistory.length; hi++) {
+        if (forkHistory[hi].type === "message_uuid") {
+          forked.messageUUIDs.push({ uuid: forkHistory[hi].uuid, type: forkHistory[hi].messageType, historyIndex: hi, turnId: forkHistory[hi].turnId || null });
+        }
+      }
+      saveFork(forked, ws);
+      if (ws) sm.switchSession(forked.localId, ws, hydrateImageRefs);
+      sm.broadcastSessionList();
+      return forked;
+    } else {
+      // Read history from CLI session files
+      var history = await require("./yoke/session-history").read(session.vendor || "claude", resolveSessionHome(session), cwd, result.sessionId);
+      revalidate();
+      var options = {
+        history: history,
+        title: forkTitle,
+        vendor: session.vendor,
+        ownerId: session.ownerId || null,
+        userKnowledgeOwnerId: session.userKnowledgeOwnerId || null,
+        sessionVisibility: sessionVisibility.normalize(session.sessionVisibility),
+        sessionVisibilityExplicit: session.sessionVisibilityExplicit === true,
+      };
+      var forked;
+      if (ws) forked = sm.resumeSession(result.sessionId, options, ws);
+      else {
+        forked = sm.createSessionRaw(Object.assign({}, options, { cliSessionId: result.sessionId }));
+        forked.title = forkTitle;
+        forked.history = history;
+        saveFork(forked, ws);
+        sm.broadcastSessionList();
+      }
+      if (forked) {
+        if (ws) ws._clayActiveSession = forked.localId;
+      }
+      return forked;
+    }
+  }
+  return { fork: fork, rewind: rewind };
+}
+module.exports = { attachSessionHistoryActions: attachSessionHistoryActions };

package/lib/project-session-pair.js

@@ -350,7 +350,7 @@ function attachSessionPair(ctx) {
     if (boundRoles && boundRoles.workers.indexOf(boundSession) !== -1) return taskControl.workerToolDefs(boundSession);
     var adHocSplit = !!(group && !group.pair);
     if (!driverEligibility.isEligibleDriverSession(boundSession, sm)) return [];
-    var persistentCatalog = boundSession.vendor === "codex" && (!group || !!group.pair);
+    var persistentCatalog = require("./yoke/session-tool-transport").contract(boundSession.vendor || "claude").catalogLifetime === "conversation" && (!group || !!group.pair);
     if (!group && !persistentCatalog) {
       return workerProposal.getToolDefs(boundSession)
         .concat(workerPermission.getToolDefs(boundSession, { dormantDriver: true }));

package/lib/project-session-runtime-actions.js

@@ -0,0 +1,64 @@
+// Legacy terminal recovery only. New terminal presentation has been retired.
+function attachSessionRuntimeActions(ctx) {
+  function inspect(session) {
+    return JSON.stringify([session.terminalId, session.runtimeTerminalId, session.tuiSuspended, [session.terminalId, session.runtimeTerminalId].map(function (id) { return typeof id === "number" && ctx.tm ? ctx.tm.identity(id) : null; })]);
+  }
+  async function change(session, mode, revalidate) {
+    revalidate();
+    if (mode !== "gui") throw new Error("New terminal presentation has been removed. Only return to GUI chat is supported; provider threads cannot migrate across vendors.");
+    if (session.isProcessing || session._queryStarting || session.queryInstance || Object.keys(session.pendingPermissions || {}).length || Object.keys(session.pendingAskUser || {}).length) throw new Error("Runtime changes require an idle session without an active provider handle or pending approvals.");
+    if (session.taskStopRequested || session._pendingMessageDrainPaused || ctx.isPendingQueuePaused && ctx.isPendingQueuePaused(session)) throw new Error("A stopped session cannot be resumed by a runtime change.");
+    var vendor = session.vendor || ctx.sm.defaultVendor || "claude";
+    var ids = Array.from(new Set([session.terminalId, session.runtimeTerminalId].filter(function (id) { return typeof id === "number"; })));
+    if (!ids.length && (session.runtimeMode || session.mode || "gui") === "gui") return { status: "completed", runtimeMode: "gui", runtimeEffect: "none", threadPreserved: true };
+    var lifecycle = require("./yoke/provider-contract").resolve(vendor);
+    if (typeof lifecycle.supportsLegacyGuiResume !== "function" || !lifecycle.supportsLegacyGuiResume(session)) throw new Error("This provider cannot return a legacy terminal thread to GUI chat.");
+    var closed = 0, persisted = false;
+    var fields = ['terminalId', 'runtimeTerminalId'];
+    var originalFields = fields.map(function (field) { return session[field]; });
+    var targets = ids.map(function (id) { return { id: id, identity: ctx.tm && ctx.tm.identity(id), closed: false }; });
+    var suspended = session.tuiSuspended;
+    function exactTerminals() {
+      if (session.tuiSuspended !== suspended) throw new Error("Terminal presentation changed during shutdown.");
+      targets.forEach(function (target) {
+        var current = ctx.tm && ctx.tm.identity(target.id);
+        if (!target.identity || (target.closed ? current !== null : current !== target.identity)) throw new Error("A terminal runtime was replaced during shutdown.");
+      });
+      fields.forEach(function (field, index) {
+        var original = originalFields[index], current = session[field];
+        if (current === original || current == null && original == null) return;
+        var target = targets.find(function (item) { return item.id === original; });
+        if (current == null && target && target.closed) return;
+        throw new Error("A new or replacement terminal was attached during shutdown.");
+      });
+    }
+    try {
+      for (var target of targets) {
+        revalidate();
+        exactTerminals();
+        if (!ctx.tm || typeof ctx.tm.closeAndWait !== "function") throw new Error("Completion-aware terminal shutdown is unavailable.");
+        ctx.tm.markReclaimed(target.id);
+        await ctx.tm.closeAndWait(target.id); target.closed = true; closed++;
+        revalidate();
+        exactTerminals();
+      }
+      revalidate();
+      exactTerminals();
+      session.terminalId = null; session.runtimeTerminalId = null;
+      ctx.prepareGui(session, { deferSave: true });
+      exactTerminals();
+      session.runtimeMode = "gui"; session.tuiSuspended = false;
+      if (ctx.sm.saveSessionFile(session) !== true) throw new Error("GUI presentation could not be saved after terminal shutdown.");
+      persisted = true;
+      ctx.sm.broadcastSessionList();
+      ctx.publishGui(session);
+      return { status: "completed", runtimeMode: "gui", runtimeEffect: closed ? "terminal_closed" : "none", persisted: true, threadPreserved: true, executionStarted: false };
+    } catch (error) {
+      error.productControlResult = { status: "failed", outcome: "partial", persisted: persisted, runtimeEffect: closed ? "terminal_closed" : "closure_unconfirmed", retrySafe: false, executionStarted: false };
+      throw error;
+    }
+  }
+  function inspectLifecycle() { return ctx.tm.list().map(function (terminal) { return Object.assign({}, terminal, { identity: ctx.tm.identity(terminal.id) }); }); }
+  return { change: change, inspect: inspect, inspectLifecycle: inspectLifecycle };
+}
+module.exports = { attachSessionRuntimeActions: attachSessionRuntimeActions };

package/lib/project-session-spawn.js

@@ -1,6 +1,5 @@
 var yoke = require("./yoke");
 var sessionSpawnMcp = require("./session-spawn-mcp-server");
-var cliSessions = require("./cli-sessions");
 var os = require("os");
 var osUsers = require("./os-users");
 
@@ -161,7 +160,7 @@ function attachSessionSpawn(ctx) {
   var sm = ctx.sm;
   var queue = createSpawnQueue(SPAWN_CONCURRENCY);
   var adapters = ctx.adapters || {};
-  var readCliSessionHistory = ctx.readCliSessionHistory || cliSessions.readCliSessionHistory;
+  var readCliSessionHistory = ctx.readCliSessionHistory || function(home, project, sessionId, provider) { return require("./yoke/session-history").read(provider || "claude", home, project, sessionId); };
 
   function resolveSessionHome(session) {
     var linuxUser = ctx.getLinuxUserForSession(session);
@@ -283,7 +282,7 @@ function attachSessionSpawn(ctx) {
               forkHistory = parent.history.slice();
             } else {
               forkHistory = await readCliSessionHistory(
-                resolveSessionHome(parent), ctx.cwd, forkResult.sessionId
+                resolveSessionHome(parent), ctx.cwd, forkResult.sessionId, parent.vendor
               );
             }
           } catch (e) {

package/lib/project-session-vendor.js

@@ -0,0 +1,55 @@
+var yoke = require('./yoke');
+function attachSessionVendor(ctx) {
+  function verifyIdentity(session, vendor) {
+    if (!ctx.osUsers) return;
+    var info = yoke.getVendorInfo(vendor), linuxUser = ctx.getLinuxUserForSession(session);
+    if (!info || !info.osUserIsolation || !linuxUser) throw new Error('The provider requires an authorized mapped OS identity.');
+    var identity = require('./os-users').resolveOsUserInfo(linuxUser);
+    if (!Number.isInteger(identity.uid) || identity.uid < 0 || !Number.isInteger(identity.gid) || identity.gid < 0) throw new Error('The mapped OS identity is unavailable.');
+  }
+  function setVendor(session, vendor, revalidate) {
+    if (!session || ctx.sm.sessions.get(session.localId) !== session) throw new Error('The Driver was deleted or replaced.');
+    if (revalidate) revalidate();
+    if (!(ctx.adapters || {})[vendor] || (ctx.sm.availableVendors || []).indexOf(vendor) < 0) throw new Error('This provider is unavailable in the project runtime.');
+    verifyIdentity(session, vendor);
+    if (session.cliSessionId || session.queryInstance || session.isProcessing || session._queryStarting || (session.history || []).length || (session.runtimeMode || session.mode || 'gui') !== 'gui') throw new Error('Provider selection requires a fresh idle GUI Driver without a provider thread or transcript.');
+    if (session.taskStopRequested || session._pendingMessageDrainPaused || ctx.isPendingQueuePaused && ctx.isPendingQueuePaused(session)) throw new Error('A stopped Driver requires an explicit separate resume action.');
+    var previous = { vendor: session.vendor, model: session.model, effort: session.effort, permissionMode: session.permissionMode, effectivePermissionMode: session.effectivePermissionMode };
+    session.vendor = vendor;
+    session.model = null;
+    session.effort = yoke.clampEffort(vendor, session.effort) || null;
+    var modes = yoke.sessionTools.contract(ctx.adapters[vendor]).permissionModes;
+    if (session.permissionMode === 'auto' && (!Array.isArray(modes) || modes.indexOf('auto') < 0)) session.permissionMode = 'default';
+    session.effectivePermissionMode = null;
+    try { if (ctx.sm.saveSessionFile(session) !== true) throw new Error('Could not persist the provider selection.'); }
+    catch (error) { Object.assign(session, previous); throw error; }
+    try {
+      ctx.sm.broadcastSessionList();
+      ctx.sm.sendToSession(session, { type: 'model_info', vendor: vendor, sessionId: session.localId, model: '', models: (ctx.sm.modelsByVendor || {})[vendor] || [], availableVendors: ctx.sm.availableVendors || [], installedVendors: ctx.sm.installedVendors || [] });
+      ctx.sm.sendToSession(session, { type: 'config_state', vendor: vendor, sessionId: session.localId, model: '', effort: session.effort, mode: session.permissionMode || ctx.sm.currentPermissionMode || 'default' });
+    } catch (error) { return { status: 'failed', outcome: 'partial', persisted: true, runtimeEffect: 'none', vendor: vendor, error: 'Provider selection saved, but publication failed: ' + error.message }; }
+    return { status: 'completed', persisted: true, runtimeEffect: 'none', vendor: vendor };
+  }
+  function newSession(source, vendor, revalidate) {
+    revalidate();
+    if (!(ctx.adapters || {})[vendor] || (ctx.sm.availableVendors || []).indexOf(vendor) < 0) throw new Error('This provider is unavailable in the project runtime.');
+    if (source.isProcessing || source._queryStarting || source.taskStopRequested || source._pendingMessageDrainPaused || ctx.isPendingQueuePaused && ctx.isPendingQueuePaused(source)) throw new Error('Create a replacement provider session only from an idle, unstopped Driver.');
+    verifyIdentity(source, vendor);
+    revalidate();
+    var created = ctx.sm.createSessionRaw({ ownerId: source.ownerId || null, vendor: vendor, mode: 'gui', sessionVisibility: 'private' });
+    var ref = require('./workspace-query-service').sessionRef(ctx.slug, created), persisted = false;
+    try {
+      revalidate();
+      if (ctx.sm.saveSessionFile(created) !== true) throw new Error('Could not save the new provider session.');
+      persisted = true;
+      revalidate();
+      ctx.sm.broadcastSessionList();
+      return { status: 'completed', persisted: true, newSessionRef: ref, vendor: vendor, threadMigrated: false, originalRetained: true, executionStarted: false };
+    } catch (error) {
+      error.productControlResult = { status: 'failed', outcome: 'partial', persisted: persisted, retainedInMemory: true, newSessionRef: ref, threadMigrated: false, originalRetained: true, executionStarted: false, retrySafe: false };
+      throw error;
+    }
+  }
+  return { setVendor: setVendor, newSession: newSession };
+}
+module.exports = { attachSessionVendor: attachSessionVendor };