remote-codex 0.11.26 → 0.11.28

package/README.md

@@ -103,6 +103,18 @@ remote-codex relay-supervisor
 `45679` is used by default in copied setup commands to avoid common local
 `8787` port conflicts. You can change it if needed.
 
+By default, `remote-codex relay-supervisor` starts itself inside a detached
+`tmux` session so closing the terminal does not take the device offline. Manage
+it with:
+
+```bash
+remote-codex relay-supervisor status
+remote-codex relay-supervisor stop
+```
+
+If `tmux` is not installed it runs in the foreground. Use
+`remote-codex relay-supervisor run` for explicit foreground/debug mode.
+
 ### Local Mode
 
 ```bash
@@ -247,6 +259,17 @@ remote-codex relay-supervisor
 
 复制命令默认使用 `45679`，用于避开本机常见的 `8787` 端口冲突；需要时可以手动换。
 
+默认情况下，`remote-codex relay-supervisor` 会尝试启动到 detached `tmux`
+session 里，这样关闭终端窗口不会让设备下线。可以用下面命令管理：
+
+```bash
+remote-codex relay-supervisor status
+remote-codex relay-supervisor stop
+```
+
+如果设备没有安装 `tmux`，它会自动退回前台运行。需要显式前台调试时使用
+`remote-codex relay-supervisor run`。
+
 ### 本地模式
 
 ```bash

package/apps/supervisor-api/dist/index.js

@@ -10862,6 +10862,15 @@ var HIDDEN_ASK_USER_QUESTION_CONTINUATION_PREFIX = "The user answered the clarif
 var SUPPRESSED_ASSISTANT_TEXTS = /* @__PURE__ */ new Set([
   "No response requested."
 ]);
+var CLAUDE_LIMIT_ERROR_PATTERNS = [
+  /\byou(?:'|’)ve hit your session limit\b/i,
+  /\byou have hit your session limit\b/i,
+  /\b(?:hit|reached|exceeded) (?:the )?(?:session|usage|rate) limit\b/i,
+  /\b(?:session|usage|rate) limit (?:hit|reached|exceeded)\b/i,
+  /\bquota exceeded\b/i,
+  /\bcredit balance (?:is )?(?:too low|insufficient|exhausted)\b/i,
+  /\binsufficient credits?\b/i
+];
 function normalizedToolName(toolName) {
   return toolName.replace(/[\s_-]+/g, "").toLowerCase();
 }
@@ -11043,6 +11052,26 @@ function isHiddenContinuationMessage(message) {
 function shouldSuppressAssistantText(text2) {
   return SUPPRESSED_ASSISTANT_TEXTS.has(text2.trim());
 }
+function claudeLimitErrorMessage(text2) {
+  const normalized = text2?.trim();
+  if (!normalized) {
+    return null;
+  }
+  return CLAUDE_LIMIT_ERROR_PATTERNS.some((pattern) => pattern.test(normalized)) ? normalized : null;
+}
+function limitErrorFromHistoryItems(items) {
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    const item = items[index];
+    if (item?.kind !== "agentMessage") {
+      continue;
+    }
+    const error = claudeLimitErrorMessage(item.text);
+    if (error) {
+      return error;
+    }
+  }
+  return null;
+}
 function userMessageToHistoryItem(id, message) {
   return {
     id,
@@ -11182,6 +11211,28 @@ function toolResultBlocks(message) {
     };
   }).filter((block) => Boolean(block));
 }
