@skaile/workspaces 4.21.0 → 4.21.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 4.21.1
+
+### Patch Changes
+
+- [#861](https://github.com/skaile-ai/workspaces/pull/861) [`0716bcf`](https://github.com/skaile-ai/workspaces/commit/0716bcf9c61a1238e1170aa1586974502a97857e) Thanks [@peteralbert](https://github.com/peteralbert)! - runner: a container that outlives a platform backend restart now comes through the gap intact. Agent events produced while no platform is connected are buffered (at most 10,000 events / 16 MiB, oldest dropped first) and flushed on reconnect between the replayed `session_init_ack` and the turn-status snapshot. A configured runner that tries to mint an AI credential while disconnected now fails transiently (`backend-error`) instead of terminally (`not-configured`), and each reconnect re-arms the proactive refresh scheduler. Capability calls in flight when the connection drops are rejected at once instead of waiting out their timeout. Today's platform needs no change.
+
 ## 4.21.0
 
 ### Minor Changes

package/dist/{chunk-ZJEQFNKE.js → chunk-N5XNEKHC.js}

@@ -4,7 +4,7 @@ import { findAiAssetsRoot } from './chunk-7IH3RKKK.js';
 import { WebSocketServerTransport } from './chunk-73ZXUUL6.js';
 import { assembleSystemPrompt, buildCapabilitiesPromptSection } from './chunk-W3UDISS2.js';
 import { prepareNativePolicy, codexInstanceEnvironment, parseCodexCredential, parseCodexRefreshInput, parseCodexRefreshResult } from './chunk-PE3A6FFW.js';
-import { resolveFlowPath } from './chunk-EJU2TOGT.js';
+import { resolveFlowPath } from './chunk-SY2HSULI.js';
 import { findAiAssetsRoot as findAiAssetsRoot$1, deployCatalogEntry, undeployCatalogEntry } from './chunk-Q6NDQ6BH.js';
 import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, driveOrchestratorTurn, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, buildSdkFlowTools } from './chunk-ZDSZGV5F.js';
 import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, isKnownSecretRef, deriveSingleMaterializedConnectorDeclaration } from './chunk-MC2MF4U5.js';
@@ -3563,6 +3563,19 @@ function resolveCapabilityResult(pending, cmd) {
   }
   return true;
 }
