@skaile/workspaces 3.12.0 → 3.14.0

package/dist/{chunk-DJ2Y5KAJ.js → chunk-GY5SLCH2.js}

@@ -1,9 +1,9 @@
-import { WorkspacePlugin } from './chunk-SVCJ5WRP.js';
+import { WorkspacePlugin } from './chunk-UTW6YKAC.js';
 import { assembleSystemPrompt, buildCapabilitiesPromptSection } from './chunk-W3UDISS2.js';
 import { WebSocketServerTransport } from './chunk-WQ7DE5UC.js';
-import { resolveFlowPath } from './chunk-TUZ4MUVP.js';
+import { resolveFlowPath } from './chunk-NELENR57.js';
 import { findAiAssetsRoot, deployCatalogEntry, undeployCatalogEntry } from './chunk-GHWJHOYX.js';
-import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, ConnectorStartupError, buildSdkConnectorTools, driveOrchestratorTurn, SessionNodeExecutor, SessionSubpromptRunner, SessionInlineSubFlowRunner, buildSdkFlowTools } from './chunk-YSAYNSML.js';
+import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, ConnectorStartupError, buildSdkConnectorTools, driveOrchestratorTurn, SessionNodeExecutor, SessionSubpromptRunner, SessionInlineSubFlowRunner, buildSdkFlowTools } from './chunk-KKMRT6GU.js';
 import { loadConnectorDeclarations, SecretProviderChain, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, isKnownSecretRef, deriveSingleMaterializedConnectorDeclaration } from './chunk-3UU3D2Q3.js';
 import { EventNormalizer } from './chunk-2A7BV6WT.js';
 import { SUPPORTED_CLOUDS, probeResumeTranscript, CLOUD_SECRET_ENV_KEYS } from './chunk-RUFTB7QN.js';
@@ -2688,6 +2688,11 @@ function isBinaryBuffer(buf) {
   }
   return false;
 }
+function nulTailPaddingLength(buf) {
+  let end = buf.length;
+  while (end > 0 && buf[end - 1] === 0) end--;
+  return buf.length - end;
+}
 function getAuthoritativeSize(state) {
   const provider = state;
   return typeof provider?.authoritativeSize === "function" ? (relPath) => provider.authoritativeSize(relPath) : void 0;
@@ -2770,7 +2775,9 @@ async function handleMountResourceRequest(command, manager, emit) {
             bytes = buf.subarray(0, authSize);
           }
         }
