@caspian2026/agent-sdk 0.0.8 → 0.0.9

package/dist/{chunk-9v13f3gm.js → chunk-ttyfhx12.js}

@@ -13,19 +13,19 @@ import {
   permissionPromptToolResultToPermissionDecision,
   processUserInput,
   reconcileMarketplaces
-} from "./chunk-0mej3p7q.js";
+} from "./chunk-0txtpamh.js";
 import {
   detectAndUninstallDelistedPlugins
-} from "./chunk-xrpstt41.js";
+} from "./chunk-hzbr9543.js";
 import {
   restoreAgentFromSession,
   restoreSessionStateFromLog,
   skillChangeDetector
-} from "./chunk-denyma1s.js";
-import"./chunk-hh3k5s1s.js";
+} from "./chunk-thenr6b3.js";
+import"./chunk-xvk90wpt.js";
 import {
   externalMetadataToAppState
-} from "./chunk-w05jpkkr.js";
+} from "./chunk-hae34yd0.js";
 import {
   getSessionState,
   notifySessionMetadataChanged,
@@ -33,30 +33,39 @@ import {
   setPermissionModeChangedListener,
   setSessionMetadataChangedListener,
   setSessionStateChangedListener
-} from "./chunk-7n51wk9k.js";
+} from "./chunk-1vp22nex.js";
 import {
-  SSETransport,
-  init_SSETransport
-} from "./chunk-a579wjd2.js";
+  init_settingsSync
+} from "./chunk-vmbht6ec.js";
+import {
+  init_refresh,
+  refreshActivePlugins
+} from "./chunk-3e4r5pmc.js";
 import {
   init_toolPool,
   mergeAndFilterTools
-} from "./chunk-vvsbvz2b.js";
-import"./chunk-q1ah9nbq.js";
+} from "./chunk-7skyagc2.js";
+import"./chunk-t1s91wrk.js";
 import {
-  init_settingsSync
-} from "./chunk-ad3v6mzw.js";
+  generateSessionTitle,
+  init_sessionTitle
+} from "./chunk-r7684mmh.js";
 import {
-  init_refresh,
-  refreshActivePlugins
-} from "./chunk-2xvc97x4.js";
+  init_systemTheme,
+  resolveThemeSetting
+} from "./chunk-cnsj3vq2.js";
 import {
   init_mappers,
   localCommandOutputToSDKAssistantMessage,
   toInternalMessages,
   toSDKCompactMetadata,
   toSDKRateLimitInfo
-} from "./chunk-23fkapww.js";
+} from "./chunk-azv68vk1.js";
+import {
+  checkGroveForNonInteractive,
+  init_grove,
+  isQualifiedForGrove
+} from "./chunk-dexkgxt4.js";
 import {
   ChannelMessageNotificationSchema,
   findChannelEntry,
@@ -66,32 +75,23 @@ import {
   init_omit,
   omit_default,
   wrapChannelMessage
-} from "./chunk-69r3hm9b.js";
-import"./chunk-234668cb.js";
-import"./chunk-1x0y4426.js";
-import {
-  generateSessionTitle,
-  init_sessionTitle
-} from "./chunk-bm5rc541.js";
-import {
-  init_systemTheme,
-  resolveThemeSetting
-} from "./chunk-cnsj3vq2.js";
+} from "./chunk-1hqb50ne.js";
+import"./chunk-thmtkfgj.js";
+import"./chunk-vtmxgm1m.js";
 import {
   collectContextData,
   init_context_noninteractive
-} from "./chunk-12k745vf.js";
+} from "./chunk-tpk67mjc.js";
 import {
   init_sideQuestion,
   runSideQuestion
-} from "./chunk-6ksdp40n.js";
+} from "./chunk-xffb3dsw.js";
 import"./chunk-rn0v1hk8.js";
 import {
   CircularBuffer,
   DEFAULT_OUTPUT_STYLE_NAME,
   EFFORT_LEVELS,
   EMPTY_USAGE,
-  OAuthService,
   SHELL_TOOL_NAMES,
   SYNTHETIC_MESSAGES,
   SYNTHETIC_OUTPUT_TOOL_NAME,
@@ -104,7 +104,6 @@ import {
   assembleToolPool,
   atomicWriteToZipCache,
   categorizeRetryableAPIError,
-  checkGroveForNonInteractive,
   cleanupSessionPluginCache,
   clearCommandsCache,
   clearMarketplacesCache,
@@ -180,7 +179,6 @@ import {
   init_abortController,
   init_applySettingsChange,
   init_auth as init_auth2,
-  init_auth1 as init_auth3,
   init_changeDetector,
   init_claude,
   init_claudeAiLimits,
@@ -193,7 +191,6 @@ import {
   init_constants1 as init_constants3,
   init_context,
   init_conversationRecovery,
-  init_cost_tracker,
   init_effort,
   init_elicitationHandler,
   init_errors as init_errors2,
@@ -205,7 +202,6 @@ import {
   init_framework,
   init_generators,
   init_gracefulShutdown,
-  init_grove,
   init_headlessProfiler,
   init_hookEvents,
   init_hookHelpers,
@@ -219,7 +215,6 @@ import {
   init_messageQueueManager,
   init_messages1 as init_messages,
   init_modelOptions,
-  init_oauth,
   init_outputStyles,
   init_outputsScanner,
   init_permissionSetup,
@@ -254,13 +249,12 @@ import {
   init_teammateMailbox,
   init_thinking,
   init_tools1 as init_tools,
-  init_types2,
+  init_types1 as init_types2,
   init_uniqBy,
   init_utils,
   init_uuid,
   init_vscodeSdkMcp,
   init_zipCache,
-  installOAuthTokens,
   isBackgroundTask,
   isBuiltInAgent,
   isBypassPermissionsModeDisabled,
@@ -268,7 +262,6 @@ import {
   isMcpServerDisabled,
   isPluginZipCacheEnabled,
   isPolicyAllowed,
-  isQualifiedForGrove,
   isResultSuccessful,
   isScratchpadEnabled,
   isShutdownApproved,
@@ -332,13 +325,18 @@ import {
   unregisterSessionActivityCallback,
   updateUsage,
   validateUuid
-} from "./chunk-f2hbn5rk.js";
-import"./chunk-jpc9zwsk.js";
-import"./chunk-hwfknpxv.js";
-import"./chunk-4nspekjp.js";
+} from "./chunk-93vwm44t.js";
+import"./chunk-mcws22k3.js";
 import"./chunk-jzthz1bx.js";
+import"./chunk-rz94yg8c.js";
+import"./chunk-hwfknpxv.js";
 import"./chunk-1gx78081.js";
-import"./chunk-qcnhb4cd.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-54wn2jdr.js";
+import {
+  init_commitAttribution
+} from "./chunk-wkt2q02c.js";
+import"./chunk-87xg6yb4.js";
 import {
   hasActiveInProcessTeammates,
   hasWorkingInProcessTeammates,
@@ -349,16 +347,11 @@ import {
   removeTeammateFromTeamFile,
   unassignTeammateTasks,
   waitForTeammatesToBecomeIdle
-} from "./chunk-s7q42kp2.js";
+} from "./chunk-2yxqz99n.js";
 import"./chunk-2gzv8nrw.js";
-import"./chunk-ehtwnxpg.js";
-import {
-  init_commitAttribution
-} from "./chunk-wr3pd88n.js";
-import"./chunk-wayfjcwt.js";
+import"./chunk-sdfvr9ps.js";
 import"./chunk-cgfdkzhb.js";
-import"./chunk-bxcfz5gy.js";
-import"./chunk-y0fhjxef.js";
+import"./chunk-xswyz2es.js";
 import {
   READ_FILE_STATE_CACHE_SIZE,
   cloneFileStateCache,
@@ -366,51 +359,75 @@ import {
   init_fileStateCache,
   mergeFileStateCaches
 } from "./chunk-j5bth84e.js";
-import"./chunk-nk82j7r2.js";
-import"./chunk-68ffk5qa.js";
+import"./chunk-b6prbsae.js";
 import"./chunk-ps49ymvj.js";
+import"./chunk-68ffk5qa.js";
+import {
+  init_betas,
+  init_cost_tracker,
+  modelSupportsAutoMode
+} from "./chunk-ratnrv9v.js";
+import {
+  ensureModelStringsInitialized,
+  getAPIProvider,
+  getDefaultMainLoopModel,
+  getFastModeState,
+  getMainLoopModel,
+  init_fastMode,
+  init_model,
+  init_modelStrings,
+  init_providers,
+  isFastModeAvailable,
+  isFastModeEnabled,
+  isFastModeSupportedByModel,
+  modelDisplayString,
+  parseUserSpecifiedModel
+} from "./chunk-7cje7scj.js";
+import {
+  createAxiosInstance,
+  getWebSocketProxyAgent,
+  getWebSocketProxyUrl,
+  getWebSocketTLSOptions,
+  init_mtls,
+  init_proxy
+} from "./chunk-7krg0dkt.js";
+import"./chunk-kxrrtr3p.js";
 import"./chunk-p7vkh4wx.js";
-import"./chunk-bmbq6nt1.js";
-import"./chunk-yc23zxmj.js";
-import"./chunk-njrt3tac.js";
-import"./chunk-m87bhhqv.js";
-import"./chunk-xwg327ys.js";
-import"./chunk-xz655xxa.js";
-import"./chunk-c11swzas.js";
-import"./chunk-chsyvavm.js";
-import"./chunk-5rv9c8yd.js";
+import"./chunk-6wzg2hpc.js";
+import"./chunk-9w114071.js";
+import"./chunk-3pzwd6qq.js";
+import"./chunk-2vteceqh.js";
+import"./chunk-xeb6075z.js";
+import"./chunk-nrjtxhyr.js";
+import {
+  ElicitRequestSchema,
+  ElicitationCompleteNotificationSchema,
+  init_types
+} from "./chunk-v4t6dyyh.js";
+import"./chunk-2vbash3m.js";
+import"./chunk-bzatg35k.js";
 import {
   AGENT_TOOL_NAME,
   KnownMarketplacesFileSchema,
   LEGACY_AGENT_TOOL_NAME,
   TASK_STOP_TOOL_NAME,
   WORKLOAD_CRON,
-  ensureModelStringsInitialized,
-  getAPIProvider,
   getAccountInformation,
   getAnthropicApiKeyWithSource,
   getClaudeCodeUserAgent,
-  getDefaultMainLoopModel,
-  getFastModeState,
   getFeatureValue_CACHED_MAY_BE_STALE,
   getGlobalConfig,
-  getMainLoopModel,
   getMcpPrefix,
   getSettingsWithSources,
   getSettings_DEPRECATED,
   hasAutoMemPathOverride,
   init_auth,
-  init_betas1 as init_betas,
   init_config,
   init_constants1 as init_constants,
-  init_fastMode,
   init_growthbook,
   init_mcpStringUtils,
-  init_model,
-  init_modelStrings,
   init_paths,
   init_prompt,
-  init_providers,
   init_schemas,
   init_settings1 as init_settings,
   init_stringUtils,
@@ -418,55 +435,35 @@ import {
   init_workloadContext,
   initializeGrowthBook,
   isExtractModeActive,
-  isFastModeAvailable,
-  isFastModeEnabled,
-  isFastModeSupportedByModel,
-  modelDisplayString,
-  modelSupportsAutoMode,
-  parseUserSpecifiedModel,
   runWithWorkload
-} from "./chunk-e7efcp3k.js";
+} from "./chunk-qctsv1d7.js";
 import {
   init_json,
   safeParseJSON
-} from "./chunk-z19sd3bt.js";
+} from "./chunk-p4196wzm.js";
 import {
   expandPath,
   init_path
-} from "./chunk-1ax1znzj.js";
+} from "./chunk-7hrmxpha.js";
 import {
   init_array,
   uniq
 } from "./chunk-6nsd9606.js";
-import"./chunk-xp61y5ba.js";
+import"./chunk-rkv8bdtr.js";
 import"./chunk-64c1avct.js";
-import {
-  createAxiosInstance,
-  getWebSocketProxyAgent,
-  getWebSocketProxyUrl,
-  getWebSocketTLSOptions,
-  init_mtls,
-  init_proxy
-} from "./chunk-wha6v7za.js";
 import {
   init_sleep,
   sleep
 } from "./chunk-8g5pe1gr.js";
-import {
-  ElicitRequestSchema,
-  ElicitationCompleteNotificationSchema,
-  init_types
-} from "./chunk-4cp6193g.js";
-import"./chunk-8g747a8x.js";
-import"./chunk-d7886r6a.js";
-import"./chunk-yvtzznds.js";
+import"./chunk-4pbx3g7s.js";
+import"./chunk-26wtxbdc.js";
+import"./chunk-z6wm96eh.js";
 import"./chunk-4jm600zv.js";
-import"./chunk-qz2x630m.js";
-import"./chunk-2f21meep.js";
-import"./chunk-nrtksr2p.js";
+import"./chunk-1v01c96r.js";
+import"./chunk-8b2y3x7a.js";
 import"./chunk-3c25bcsw.js";
-import"./chunk-s3hsqf80.js";
-import"./chunk-yyf72f78.js";
+import"./chunk-cexw1jmv.js";
+import"./chunk-j35mw64g.js";
 import"./chunk-cdz5yb0r.js";
 import {
   init_strip_ansi,
@@ -479,15 +476,15 @@ import {
   init_analytics,
   logEvent
 } from "./chunk-x8d2ehd7.js";
-import"./chunk-15m49c67.js";
+import"./chunk-3e28fvn0.js";
 import {
   init_diagLogs,
   logForDiagnosticsNoPII,
   withDiagnosticsTiming
-} from "./chunk-tdbz9gbm.js";
-import"./chunk-0awwmrwr.js";
+} from "./chunk-kjqyhxz7.js";
+import"./chunk-4ayjwyqj.js";
 import"./chunk-qnfx3qtx.js";
-import"./chunk-70eey1nh.js";
+import"./chunk-40s88wdg.js";
 import {
   LOCAL_COMMAND_STDERR_TAG,
   LOCAL_COMMAND_STDOUT_TAG,
@@ -497,13 +494,13 @@ import {
   init_xml,
   logError,
   logMCPDebug
-} from "./chunk-1nk93fqz.js";
+} from "./chunk-5cxjxxx8.js";
 import {
   getCwd,
   init_cwd
 } from "./chunk-s8kj6ajy.js";
-import"./chunk-eenq3avg.js";
-import"./chunk-7mqab3z7.js";
+import"./chunk-qcrpqjya.js";
+import"./chunk-skp5w8bq.js";
 import"./chunk-5z28bqne.js";
 import"./chunk-qajrkk97.js";
 import {
@@ -521,18 +518,18 @@ import {
   logForDebugging,
   registerCleanup,
   toError
-} from "./chunk-phd1qfpc.js";
-import {
-  init_process,
-  registerProcessOutputErrorHandlers,
-  writeToStdout
-} from "./chunk-fbv4apne.js";
+} from "./chunk-pd2vy8hx.js";
 import {
   init_envUtils,
   isBareMode,
   isEnvDefinedFalsy,
   isEnvTruthy
-} from "./chunk-jaaxk89e.js";
+} from "./chunk-nsc89h0n.js";
+import {
+  init_process,
+  registerProcessOutputErrorHandlers,
+  writeToStdout
+} from "./chunk-fbv4apne.js";
 import {
   getAllowedChannels,
   getFlagSettingsInline,
@@ -1344,8 +1341,412 @@ class CCRClient {
   }
 }
 
-// src/cli/remoteIO.ts
-init_SSETransport();
+// src/cli/transports/SSETransport.ts
+init_axios();
+init_debug();
+init_diagLogs();
+init_errors();
+init_sessionIngressAuth();
+init_sleep();
+init_slowOperations();
+init_userAgent();
+var RECONNECT_BASE_DELAY_MS = 1000;
+var RECONNECT_MAX_DELAY_MS = 30000;
+var RECONNECT_GIVE_UP_MS = 600000;
+var LIVENESS_TIMEOUT_MS = 45000;
+var PERMANENT_HTTP_CODES = new Set([401, 403, 404]);
+var POST_MAX_RETRIES = 10;
+var POST_BASE_DELAY_MS = 500;
+var POST_MAX_DELAY_MS = 8000;
+var STREAM_DECODE_OPTS = { stream: true };
+function alwaysValidStatus2() {
+  return true;
+}
+function parseSSEFrames(buffer) {
+  const frames = [];
+  let pos = 0;
+  const frameDelimiter = /\r?\n\r?\n/g;
+  frameDelimiter.lastIndex = pos;
+  let delimiterMatch;
+  while ((delimiterMatch = frameDelimiter.exec(buffer)) !== null) {
+    const frameEnd = delimiterMatch.index;
+    const rawFrame = buffer.slice(pos, frameEnd);
+    pos = frameEnd + delimiterMatch[0].length;
+    if (!rawFrame.trim())
+      continue;
+    const frame = {};
+    let isComment = false;
+    for (const rawLine of rawFrame.split(`
+`)) {
+      const line = rawLine[rawLine.length - 1] === "\r" ? rawLine.slice(0, -1) : rawLine;
+      if (line.startsWith(":")) {
+        isComment = true;
+        continue;
+      }
+      const colonIdx = line.indexOf(":");
+      if (colonIdx === -1)
+        continue;
+      const field = line.slice(0, colonIdx);
+      const value = line[colonIdx + 1] === " " ? line.slice(colonIdx + 2) : line.slice(colonIdx + 1);
+      switch (field) {
+        case "event":
+          frame.event = value;
+          break;
+        case "id":
+          frame.id = value;
+          break;
+        case "data":
+          frame.data = frame.data ? frame.data + `
+` + value : value;
+          break;
+      }
+    }
+    if (frame.data || isComment) {
+      frames.push(frame);
+    }
+  }
+  return { frames, remaining: buffer.slice(pos) };
+}
+
+class SSETransport {
+  url;
+  state = "idle";
+  onData;
+  onCloseCallback;
+  onEventCallback;
+  headers;
+  sessionId;
+  refreshHeaders;
+  getAuthHeaders;
+  abortController = null;
+  lastSequenceNum = 0;
+  seenSequenceNums = new Set;
+  reconnectAttempts = 0;
+  reconnectStartTime = null;
+  reconnectTimer = null;
+  livenessTimer = null;
+  postUrl;
+  constructor(url, headers = {}, sessionId, refreshHeaders, initialSequenceNum, getAuthHeaders) {
+    this.url = url;
+    this.headers = headers;
+    this.sessionId = sessionId;
+    this.refreshHeaders = refreshHeaders;
+    this.getAuthHeaders = getAuthHeaders ?? getSessionIngressAuthHeaders;
+    this.postUrl = convertSSEUrlToPostUrl(url);
+    if (initialSequenceNum !== undefined && initialSequenceNum > 0) {
+      this.lastSequenceNum = initialSequenceNum;
+    }
+    logForDebugging(`SSETransport: SSE URL = ${url.href}`);
+    logForDebugging(`SSETransport: POST URL = ${this.postUrl}`);
+    logForDiagnosticsNoPII("info", "cli_sse_transport_initialized");
+  }
+  getLastSequenceNum() {
+    return this.lastSequenceNum;
+  }
+  async connect() {
+    if (this.state !== "idle" && this.state !== "reconnecting") {
+      logForDebugging(`SSETransport: Cannot connect, current state is ${this.state}`, { level: "error" });
+      logForDiagnosticsNoPII("error", "cli_sse_connect_failed");
+      return;
+    }
+    this.state = "reconnecting";
+    const connectStartTime = Date.now();
+    const sseUrl = new URL(this.url.href);
+    if (this.lastSequenceNum > 0) {
+      sseUrl.searchParams.set("from_sequence_num", String(this.lastSequenceNum));
+    }
+    const authHeaders = this.getAuthHeaders();
+    const headers = {
+      ...this.headers,
+      ...authHeaders,
+      Accept: "text/event-stream",
+      "anthropic-version": "2023-06-01",
+      "User-Agent": getClaudeCodeUserAgent()
+    };
+    if (authHeaders["Cookie"]) {
+      delete headers["Authorization"];
+    }
+    if (this.lastSequenceNum > 0) {
+      headers["Last-Event-ID"] = String(this.lastSequenceNum);
+    }
+    logForDebugging(`SSETransport: Opening ${sseUrl.href}`);
+    logForDiagnosticsNoPII("info", "cli_sse_connect_opening");
+    this.abortController = new AbortController;
+    try {
+      const response = await fetch(sseUrl.href, {
+        headers,
+        signal: this.abortController.signal
+      });
+      if (!response.ok) {
+        const isPermanent = PERMANENT_HTTP_CODES.has(response.status);
+        logForDebugging(`SSETransport: HTTP ${response.status}${isPermanent ? " (permanent)" : ""}`, { level: "error" });
+        logForDiagnosticsNoPII("error", "cli_sse_connect_http_error", {
+          status: response.status
+        });
+        if (isPermanent) {
+          this.state = "closed";
+          this.onCloseCallback?.(response.status);
+          return;
+        }
+        this.handleConnectionError();
+        return;
+      }
+      if (!response.body) {
+        logForDebugging("SSETransport: No response body");
+        this.handleConnectionError();
+        return;
+      }
+      const connectDuration = Date.now() - connectStartTime;
+      logForDebugging("SSETransport: Connected");
+      logForDiagnosticsNoPII("info", "cli_sse_connect_connected", {
+        duration_ms: connectDuration
+      });
+      this.state = "connected";
+      this.reconnectAttempts = 0;
+      this.reconnectStartTime = null;
+      this.resetLivenessTimer();
+      await this.readStream(response.body);
+    } catch (error) {
+      if (this.abortController?.signal.aborted) {
+        return;
+      }
+      logForDebugging(`SSETransport: Connection error: ${errorMessage(error)}`, { level: "error" });
+      logForDiagnosticsNoPII("error", "cli_sse_connect_error");
+      this.handleConnectionError();
+    }
+  }
+  async readStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder;
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, STREAM_DECODE_OPTS);
+        const { frames, remaining } = parseSSEFrames(buffer);
+        buffer = remaining;
+        for (const frame of frames) {
+          this.resetLivenessTimer();
+          if (frame.id) {
+            const seqNum = parseInt(frame.id, 10);
+            if (!isNaN(seqNum)) {
+              if (this.seenSequenceNums.has(seqNum)) {
+                logForDebugging(`SSETransport: DUPLICATE frame seq=${seqNum} (lastSequenceNum=${this.lastSequenceNum}, seenCount=${this.seenSequenceNums.size})`, { level: "warn" });
+                logForDiagnosticsNoPII("warn", "cli_sse_duplicate_sequence");
+              } else {
+                this.seenSequenceNums.add(seqNum);
+                if (this.seenSequenceNums.size > 1000) {
+                  const threshold = this.lastSequenceNum - 200;
+                  for (const s of this.seenSequenceNums) {
+                    if (s < threshold) {
+                      this.seenSequenceNums.delete(s);
+                    }
+                  }
+                }
+              }
+              if (seqNum > this.lastSequenceNum) {
+                this.lastSequenceNum = seqNum;
+              }
+            }
+          }
+          if (frame.event && frame.data) {
+            this.handleSSEFrame(frame.event, frame.data);
+          } else if (frame.data) {
+            logForDebugging("SSETransport: Frame has data: but no event: field \u2014 dropped", { level: "warn" });
+            logForDiagnosticsNoPII("warn", "cli_sse_frame_missing_event_field");
+          }
+        }
+      }
+    } catch (error) {
+      if (this.abortController?.signal.aborted)
+        return;
+      logForDebugging(`SSETransport: Stream read error: ${errorMessage(error)}`, { level: "error" });
+      logForDiagnosticsNoPII("error", "cli_sse_stream_read_error");
+    } finally {
+      reader.releaseLock();
+    }
+    if (this.state !== "closing" && this.state !== "closed") {
+      logForDebugging("SSETransport: Stream ended, reconnecting");
+      this.handleConnectionError();
+    }
+  }
+  handleSSEFrame(eventType, data) {
+    if (eventType !== "client_event") {
+      logForDebugging(`SSETransport: Unexpected SSE event type '${eventType}' on worker stream`, { level: "warn" });
+      logForDiagnosticsNoPII("warn", "cli_sse_unexpected_event_type", {
+        event_type: eventType
+      });
+      return;
+    }
+    let ev;
+    try {
+      ev = jsonParse(data);
+    } catch (error) {
+      logForDebugging(`SSETransport: Failed to parse client_event data: ${errorMessage(error)}`, { level: "error" });
+      return;
+    }
+    const payload = ev.payload;
+    if (payload && typeof payload === "object" && "type" in payload) {
+      const sessionLabel = this.sessionId ? ` session=${this.sessionId}` : "";
+      logForDebugging(`SSETransport: Event seq=${ev.sequence_num} event_id=${ev.event_id} event_type=${ev.event_type} payload_type=${String(payload.type)}${sessionLabel}`);
+      logForDiagnosticsNoPII("info", "cli_sse_message_received");
+      this.onData?.(jsonStringify(payload) + `
+`);
+    } else {
+      logForDebugging(`SSETransport: Ignoring client_event with no type in payload: event_id=${ev.event_id}`);
+    }
+    this.onEventCallback?.(ev);
+  }
+  handleConnectionError() {
+    this.clearLivenessTimer();
+    if (this.state === "closing" || this.state === "closed")
+      return;
+    this.abortController?.abort();
+    this.abortController = null;
+    const now = Date.now();
+    if (!this.reconnectStartTime) {
+      this.reconnectStartTime = now;
+    }
+    const elapsed = now - this.reconnectStartTime;
+    if (elapsed < RECONNECT_GIVE_UP_MS) {
+      if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+      }
+      if (this.refreshHeaders) {
+        const freshHeaders = this.refreshHeaders();
+        Object.assign(this.headers, freshHeaders);
+        logForDebugging("SSETransport: Refreshed headers for reconnect");
+      }
+      this.state = "reconnecting";
+      this.reconnectAttempts++;
+      const baseDelay = Math.min(RECONNECT_BASE_DELAY_MS * Math.pow(2, this.reconnectAttempts - 1), RECONNECT_MAX_DELAY_MS);
+      const delay = Math.max(0, baseDelay + baseDelay * 0.25 * (2 * Math.random() - 1));
+      logForDebugging(`SSETransport: Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts}, ${Math.round(elapsed / 1000)}s elapsed)`);
+      logForDiagnosticsNoPII("error", "cli_sse_reconnect_attempt", {
+        reconnectAttempts: this.reconnectAttempts
+      });
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnectTimer = null;
+        this.connect();
+      }, delay);
+    } else {
+      logForDebugging(`SSETransport: Reconnection time budget exhausted after ${Math.round(elapsed / 1000)}s`, { level: "error" });
+      logForDiagnosticsNoPII("error", "cli_sse_reconnect_exhausted", {
+        reconnectAttempts: this.reconnectAttempts,
+        elapsedMs: elapsed
+      });
+      this.state = "closed";
+      this.onCloseCallback?.();
+    }
+  }
+  onLivenessTimeout = () => {
+    this.livenessTimer = null;
+    logForDebugging("SSETransport: Liveness timeout, reconnecting", {
+      level: "error"
+    });
+    logForDiagnosticsNoPII("error", "cli_sse_liveness_timeout");
+    this.abortController?.abort();
+    this.handleConnectionError();
+  };
+  resetLivenessTimer() {
+    this.clearLivenessTimer();
+    this.livenessTimer = setTimeout(this.onLivenessTimeout, LIVENESS_TIMEOUT_MS);
+  }
+  clearLivenessTimer() {
+    if (this.livenessTimer) {
+      clearTimeout(this.livenessTimer);
+      this.livenessTimer = null;
+    }
+  }
+  async write(message) {
+    const authHeaders = this.getAuthHeaders();
+    if (Object.keys(authHeaders).length === 0) {
+      logForDebugging("SSETransport: No session token available for POST");
+      logForDiagnosticsNoPII("warn", "cli_sse_post_no_token");
+      return;
+    }
+    const headers = {
+      ...authHeaders,
+      "Content-Type": "application/json",
+      "anthropic-version": "2023-06-01",
+      "User-Agent": getClaudeCodeUserAgent()
+    };
+    logForDebugging(`SSETransport: POST body keys=${Object.keys(message).join(",")}`);
+    for (let attempt = 1;attempt <= POST_MAX_RETRIES; attempt++) {
+      try {
+        const response = await axios_default.post(this.postUrl, message, {
+          headers,
+          validateStatus: alwaysValidStatus2
+        });
+        if (response.status === 200 || response.status === 201) {
+          logForDebugging(`SSETransport: POST success type=${message.type}`);
+          return;
+        }
+        logForDebugging(`SSETransport: POST ${response.status} body=${jsonStringify(response.data).slice(0, 200)}`);
+        if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+          logForDebugging(`SSETransport: POST returned ${response.status} (client error), not retrying`);
+          logForDiagnosticsNoPII("warn", "cli_sse_post_client_error", {
+            status: response.status
+          });
+          return;
+        }
+        logForDebugging(`SSETransport: POST returned ${response.status}, attempt ${attempt}/${POST_MAX_RETRIES}`);
+        logForDiagnosticsNoPII("warn", "cli_sse_post_retryable_error", {
+          status: response.status,
+          attempt
+        });
+      } catch (error) {
+        const axiosError = error;
+        logForDebugging(`SSETransport: POST error: ${axiosError.message}, attempt ${attempt}/${POST_MAX_RETRIES}`);
+        logForDiagnosticsNoPII("warn", "cli_sse_post_network_error", {
+          attempt
+        });
+      }
+      if (attempt === POST_MAX_RETRIES) {
+        logForDebugging(`SSETransport: POST failed after ${POST_MAX_RETRIES} attempts, continuing`);
+        logForDiagnosticsNoPII("warn", "cli_sse_post_retries_exhausted");
+        return;
+      }
+      const delayMs = Math.min(POST_BASE_DELAY_MS * Math.pow(2, attempt - 1), POST_MAX_DELAY_MS);
+      await sleep(delayMs);
+    }
+  }
+  isConnectedStatus() {
+    return this.state === "connected";
+  }
+  isClosedStatus() {
+    return this.state === "closed";
+  }
+  setOnData(callback) {
+    this.onData = callback;
+  }
+  setOnClose(callback) {
+    this.onCloseCallback = callback;
+  }
+  setOnEvent(callback) {
+    this.onEventCallback = callback;
+  }
+  close() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.clearLivenessTimer();
+    this.state = "closing";
+    this.abortController?.abort();
+    this.abortController = null;
+  }
+}
+function convertSSEUrlToPostUrl(sseUrl) {
+  let pathname = sseUrl.pathname;
+  if (pathname.endsWith("/stream")) {
+    pathname = pathname.slice(0, -"/stream".length);
+  }
+  return `${sseUrl.protocol}//${sseUrl.host}${pathname}`;
+}
 
 // src/cli/transports/transportUtils.ts
 init_envUtils();
