@cydm/pie 2.7.0 → 2.7.1

package/dist/chunks/{chunk-R5I2QLF2.js → chunk-XUROMYTT.js}

@@ -475,6 +475,7 @@ function calculateCost(model, usage) {
   const cacheRead = model.cost.cacheRead / 1e6 * usage.cacheRead;
   const cacheWrite = model.cost.cacheWrite / 1e6 * usage.cacheWrite;
   const cacheWriteLongTokens = usage.cacheWriteLong ?? 0;
+  const hasExplicitLongRate = model.cost.cacheWriteLong !== void 0;
   const cacheWriteLongRate = model.cost.cacheWriteLong ?? model.cost.input * 2;
   const cacheWriteLong = cacheWriteLongTokens > 0 ? cacheWriteLongRate / 1e6 * cacheWriteLongTokens : 0;
   return {
@@ -482,7 +483,10 @@ function calculateCost(model, usage) {
     output,
     cacheRead,
     cacheWrite,
-    ...cacheWriteLongTokens > 0 ? { cacheWriteLong } : {},
+    ...cacheWriteLongTokens > 0 ? {
+      cacheWriteLong,
+      ...hasExplicitLongRate ? {} : { cacheWriteLongEstimated: true }
+    } : {},
     total: input + output + cacheRead + cacheWrite + cacheWriteLong
   };
 }
@@ -1872,6 +1876,8 @@ function getHttpAgent() {
   return globalHttpAgent;
 }
 var NodeHttpClient = class {
+  /** The Node client never re-sends a request: one `request()` call is one submission. */
+  transportCapabilities = { singleAttempt: true };
   async request(url, options = {}) {
     const requestStartTime = Date.now();
     const requestId = `${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
@@ -2194,6 +2200,8 @@ var NodeHttpClient = class {
   }
 };
 var PuerTSHttpClient = class {
+  /** No internal re-send: each call starts exactly one bridge request. */
+  transportCapabilities = { singleAttempt: true };
   async request(url, options = {}) {
     logHttp("DEBUG", `PuerTS Request started`, {
       url: url.slice(0, 100),
@@ -3316,6 +3324,9 @@ function getHttpClient() {
 }
 
 // ../../packages/ai/src/utils/http.ts
+function getHttpTransport() {
+  return getHttpClient();
+}
 function httpRequest(url, options = {}) {
   const client = getHttpClient();
   return client.request(url, options);
@@ -3359,6 +3370,7 @@ function buildBaseOptions(model, options, apiKey) {
     timeoutMs: options?.timeoutMs,
     onPayload: options?.onPayload,
     onTransportDiagnostic: options?.onTransportDiagnostic,
+    onTransportLifecycle: options?.onTransportLifecycle,
     maxRetryDelayMs: options?.maxRetryDelayMs,
     metadata: options?.metadata
   };
@@ -4411,6 +4423,35 @@ import Anthropic from "@anthropic-ai/sdk";
 function sanitizeSurrogates(text) {
   return text.replace(/[\uD800-\uDFFF]/g, "");
 }
+function applyAnthropicUsageUpdate(model, usage, payload) {
+  if (payload.input_tokens != null) usage.input = Math.max(0, payload.input_tokens);
+  if (payload.output_tokens != null) usage.output = Math.max(0, payload.output_tokens);
+  if (payload.cache_read_input_tokens != null) usage.cacheRead = Math.max(0, payload.cache_read_input_tokens);
+  const reportedWriteTotal = payload.cache_creation_input_tokens;
+  const breakdown = payload.cache_creation ?? void 0;
+  const breakdownTotal = (breakdown?.ephemeral_5m_input_tokens ?? 0) + (breakdown?.ephemeral_1h_input_tokens ?? 0);
+  if (reportedWriteTotal == null && breakdown !== void 0 && breakdownTotal === 0) {
+    usage.cacheWrite = Math.max(0, usage.cacheWrite);
+  } else if (reportedWriteTotal != null || breakdown !== void 0) {
+    const previousLong = usage.cacheWriteLong ?? 0;
+    const previousTotal = usage.cacheWrite + previousLong;
+    const writeTotal = Math.max(
+      0,
+      reportedWriteTotal != null ? reportedWriteTotal : breakdownTotal > 0 ? breakdownTotal : previousTotal
+    );
+    const longTokens = breakdown?.ephemeral_1h_input_tokens ?? 0;
+    if (longTokens > 0) {
+      const long = Math.min(longTokens, writeTotal);
+      usage.cacheWriteLong = long;
+      usage.cacheWrite = writeTotal - long;
+    } else {
+      delete usage.cacheWriteLong;
+      usage.cacheWrite = writeTotal;
+    }
+  }
+  usage.totalTokens = usage.input + usage.output + usage.cacheRead + usage.cacheWrite + (usage.cacheWriteLong ?? 0);
+  usage.cost = calculateCost(model, usage);
+}
 var ANTHROPIC_PROVIDER_HEADERS = {
   accept: "application/json",
   "anthropic-dangerous-direct-browser-access": "true",
@@ -4696,17 +4737,7 @@ var streamAnthropic = (model, context, options) => {
       const blocks = output.content;
       for await (const event of anthropicStream) {
         if (event.type === "message_start") {
-          output.usage.input = event.message.usage.input_tokens || 0;
-          output.usage.output = event.message.usage.output_tokens || 0;
-          output.usage.cacheRead = event.message.usage.cache_read_input_tokens || 0;
-          output.usage.cacheWrite = event.message.usage.cache_creation_input_tokens || 0;
-          const creation = event.message.usage.cache_creation;
-          if (creation?.ephemeral_1h_input_tokens) {
-            output.usage.cacheWriteLong = creation.ephemeral_1h_input_tokens;
-            output.usage.cacheWrite = Math.max(0, output.usage.cacheWrite - creation.ephemeral_1h_input_tokens);
-          }
-          output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite + (output.usage.cacheWriteLong ?? 0);
-          calculateCost(model, output.usage);
+          applyAnthropicUsageUpdate(model, output.usage, event.message.usage);
         } else if (event.type === "content_block_start") {
           if (event.content_block.type === "text") {
             const block = { type: "text", text: "", index: event.index };
@@ -4810,19 +4841,7 @@ var streamAnthropic = (model, context, options) => {
           if (event.delta.stop_reason) {
             output.stopReason = mapStopReason(event.delta.stop_reason);
           }
-          if (event.usage.input_tokens != null) output.usage.input = event.usage.input_tokens;
-          if (event.usage.output_tokens != null) output.usage.output = event.usage.output_tokens;
-          if (event.usage.cache_read_input_tokens != null) output.usage.cacheRead = event.usage.cache_read_input_tokens;
-          if (event.usage.cache_creation_input_tokens != null) {
-            output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
-            const creationDelta = event.usage.cache_creation;
-            if (creationDelta?.ephemeral_1h_input_tokens) {
-              output.usage.cacheWriteLong = creationDelta.ephemeral_1h_input_tokens;
-              output.usage.cacheWrite = Math.max(0, output.usage.cacheWrite - creationDelta.ephemeral_1h_input_tokens);
-            }
-          }
-          output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite + (output.usage.cacheWriteLong ?? 0);
-          calculateCost(model, output.usage);
+          applyAnthropicUsageUpdate(model, output.usage, event.usage);
         }
       }
       if (options?.signal?.aborted) {
@@ -5567,6 +5586,22 @@ function reportSubmission(options, body, details) {
   } catch {
   }
 }
+function reportLifecycle(options, event) {
+  if (!options?.onTransportLifecycle) return;
+  try {
+    options.onTransportLifecycle({ ...event });
+  } catch {
+  }
+}
+var localRequestCounter = 0;
+function nextLocalRequestId(prefix = "req") {
+  localRequestCounter += 1;
+  return `${prefix}-${localRequestCounter}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function monotonicNow() {
+  const perf = globalThis.performance;
+  return typeof perf?.now === "function" ? perf.now() : Date.now();
+}
 
 // ../../packages/ai/src/providers/responses/responses-sse.ts
 var DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
@@ -5578,15 +5613,134 @@ function parseSSEDataLine2(line) {
   const data = trimmed.slice(5);
   return data.startsWith(" ") ? data.slice(1) : data;
 }
+function singleAttemptSupport() {
+  let capabilities;
+  try {
+    capabilities = getHttpTransport().transportCapabilities;
+  } catch {
+    capabilities = void 0;
+  }
+  return capabilities?.singleAttempt === true ? "verified" : "unverified";
+}
+function assertSingleAttempt() {
+  if (singleAttemptSupport() === "verified") return;
+  throw new ResponsesProtocolError(
+    "Responses SSE requires the platform HTTP adapter to declare transportCapabilities.singleAttempt; refusing to submit because a submitted generation must not be re-sent by the transport."
+  );
+}
+function explicitBudget(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new ResponsesProtocolError(`Invalid ${field}: expected a finite positive number of milliseconds.`);
+  }
+  return value;
+}
+function resolveSSEBudgets(options) {
+  const firstResponse = explicitBudget(options?.firstResponseTimeoutMs, "firstResponseTimeoutMs");
+  const streamIdle = explicitBudget(options?.streamIdleTimeoutMs, "streamIdleTimeoutMs");
+  const requestTimeoutMs = explicitBudget(options?.requestTimeoutMs, "requestTimeoutMs");
+  explicitBudget(options?.connectionIdleTimeoutMs, "connectionIdleTimeoutMs");
+  if (firstResponse !== void 0 || streamIdle !== void 0) {
+    return {
+      http: {
+        firstByteTimeoutMs: firstResponse ?? DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS,
+        streamIdleTimeoutMs: streamIdle ?? DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS
+      },
+      requestTimeoutMs
+    };
+  }
+  if (options?.timeoutMs !== void 0) return { http: { timeoutMs: options.timeoutMs }, requestTimeoutMs };
+  return {
+    http: {
+      firstByteTimeoutMs: DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS,
+      streamIdleTimeoutMs: DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS
+    },
+    requestTimeoutMs
+  };
+}
 function streamResponsesSSE(model, context, options) {
   const stream = new AssistantMessageEventStream();
   void (async () => {
     const reducer = new ResponsesEventReducer(model);
+    const localRequestId = nextLocalRequestId("sse");
+    const startedAt = monotonicNow();
+    let lastReceiveAt = startedAt;
+    let receivedMessageCount = 0;
+    let sawModelContent = false;
+    let submitted = false;
+    let terminalAccepted = false;
+    let phase = "request_start";
+    let budgets = {};
+    let totalTimer;
+    let internalTimeout;
+    let localFailure = false;
+    const requestAbort = new AbortController();
+    const onUserAbort = () => requestAbort.abort();
+    const clearTotalTimer = () => {
+      if (totalTimer !== void 0) {
+        clearTimeout(totalTimer);
+        totalTimer = void 0;
+      }
+    };
+    const lifecycle = (extra = {}) => reportLifecycle(options, {
+      ...extra,
+      transport: "sse",
+      localRequestId,
+      requestGeneration: 1,
+      reusedConnection: false,
+      phase,
+      requestAgeMs: Math.round(monotonicNow() - startedAt),
+      lastReceiveAgeMs: Math.round(monotonicNow() - lastReceiveAt),
+      budgets,
+      receivedMessageCount,
+      sawModelContent,
+      submissionAttempted: submitted,
+      terminalAccepted,
+      singleAttempt: singleAttemptSupport()
+    });
     try {
+      let resolved;
+      try {
+        resolved = resolveSSEBudgets(options);
+      } catch (error) {
+        localFailure = true;
+        throw error;
+      }
+      budgets = {
+        firstResponseTimeoutMs: resolved.http.firstByteTimeoutMs ?? resolved.http.timeoutMs,
+        streamIdleTimeoutMs: resolved.http.streamIdleTimeoutMs ?? resolved.http.timeoutMs,
+        requestTimeoutMs: resolved.requestTimeoutMs
+      };
+      options?.signal?.addEventListener("abort", onUserAbort, { once: true });
+      if (options?.signal?.aborted) requestAbort.abort();
+      if (resolved.requestTimeoutMs !== void 0) {
+        totalTimer = setTimeout(() => {
+          totalTimer = void 0;
+          if (terminalAccepted || requestAbort.signal.aborted) return;
+          internalTimeout = "request_total";
+          phase = "timeout";
+          lifecycle({
+            timeoutKind: "request_total",
+            terminalAccepted: false,
+            cancelSource: "internal_timeout",
+            retryAllowed: !submitted,
+            retryDecision: submitted ? "not_retryable_after_submission" : "not_submitted"
+          });
+          requestAbort.abort();
+        }, resolved.requestTimeoutMs);
+        totalTimer.unref?.();
+      }
+      lifecycle();
       const apiKey = options?.apiKey || getEnvApiKey(model.provider, model.apiKeyEnv) || "";
       if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
       }
+      try {
+        assertSingleAttempt();
+      } catch (error) {
+        localFailure = true;
+        throw error;
+      }
       const payload = buildResponsesSSEPayload(model, context, options);
       options?.onPayload?.(payload);
       const headers = {
@@ -5598,15 +5752,17 @@ function streamResponsesSSE(model, context, options) {
       };
       const body = JSON.stringify(payload);
       reportSubmission(options, body, { transport: "sse", reusedConnection: false, continuation: false, attempt: 1 });
+      submitted = true;
+      phase = "submission_attempted";
+      lifecycle();
       const response = await httpRequest(`${model.baseUrl}/responses`, {
         method: "POST",
         headers,
         body,
-        signal: options?.signal,
-        ...options?.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {
-          firstByteTimeoutMs: DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS,
-          streamIdleTimeoutMs: DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS
-        },
+        signal: requestAbort.signal,
+        // The transport must not re-send a submitted generation.
+        retryPolicy: "never",
+        ...resolved.http,
         label: `${model.provider}/${model.id}`
       });
       if (!response.ok) {
@@ -5616,9 +5772,15 @@ function streamResponsesSSE(model, context, options) {
       if (!response.readSSELines) {
         throw new Error("SSE streaming not supported on this platform");
       }
-      for await (const line of response.readSSELines(options?.signal)) {
+      for await (const line of response.readSSELines(requestAbort.signal)) {
+        receivedMessageCount += 1;
+        lastReceiveAt = monotonicNow();
         const data = parseSSEDataLine2(line);
         if (data === null) continue;
+        if (phase === "submission_attempted") {
+          phase = "first_application_message";
+          lifecycle();
+        }
         if (data === "[DONE]") {
           continue;
         }
@@ -5632,35 +5794,51 @@ function streamResponsesSSE(model, context, options) {
         if (!isResponsesEventLike(event)) {
           throw new ResponsesProtocolError("Responses SSE payload is not an event object with a string type.");
         }
+        if (typeof event.type === "string" && (event.type.startsWith("response.output") || event.type.startsWith("response.content") || event.type.startsWith("response.reasoning"))) {
+          sawModelContent = true;
+        }
         for (const assistantEvent of reducer.feed(event)) {
           stream.push(assistantEvent);
         }
-        if (reducer.isTerminal) break;
+        if (reducer.isTerminal) {
+          terminalAccepted = true;
+          phase = "terminal_accepted";
+          clearTotalTimer();
+          lifecycle({ retryAllowed: reducer.message.retryable !== false, retryDecision: "terminal" });
+          break;
+        }
       }
       if (reducer.isTerminal) {
         stream.end();
         return;
       }
-      if (options?.signal?.aborted) {
-        throw new Error("Request was aborted");
-      }
-      if (!reducer.isTerminal) {
-        throw reducer.finishWithoutTerminal();
+      if (requestAbort.signal.aborted) {
+        throw new Error(internalTimeout ? `Responses request timeout (${internalTimeout})` : "Request was aborted");
       }
-      if (reducer.message.stopReason === "error" || reducer.message.stopReason === "aborted") {
-        throw new Error(reducer.message.errorMessage ?? "An unknown error occurred");
-      }
-      stream.end();
+      throw reducer.finishWithoutTerminal();
     } catch (error) {
       if (reducer.isTerminal) {
         stream.end();
         return;
       }
       const message = reducer.message;
-      message.stopReason = options?.signal?.aborted ? "aborted" : "error";
-      message.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+      const userAborted = options?.signal?.aborted === true;
+      message.stopReason = userAborted ? "aborted" : "error";
+      message.errorMessage = internalTimeout ? `Responses request timeout (${internalTimeout}) after ${Math.round(monotonicNow() - startedAt)}ms` : error instanceof Error ? error.message : JSON.stringify(error);
+      if (submitted || localFailure) message.retryable = false;
+      phase = "cleanup";
+      lifecycle({
+        timeoutKind: internalTimeout,
+        retryAllowed: !submitted && !userAborted && !localFailure,
+        retryDecision: submitted ? "not_retryable_after_submission" : localFailure ? "local_configuration_error" : "not_submitted",
+        cancelSource: userAborted ? "user" : internalTimeout ? "internal_timeout" : "none",
+        cleanupOutcome: "request_abandoned"
+      });
       stream.push({ type: "error", reason: message.stopReason, error: message });
       stream.end();
+    } finally {
+      clearTotalTimer();
+      options?.signal?.removeEventListener("abort", onUserAbort);
     }
   })();
   return stream;
@@ -5669,26 +5847,77 @@ function streamResponsesSSE(model, context, options) {
 // ../../packages/ai/src/providers/responses/responses-ws.ts
 var owners = /* @__PURE__ */ new WeakMap();
 var MAX_ANCHOR_BYTES = 1024 * 1024;
+var DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
+var DEFAULT_FIRST_RESPONSE_TIMEOUT_MS = 2 * 60 * 1e3;
+var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
+var DEFAULT_CONNECTION_IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
+var ITERATOR_CLEANUP_TIMEOUT_MS = 1e3;
+function explicitBudget2(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new ResponsesProtocolError(`Invalid ${field}: expected a finite positive number of milliseconds.`);
+  }
+  return value;
+}
+function resolveBudgets(options) {
+  const firstResponse = explicitBudget2(options?.firstResponseTimeoutMs, "firstResponseTimeoutMs");
+  const streamIdle = explicitBudget2(options?.streamIdleTimeoutMs, "streamIdleTimeoutMs");
+  const requestTimeout = explicitBudget2(options?.requestTimeoutMs, "requestTimeoutMs");
+  const connectionIdle = explicitBudget2(options?.connectionIdleTimeoutMs, "connectionIdleTimeoutMs");
+  const legacy = options?.timeoutMs !== void 0 && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : void 0;
+  return {
+    connectTimeoutMs: legacy ?? DEFAULT_CONNECT_TIMEOUT_MS,
+    firstResponseTimeoutMs: firstResponse ?? legacy ?? DEFAULT_FIRST_RESPONSE_TIMEOUT_MS,
+    streamIdleTimeoutMs: streamIdle ?? legacy ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+    requestTimeoutMs: requestTimeout,
+    connectionIdleTimeoutMs: connectionIdle ?? DEFAULT_CONNECTION_IDLE_TIMEOUT_MS
+  };
+}
 function disposeModelTransports(owner) {
   const state = owners.get(owner);
   if (!state) return;
   disposeState(owner, state);
 }
+function clearConnectionIdleTimer(state) {
+  if (state.idleTimer !== void 0) {
+    clearTimeout(state.idleTimer);
+    state.idleTimer = void 0;
+  }
+}
 function disposeState(owner, state) {
   if (owners.get(owner) === state) owners.delete(owner);
+  clearConnectionIdleTimer(state);
   state.anchor = void 0;
   state.abort.abort();
-  void state.connection?.close().catch(() => {
+  const connection = state.connection;
+  state.connection = void 0;
+  void connection?.close().catch(() => {
   });
 }
 function stateFor(owner) {
   let state = owners.get(owner);
   if (!state) {
-    state = { busy: false, abort: new AbortController() };
+    state = { busy: false, abort: new AbortController(), requestGeneration: 0, connectionGeneration: 0 };
     owners.set(owner, state);
   }
   return state;
 }
+function armConnectionIdleRecycle(state, connection, generation, timeoutMs) {
+  clearConnectionIdleTimer(state);
+  if (!(timeoutMs > 0)) return;
+  const timer = setTimeout(() => {
+    if (state.idleTimer !== timer) return;
+    state.idleTimer = void 0;
+    if (state.busy || state.connectionGeneration !== generation || state.connection !== connection) return;
+    state.connection = void 0;
+    state.anchor = void 0;
+    state.identity = void 0;
+    void connection.close().catch(() => {
+    });
+  }, timeoutMs);
+  timer.unref?.();
+  state.idleTimer = timer;
+}
 function websocketUrl(base) {
   const url = new URL(`${base.replace(/\/$/, "")}/responses`);
   if (url.protocol !== "https:" && url.protocol !== "http:") throw new ResponsesProtocolError("Responses requires an HTTP(S) API root.");
@@ -5706,19 +5935,190 @@ function streamResponsesWS(model, context, options) {
     stream.end();
     return stream;
   }
+  let budgets;
+  try {
+    budgets = resolveBudgets(options);
+  } catch (error) {
+    reducer.message.stopReason = "error";
+    reducer.message.errorMessage = error instanceof Error ? error.message : String(error);
+    reducer.message.retryable = false;
+    stream.push({ type: "error", reason: "error", error: reducer.message });
+    stream.end();
+    return stream;
+  }
   state.busy = true;
+  const localRequestId = nextLocalRequestId("ws");
+  const requestGeneration = ++state.requestGeneration;
+  const startedAt = monotonicNow();
+  let lastReceiveAt = startedAt;
+  let receivedMessageCount = 0;
+  let sawResponseCreated = false;
+  let sawModelContent = false;
+  let reusedConnection = false;
+  let connectionGeneration = state.connectionGeneration;
   void (async () => {
     let sent = false;
     let finished = false;
     let terminalEvents = [];
     let fallback = false;
+    let timedOut;
+    let retryDecision = "none";
+    let requestTimer;
+    let totalTimer;
+    let receiveCleanupFailed = false;
+    let cleanupCancelSource;
+    const requestAbort = new AbortController();
     const publish = (event) => {
       if (event.type === "done" || event.type === "error") terminalEvents.push(event);
       else stream.push(event);
     };
+    const ageMs = () => Math.round(monotonicNow() - startedAt);
+    const lastReceiveAgeMs = () => Math.round(monotonicNow() - lastReceiveAt);
+    const lifecycle = (phase, extra = {}) => reportLifecycle(options, {
+      ...extra,
+      transport: "websocket",
+      localRequestId,
+      requestGeneration,
+      connectionGeneration,
+      reusedConnection,
+      phase,
+      requestAgeMs: ageMs(),
+      lastReceiveAgeMs: lastReceiveAgeMs(),
+      budgets,
+      receivedMessageCount,
+      sawResponseCreated,
+      sawModelContent,
+      // The WS transport never re-sends a submitted frame (no hidden retry).
+      singleAttempt: "verified"
+    });
+    const clearRequestTimers = () => {
+      if (requestTimer !== void 0) {
+        clearTimeout(requestTimer);
+        requestTimer = void 0;
+      }
+      if (totalTimer !== void 0) {
+        clearTimeout(totalTimer);
+        totalTimer = void 0;
+      }
+    };
+    const armTotalTimer = () => {
+      if (budgets.requestTimeoutMs === void 0 || totalTimer !== void 0) return;
+      const generation = requestGeneration;
+      totalTimer = setTimeout(() => {
+        totalTimer = void 0;
+        if (generation !== requestGeneration || finished || requestAbort.signal.aborted) return;
+        timedOut = "request_total";
+        retryDecision = sent ? "not_retryable_after_submission" : "not_submitted";
+        lifecycle("timeout", {
+          timeoutKind: "request_total",
+          terminalAccepted: false,
+          cancelSource: "internal_timeout",
+          retryAllowed: !sent,
+          retryDecision,
+          submissionAttempted: sent
+        });
+        requestAbort.abort();
+      }, budgets.requestTimeoutMs);
+      totalTimer.unref?.();
+    };
+    const remainingRequestBudget = () => {
+      if (budgets.requestTimeoutMs === void 0) return void 0;
+      return Math.max(0, Math.floor(budgets.requestTimeoutMs - ageMs()));
+    };
+    let fallbackAbort;
+    let detachFallbackAbort;
+    const fallbackSignal = () => {
+      if (!fallbackAbort) {
+        const controller = new AbortController();
+        const onAbort = () => controller.abort();
+        options?.signal?.addEventListener("abort", onAbort, { once: true });
+        state.abort.signal.addEventListener("abort", onAbort, { once: true });
+        if (options?.signal?.aborted || state.abort.signal.aborted) controller.abort();
+        fallbackAbort = controller;
+        detachFallbackAbort = () => {
+          options?.signal?.removeEventListener("abort", onAbort);
+          state.abort.signal.removeEventListener("abort", onAbort);
+        };
+      }
+      return fallbackAbort.signal;
+    };
+    const closeReceiveIterator = async (iterator) => {
+      const returnFn = iterator.return;
+      if (typeof returnFn !== "function") return;
+      let timer;
+      try {
+        await Promise.race([
+          Promise.resolve().then(() => returnFn.call(iterator)),
+          new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("bounded iterator cleanup")), ITERATOR_CLEANUP_TIMEOUT_MS);
+            timer.unref?.();
+          })
+        ]);
+      } catch {
+        receiveCleanupFailed = true;
+        state.connection = void 0;
+        state.anchor = void 0;
+        requestAbort.abort();
+      } finally {
+        if (timer !== void 0) clearTimeout(timer);
+      }
+    };
+    const armPhaseTimer = (kind, timeoutMs) => {
+      if (requestTimer !== void 0) {
+        clearTimeout(requestTimer);
+        requestTimer = void 0;
+      }
+      if (timeoutMs === void 0 || timeoutMs <= 0 || finished) return;
+      const generation = requestGeneration;
+      requestTimer = setTimeout(() => {
+        requestTimer = void 0;
+        if (generation !== requestGeneration || finished || requestAbort.signal.aborted) return;
+        timedOut = kind;
+        retryDecision = sent ? "not_retryable_after_submission" : "not_submitted";
+        lifecycle("timeout", {
+          timeoutKind: kind,
+          terminalAccepted: false,
+          cancelSource: "internal_timeout",
+          retryAllowed: !sent,
+          retryDecision,
+          submissionAttempted: sent
+        });
+        requestAbort.abort();
+      }, timeoutMs);
+      requestTimer.unref?.();
+    };
+    const onOwnerAbort = () => requestAbort.abort();
+    if (state.abort.signal.aborted) requestAbort.abort();
+    else state.abort.signal.addEventListener("abort", onOwnerAbort, { once: true });
     const abort = () => disposeState(owner, state);
     options?.signal?.addEventListener("abort", abort, { once: true });
+    const runSSEFallback = async () => {
+      const remaining = remainingRequestBudget();
+      if (remaining !== void 0 && remaining <= 0) {
+        timedOut = "request_total";
+        retryDecision = sent ? "not_retryable_after_submission" : "not_submitted";
+        lifecycle("timeout", {
+          timeoutKind: "request_total",
+          terminalAccepted: false,
+          cancelSource: "internal_timeout",
+          retryAllowed: !sent,
+          retryDecision,
+          submissionAttempted: sent
+        });
+        throw new Error("Responses request timeout (request_total)");
+      }
+      clearRequestTimers();
+      fallback = true;
+      const fallbackOptions = {
+        ...options,
+        signal: fallbackSignal(),
+        ...remaining !== void 0 ? { requestTimeoutMs: remaining } : {}
+      };
+      for await (const event of streamResponsesSSE(model, context, fallbackOptions)) publish(event);
+      finished = true;
+    };
     try {
+      armTotalTimer();
       if (options?.signal?.aborted) {
         abort();
         throw new Error("Request aborted");
@@ -5729,42 +6129,52 @@ function streamResponsesWS(model, context, options) {
       const headers = { Authorization: `Bearer ${key}`, ...model.headers, ...options?.headers };
       const { input, ...settings } = payload;
       const identity = JSON.stringify([model.provider, model.api, model.id, model.baseUrl, headers, settings]);
+      clearConnectionIdleTimer(state);
       if (state.identity !== identity || state.connection?.state() !== "open") {
-        await state.connection?.close();
+        const stale = state.connection;
         state.connection = void 0;
         state.anchor = void 0;
         state.identity = identity;
+        await stale?.close().catch(() => {
+        });
       }
+      reusedConnection = !!state.connection;
       if (state.abort.signal.aborted) throw new Error("Request aborted");
+      lifecycle("request_start");
       const client = getWebSocketClient();
       if (!client) {
         if (options?.transport === "auto") {
-          fallback = true;
-          for await (const event of streamResponsesSSE(model, context, { ...options, signal: state.abort.signal })) publish(event);
-          finished = true;
+          await runSSEFallback();
           return;
         }
         throw new Error("WebSocket transport is not available on this host.");
       }
-      const reusedConnection = !!state.connection;
-      if (!state.connection) {
+      let connection = state.connection;
+      if (!connection) {
         try {
-          state.connection = await client.connect(websocketUrl(model.baseUrl), {
+          connection = await client.connect(websocketUrl(model.baseUrl), {
             headers,
-            signal: state.abort.signal,
-            connectTimeoutMs: options?.timeoutMs ?? 3e4,
-            idleTimeoutMs: options?.timeoutMs ?? 12e4
+            signal: requestAbort.signal,
+            connectTimeoutMs: budgets.connectTimeoutMs
           });
         } catch (error) {
+          if (error instanceof WebSocketTransportError && error.kind === "timeout") timedOut = "connect";
           if (options?.transport === "auto" && error instanceof WebSocketTransportError && error.kind === "handshake" && [404, 405, 426, 501].includes(error.status ?? 0) && !options.signal?.aborted && !state.abort.signal.aborted) {
-            fallback = true;
-            for await (const event of streamResponsesSSE(model, context, { ...options, signal: state.abort.signal })) publish(event);
-            finished = true;
+            await runSSEFallback();
             return;
           }
           throw error;
         }
+        state.connection = connection;
+        connectionGeneration = ++state.connectionGeneration;
+        if (state.abort.signal.aborted || requestAbort.signal.aborted) {
+          state.connection = void 0;
+          void connection.close().catch(() => {
+          });
+          throw new Error("Request aborted");
+        }
       }
+      const activeConnection = connection;
       const fullInput = input;
       const anchor = state.anchor;
       if (!options?.onPayload && model.compat?.responsesContinuation && anchor && fullInput.length > anchor.count && JSON.stringify(fullInput.slice(0, anchor.count)) === anchor.prefix) {
@@ -5775,65 +6185,123 @@ function streamResponsesWS(model, context, options) {
       for (let attempt = 0; attempt < 2; attempt++) {
         let rebuild = false;
         options?.onPayload?.(payload);
-        if (state.abort.signal.aborted) throw new Error("Request aborted");
+        if (state.abort.signal.aborted || requestAbort.signal.aborted) throw new Error("Request aborted");
         sent = true;
         const body = JSON.stringify(payload);
         reportSubmission(options, body, { transport: "websocket", reusedConnection: reusedConnection || attempt > 0, continuation: !!payload.previous_response_id, attempt: attempt + 1 });
-        await state.connection.send(body, { signal: state.abort.signal });
+        lifecycle("submission_attempted", { submissionAttempted: true });
+        armPhaseTimer("first_response", budgets.firstResponseTimeoutMs);
+        await activeConnection.send(body, { signal: requestAbort.signal });
         let started = false;
         let responseId;
-        for await (const message of state.connection.receive(state.abort.signal)) {
-          if (state.abort.signal.aborted) throw new Error("Request aborted");
-          if (message.isBinary) throw new ResponsesProtocolError("Responses requires JSON text messages.");
-          const event = JSON.parse(message.data);
-          if (!isRecord2(event)) throw new ResponsesProtocolError("Invalid Responses WebSocket event.");
-          if (!started && attempt === 0 && payload.previous_response_id && event.type === "error" && event.status === 400 && isRecord2(event.error) && event.error.code === "previous_response_not_found" && event.error.param === "previous_response_id") {
-            delete payload.previous_response_id;
-            payload.input = fullInput;
-            rebuild = true;
-            break;
-          }
-          if (!started && typeof event.type === "string" && event.type !== "error" && !event.type.startsWith("response.")) continue;
-          if (!started && event.type !== "error") {
-            if (event.type !== "response.created" || !isRecord2(event.response) || typeof event.response.id !== "string" || event.response.id === state.lastResponseId) {
-              throw new ResponsesProtocolError("Expected a new response.created before output.");
+        const receiveIterator = activeConnection.receive(requestAbort.signal)[Symbol.asyncIterator]();
+        let receiveDone = false;
+        try {
+          while (true) {
+            const step = await receiveIterator.next();
+            if (step.done) {
+              receiveDone = true;
+              break;
             }
-            started = true;
-            responseId = event.response.id;
-          }
-          if (responseId && isRecord2(event.response) && event.response.id !== responseId) throw new ResponsesProtocolError("Response identity changed within a request.");
-          const events = reducer.feed(event);
-          if (reducer.isTerminal) {
-            if (reducer.message.stopReason === "error") reducer.message.retryable = false;
-            const response = reducer.terminalResponse;
-            state.lastResponseId = response?.id;
-            if (!options?.onPayload && response?.status === "completed" && reducer.message.stopReason !== "error") {
-              const prefixItems = [...fullInput, ...buildResponsesOutput(reducer.message)];
-              const prefix = JSON.stringify(prefixItems);
-              if (prefix.length * 2 <= MAX_ANCHOR_BYTES) state.anchor = { id: response.id, prefix, count: prefixItems.length };
+            const message = step.value;
+            receivedMessageCount += 1;
+            lastReceiveAt = monotonicNow();
+            armPhaseTimer("stream_idle", budgets.streamIdleTimeoutMs);
+            if (receivedMessageCount === 1) lifecycle("first_application_message");
+            if (state.abort.signal.aborted || requestAbort.signal.aborted) {
+              throw new Error(timedOut ? `Responses request timeout (${timedOut})` : "Request aborted");
+            }
+            if (message.isBinary) throw new ResponsesProtocolError("Responses requires JSON text messages.");
+            const event = JSON.parse(message.data);
+            if (!isRecord2(event)) throw new ResponsesProtocolError("Invalid Responses WebSocket event.");
+            if (typeof event.type === "string") {
+              if (event.type === "response.created") sawResponseCreated = true;
+              else if (event.type.startsWith("response.output") || event.type.startsWith("response.content") || event.type.startsWith("response.reasoning")) sawModelContent = true;
+            }
+            if (!started && attempt === 0 && payload.previous_response_id && event.type === "error" && event.status === 400 && isRecord2(event.error) && event.error.code === "previous_response_not_found" && event.error.param === "previous_response_id") {
+              delete payload.previous_response_id;
+              payload.input = fullInput;
+              rebuild = true;
+              break;
+            }
+            if (!started && typeof event.type === "string" && event.type !== "error" && !event.type.startsWith("response.")) continue;
+            if (!started && event.type !== "error") {
+              if (event.type !== "response.created" || !isRecord2(event.response) || typeof event.response.id !== "string" || event.response.id === state.lastResponseId) {
+                throw new ResponsesProtocolError("Expected a new response.created before output.");
+              }
+              started = true;
+              responseId = event.response.id;
+            }
+            if (responseId && isRecord2(event.response) && event.response.id !== responseId) throw new ResponsesProtocolError("Response identity changed within a request.");
+            const events = reducer.feed(event);
+            if (reducer.isTerminal) {
+              if (reducer.message.stopReason === "error") reducer.message.retryable = false;
+              const response = reducer.terminalResponse;
+              state.lastResponseId = response?.id;
+              if (!options?.onPayload && response?.status === "completed" && reducer.message.stopReason !== "error") {
+                const prefixItems = [...fullInput, ...buildResponsesOutput(reducer.message)];
+                const prefix = JSON.stringify(prefixItems);
+                if (prefix.length * 2 <= MAX_ANCHOR_BYTES) state.anchor = { id: response.id, prefix, count: prefixItems.length };
+              }
+              finished = true;
+              clearRequestTimers();
+              lifecycle("terminal_accepted", {
+                terminalAccepted: true,
+                retryAllowed: reducer.message.retryable !== false,
+                retryDecision: "terminal"
+              });
+              for (const e of events) publish(e);
+              break;
             }
-            finished = true;
             for (const e of events) publish(e);
-            break;
           }
-          for (const e of events) publish(e);
+        } finally {
+          if (!receiveDone) await closeReceiveIterator(receiveIterator);
+        }
+        if (rebuild) {
+          retryDecision = "rebuild_previous_response";
+          continue;
         }
-        if (rebuild) continue;
         if (!reducer.isTerminal) throw reducer.finishWithoutTerminal();
         break;
       }
     } catch (error) {
       if (!finished) {
         const message = reducer.message;
-        message.stopReason = options?.signal?.aborted || state.abort.signal.aborted ? "aborted" : "error";
-        message.errorMessage = error instanceof Error ? error.message : String(error);
-        if (sent) message.retryable = false;
+        const userAborted = options?.signal?.aborted === true;
+        const ownerDisposed = !userAborted && !timedOut && state.abort.signal.aborted;
+        message.stopReason = userAborted || ownerDisposed ? "aborted" : "error";
+        const cause = timedOut ? `Responses request timeout (${timedOut}) after ${ageMs()}ms` : error instanceof Error ? error.message : String(error);
+        message.errorMessage = cause;
+        if (sent) {
+          message.retryable = false;
+          retryDecision = "not_retryable_after_submission";
+        }
+        cleanupCancelSource = userAborted ? "user" : timedOut ? "internal_timeout" : ownerDisposed ? "owner_disposal" : "none";
         stream.push({ type: "error", reason: message.stopReason, error: message });
       }
     } finally {
+      clearRequestTimers();
+      detachFallbackAbort?.();
+      state.abort.signal.removeEventListener("abort", onOwnerAbort);
       options?.signal?.removeEventListener("abort", abort);
       state.busy = false;
-      if (fallback || !finished || !options?.transportOwner || reducer.message.stopReason === "error") disposeState(owner, state);
+      const cancelSource = cleanupCancelSource ?? (options?.signal?.aborted ? "user" : timedOut ? "internal_timeout" : state.abort.signal.aborted ? "owner_disposal" : "none");
+      const retain = finished && !fallback && !receiveCleanupFailed && !!options?.transportOwner && reducer.message.stopReason !== "error" && !timedOut && state.connection !== void 0 && !state.abort.signal.aborted;
+      if (!retain) disposeState(owner, state);
+      else if (state.connection) {
+        armConnectionIdleRecycle(state, state.connection, connectionGeneration, budgets.connectionIdleTimeoutMs);
+      }
+      const cleanupOutcome = receiveCleanupFailed ? "cleanup_failed" : retain ? "connection_reused" : finished ? "connection_closed" : "request_abandoned";
+      lifecycle("cleanup", {
+        terminalAccepted: finished,
+        timeoutKind: timedOut,
+        submissionAttempted: sent,
+        retryAllowed: !finished && !sent && reducer.message.stopReason !== "aborted" && reducer.message.retryable !== false,
+        cancelSource,
+        retryDecision,
+        cleanupOutcome
+      });
       for (const event of terminalEvents) stream.push(event);
       stream.end();
     }