+function xmlTagText(input, tagName) {
+  const match = new RegExp(`<${tagName}>([\\s\\S]*?)</${tagName}>`, "i").exec(input);
+  return match?.[1]?.trim() || null;
+}
+function decodeBasicXmlEntities(input) {
+  return input.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+}
+function taskNotificationToolResult(message) {
+  const text2 = messageContentText(message).trim();
+  if (!text2.startsWith("<task-notification>") || !text2.includes("</task-notification>")) {
+    return null;
+  }
+  const toolUseId = xmlTagText(text2, "tool-use-id");
+  if (!toolUseId) {
+    return null;
+  }
+  const result = xmlTagText(text2, "result") ?? xmlTagText(text2, "summary") ?? text2;
+  return {
+    toolUseId,
+    result: decodeBasicXmlEntities(result)
+  };
+}
 function suppressedClaudeToolUseIds(message) {
   const ids = /* @__PURE__ */ new Set();
   for (const block of contentBlocks(message)) {
@@ -11892,6 +11943,13 @@ function queryResultError(message) {
   }
   return message.errors?.join("\n") || message.stop_reason || "Claude turn failed.";
 }
+function statusForHistoricalItems(items) {
+  const limitError = limitErrorFromHistoryItems(items);
+  return {
+    status: limitError ? "failed" : "completed",
+    error: limitError
+  };
+}
 function assistantMessagePayload(message) {
   return message.type === "assistant" ? message.message : null;
 }
@@ -12699,7 +12757,8 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         this.deleteActiveTurn(state);
         this.emitUsage(state);
         const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-        const status = state.interrupted ? "interrupted" : terminalStatus ?? "completed";
+        const limitError = limitErrorFromHistoryItems(orderedItems(state));
+        const status = state.interrupted ? "interrupted" : limitError ? "failed" : terminalStatus ?? "completed";
         this.emitRuntimeEvent({
           type: "turn.completed",
           provider: "claude",
@@ -12708,7 +12767,7 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
             providerTurnId: state.providerTurnId,
             startedAt: state.startedAt,
             status,
-            error: terminalError,
+            error: limitError ?? terminalError,
             items: finalizeTurnItems(state, status, completedAt),
             rawTurn: rawMessages
           })
@@ -12801,6 +12860,18 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       return;
     }
     if (message.type === "user") {
+      const taskNotification = taskNotificationToolResult(message.message);
+      if (taskNotification && !state.suppressedToolUseIds.has(taskNotification.toolUseId)) {
+        const item = resultForToolUse({
+          toolUseId: taskNotification.toolUseId,
+          result: message.tool_use_result ?? taskNotification.result,
+          previous: state.items.get(taskNotification.toolUseId) ?? null
+        });
+        const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+        addOrUpdateItem(state, nextItem);
+        this.emitItem(state, nextItem, "item.completed");
+        return;
+      }
       const rawToolResults = toolResultBlocks(message.message);
       const toolResults = rawToolResults.filter(
         (toolResult) => !state.suppressedToolUseIds.has(toolResult.toolUseId)
@@ -13108,6 +13179,24 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
     };
     for (const message of messages) {
       if (message.type === "user") {
+        const taskNotification = taskNotificationToolResult(message.message);
+        if (taskNotification) {
+          if (suppressedToolUseIds.has(taskNotification.toolUseId)) {
+            continue;
+          }
+          const previous = current?.itemsById.get(taskNotification.toolUseId) ?? null;
+          upsertCurrentItem(
+            withHistoryItemCreatedAt(
+              resultForToolUse({
+                toolUseId: taskNotification.toolUseId,
+                result: message.tool_use_result ?? taskNotification.result,
+                previous
+              }),
+              sessionMessageTimestamp(message) ?? current?.startedAt
+            )
+          );
+          continue;
+        }
         const rawToolResults = toolResultBlocks(message.message);
         const toolResults = rawToolResults.filter(
           (toolResult) => !suppressedToolUseIds.has(toolResult.toolUseId)
@@ -13143,10 +13232,12 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         }
         skippingHiddenInit = false;
         if (current && current.items.length > 0) {
+          const outcome = statusForHistoricalItems(current.items);
           turns.push(buildAgentTurn({
             providerTurnId: current.providerTurnId,
             startedAt: current.startedAt,
-            status: "completed",
+            status: outcome.status,
+            error: outcome.error,
             items: current.items
           }));
         }
@@ -13201,10 +13292,12 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       }
     }
     if (current && current.items.length > 0) {
+      const outcome = statusForHistoricalItems(current.items);
       turns.push(buildAgentTurn({
         providerTurnId: current.providerTurnId,
         startedAt: current.startedAt,
-        status: "completed",
+        status: outcome.status,
+        error: outcome.error,
         items: current.items
       }));
     }
@@ -17797,8 +17890,10 @@ var ThreadRuntimeEventProjector = class {
         }
         const turnId = liveState.displayTurnIdForRuntimeTurn(record.id, event.providerTurnId) ?? event.providerTurnId;
         updateThreadRecord(db, record.id, {
+          providerTurnId: null,
           status: "failed",
-          lastError: event.error
+          lastError: event.error,
+          lastTurnCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         liveState.setLivePlan(record.id, null);
         liveState.setLiveItems(record.id, null);
@@ -18267,6 +18362,9 @@ var ThreadDetailAssembler = class {
       input.record.model,
       input.record.reasoningEffort
     );
+    const persistedItemsByTurnIdForPatch = this.input.callbacks.listPersistedHistoryItemsByTurnId(
+      input.localThreadId
+    );
     const activeDisplayTurnId = this.input.liveState.displayTurnIdForRuntimeTurn(
       input.localThreadId,
       input.record.providerTurnId
@@ -18278,7 +18376,20 @@ var ThreadDetailAssembler = class {
     if (input.record.providerTurnId && threadPatch.status === "idle" && activeLiveItems && activeLiveItems.items.length > 0) {
       threadPatch.status = "running";
     }
-    this.input.callbacks.updateThreadRecord(input.record.id, threadPatch);
+    const latestPersistedFailure = latestPersistedFailureAfter(
+      persistedItemsByTurnIdForPatch,
+      input.turnMetadataById,
+      newestRemoteTurnStartedAt(remoteSession.turns)
+    );
+    if (threadPatch.status !== "running" && latestPersistedFailure) {
+      threadPatch.status = "failed";
+      threadPatch.lastError = latestPersistedFailure.error;
+    }
+    const nextThreadPatch = {
+      ...threadPatch,
+      ...threadPatch.status !== "running" ? { providerTurnId: null } : {}
+    };
+    this.input.callbacks.updateThreadRecord(input.record.id, nextThreadPatch);
     const updated = this.input.callbacks.getUpdatedThreadRecord(input.record.id);
     this.input.callbacks.syncAfterRemoteSession(updated.id, remoteSession);
     const deferredDetails = /* @__PURE__ */ new Map();
@@ -18301,8 +18412,17 @@ var ThreadDetailAssembler = class {
       this.input.liveState,
       input.turnMetadataById
     );
-    const orderedVisibleTurns = applyLiveAgentMessageOrderingHints(
+    const visibleTurnsWithPersistedFailures = appendPersistedFailureTurnsIfMissing(
       visibleTurnsWithActiveLiveTurn,
+      persistedItemsByTurnId,
+      input.turnMetadataById,
+      {
+        includeAllMissing: shouldCacheFullDetail,
+        includeLatestMissing: options.beforeTurnId === void 0
+      }
+    );
+    const orderedVisibleTurns = applyLiveAgentMessageOrderingHints(
+      visibleTurnsWithPersistedFailures,
       input.localThreadId,
       this.input.liveState
     );
@@ -18348,13 +18468,16 @@ var ThreadDetailAssembler = class {
       input.record,
       latestThreadTurnMetadata(input.turnMetadataById)
     );
-    const localTurns = localSession?.turns ?? [...persistedItemsByTurnId.keys()].map((turnId) => ({
-      id: turnId,
-      startedAt: null,
-      status: "completed",
-      error: null,
-      items: []
-    }));
+    const localTurns = localSession?.turns ?? [...persistedItemsByTurnId.entries()].map(([turnId, items]) => {
+      const error = persistedTurnError(items);
+      return {
+        id: turnId,
+        startedAt: input.turnMetadataById.get(turnId)?.createdAt ?? null,
+        status: error ? "failed" : "completed",
+        error,
+        items: []
+      };
+    });
     const turns = mergePersistedHistoryItemsIntoTurns(
       applyRecordedTurnItemOrders(
         localTurns,
@@ -18453,6 +18576,87 @@ function appendActiveLiveTurnIfMissing(turns, localThreadId, providerTurnId, liv
     }
   ];
 }
+function appendPersistedFailureTurnsIfMissing(turns, persistedItemsByTurnId, metadataById, options) {
+  if (persistedItemsByTurnId.size === 0) {
+    return turns;
+  }
+  const existingTurnIds = new Set(turns.map((turn) => turn.id));
+  const newestVisibleStartedAt = newestStartedAt(turns);
+  const missingFailureTurns = [];
+  for (const [turnId, items] of persistedItemsByTurnId.entries()) {
+    if (existingTurnIds.has(turnId)) {
+      continue;
+    }
+    const error = persistedTurnError(items);
+    if (!error) {
+      continue;
+    }
+    const startedAt = metadataById.get(turnId)?.createdAt ?? earliestItemCreatedAt(items);
+    const shouldInclude = options.includeAllMissing || options.includeLatestMissing && (!newestVisibleStartedAt || !startedAt || startedAt >= newestVisibleStartedAt);
+    if (!shouldInclude) {
+      continue;
+    }
+    missingFailureTurns.push({
+      id: turnId,
+      startedAt,
+      status: "failed",
+      error,
+      items: []
+    });
+  }
+  if (missingFailureTurns.length === 0) {
+    return turns;
+  }
+  return sortTurnsByStartedAt([...turns, ...missingFailureTurns]);
+}
+function persistedTurnError(items) {
+  const failedItem = [...items].reverse().find(
+    (item) => item.status === "failed" || item.status === "error"
+  );
+  return failedItem?.text?.trim() || null;
+}
+function earliestItemCreatedAt(items) {
+  return items.map((item) => item.createdAt).filter((value) => Boolean(value)).sort()[0] ?? null;
+}
+function newestStartedAt(turns) {
+  return turns.map((turn) => turn.startedAt).filter((value) => Boolean(value)).sort().at(-1) ?? null;
+}
+function newestRemoteTurnStartedAt(turns) {
+  return turns.map((turn) => turn.startedAt).filter((value) => Boolean(value)).sort().at(-1) ?? null;
+}
+function latestPersistedFailureAfter(persistedItemsByTurnId, metadataById, timestamp) {
+  let latest = null;
+  for (const [turnId, items] of persistedItemsByTurnId.entries()) {
+    const error = persistedTurnError(items);
+    if (!error) {
+      continue;
+    }
+    const startedAt = metadataById.get(turnId)?.createdAt ?? earliestItemCreatedAt(items);
+    if (timestamp && startedAt && startedAt < timestamp) {
+      continue;
+    }
+    if (!latest || !latest.startedAt && startedAt || latest.startedAt && startedAt && startedAt > latest.startedAt) {
+      latest = { error, startedAt };
+    }
+  }
+  return latest;
+}
+function sortTurnsByStartedAt(turns) {
+  return turns.map((turn, index) => ({ turn, index })).sort((left, right) => {
+    const leftStartedAt = left.turn.startedAt;
+    const rightStartedAt = right.turn.startedAt;
+    if (!leftStartedAt && !rightStartedAt) {
+      return left.index - right.index;
+    }
+    if (!leftStartedAt) {
+      return 1;
+    }
+    if (!rightStartedAt) {
+      return -1;
+    }
+    return leftStartedAt.localeCompare(rightStartedAt) || left.index - right.index;
+  }).map(({ turn }) => turn);
+}
 function buildTurnDto(turn, metadata) {
   const tokenUsage = parseThreadTurnTokenUsageJson(metadata?.tokenUsageJson);
   const displayPrompt = metadata?.displayPrompt?.trim();
@@ -18906,10 +19110,20 @@ var ThreadManagementCoordinator = class {
 };
 
 // src/thread-prompt-turn-coordinator.ts
+import { randomUUID as randomUUID3 } from "crypto";
 function isAutoGeneratedTitle(title) {
   const normalized = title?.trim();
   return !normalized || normalized === "Untitled thread" || normalized === "Thread";
 }
+function errorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function promptStartFailureMessage(error, runtime, fallbackProvider) {
+  const providerLabel = runtime.displayName || fallbackProvider || "Agent backend";
+  const rawMessage = errorMessage3(error).trim() || "Unknown error.";
+  const codeLabel = error instanceof AgentRuntimeError ? ` (${error.code})` : "";
+  return `${providerLabel} failed to start this turn${codeLabel}: ${rawMessage}`;
+}
 var ThreadPromptTurnCoordinator = class {
   constructor(db, liveState, providerRuntime, callbacks) {
     this.db = db;
@@ -18952,7 +19166,22 @@ var ThreadPromptTurnCoordinator = class {
     if (input.displayTurnId) {
       startTurnInput.displayTurnId = input.displayTurnId;
     }
-    const turn = await runtime.startTurn(startTurnInput);
+    let turn;
+    try {
+      turn = await runtime.startTurn(startTurnInput);
+    } catch (error) {
+      const failureMessage = promptStartFailureMessage(error, runtime, record.provider);
+      this.persistPromptStartFailure(localThreadId, record, input, {
+        displayPrompt,
+        message: failureMessage,
+        modelRecords,
+        pricingSnapshot
+      });
+      throw new HttpError(503, {
+        code: "service_unavailable",
+        message: failureMessage
+      });
+    }
     const displayTurnId = input.displayTurnId ?? turn.providerTurnId;
     if (displayTurnId !== turn.providerTurnId) {
       this.liveState.setRuntimeDisplayTurnMapping(localThreadId, {
@@ -19005,6 +19234,80 @@ var ThreadPromptTurnCoordinator = class {
     const updated = getThreadRecordById(this.db, localThreadId);
     return this.callbacks.toThreadDto(updated, /* @__PURE__ */ new Set([record.providerSessionId]));
   }
+  persistPromptStartFailure(localThreadId, record, input, failure) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const displayTurnId = input.displayTurnId ?? `local-failed-${randomUUID3()}`;
+    const items = input.hidden ? [
+      {
+        id: `${displayTurnId}:error`,
+        kind: "agentMessage",
+        text: failure.message,
+        status: "failed",
+        createdAt: now,
+        transcriptOrder: 0,
+        sourceTurnId: displayTurnId
+      }
+    ] : [
+      {
+        id: `${displayTurnId}:user`,
+        kind: "userMessage",
+        text: failure.displayPrompt,
+        createdAt: now,
+        transcriptOrder: 0
+      },
+      {
+        id: `${displayTurnId}:error`,
+        kind: "agentMessage",
+        text: failure.message,
+        status: "failed",
+        createdAt: now,
+        transcriptOrder: 1,
+        sourceTurnId: displayTurnId
+      }
+    ];
+    upsertThreadTurnMetadata(this.db, {
+      threadId: localThreadId,
+      turnId: displayTurnId,
+      model: input.effectiveModel,
+      reasoningEffort: input.normalizedReasoning,
+      reasoningEffortAvailable: this.providerRuntime.reasoningEffortAvailableForModel(
+        failure.modelRecords,
+        input.effectiveModel
+      ),
+      pricingModelKey: failure.pricingSnapshot?.pricingModelKey ?? null,
+      pricingTierKey: failure.pricingSnapshot?.pricingTierKey ?? null,
+      displayPrompt: input.hidden ? null : failure.displayPrompt
+    });
+    for (const item of items) {
+      upsertThreadHistoryItemRecord(this.db, {
+        threadId: localThreadId,
+        turnId: displayTurnId,
+        itemId: item.id,
+        itemJson: JSON.stringify(item)
+      });
+    }
+    const patch = {
+      providerTurnId: displayTurnId,
+      status: "failed",
+      lastError: failure.message,
+      lastTurnStartedAt: now,
+      lastTurnCompletedAt: now,
+      model: input.effectiveModel,
+      reasoningEffort: input.normalizedReasoning,
+      collaborationMode: input.collaborationMode,
+      sandboxMode: input.sandboxMode
+    };
+    if (!input.hidden) {
+      patch.summaryText = failure.displayPrompt;
+      if (isAutoGeneratedTitle(record.title)) {
+        patch.title = truncateAutoThreadTitle(failure.displayPrompt);
+      }
+    }
+    updateThreadRecord(this.db, localThreadId, patch);
+    this.liveState.setLivePlan(localThreadId, null);
+    this.liveState.setLiveItems(localThreadId, null);
+    this.callbacks.invalidateThreadDetailCache(localThreadId);
+  }
   async steerOrStartPromptTurn(localThreadId, record, input) {
     const runtime = this.callbacks.runtimeForProvider(record.provider);
     let steerTurnId = record.providerTurnId;
@@ -19115,19 +19418,21 @@ function normalizeCollaborationMode(value) {
   return value === "plan" ? "plan" : "default";
 }
 function buildThreadPatch(remoteSession, model, reasoningEffort) {
-  const failedTurn = "turns" in remoteSession ? remoteSession.turns.find((turn) => turn.status === "failed") : null;
+  const latestTurn = "turns" in remoteSession ? remoteSession.turns.at(-1) ?? null : null;
+  const latestStatus = latestTurn?.status === "failed" ? "failed" : latestTurn?.status === "interrupted" ? "interrupted" : remoteSession.status;
   return {
     provider: remoteSession.provider,
     providerSessionId: remoteSession.providerSessionId,
-    status: remoteSession.status,
+    status: latestStatus,
     summaryText: remoteSession.preview || null,
     model: model ?? null,
     reasoningEffort: normalizeReasoningEffort2(reasoningEffort),
-    lastError: failedTurn?.error?.message ?? null,
+    lastError: latestTurn?.status === "failed" ? latestTurn.error?.message ?? "Turn failed." : null,
     updatedAt: remoteSession.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
   };
 }
 function toThreadDto(record, loadedIds, callbacks) {
+  const status = record.status ?? "idle";
   return {
     id: record.id,
     workspaceId: record.workspaceId,
@@ -19141,10 +19446,10 @@ function toThreadDto(record, loadedIds, callbacks) {
     collaborationMode: normalizeCollaborationMode(record.collaborationMode),
     approvalMode: record.approvalMode ?? "yolo",
     sandboxMode: normalizeSandboxMode(record.sandboxMode) ?? defaultSandboxModeForApprovalMode(record.approvalMode ?? "yolo"),
-    status: record.status ?? "idle",
+    status,
     summaryText: record.summaryText ?? null,
     lastError: record.lastError ?? null,
-    activeTurnId: record.providerTurnId ?? null,
+    activeTurnId: status === "running" ? record.providerTurnId ?? null : null,
     isLoaded: record.isConnected !== false && (record.providerSessionId ? loadedIds.has(record.providerSessionId) : false),
     isPinned: record.isPinned,
     createdAt: record.createdAt,
@@ -21187,7 +21492,7 @@ var ThreadForkCoordinator = class {
 };
 
 // src/thread-attachment-coordinator.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import fs12 from "fs/promises";
 import path16 from "path";
 async function pathExists(absPath) {
@@ -21205,7 +21510,7 @@ function sanitizeAttachmentFileName(originalName) {
   const sanitizedStem = rawStem.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 64);
   const stem = sanitizedStem || "attachment";
   const normalizedExtension = extension.slice(0, 16);
-  return `${stem}-${randomUUID3().slice(0, 8)}${normalizedExtension}`;
+  return `${stem}-${randomUUID4().slice(0, 8)}${normalizedExtension}`;
 }
 function threadTempDirectoryPath2(workspacePath, localThreadId) {
   return path16.join(workspacePath, ".temp", "threads", localThreadId);
@@ -24910,7 +25215,7 @@ async function registerAuthRoutes(app2) {
 // src/provider-host-config-service.ts
 import fs20 from "fs/promises";
 import path23 from "path";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 function providerError(message, statusCode = 404) {
   const error = new Error(message);
   error.statusCode = statusCode;
@@ -25058,7 +25363,7 @@ var ProviderHostConfigService = class {
     const providerHome = this.providerHome(provider2);
     const fileNames = this.archiveFileNames(provider2);
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-    const id = `${createdAt.replace(/[-:.TZ]/g, "").slice(0, 14)}-${randomUUID4().slice(0, 8)}`;
+    const id = `${createdAt.replace(/[-:.TZ]/g, "").slice(0, 14)}-${randomUUID5().slice(0, 8)}`;
     const archivePath = resolveArchivePath(providerHome, id);
     const files = Object.fromEntries(
       fileNames.map((name) => [