@@ -1990,7 +2391,6 @@ function convertWsUrlToPostUrl(wsUrl) {
 }
 
 // src/cli/transports/transportUtils.ts
-init_SSETransport();
 function getTransportForUrl(url, headers = {}, sessionId, refreshHeaders) {
   if (isEnvTruthy(process.env.CLAUDE_CODE_USE_CCR_V2)) {
     const sseUrl = new URL2(url.href);
@@ -2449,6 +2849,7 @@ class QueryEngine {
     this.totalUsage = EMPTY_USAGE;
   }
   async* submitMessage(prompt, options) {
+    this.abortController = createAbortController();
     const {
       cwd,
       commands,
@@ -3254,8 +3655,6 @@ init_permissionSetup();
 init_promptSuggestion();
 init_forkedAgent();
 init_auth();
-init_oauth();
-init_auth3();
 init_providers();
 init_state();
 init_SyntheticOutputTool();
@@ -4272,7 +4671,7 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands, tools, initial
       }
       pluginInstallPromise = null;
       await refreshPluginState();
-      const { setupPluginHookHotReload } = await import("./chunk-ya40p6vj.js");
+      const { setupPluginHookHotReload } = await import("./chunk-b89ese8r.js");
       setupPluginHookHotReload();
     }
     const isMainThread = (cmd) => cmd.agentId === undefined;
@@ -5191,76 +5590,6 @@ ${m.text}
           } else {
             sendControlResponseError(message, `No active OAuth flow for server: ${serverName}`);
           }
-        } else if (message.request.subtype === "claude_authenticate") {
-          const { loginWithClaudeAi } = message.request;
-          claudeOAuth?.service.cleanup();
-          logEvent("tengu_oauth_flow_start", {
-            loginWithClaudeAi: loginWithClaudeAi ?? true
-          });
-          const service = new OAuthService;
-          let urlResolver;
-          const urlPromise = new Promise((resolve) => {
-            urlResolver = resolve;
-          });
-          const flow = service.startOAuthFlow(async (manualUrl, automaticUrl) => {
-            urlResolver({ manualUrl, automaticUrl });
-          }, {
-            loginWithClaudeAi: loginWithClaudeAi ?? true,
-            skipBrowserOpen: true
-          }).then(async (tokens) => {
-            await installOAuthTokens(tokens);
-            logEvent("tengu_oauth_success", {
-              loginWithClaudeAi: loginWithClaudeAi ?? true
-            });
-          }).finally(() => {
-            service.cleanup();
-            if (claudeOAuth?.service === service) {
-              claudeOAuth = null;
-            }
-          });
-          claudeOAuth = { service, flow };
-          flow.catch((err) => logForDebugging(`claude_authenticate flow ended: ${err}`, {
-            level: "info"
-          }));
-          try {
-            const { manualUrl, automaticUrl } = await Promise.race([
-              urlPromise,
-              flow.then(() => {
-                throw new Error("OAuth flow completed without producing auth URLs");
-              })
-            ]);
-            sendControlResponseSuccess(message, {
-              manualUrl,
-              automaticUrl
-            });
-          } catch (error) {
-            sendControlResponseError(message, errorMessage(error));
-          }
-        } else if (message.request.subtype === "claude_oauth_callback" || message.request.subtype === "claude_oauth_wait_for_completion") {
-          if (!claudeOAuth) {
-            sendControlResponseError(message, "No active claude_authenticate flow");
-          } else {
-            if (message.request.subtype === "claude_oauth_callback") {
-              claudeOAuth.service.handleManualAuthCodeInput({
-                authorizationCode: message.request.authorizationCode,
-                state: message.request.state
-              });
-            }
-            const { flow } = claudeOAuth;
-            flow.then(() => {
-              const accountInfo = getAccountInformation();
-              sendControlResponseSuccess(message, {
-                account: {
-                  email: accountInfo?.email,
-                  organization: accountInfo?.organization,
-                  subscriptionType: accountInfo?.subscription,
-                  tokenSource: accountInfo?.tokenSource,
-                  apiKeySource: accountInfo?.apiKeySource,
-                  apiProvider: getAPIProvider()
-                }
-              });
-            }, (error) => sendControlResponseError(message, errorMessage(error)));
-          }
         } else if (message.request.subtype === "mcp_clear_auth") {
           const { serverName } = message.request;
           const currentAppState = getAppState();
@@ -6017,7 +6346,7 @@ async function loadInitialMessages(setAppState, options) {
         processMessagesForTeleportResume,
         teleportResumeCodeSession,
         validateGitState
-      } = await import("./chunk-cdj51xbj.js");
+      } = await import("./chunk-9byfzaeq.js");
       await validateGitState();
       const teleportResult = await teleportResumeCodeSession(options.teleport);
       const { branchError } = await checkOutTeleportedSessionBranch(teleportResult.branch);