@nuvin/session 0.4.0-rc.1 → 0.4.0-rc.11

package/dist/chunk-4AOFJGGN.js

@@ -0,0 +1,141 @@
+// src/protocol/control-center.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isScope(value) {
+  return isRecord(value) && ["profile", "workspace", "cwd"].every(
+    (key) => value[key] === void 0 || typeof value[key] === "string"
+  );
+}
+function isAgentDefinition(value) {
+  return isRecord(value) && ["filename", "name", "description", "systemPrompt"].every(
+    (key) => typeof value[key] === "string"
+  ) && (value.model === void 0 || typeof value.model === "string") && typeof value.enabled === "boolean" && isStringArray(value.tools) && isStringArray(value.skills);
+}
+function isAgentMutation(value) {
+  return isRecord(value) && ["sourceKey", "agentId", "expectedRevision"].every((key) => typeof value[key] === "string");
+}
+var noArgs = (args) => args.length === 0;
+var oneString = (args) => args.length === 1 && typeof args[0] === "string";
+var argumentValidators = {
+  getState: noArgs,
+  completeSlashCommand: (args) => args.length === 2 && args.every((value) => typeof value === "string"),
+  runSlashCommand: oneString,
+  setConfig: (args) => args.length === 1 && Array.isArray(args[0]) && args[0].every(
+    (patch) => isRecord(patch) && typeof patch.key === "string" && Object.hasOwn(patch, "value") && patch.value !== void 0 && (patch.scope === "global" || patch.scope === "local")
+  ),
+  listSkills: noArgs,
+  getSkill: oneString,
+  listAgents: noArgs,
+  getAgent: oneString,
+  getAgentEditorData: (args) => args.length === 0 || args.length === 1 && (args[0] === void 0 || typeof args[0] === "string"),
+  createAgent: (args) => args.length === 1 && isAgentDefinition(args[0]),
+  updateAgent: (args) => args.length === 1 && isAgentMutation(args[0]) && isAgentDefinition(args[0].definition),
+  deleteAgent: (args) => args.length === 1 && isAgentMutation(args[0]),
+  getCommand: oneString,
+  listMcpServers: noArgs,
+  mcpAction: (args) => args.length === 2 && ["enable", "disable", "reload", "login"].includes(args[0]) && typeof args[1] === "string",
+  listWorkspaceMemories: noArgs,
+  getWorkspaceMemory: oneString,
+  removeWorkspaceMemory: oneString,
+  listConsolidateProposals: noArgs,
+  getConsolidateProposal: oneString,
+  decideConsolidateProposal: (args) => (args.length === 2 || args.length === 3) && typeof args[0] === "string" && (args[1] === "approve" || args[1] === "reject") && (args.length === 2 || args[2] === void 0 || isStringArray(args[2])),
+  runConsolidate: noArgs
+};
+function parseControlCenterRequest(value) {
+  if (!isRecord(value) || !isScope(value.scope) || typeof value.operation !== "string" || !Object.hasOwn(argumentValidators, value.operation) || !Array.isArray(value.args) || !argumentValidators[value.operation](value.args)) {
+    throw new Error("Invalid management request.");
+  }
+  return value;
+}
+
+// src/protocol/history-text.ts
+function stripTerminalStringSequences(value) {
+  let sanitized = "";
+  for (let index = 0; index < value.length; ) {
+    const code = value.charCodeAt(index);
+    const next = value.charCodeAt(index + 1);
+    const isSevenBitSequence = code === 27 && [80, 88, 93, 94, 95].includes(next);
+    const isEightBitSequence = [144, 152, 157, 158, 159].includes(code);
+    if (!isSevenBitSequence && !isEightBitSequence) {
+      sanitized += value[index];
+      index += 1;
+      continue;
+    }
+    index += isSevenBitSequence ? 2 : 1;
+    while (index < value.length) {
+      const terminator = value.charCodeAt(index);
+      if (terminator === 7 || terminator === 156) {
+        index += 1;
+        break;
+      }
+      if (terminator === 27 && value.charCodeAt(index + 1) === 92) {
+        index += 2;
+        break;
+      }
+      index += 1;
+    }
+  }
+  return sanitized;
+}
+function stripTerminalControlSequences(value) {
+  let sanitized = "";
+  for (let index = 0; index < value.length; ) {
+    const code = value.charCodeAt(index);
+    const isCsi = code === 155 || code === 27 && value.charCodeAt(index + 1) === 91;
+    if (isCsi) {
+      index += code === 27 ? 2 : 1;
+      while (index < value.length) {
+        const current = value.charCodeAt(index);
+        index += 1;
+        if (current >= 64 && current <= 126) break;
+      }
+      continue;
+    }
+    if (code === 27) {
+      index += 1;
+      while (index < value.length) {
+        const current = value.charCodeAt(index);
+        index += 1;
+        if (current < 32 || current > 47) break;
+      }
+      continue;
+    }
+    sanitized += value[index];
+    index += 1;
+  }
+  return sanitized;
+}
+function sanitizeHistoryDisplayText(value) {
+  return stripTerminalControlSequences(stripTerminalStringSequences(value.normalize("NFKC"))).replace(new RegExp("\\p{Cc}", "gu"), (control) => /\s/u.test(control) ? " " : "").replace(/\s+/gu, " ").trim();
+}
+function normalizeHistoryText(value) {
+  return sanitizeHistoryDisplayText(value).toLowerCase();
+}
+function escapeLikeLiteral(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}
+
+// src/protocol/model-identity.ts
+function modelNameFromIdentity(modelIdentity) {
+  const separator = modelIdentity.indexOf(":");
+  return separator === -1 ? modelIdentity : modelIdentity.slice(separator + 1);
+}
+function providerFromIdentity(modelIdentity) {
+  const separator = modelIdentity.indexOf(":");
+  if (separator <= 0) return void 0;
+  return modelIdentity.slice(0, separator);
+}
+
+export {
+  parseControlCenterRequest,
+  sanitizeHistoryDisplayText,
+  normalizeHistoryText,
+  escapeLikeLiteral,
+  modelNameFromIdentity,
+  providerFromIdentity
+};