+function rejectPendingCapabilityCallsOnDisconnect(pending, keep = () => false) {
+  const entries = [...pending].filter(([callId]) => !keep(callId));
+  for (const [callId] of entries) pending.delete(callId);
+  for (const [callId, entry] of entries) {
+    clearTimeout(entry.timer);
+    entry.reject(
+      new Error(
+        `Platform connection dropped while capability call ${callId} was in flight (the platform backend may be restarting). Its outcome is unknown; retry once the platform is back if the call is safe to repeat.`
+      )
+    );
+  }
+  return entries.length;
+}
 function rejectCapabilityOnApprovalDeny(pending, callId, feedback) {
   const entry = pending.get(callId);
   if (!entry) return false;
@@ -4181,6 +4194,23 @@ var MINT_RETRY_MAX_DELAY_MS = 5e3;
 function isTransientMintFailure(code) {
   return code === "backend-error";
 }
+function aiMintPreconditionFailure(args) {
+  if (args.configId === void 0) {
+    return {
+      ok: false,
+      code: "not-configured",
+      message: "no aiProviderConfigId; standalone runner cannot mediate refresh"
+    };
+  }
+  if (!args.connected) {
+    return {
+      ok: false,
+      code: "backend-error",
+      message: "transport disconnected; the platform connection is down, refresh will be retried"
+    };
+  }
+  return null;
+}
 function mintRetryDelayMs(retryNumber) {
   const delay = MINT_RETRY_BASE_DELAY_MS * 2 ** Math.max(0, retryNumber - 1);
   return Math.min(delay, MINT_RETRY_MAX_DELAY_MS);
@@ -4874,6 +4904,105 @@ async function routeReply(deps) {
   return "fresh-turn";
 }
 
+// runner/src/event-gap-buffer.ts
+var EVENT_GAP_BUFFER_MAX_EVENTS = 1e4;
+var EVENT_GAP_BUFFER_MAX_BYTES = 16 * 1024 * 1024;
+var UNBUFFERED_TYPES = /* @__PURE__ */ new Set([
+  "session_init_ack",
+  "log_entry",
+  "capability_result"
+]);
+function measure(event) {
+  try {
+    const json = JSON.stringify(event);
+    return json === void 0 ? 0 : Buffer.byteLength(json, "utf8");
+  } catch {
+    return 0;
+  }
+}
+var EventGapBuffer = class _EventGapBuffer {
+  maxEvents;
+  maxBytes;
+  entries = [];
+  /** Index of the oldest live entry; eviction advances it instead of shifting the array. */
+  head = 0;
+  bytes = 0;
+  dropped = 0;
+  constructor(opts = {}) {
+    this.maxEvents = opts.maxEvents ?? EVENT_GAP_BUFFER_MAX_EVENTS;
+    this.maxBytes = opts.maxBytes ?? EVENT_GAP_BUFFER_MAX_BYTES;
+  }
+  /** Number of events currently held. */
+  get size() {
+    return this.entries.length - this.head;
+  }
+  /** Whether a drain would report anything (held events or drops). */
+  get hasPending() {
+    return this.size > 0 || this.dropped > 0;
+  }
+  /** The callIds of the `capability_invoked` events currently held. */
+  heldCapabilityCallIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (let i = this.head; i < this.entries.length; i++) {
+      const event = this.entries[i]?.event;
+      if (event?.type === "capability_invoked") ids.add(event.callId);
+    }
+    return ids;
+  }
+  /** Whether {@link push} would hold this event type at all. */
+  static accepts(event) {
+    return !UNBUFFERED_TYPES.has(event.type);
+  }
+  /**
+   * Append an event, evicting the oldest past either cap. An event larger than
+   * the byte cap on its own is counted as dropped and not held.
+   */
+  push(event, opts = {}) {
+    if (!_EventGapBuffer.accepts(event)) return;
+    const bytes = measure(event);
+    if (bytes > this.maxBytes) {
+      this.dropped += 1;
+      return;
+    }
+    this.entries.push({ event, bytes, ...opts.isStale ? { isStale: opts.isStale } : {} });
+    this.bytes += bytes;
+    while (this.size > this.maxEvents || this.bytes > this.maxBytes) {
+      const oldest = this.entries[this.head];
+      if (!oldest) break;
+      this.head += 1;
+      this.bytes -= oldest.bytes;
+      this.dropped += 1;
+    }
+    if (this.head > 1024 && this.head * 2 > this.entries.length) {
+      this.entries = this.entries.slice(this.head);
+      this.head = 0;
+    }
+  }
+  /** Hand back everything held, oldest first, and reset. */
+  drain() {
+    const events = [];
+    let stale = 0;
+    for (let i = this.head; i < this.entries.length; i++) {
+      const entry = this.entries[i];
+      if (!entry) continue;
+      if (entry.isStale?.()) stale += 1;
+      else events.push(entry.event);
+    }
+    const dropped = this.dropped;
+    this.clear();
+    return { events, dropped, stale };
+  }
+  /** Discard everything held. Returns how many events were discarded. */
+  clear() {
+    const discarded = this.size;
+    this.entries = [];
+    this.head = 0;
+    this.bytes = 0;
+    this.dropped = 0;
+    return discarded;
+  }
+};
+
 // runner/src/compaction/prompt.ts
 var DEFAULT_COMPACTION_PROMPT = `You are being asked to compact this conversation into a structured summary.
 This summary will replace the full conversation history when the session
@@ -6184,8 +6313,8 @@ var ContextUsageCollector = class {
     if (opts.measure && driver?.getContextUsageReport) {
       try {
         const detail = opts.measure;
-        const measure = driver.getContextUsageReport.bind(driver);
-        report = await this.sharedMeasurement(detail, () => measure({ detail }));
+        const measure2 = driver.getContextUsageReport.bind(driver);
+        report = await this.sharedMeasurement(detail, () => measure2({ detail }));
         if (report) {
           this.lastReport = report;
           reportFresh = true;
@@ -6222,11 +6351,11 @@ var ContextUsageCollector = class {
    * lands while a `full` count is running (two panels, a double click) shares
    * it instead of paying for another round of `count_tokens` calls.
    */
-  sharedMeasurement(detail, measure) {
+  sharedMeasurement(detail, measure2) {
     const running = this.inflight.get(detail);
     if (running) return running;
     const measurement = withTimeout(
-      measure(),
+      measure2(),
       this.deps.measureTimeoutMs ?? DEFAULT_MEASURE_TIMEOUT_MS
     ).finally(() => {
       if (this.inflight.get(detail) === measurement) this.inflight.delete(detail);
@@ -7814,11 +7943,21 @@ async function startAgentServer(opts) {
     })
   );
   const turnStatus = new TurnStatusTracker();
+  const eventGapBuffer = new EventGapBuffer();
   function sendEvent(event) {
     turnStatus.observe(event);
     if (transport.connected) {
       transport.send(event);
+      return;
     }
+    if (!initAcknowledged) return;
+    eventGapBuffer.push(event, { isStale: settledCapabilityCallCheck(event) });
+  }
+  function settledCapabilityCallCheck(event) {
+    if (event.type !== "capability_invoked") return void 0;
+    const { callId } = event;
+    if (!pendingCapabilityCalls.has(callId)) return void 0;
+    return () => !pendingCapabilityCalls.has(callId);
   }
   let initAcknowledged = false;
   let initGeneration = 0;
@@ -7836,6 +7975,20 @@ async function startAgentServer(opts) {
   bootstrapCapabilityRegistry(capabilityRegistry);
   const hostRuntimeCapabilities = /* @__PURE__ */ new Set();
   const pendingCapabilityCalls = /* @__PURE__ */ new Map();
+  function rejectCallsSentToPreviousPeer(trigger) {
+    const unsent = eventGapBuffer.heldCapabilityCallIds();
+    const rejected = rejectPendingCapabilityCallsOnDisconnect(
+      pendingCapabilityCalls,
+      (callId) => unsent.has(callId)
+    );
+    if (rejected > 0) {
+      serverLog.warn(
+        `[serve] platform connection dropped (${trigger}); rejected ${rejected} in-flight capability call(s)`
+      );
+    }
+  }
+  transport.onDisconnect(() => rejectCallsSentToPreviousPeer("disconnect"));
+  transport.onConnect(() => rejectCallsSentToPreviousPeer("replaced connection"));
   const remoteCapabilityInvoker = (name, input, timeoutMs, signal) => {
     const callId = typeof crypto?.randomUUID === "function" ? crypto.randomUUID() : `rcap-${Date.now()}-${Math.floor(Math.random() * 1e9)}`;
     return new Promise((resolve4, reject) => {
@@ -7878,13 +8031,11 @@ async function startAgentServer(opts) {
     t.unref?.();
   });
   async function mintAndPersistAiCredential(args) {
-    if (!transport.connected || aiProviderConfigId === void 0) {
-      return {
-        ok: false,
-        code: "not-configured",
-        message: "no transport or aiProviderConfigId; standalone runner cannot mediate refresh"
-      };
-    }
+    const precondition = aiMintPreconditionFailure({
+      connected: transport.connected,
+      configId: aiProviderConfigId
+    });
+    if (precondition) return precondition;
     const targetConfigId = args.configId || aiProviderConfigId;
     try {
       const home = process.env.HOME || homedir();
@@ -8824,6 +8975,7 @@ async function startAgentServer(opts) {
   async function cleanup() {
     if (managedHost) managedBootstrapClosed = true;
     initAcknowledged = false;
+    eventGapBuffer.clear();
     try {
       await Promise.race([
         sessionReady,
@@ -9994,9 +10146,28 @@ async function startAgentServer(opts) {
       replayed: true
     });
   });
+  transport.onConnect(() => {
+    if (!eventGapBuffer.hasPending) return;
+    if (!initAcknowledged || sessionReadyOutcome === "rejected") {
+      const discarded = eventGapBuffer.clear();
+      serverLog.warn(
+        `[serve] discarded ${discarded} event(s) buffered while disconnected: the init they belong to is no longer acknowledged`
+      );
+      return;
+    }
+    const { events, dropped, stale } = eventGapBuffer.drain();
+    for (const event of events) transport.send(event);
+    serverLog.warn(
+      `[serve] flushed ${events.length} event(s) buffered while the platform was disconnected; dropped ${dropped} over the buffer cap, withheld ${stale} settled capability call(s)`
+    );
+  });
   transport.onConnect(() => {
     sendEvent(turnStatus.snapshot());
   });
+  transport.onConnect(() => {
+    if (!initAcknowledged || managedCodex || aiProviderConfigId === void 0) return;
+    aiCredentialRefreshScheduler.ensureArmed();
+  });
   transport.onConnect(() => {
     if (managedHost && !managedBootstrapClosed)
       sendEvent({
@@ -10211,6 +10382,6 @@ function touchSession(state) {
   return { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
-export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, computeDirectoryTotals, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createManagedCodexSubpromptDriver, createSessionStimulusBus, defineCapability, deleteSession, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isSessionRootPathAllowed, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadManagedCodexHostConfig, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, supportsLiveToolUpdates, takeRunnerWsAuthToken, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
-//# sourceMappingURL=chunk-ZJEQFNKE.js.map
-//# sourceMappingURL=chunk-ZJEQFNKE.js.map
+export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, computeDirectoryTotals, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createManagedCodexSubpromptDriver, createSessionStimulusBus, defineCapability, deleteSession, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isSessionRootPathAllowed, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadManagedCodexHostConfig, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, rejectPendingCapabilityCallsOnDisconnect, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, supportsLiveToolUpdates, takeRunnerWsAuthToken, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
+//# sourceMappingURL=chunk-N5XNEKHC.js.map
+//# sourceMappingURL=chunk-N5XNEKHC.js.map