-        if (isBinaryBuffer(bytes)) {
+        const padding = nulTailPaddingLength(bytes);
+        const body = bytes.subarray(0, bytes.length - padding);
+        if (padding > 0 && body.length === 0 || isBinaryBuffer(body)) {
           data = {
             data: bytes.toString("base64"),
             contentType,
@@ -2778,7 +2785,7 @@ async function handleMountResourceRequest(command, manager, emit) {
           };
         } else {
           data = {
-            data: bytes.toString("utf-8"),
+            data: body.toString("utf-8"),
             contentType,
             encoding: "utf-8"
           };
@@ -3237,6 +3244,14 @@ What still needs to be done or is waiting on user input.
 
 ### Context
 User preferences, constraints, or instructions that must carry forward.`;
+var RE_COMPACTION_MERGE_INSTRUCTION = `This conversation has already been compacted once. The summary below replaced
+everything that came before it, and your reply will in turn replace this
+summary -- anything you leave out is lost for good.
+
+Your reply must be the COMPLETE merged summary in the section format above:
+restate everything from the previous summary that still matters, then fold in
+what has happened since. Do NOT reply with a delta, a diff, a list of changes,
+or a note that the previous summary still applies.`;
 function buildCompactionPrompt(opts) {
   const base = opts.agentPrompt ?? DEFAULT_COMPACTION_PROMPT;
   const parts = [base];
@@ -3249,6 +3264,19 @@ function buildCompactionPrompt(opts) {
 ${allDirectives.map((d) => `- ${d}`).join("\n")}`
     );
   }
+  if (opts.previousSummary) {
+    parts.push(
+      `
+
+## Previous Summary
+
+<previous_summary>
+${opts.previousSummary}
+</previous_summary>
+
+${RE_COMPACTION_MERGE_INSTRUCTION}`
+    );
+  }
   if (opts.focus) {
     parts.push(`
 
@@ -3280,6 +3308,31 @@ var TokenThresholdStrategy = class {
 var MIN_SUMMARY_CHARS = 200;
 var MAX_COMPRESSION_RATIO = 0.9;
 var DEFAULT_CONTEXT_WINDOW = 2e5;
+var ONE_MILLION_CONTEXT_WINDOW = 1e6;
+var ONE_MILLION_ALIAS_PATTERN = /\[1m\]|-1m$/i;
+var DEFAULT_COMPACTION_TIMEOUT_MS = 10 * 6e4;
+function compactionTimeoutMs() {
+  const raw = Number(process.env.SKAILE_COMPACTION_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_COMPACTION_TIMEOUT_MS;
+}
+var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set(["timeout", "unknown"]);
+var RETRY_FOCUS_DIRECTIVE = `The previous attempt to write this summary did not finish in time, most likely
+because it ran long. Be economical: compress aggressively, and drop low-value
+detail rather than exceeding a few hundred words.
+
+Cover exactly the same ground as before -- if a previous summary appears above,
+still restate everything in it that still matters. The saving comes from
+tighter prose, never from leaving material out.`;
+var ABORT_SETTLE_GRACE_MS = 5e3;
+var MAX_CARRIED_SUMMARY_CHARS = 24e3;
+var MAX_FAILURE_DIAGNOSTIC_CHARS = 4e3;
+function truncateTo(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}... [truncated]`;
+}
+function truncateDiagnostic(text) {
+  return truncateTo(text, MAX_FAILURE_DIAGNOSTIC_CHARS);
+}
 var RATE_LIMIT_TEXT_MAX_CHARS = 1500;
 var RATE_LIMIT_TEXT_PATTERNS = [
   /you('?| ha)ve hit your (rate |usage )?limit/i,
@@ -3296,6 +3349,12 @@ function contextTokens(usage) {
   const cacheCreation = usage?.cacheCreationTokens ?? 0;
   return Math.max(input, cacheRead) + cacheCreation;
 }
+function resolveContextWindow(driverWindow, model) {
+  if (model && ONE_MILLION_ALIAS_PATTERN.test(model)) {
+    return Math.max(driverWindow ?? 0, ONE_MILLION_CONTEXT_WINDOW);
+  }
+  return driverWindow || DEFAULT_CONTEXT_WINDOW;
+}
 function detectRateLimitInSummary(text) {
   if (text.length > RATE_LIMIT_TEXT_MAX_CHARS) return false;
   return RATE_LIMIT_TEXT_PATTERNS.some((p) => p.test(text));
@@ -3317,6 +3376,12 @@ var CompactionOrchestrator = class {
   _isCompacting = false;
   lastCompactionSeq = null;
   lastCompactionTime = null;
+  /**
+   * Summary of the last successful compaction, carried into the next one.
+   * Per-instance, in step with `lastCompactionSeq`: a driver rebuild resets
+   * both, so the first compaction after one is not treated as a re-compaction.
+   */
+  lastSummary = null;
   currentSeq = 0;
   messagesSinceCompaction = 0;
   constructor(opts) {
@@ -3346,7 +3411,10 @@ var CompactionOrchestrator = class {
   shouldCompact() {
     if (!this.config.enabled) return false;
     const usage = this.driver.getTokenUsage();
-    const contextWindow = this.driver.getContextWindow() || DEFAULT_CONTEXT_WINDOW;
+    const contextWindow = resolveContextWindow(
+      this.driver.getContextWindow(),
+      this.driver.getModel() ?? null
+    );
     const estimatedTokens = this.contextFill(usage);
     if (estimatedTokens <= 0) return false;
     return this.strategy.shouldCompact({
@@ -3366,8 +3434,17 @@ var CompactionOrchestrator = class {
       this._isCompacting = false;
     }
   }
-  async _doCompact(trigger, focus) {
-    const tokensBefore = this.contextFill(this.driver.getTokenUsage());
+  /**
+   * One compaction attempt, plus at most one narrowed retry.
+   *
+   * @param retryOf Set only by the retry path. It suppresses a second
+   *   `onCompactionStart` (the retry continues the same compaction phase),
+   *   guarantees the retry can never itself retry, and carries the first
+   *   attempt's context reading forward.
+   */
+  async _doCompact(trigger, focus, retryOf) {
+    const isRetry = retryOf !== void 0;
+    const tokensBefore = retryOf?.tokensBefore ?? this.contextFill(this.driver.getTokenUsage());
     const driverSessionId = this.driver.runtimeSessionId ?? null;
     const driverModel = this.driver.getModel() ?? null;
     const driverProvider = this.driver.driverInfo?.id ?? null;
@@ -3384,25 +3461,37 @@ var CompactionOrchestrator = class {
       modelAtCompaction: driverModel,
       capabilitySignatureAtCompaction
     };
-    this.opts.onCompactionStart?.(trigger);
-    this.opts.onLog?.(`[compaction] Starting (trigger=${trigger}, tokens=${tokensBefore})`);
+    if (!isRetry) this.opts.onCompactionStart?.(trigger);
+    this.opts.onLog?.(
+      `[compaction] ${isRetry ? "Retrying" : "Starting"} (trigger=${trigger}, tokens=${tokensBefore})`
+    );
     const prompt = buildCompactionPrompt({
       agentPrompt: this.opts.agentCompactionPrompt,
       skillDirectives: this.opts.skillDirectives,
       mcpDirectives: this.opts.mcpDirectives,
-      focus
+      focus,
+      // A re-compaction's reply replaces the previous summary, so the model has
+      // to see it — otherwise it answers with a delta that fails validation.
+      previousSummary: coversFromSeq > 0 ? this._carriedSummary() : void 0
     });
-    const { summaryText, promptError, elapsedMs } = await this._runCompactionPrompt(prompt);
+    const { summaryText, promptError, elapsedMs, timedOut } = await this._runCompactionPrompt(prompt);
     const attempt = { ...attemptBase, elapsedMs };
     if (promptError !== null) {
-      this._emitThrownFailure(attempt, promptError);
+      const errorCode = this._emitThrownFailure(attempt, promptError, timedOut);
+      this._beginCooldown();
+      if (this._shouldRetry(trigger, errorCode, focus, isRetry)) {
+        return await this._doCompact(trigger, RETRY_FOCUS_DIRECTIVE, { tokensBefore });
+      }
+      this.opts.onCompactionEnd?.();
       return null;
     }
     const actualUsage = this.driver.getTokenUsage();
     const tokensAfter = actualUsage?.outputTokens ?? Math.ceil(summaryText.length / 4);
     const validation = validateCompactionOutput(summaryText, tokensBefore, tokensAfter);
     if (!validation.ok) {
-      this._emitValidationFailure(attempt, validation.errorCode, tokensAfter);
+      this._emitValidationFailure(attempt, validation.errorCode, tokensAfter, summaryText);
+      this._beginCooldown();
+      this.opts.onCompactionEnd?.();
       return null;
     }
     return await this._completeCompaction(
@@ -3414,6 +3503,40 @@ var CompactionOrchestrator = class {
       coversFromSeq
     );
   }
+  /**
+   * The previous summary as it goes into a re-compaction prompt, capped so the
+   * prompt cannot grow without bound. Truncating loses context the model is
+   * being asked to restate, so it is logged when it happens.
+   */
+  _carriedSummary() {
+    const summary = this.lastSummary;
+    if (!summary) return void 0;
+    if (summary.length <= MAX_CARRIED_SUMMARY_CHARS) return summary;
+    this.opts.onLog?.(
+      `[compaction] Previous summary truncated to ${MAX_CARRIED_SUMMARY_CHARS} of ${summary.length} chars`
+    );
+    return truncateTo(summary, MAX_CARRIED_SUMMARY_CHARS);
+  }
+  /**
+   * Start the anti-thrash cooldown after a failed attempt.
+   *
+   * `TokenThresholdStrategy` skips its cooldown gate entirely while
+   * `lastCompactionTime` is null, and only success used to set it — so any
+   * failing session re-ran a full-context compaction on every single turn.
+   */
+  _beginCooldown() {
+    this.lastCompactionTime = Date.now();
+  }
+  /**
+   * Whether a failed attempt earns the one narrowed retry.
+   *
+   * Only automatic (threshold) compactions retry: a `manual` or `hibernate`
+   * caller owns the decision to try again, and a caller-supplied `focus` would
+   * be discarded by the retry's own directive.
+   */
+  _shouldRetry(trigger, errorCode, focus, isRetry) {
+    return !isRetry && trigger === "threshold" && focus === void 0 && RETRYABLE_ERROR_CODES.has(errorCode);
+  }
   /**
    * Drive the compaction `prompt()` call, capturing summary text from the
    * driver's raw bridge-level events and any thrown error. The listener is
@@ -3422,6 +3545,10 @@ var CompactionOrchestrator = class {
    * `elapsedMs` is the wall-clock cost of the `prompt()` call. It is the only
    * thing that separates a genuinely empty model response from a turn that was
    * settled by something other than the model, which resolves in milliseconds.
+   *
+   * The call is bounded by {@link compactionTimeoutMs}; on expiry the turn is
+   * aborted and `timedOut` is returned so the caller can record a classified
+   * `timeout` rather than wait out the driver's much longer stall watchdog.
    */
   async _runCompactionPrompt(prompt) {
     let summaryText = "";
@@ -3457,58 +3584,103 @@ var CompactionOrchestrator = class {
       }
     };
     let promptError = null;
+    let timedOut = false;
+    let timer;
     const startedAt = Date.now();
+    const timeoutMs = compactionTimeoutMs();
     try {
       this.driver.on("agent-event", captureHandler);
-      await this.driver.prompt(prompt);
+      const running = this.driver.prompt(prompt);
+      const expiry = new Promise((resolve4) => {
+        timer = setTimeout(() => resolve4("expired"), timeoutMs);
+      });
+      const outcome = await Promise.race([running.then(() => "settled"), expiry]);
+      if (outcome === "expired") {
+        timedOut = true;
+        const settled = running.then(
+          () => void 0,
+          () => void 0
+        );
+        promptError = new Error(
+          `Compaction prompt did not complete within ${timeoutMs}ms; the turn was aborted.`
+        );
+        const aborted = this.driver.abort().catch((abortErr) => {
+          this.opts.onLog?.(`[compaction] abort after timeout failed: ${String(abortErr)}`);
+        });
+        let settleTimer;
+        const graceExpired = new Promise((resolve4) => {
+          settleTimer = setTimeout(resolve4, ABORT_SETTLE_GRACE_MS);
+          settleTimer.unref?.();
+        });
+        await Promise.race([Promise.all([aborted, settled]), graceExpired]);
+        clearTimeout(settleTimer);
+      }
     } catch (err) {
       promptError = err;
     } finally {
+      clearTimeout(timer);
       this.driver.removeListener("agent-event", captureHandler);
     }
-    return { summaryText, promptError, elapsedMs: Date.now() - startedAt };
+    return { summaryText, promptError, elapsedMs: Date.now() - startedAt, timedOut };
   }
   /**
    * Record a `failed` attempt for a thrown `prompt()` error: classify the
-   * error, map it to an error code, log, emit the attempt event, and signal
-   * compaction end.
+   * error, map it to an error code, log the raw text, and emit the attempt
+   * event. Signalling compaction end is the caller's job — a retry continues
+   * the same phase.
+   *
+   * @param timedOut Set when the bound in {@link _runCompactionPrompt} expired.
+   *   The synthetic message carries none of the classifier's keywords, so
+   *   round-tripping it would report the opaque `unknown` this bound replaces.
+   * @returns The error code recorded, so the caller can decide about a retry.
    */
-  _emitThrownFailure(attemptBase, promptError) {
-    const classified = classifyClaudeSdkError(
-      promptError instanceof Error ? promptError.message : String(promptError)
-    );
-    const errorCode = classified.category === "rate_limit" ? "rate_limit" : classified.category === "auth" ? "auth" : classified.category === "network" ? "timeout" : classified.category === "validation" ? "parse_error" : classified.category;
+  _emitThrownFailure(attemptBase, promptError, timedOut = false) {
+    const rawMessage = promptError instanceof Error ? promptError.message : String(promptError);
+    const classified = classifyClaudeSdkError(rawMessage);
+    const classifiedCode = classified.category === "rate_limit" ? "rate_limit" : classified.category === "auth" ? "auth" : classified.category === "network" ? "timeout" : classified.category === "validation" ? "parse_error" : classified.category;
+    const errorCode = timedOut ? "timeout" : classifiedCode;
+    const diagnostic = truncateDiagnostic(classified.message);
     this.opts.onLog?.(`[compaction] Failed: ${classified.message} (${errorCode})`);
     this.opts.onCompactionAttempt?.({
+      // Spread first: `status`/`validatedAt` below are load-bearing (see the
+      // summary comment) and must not be override-able from the base object.
+      ...attemptBase,
       type: "compaction_attempt",
       status: "failed",
       errorCode,
-      summary: "",
+      errorMessage: diagnostic,
+      // Mirrored so the platform's existing `summary` column explains the
+      // failure with no schema change. Safe: a failed attempt is never
+      // restored — restoration needs `success` plus a `validatedAt` stamp.
+      summary: diagnostic,
       outputTokens: 0,
-      validatedAt: null,
-      ...attemptBase
+      validatedAt: null
     });
-    this.opts.onCompactionEnd?.();
+    return errorCode;
   }
   /**
    * Record a `failed` attempt for output that passed `prompt()` but failed
-   * structural validation. Logs, emits the attempt event, and signals
-   * compaction end.
+   * structural validation. The rejected text is persisted so the next
+   * occurrence is diagnosable from the row alone; signalling compaction end is
+   * the caller's job.
    */
-  _emitValidationFailure(attemptBase, errorCode, tokensAfter) {
+  _emitValidationFailure(attemptBase, errorCode, tokensAfter, rejectedText) {
     this.opts.onLog?.(
       `[compaction] Output failed validation (${errorCode}); recording failed attempt`
     );
     this.opts.onCompactionAttempt?.({
+      // Spread first — see _emitThrownFailure.
+      ...attemptBase,
       type: "compaction_attempt",
       status: "failed",
       errorCode,
-      summary: "",
+      errorMessage: `Compaction output rejected by validation (${errorCode}): ${rejectedText.length} chars, ${tokensAfter} output tokens`,
+      // The rejected text itself, not a summary — see _emitThrownFailure on
+      // why persisting it here cannot leak into a restored session.
+      summary: truncateDiagnostic(rejectedText),
       outputTokens: tokensAfter,
-      validatedAt: null,
-      ...attemptBase
+      validatedAt: null
     });
-    this.opts.onCompactionEnd?.();
   }
   /**
    * Success path: emit the attempt + snapshot events, update internal state,
@@ -3526,17 +3698,18 @@ var CompactionOrchestrator = class {
       tokensAfter
     };
     this.opts.onCompactionAttempt?.({
+      ...attemptBase,
       type: "compaction_attempt",
       status: "success",
       errorCode: null,
       summary: summaryText,
       outputTokens: tokensAfter,
-      validatedAt,
-      ...attemptBase
+      validatedAt
     });
     this.opts.onSnapshot?.(snapshot);
     this.lastCompactionSeq = this.currentSeq + 1;
     this.lastCompactionTime = Date.now();
+    this.lastSummary = summaryText;
     this.messagesSinceCompaction = 0;
     this.opts.onCompactionEnd?.();
     if (trigger !== "hibernate") {
@@ -7020,6 +7193,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_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createSessionStimulusBus, defineCapability, deleteSession, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadSession, loadSessionById, mcpAuthSecretKey, newSession, pickRepointedManager, planFlowMutate, reconcilePendingDecisions, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
-//# sourceMappingURL=chunk-DJ2Y5KAJ.js.map
-//# sourceMappingURL=chunk-DJ2Y5KAJ.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_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createSessionStimulusBus, defineCapability, deleteSession, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickRepointedManager, planFlowMutate, reconcilePendingDecisions, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
+//# sourceMappingURL=chunk-GY5SLCH2.js.map
+//# sourceMappingURL=chunk-GY5SLCH2.js.map