package/dist/{chunk-DTLHDYZC.js → chunk-4FXP5TSI.js}

@@ -3,8 +3,6 @@ var BACKGROUNDLESS_TOOLS = /* @__PURE__ */ new Set([
   "FileRead",
   "ViewFile",
   "Ls",
-  "Grep",
-  "Glob",
   "LoadSkill",
   "Lsp",
   "WebFetch",
@@ -179,6 +177,16 @@ function withUpdatedMessage(state, id, update) {
     messages: state.messages.map((message) => message.id === id ? update(message) : message)
   };
 }
+function withDelegatedModel(message, model) {
+  if (message.toolName !== "AssignTask") return message;
+  const prior = message.delegatedModel;
+  if (prior !== void 0) {
+    if (prior.runId !== model.runId || prior.turnNumber > model.turnNumber) return message;
+    if (prior.turnNumber === model.turnNumber && (prior.source === "resolution" || model.source === "assistant"))
+      return message;
+  }
+  return { ...message, delegatedModel: { ...model } };
+}
 function addMessage(state, message) {
   return {
     ...state,
@@ -192,20 +200,33 @@ function cloneToolCallPath(toolCallPath) {
 function scopedRegistryKey(toolCallPath, id) {
   return scopedToolKey(toolCallPath, id);
 }
-function compactError(error) {
-  const normalized = error.trim().replace(/\s+/g, " ");
-  return normalized.length <= 160 ? normalized : `${normalized.slice(0, 159)}\u2026`;
-}
-function retryDelayText(delayMs) {
-  return delayMs === 0 ? "retry now" : `retry after ${Math.max(1, Math.ceil(delayMs / 1e3))}s`;
-}
-function retryReasonText(event) {
-  if (event.reason === "transport_error") return "Network interrupted";
-  if (event.reason === "stream_error") return "Provider stream interrupted";
-  return event.status === void 0 ? "Provider unavailable" : `Provider unavailable (HTTP ${event.status})`;
-}
-function formatProviderRetryText(event) {
-  return `${retryReasonText(event)}: ${compactError(event.error)} \xB7 ${retryDelayText(event.delayMs)} \xB7 attempt ${event.attempt + 1}/${event.maxAttempts}`;
+function retryReasonText(reason, status) {
+  if (reason === "transport_error") return "Network interrupted";
+  if (reason === "stream_error") return "Provider stream interrupted";
+  return status === void 0 ? "Provider unavailable" : `Provider unavailable (HTTP ${status})`;
+}
+function pluralize(count, singular, plural = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function formatProviderRetrySummary(detail) {
+  const last = detail.attempts[detail.attempts.length - 1];
+  if (last === void 0) return "Provider request interrupted";
+  const reason = retryReasonText(last.reason, last.status);
+  if (detail.outcome === "recovered") {
+    const restored = `restored after ${pluralize(detail.attempts.length, "retry", "retries")}`;
+    if (detail.settledAt === void 0) return `${reason} \u2014 ${restored}`;
+    const elapsedSeconds = Math.max(
+      0,
+      Math.round((detail.settledAt - detail.attempts[0].occurredAt) / 1e3)
+    );
+    return `${reason} \u2014 ${restored} \xB7 ${elapsedSeconds}s`;
+  }
+  if (detail.outcome === "stopped") {
+    return `${reason} \u2014 gave up after ${pluralize(detail.attempts.length, "attempt")}`;
+  }
+  const nextAttempt = Math.min(last.failedAttempt + 1, last.maxAttempts);
+  const delay = last.delayMs === 0 ? "now" : `in ${Math.max(1, Math.ceil(last.delayMs / 1e3))}s`;
+  return `${reason} \u2014 retrying attempt ${nextAttempt}/${last.maxAttempts} ${delay}`;
 }
 function removeProviderStreamMessages(state, assistantMessageId, reasoningMessageId, toolCallPath) {
   const assistantKey = scopedRegistryKey(toolCallPath, assistantMessageId);
@@ -249,33 +270,39 @@ function upsertProviderRetryMessage(state, event, toolCallPath, now) {
     ...event.status !== void 0 ? { status: event.status } : {},
     occurredAt: now
   };
-  const text = formatProviderRetryText(event);
   if (existingId) {
     return withUpdatedMessage(state, existingId, (message) => {
       if (!isProviderRetryMessage(message)) {
         return message;
       }
+      const detail2 = {
+        ...message.providerRetry,
+        attempts: [...message.providerRetry.attempts, attempt],
+        // A retry arriving for a settled row means the request recovered once
+        // and dropped again — the new attempt reopens the row.
+        outcome: "retrying",
+        settledAt: void 0
+      };
       return {
         ...message,
-        text,
-        providerRetry: {
-          ...message.providerRetry,
-          attempts: [...message.providerRetry.attempts, attempt]
-        }
+        text: formatProviderRetrySummary(detail2),
+        providerRetry: detail2
       };
     });
   }
+  const detail = {
+    assistantMessageId: event.assistantMessageId,
+    attempts: [attempt],
+    outcome: "retrying"
+  };
   const id = createMessageId(state);
   const storedToolCallPath = cloneToolCallPath(toolCallPath);
   const nextState = addMessage(state, {
     id,
     role: "warning",
-    text,
+    text: formatProviderRetrySummary(detail),
     ...storedToolCallPath ? { toolCallPath: storedToolCallPath } : {},
-    providerRetry: {
-      assistantMessageId: event.assistantMessageId,
-      attempts: [attempt]
-    }
+    providerRetry: detail
   });
   return {
     ...nextState,
@@ -285,6 +312,41 @@ function upsertProviderRetryMessage(state, event, toolCallPath, now) {
     }
   };
 }
+var REASONING_MESSAGE_ID_SUFFIX = ":reasoning";
+function assistantIdFromStreamMessageId(messageId) {
+  return messageId.endsWith(REASONING_MESSAGE_ID_SUFFIX) ? messageId.slice(0, -REASONING_MESSAGE_ID_SUFFIX.length) : messageId;
+}
+function markProviderRetryRecovered(state, assistantMessageId, toolCallPath, now) {
+  const rowId = state.providerRetryMessageIds[scopedRegistryKey(toolCallPath, assistantMessageId)];
+  if (rowId === void 0) return state;
+  return withUpdatedMessage(state, rowId, (message) => {
+    if (!isProviderRetryMessage(message) || message.providerRetry.outcome !== "retrying") {
+      return message;
+    }
+    const detail = {
+      ...message.providerRetry,
+      outcome: "recovered",
+      settledAt: now
+    };
+    return { ...message, text: formatProviderRetrySummary(detail), providerRetry: detail };
+  });
+}
+function settleAllProviderRetries(state, now) {
+  let changed = false;
+  const messages = state.messages.map((message) => {
+    if (isProviderRetryMessage(message) && message.providerRetry.outcome === "retrying") {
+      changed = true;
+      const detail = {
+        ...message.providerRetry,
+        outcome: "stopped",
+        settledAt: now
+      };
+      return { ...message, text: formatProviderRetrySummary(detail), providerRetry: detail };
+    }
+    return message;
+  });
+  return changed ? { ...state, messages } : state;
+}
 function upsertTrackedTextMessage(state, registryKey, messageId, role, text, mode, live, toolCallPath, timing) {
   const trackingKey = scopedRegistryKey(toolCallPath, messageId);
   const existingId = state[registryKey][trackingKey];
@@ -608,13 +670,15 @@ function createMessageStateFromMessages(messages) {
     toolMessageIds
   };
 }
-function appendUserMessage(state, text, attachmentLabels, createdAt) {
+function appendUserMessage(state, text, attachmentLabels, createdAt, steeredAt, submissionId) {
   return addMessage(state, {
     id: createMessageId(state),
     role: "user",
     text,
     ...attachmentLabels && attachmentLabels.length > 0 ? { attachmentLabels } : {},
-    ...createdAt !== void 0 ? { createdAt } : {}
+    ...createdAt !== void 0 ? { createdAt } : {},
+    ...steeredAt !== void 0 ? { steeredAt } : {},
+    ...submissionId === void 0 ? {} : { submissionId }
   });
 }
 function appendErrorMessage(state, text) {
@@ -668,12 +732,18 @@ function applyAgentEvent(state, event, toolCallPath, now = Date.now()) {
         toolCallPath: nestedPath
       });
     }
-    case "assistant_chunk":
+    case "assistant_chunk": {
+      const recovered = markProviderRetryRecovered(
+        state,
+        assistantIdFromStreamMessageId(event.messageId),
+        toolCallPath,
+        now
+      );
       if (!event.chunk.text) {
-        return state;
+        return recovered;
       }
       return upsertTrackedTextMessage(
-        settleLiveReasoning(state, toolCallPath, now),
+        settleLiveReasoning(recovered, toolCallPath, now),
         "assistantMessageIds",
         event.messageId,
         "assistant",
@@ -682,13 +752,20 @@ function applyAgentEvent(state, event, toolCallPath, now = Date.now()) {
         true,
         toolCallPath
       );
+    }
     case "assistant_message": {
+      const recovered = markProviderRetryRecovered(
+        state,
+        assistantIdFromStreamMessageId(event.message.id),
+        toolCallPath,
+        now
+      );
       const text = getTextFromMessage(event.message).trim();
       if (text.length === 0) {
-        return state;
+        return recovered;
       }
       return upsertTrackedTextMessage(
-        settleLiveReasoning(state, toolCallPath, now),
+        settleLiveReasoning(recovered, toolCallPath, now),
         "assistantMessageIds",
         event.message.id,
         "assistant",
@@ -698,12 +775,18 @@ function applyAgentEvent(state, event, toolCallPath, now = Date.now()) {
         toolCallPath
       );
     }
-    case "reasoning_chunk":
+    case "reasoning_chunk": {
+      const recovered = markProviderRetryRecovered(
+        state,
+        assistantIdFromStreamMessageId(event.messageId),
+        toolCallPath,
+        now
+      );
       if (!event.text) {
-        return state;
+        return recovered;
       }
       return upsertTrackedTextMessage(
-        state,
+        recovered,
         "reasoningMessageIds",
         event.messageId,
         "reasoning",
@@ -713,13 +796,20 @@ function applyAgentEvent(state, event, toolCallPath, now = Date.now()) {
         toolCallPath,
         now
       );
+    }
     case "reasoning_message": {
+      const recovered = markProviderRetryRecovered(
+        state,
+        assistantIdFromStreamMessageId(event.message.id),
+        toolCallPath,
+        now
+      );
       const text = getReasoningTextFromMessage(event.message).trim();
       if (text.length === 0) {
-        return state;
+        return recovered;
       }
       return upsertTrackedTextMessage(
-        state,
+        recovered,
         "reasoningMessageIds",
         event.message.id,
         "reasoning",
@@ -731,12 +821,18 @@ function applyAgentEvent(state, event, toolCallPath, now = Date.now()) {
       );
     }
     case "final_message": {
+      const recovered = markProviderRetryRecovered(
+        state,
+        assistantIdFromStreamMessageId(event.message.id),
+        toolCallPath,
+        now
+      );
       const text = getTextFromMessage(event.message).trim();
       if (text.length === 0) {
-        return state;
+        return recovered;
       }
       return upsertTrackedTextMessage(
-        settleLiveReasoning(state, toolCallPath, now),
+        settleLiveReasoning(recovered, toolCallPath, now),
         "assistantMessageIds",
         event.message.id,
         "assistant",
@@ -746,6 +842,39 @@ function applyAgentEvent(state, event, toolCallPath, now = Date.now()) {
         toolCallPath
       );
     }
+    // Tool-use stream/message events prove the retried request resumed even
+    // when the response carries no assistant text — mark recovery only; tool
+    // rows themselves are created by the tool_call case.
+    case "tool_use_chunk":
+      return markProviderRetryRecovered(
+        state,
+        assistantIdFromStreamMessageId(event.messageId),
+        toolCallPath,
+        now
+      );
+    case "tool_use_message":
+      return markProviderRetryRecovered(
+        state,
+        assistantIdFromStreamMessageId(event.message.id),
+        toolCallPath,
+        now
+      );
+    case "delegated_model_resolved": {
+      const id = state.toolMessageIds[scopedToolKey(toolCallPath, event.parentToolCallId)];
+      if (id === void 0) return state;
+      const model = {
+        runId: event.runId,
+        turnNumber: event.turnNumber,
+        ...event.turnId === void 0 ? {} : { turnId: event.turnId },
+        modelIdentity: event.modelIdentity,
+        source: "resolution"
+      };
+      return withUpdatedMessage(
+        state,
+        id,
+        (message) => message.role === "tool" ? withDelegatedModel(message, model) : message
+      );
+    }
     case "tool_call":
       return ensureToolMessage(state, event.toolCall, toolCallPath);
     case "tool_started": {
@@ -893,6 +1022,7 @@ ${sanitizeMultilineDisplayText(split.body)}`;
 }
 
 // src/state/session.ts
+import { isAgentOnlyCoordinatorNotice } from "@nuvin/agent-core/shared";
 function cloneApproval(approval) {
   const { toolCallPath, ...rootApproval } = approval;
   return toolCallPath && toolCallPath.length > 0 ? { ...rootApproval, toolCallPath: [...toolCallPath] } : rootApproval;
@@ -902,7 +1032,8 @@ function cloneQuestion2(question) {
   return toolCallPath && toolCallPath.length > 0 ? { ...rootQuestion, toolCallPath: [...toolCallPath] } : rootQuestion;
 }
 function cloneMessage(message) {
-  const { toolCallPath, ...rootMessage } = message;
+  const cloned = message.role === "tool" && message.delegatedModel !== void 0 ? { ...message, delegatedModel: { ...message.delegatedModel } } : message;
+  const { toolCallPath, ...rootMessage } = cloned;
   return toolCallPath && toolCallPath.length > 0 ? { ...rootMessage, toolCallPath: [...toolCallPath] } : rootMessage;
 }
 function cloneBackgroundWorkSummary(summary) {
@@ -917,6 +1048,8 @@ function cloneBackgroundWorkActive(active) {
 function normalizeResetState(state) {
   return {
     ...state,
+    recall: copyRecallState(state.recall),
+    activeHumanSubmission: state.activeHumanSubmission === null ? null : structuredClone(state.activeHumanSubmission),
     backgroundAgents: {
       ...state.backgroundAgents,
       runningRunIds: [...state.backgroundAgents.runningRunIds]
@@ -944,6 +1077,8 @@ function normalizeResetState(state) {
 }
 function createSessionViewState() {
   return {
+    recall: { identity: null, entries: [] },
+    activeHumanSubmission: null,
     approval: createApprovalQueueState(),
     authFlow: null,
     backgroundAgents: { running: 0, queued: 0, runningRunIds: [] },
@@ -960,6 +1095,32 @@ function createSessionViewState() {
 }
 function reduceSessionEvent(state, event) {
   switch (event.type) {
+    case "active-human-submission":
+      return {
+        ...state,
+        activeHumanSubmission: event.key === null ? null : structuredClone(event.key)
+      };
+    case "submission-retracted": {
+      const { key, rawText } = event.result;
+      const identity = state.recall.identity;
+      if (identity === null || identity.profile !== key.identity.profile || identity.workspace !== key.identity.workspace || identity.sessionId !== key.identity.sessionId)
+        return state;
+      const recall = appendRecallEntry(state.recall, { key, rawText, retracted: true });
+      const removed = new Set(event.removedMessageIds);
+      return {
+        ...state,
+        recall,
+        activeHumanSubmission: state.activeHumanSubmission?.submissionId === key.submissionId ? null : state.activeHumanSubmission,
+        messages: {
+          ...state.messages,
+          messages: state.messages.messages.filter(
+            (message) => !(message.role === "user" && message.submissionId === key.submissionId && removed.has(message.id))
+          )
+        }
+      };
+    }
+    case "recall-state":
+      return { ...state, recall: copyRecallState(event.recall) };
     case "agent-event": {
       let messages = applyAgentEvent(
         state.messages,
@@ -988,7 +1149,14 @@ function reduceSessionEvent(state, event) {
     case "user-message":
       return {
         ...state,
-        messages: appendUserMessage(state.messages, event.text, event.attachmentLabels, event.at)
+        messages: appendUserMessage(
+          state.messages,
+          event.text,
+          event.attachmentLabels,
+          event.at,
+          event.steeredAt,
+          event.submissionId
+        )
       };
     case "approval-requested":
       return {
@@ -1031,7 +1199,7 @@ function reduceSessionEvent(state, event) {
         question: removeQuestion(state.question, event.questionId, event.toolCallPath)
       };
     case "turn-status": {
-      const messages = event.busy ? state.messages : settleAllLiveReasoning(state.messages, event.at);
+      const messages = event.busy ? state.messages : settleAllProviderRetries(settleAllLiveReasoning(state.messages, event.at), event.at);
       return {
         ...state,
         busy: event.busy,
@@ -1052,6 +1220,7 @@ function reduceSessionEvent(state, event) {
     case "background-work-active":
       return { ...state, backgroundWork: cloneBackgroundWorkActive(event.active) };
     case "info": {
+      if (isAgentOnlyCoordinatorNotice(event)) return state;
       const report = resolveSubagentReport(event.message, event.subagentReport);
       return {
         ...state,
@@ -1062,7 +1231,7 @@ function reduceSessionEvent(state, event) {
       return {
         ...state,
         messages: appendErrorMessage(
-          settleAllLiveReasoning(state.messages, event.at),
+          settleAllProviderRetries(settleAllLiveReasoning(state.messages, event.at), event.at),
           event.message
         )
       };
@@ -1080,6 +1249,36 @@ function reduceSessionEvent(state, event) {
       return state;
   }
 }
+function appendRecallEntry(state, entry) {
+  const identity = state.identity;
+  if (identity === null || identity.profile !== entry.key.identity.profile || identity.workspace !== entry.key.identity.workspace || identity.sessionId !== entry.key.identity.sessionId)
+    return state;
+  if (typeof entry.key.submissionId !== "string" || entry.key.submissionId.trim().length === 0 || typeof entry.rawText !== "string" || typeof entry.retracted !== "boolean") {
+    throw new Error("Invalid recall entry");
+  }
+  const index = state.entries.findIndex((item) => item.key.submissionId === entry.key.submissionId);
+  const previous = state.entries[index];
+  if (previous !== void 0) {
+    if (previous.rawText !== entry.rawText) throw new Error("Conflicting submission raw text");
+    if (previous.retracted || !entry.retracted) return state;
+    const entries = [...state.entries];
+    entries[index] = { ...previous, retracted: true };
+    return { ...state, entries };
+  }
+  return { ...state, entries: [structuredClone(entry), ...state.entries] };
+}
+function copyRecallState(recall) {
+  let copy = {
+    identity: recall.identity === null ? null : { ...recall.identity },
+    entries: []
+  };
+  for (const entry of [...recall.entries].reverse()) {
+    if (copy.identity === null || copy.identity.profile !== entry.key.identity.profile || copy.identity.workspace !== entry.key.identity.workspace || copy.identity.sessionId !== entry.key.identity.sessionId)
+      throw new Error("Recall entry identity mismatch");
+    copy = appendRecallEntry(copy, entry);
+  }
+  return copy;
+}
 
 export {
   BACKGROUNDLESS_TOOLS,
@@ -1094,6 +1293,8 @@ export {
   asJsonObject,
   scopedToolKey,
   isProviderRetryMessage,
+  withDelegatedModel,
+  settleAllProviderRetries,
   settleAllLiveReasoning,
   summarizeToolCallInput,
   setToolMessageStatus,
@@ -1115,5 +1316,7 @@ export {
   splitSanitizableDelivery,
   sanitizeCoordinatorDeliveryText,
   createSessionViewState,
-  reduceSessionEvent
+  reduceSessionEvent,
+  appendRecallEntry,
+  copyRecallState
 };