@cydm/pie 2.6.12 → 2.7.1

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

@@ -474,12 +474,20 @@ function calculateCost(model, usage) {
   const output = model.cost.output / 1e6 * usage.output;
   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 {
     input,
     output,
     cacheRead,
     cacheWrite,
-    total: input + output + cacheRead + cacheWrite
+    ...cacheWriteLongTokens > 0 ? {
+      cacheWriteLong,
+      ...hasExplicitLongRate ? {} : { cacheWriteLongEstimated: true }
+    } : {},
+    total: input + output + cacheRead + cacheWrite + cacheWriteLong
   };
 }
 
@@ -1868,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)}`;
@@ -2190,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),
@@ -3047,6 +3059,227 @@ function deletePuertsDirectoryByEnumeration(path, recursive) {
   warnPuertsDeletionShellsOnce(path);
 }
 
+// ../../packages/platform/src/websocket-node.ts
+import { createRequire as createRequire5 } from "node:module";
+var require5 = createRequire5(import.meta.url);
+var failure = (kind, message) => new WebSocketTransportError(kind, message);
+var NodeWebSocketClient = class {
+  async connect(url, options = {}) {
+    if (options.signal?.aborted) throw failure("aborted", "Connection aborted");
+    for (const field of ["maxMessageBytes", "maxBufferedBytes", "maxBufferedMessages", "connectTimeoutMs"]) {
+      const value = options[field];
+      if (value !== void 0 && (!Number.isFinite(value) || value <= 0)) throw failure("protocol", `Invalid ${field}`);
+    }
+    const WS = require5("ws");
+    const socket = new WS(url, {
+      headers: options.headers,
+      maxPayload: options.maxMessageBytes ?? 32 * 1024 * 1024
+    });
+    return new Promise((resolve, reject) => {
+      const connection = new NodeConnection(socket, options);
+      const timeout = setTimeout(() => connection.fail(failure("timeout", "WebSocket handshake timed out")), options.connectTimeoutMs ?? 3e4);
+      const cleanup = () => {
+        clearTimeout(timeout);
+        socket.off("open", opened);
+        socket.off("error", error);
+        socket.off("close", closed);
+        socket.off("unexpected-response", refused);
+      };
+      const opened = () => {
+        cleanup();
+        resolve(connection);
+      };
+      const error = () => {
+        cleanup();
+        reject(connection.error ?? failure("handshake", "WebSocket connection failed"));
+      };
+      const closed = () => {
+        cleanup();
+        reject(connection.error ?? failure("handshake", "Connection closed before opening"));
+      };
+      const refused = (_, response) => {
+        cleanup();
+        const err = new WebSocketTransportError("handshake", "WebSocket upgrade refused", { status: response.statusCode });
+        connection.fail(err);
+        response.destroy();
+        reject(err);
+      };
+      socket.once("open", opened);
+      socket.once("error", error);
+      socket.once("close", closed);
+      socket.once("unexpected-response", refused);
+    });
+  }
+};
+var NodeConnection = class {
+  constructor(socket, options) {
+    this.socket = socket;
+    this.options = options;
+    this.closed = new Promise((resolve) => {
+      this.resolveClosed = resolve;
+    });
+    socket.on("error", (error) => this.fail(failure(
+      error.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" ? "overflow" : this.opened ? "protocol" : "handshake",
+      "WebSocket transport failed"
+    )));
+    socket.on("open", () => {
+      this.opened = true;
+      this.armIdle();
+    });
+    socket.on("message", (data, isBinary) => {
+      if (this.ended || this.error) return;
+      const buffer = Array.isArray(data) ? Buffer.concat(data) : Buffer.from(data);
+      const bytes = buffer.byteLength;
+      if (bytes > (options.maxMessageBytes ?? 32 * 1024 * 1024) || this.queue.length >= (options.maxBufferedMessages ?? 256) || this.queuedBytes + bytes > (options.maxBufferedBytes ?? 32 * 1024 * 1024)) {
+        this.fail(failure("overflow", "Incoming WebSocket buffer exceeded"));
+        return;
+      }
+      this.queue.push({ data: buffer.toString("utf8"), isBinary, bytes });
+      this.queuedBytes += bytes;
+      this.armIdle();
+      this.wake?.();
+    });
+    socket.once("close", (code, reason) => {
+      this.ended = true;
+      clearTimeout(this.idle);
+      clearTimeout(this.closeTimer);
+      options.signal?.removeEventListener("abort", this.abort);
+      this.resolveClosed({ code, reason: reason.toString() });
+      this.wake?.();
+    });
+    options.signal?.addEventListener("abort", this.abort, { once: true });
+    if (options.signal?.aborted) this.abort();
+  }
+  socket;
+  options;
+  closed;
+  error;
+  resolveClosed;
+  queue = [];
+  queuedBytes = 0;
+  pendingBytes = 0;
+  pendingMessages = 0;
+  sending = Promise.resolve();
+  wake;
+  receiving = false;
+  ended = false;
+  opened = false;
+  idle;
+  closeTimer;
+  abort = () => this.fail(failure("aborted", "Connection aborted"));
+  fail(error) {
+    if (this.ended || this.error) return;
+    this.error = error;
+    this.queue = [];
+    this.queuedBytes = 0;
+    clearTimeout(this.idle);
+    this.socket.terminate();
+    this.wake?.();
+  }
+  armIdle() {
+    clearTimeout(this.idle);
+    if (this.options.idleTimeoutMs && this.options.idleTimeoutMs > 0) {
+      this.idle = setTimeout(() => this.fail(failure("timeout", "WebSocket idle timeout")), this.options.idleTimeoutMs);
+    }
+  }
+  async send(message, options) {
+    const bytes = Buffer.byteLength(message);
+    if (bytes > (this.options.maxMessageBytes ?? 32 * 1024 * 1024) || this.pendingBytes + bytes > (this.options.maxBufferedBytes ?? 32 * 1024 * 1024) || this.pendingMessages >= (this.options.maxBufferedMessages ?? 256)) {
+      throw failure("overflow", "Outgoing WebSocket buffer exceeded");
+    }
+    const signal = options?.signal;
+    if (signal?.aborted) {
+      this.abort();
+      throw failure("aborted", "Send aborted");
+    }
+    const abortSend = () => this.abort();
+    signal?.addEventListener("abort", abortSend, { once: true });
+    this.pendingBytes += bytes;
+    this.pendingMessages++;
+    const operation = this.sending.then(() => new Promise((resolve, reject) => {
+      if (this.error) {
+        reject(this.error);
+        return;
+      }
+      if (this.socket.readyState !== 1) {
+        reject(failure("closed", "Connection is not open"));
+        return;
+      }
+      this.socket.send(message, (error) => error ? reject(this.error ?? failure("closed", "Send failed")) : resolve());
+    }));
+    this.sending = operation.catch(() => {
+    });
+    try {
+      await operation;
+    } finally {
+      this.pendingBytes -= bytes;
+      this.pendingMessages--;
+      signal?.removeEventListener("abort", abortSend);
+    }
+  }
+  async *receive(signal) {
+    if (this.receiving) throw failure("protocol", "Only one receiver is permitted");
+    this.receiving = true;
+    const abortReceive = () => this.abort();
+    signal?.addEventListener("abort", abortReceive, { once: true });
+    try {
+      while (true) {
+        if (signal?.aborted) this.abort();
+        if (this.error) throw this.error;
+        const item = this.queue.shift();
+        if (item) {
+          this.queuedBytes -= item.bytes;
+          yield item;
+          continue;
+        }
+        if (this.ended) return;
+        await new Promise((resolve) => {
+          this.wake = resolve;
+        });
+        this.wake = void 0;
+      }
+    } finally {
+      this.receiving = false;
+      this.wake = void 0;
+      signal?.removeEventListener("abort", abortReceive);
+    }
+  }
+  async close(code = 1e3, reason = "") {
+    if (!this.ended && this.socket.readyState < 2) {
+      this.socket.close(code, reason);
+      this.closeTimer = setTimeout(() => this.socket.terminate(), 1e3);
+    }
+    await this.closed;
+  }
+  state() {
+    return ["connecting", "open", "closing", "closed"][this.socket.readyState];
+  }
+};
+
+// ../../packages/platform/src/websocket.ts
+var WebSocketTransportError = class extends Error {
+  kind;
+  /** HTTP status of a refused handshake, when the transport reports one. */
+  status;
+  /** Close code carried by the failure, when one exists. */
+  closeCode;
+  constructor(kind, message, details = {}) {
+    super(`[websocket:${kind}] ${message}`);
+    this.name = "WebSocketTransportError";
+    this.kind = kind;
+    if (details.status !== void 0) this.status = details.status;
+    if (details.closeCode !== void 0) this.closeCode = details.closeCode;
+  }
+};
+var webSocketClientInstance;
+function getNodeWebSocketClient() {
+  return detectPlatform() === "node" ? new NodeWebSocketClient() : void 0;
+}
+function getWebSocketClient() {
+  if (webSocketClientInstance === void 0) webSocketClientInstance = getNodeWebSocketClient() ?? null;
+  return webSocketClientInstance ?? void 0;
+}
+
 // ../../packages/platform/src/index.ts
 var fileSystemInstance = null;
 var httpClientInstance = null;
@@ -3091,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);
@@ -3123,6 +3359,8 @@ function buildBaseOptions(model, options, apiKey) {
   const modelMaxTokens = positiveFiniteOrInfinity(model.maxTokens);
   return {
     temperature: options?.temperature,
+    transport: options?.transport ?? model.transport,
+    transportOwner: options?.transportOwner,
     maxTokens: options?.maxTokens || Math.min(modelMaxTokens, DEFAULT_MAX_TOKENS),
     signal: options?.signal,
     apiKey: apiKey || options?.apiKey,
@@ -3131,6 +3369,8 @@ function buildBaseOptions(model, options, apiKey) {
     headers: options?.headers,
     timeoutMs: options?.timeoutMs,
     onPayload: options?.onPayload,
+    onTransportDiagnostic: options?.onTransportDiagnostic,
+    onTransportLifecycle: options?.onTransportLifecycle,
     maxRetryDelayMs: options?.maxRetryDelayMs,
     metadata: options?.metadata
   };
@@ -3729,6 +3969,7 @@ function tryParseFinalToolArguments(partialArgs) {
   }
 }
 var streamOpenAICompletions = (model, context, options) => {
+  if ((options?.transport ?? model.transport) === "websocket") throw new Error(`API ${model.api} does not support WebSocket transport.`);
   const stream = new AssistantMessageEventStream();
   (async () => {
     const output = {
@@ -4182,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",
@@ -4395,6 +4665,7 @@ function applyCacheBreakpoints(params, retention) {
   }
 }
 var streamAnthropic = (model, context, options) => {
+  if ((options?.transport ?? model.transport) === "websocket") throw new Error(`API ${model.api} does not support WebSocket transport.`);
   const stream = new AssistantMessageEventStream();
   (async () => {
     const output = {
@@ -4466,12 +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;
-          output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-          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 };
@@ -4575,13 +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;
-          output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-          calculateCost(model, output.usage);
+          applyAnthropicUsageUpdate(model, output.usage, event.usage);
         }
       }
       if (options?.signal?.aborted) {
@@ -4619,6 +4879,1473 @@ var streamSimpleAnthropic = (model, context, options) => {
   });
 };
 
+// ../../packages/ai/src/providers/responses/responses-compat.ts
+function getResponsesCompat(model) {
+  const compat = model.compat ?? {};
+  return {
+    store: compat.store ?? false,
+    supportsStore: compat.supportsStore ?? true,
+    supportsReasoningEffort: compat.supportsReasoningEffort ?? true,
+    supportsEncryptedReasoning: compat.supportsEncryptedReasoning ?? true,
+    responsesContinuation: compat.responsesContinuation ?? false
+  };
+}
+
+// ../../packages/ai/src/providers/responses/responses-wire.ts
+var RESPONSES_PROTOCOL_ERROR_CODE = "responses_protocol_error";
+var ResponsesProtocolError = class extends Error {
+  code = RESPONSES_PROTOCOL_ERROR_CODE;
+  constructor(message) {
+    super(`${RESPONSES_PROTOCOL_ERROR_CODE}: ${message}`);
+    this.name = "ResponsesProtocolError";
+  }
+};
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isResponsesEventLike(value) {
+  return isRecord2(value) && typeof value.type === "string";
+}
+function formatResponsesErrorEvent(event) {
+  const source = isRecord2(event.error) ? event.error : event;
+  const message = typeof source.message === "string" && source.message.length > 0 ? source.message : "Responses stream returned an error";
+  const metadata = [];
+  if (typeof source.code === "string" && source.code.length > 0) {
+    metadata.push(`code=${source.code}`);
+  }
+  if (typeof source.param === "string" && source.param.length > 0) {
+    metadata.push(`param=${source.param}`);
+  }
+  if (typeof event.status === "number") {
+    metadata.push(`status=${event.status}`);
+  }
+  return metadata.length > 0 ? `${message} (${metadata.join(", ")})` : message;
+}
+
+// ../../packages/ai/src/providers/responses/responses-request.ts
+var MAX_REASONING_ENVELOPE_BYTES = 512 * 1024;
+function decodeReasoningEnvelope(signature) {
+  if (typeof signature !== "string" || signature.length === 0 || signature.length > MAX_REASONING_ENVELOPE_BYTES) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(signature);
+  } catch {
+    return null;
+  }
+  if (!isRecord2(parsed) || parsed.v !== 1 || typeof parsed.id !== "string" || parsed.id.length === 0) {
+    return null;
+  }
+  const encrypted = parsed.encrypted_content;
+  if (encrypted !== void 0 && encrypted !== null && typeof encrypted !== "string") {
+    return null;
+  }
+  return { v: 1, id: parsed.id, encrypted_content: encrypted };
+}
+function buildResponsesInput(model, context) {
+  const items = [];
+  const isSameModel = (msg) => msg.provider === model.provider && msg.api === model.api && msg.model === model.id;
+  const transformed = transformMessages(context.messages, model);
+  for (const msg of transformed) {
+    if (msg.role === "user") {
+      items.push(encodeUserMessage(msg.content, model));
+    } else if (msg.role === "assistant") {
+      encodeAssistantMessage(msg, isSameModel, items);
+    } else if (msg.role === "toolResult") {
+      items.push(encodeToolResult(msg, model));
+    }
+  }
+  return items;
+}
+function encodeUserMessage(content, model) {
+  if (typeof content === "string") {
+    return { role: "user", type: "message", content };
+  }
+  const parts = [];
+  for (const block of content) {
+    parts.push(...encodeUserContentBlock(block, model));
+  }
+  if (parts.length === 0) {
+    return { role: "user", type: "message", content: "" };
+  }
+  return { role: "user", type: "message", content: parts };
+}
+function encodeUserContentBlock(block, model) {
+  const modality = block.type === "fileRef" ? block.modality : block.type;
+  if (modality !== "text" && !model.input.includes(modality)) {
+    throw new ResponsesProtocolError(`Current model does not support ${modality} input.`);
+  }
+  switch (block.type) {
+    case "text":
+      return [{ type: "input_text", text: block.text }];
+    case "image":
+      return [{ type: "input_image", image_url: `data:${block.mimeType};base64,${block.data}` }];
+    case "video":
+    case "audio":
+      throw new ResponsesProtocolError(`Responses ${block.type} input is not supported by this provider.`);
+    case "fileRef": {
+      const ref = block;
+      if (ref.modality === "image") {
+        return [{ type: "input_image", image_url: ref.url }];
+      }
+      throw new ResponsesProtocolError(`Responses ${ref.modality} file references are not supported by this provider.`);
+    }
+    default:
+      throw new ResponsesProtocolError("Unsupported Responses content block.");
+  }
+}
+function encodeAssistantMessage(msg, isSameModel, items) {
+  for (const block of msg.content) {
+    if (block.type === "thinking") {
+      const thinking = block;
+      if (isSameModel(msg)) {
+        const envelope = decodeReasoningEnvelope(thinking.thinkingSignature);
+        if (thinking.thinkingSignature && !envelope) {
+          throw new ResponsesProtocolError("Invalid Responses reasoning signature.");
+        }
+        if (envelope) {
+          items.push({
+            type: "reasoning",
+            id: envelope.id,
+            summary: thinking.thinking.trim() ? [{ type: "summary_text", text: thinking.thinking }] : [],
+            ...envelope.encrypted_content ? { encrypted_content: envelope.encrypted_content } : {}
+          });
+          continue;
+        }
+      }
+      if (thinking.thinking && thinking.thinking.trim().length > 0) {
+        items.push({ role: "assistant", type: "message", content: thinking.thinking });
+      }
+      continue;
+    }
+    if (block.type === "text") {
+      const text = block;
+      if (text.text && text.text.trim().length > 0) {
+        items.push({ role: "assistant", type: "message", content: text.text });
+      }
+      continue;
+    }
+    if (block.type === "toolCall") {
+      const call = block;
+      items.push({
+        type: "function_call",
+        call_id: call.id,
+        name: call.name,
+        arguments: JSON.stringify(call.arguments ?? {})
+      });
+    }
+  }
+}
+function buildResponsesOutput(message) {
+  const items = [];
+  encodeAssistantMessage(message, () => true, items);
+  return items;
+}
+function encodeToolResult(msg, model) {
+  const output = msg.content.every((block) => block.type === "text") ? msg.content.map((block) => block.text).join("\n") || "(empty result)" : msg.content.flatMap((block) => encodeUserContentBlock(block, model));
+  return { type: "function_call_output", call_id: msg.toolCallId, output };
+}
+function encodeTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters ?? { type: "object", properties: {} },
+    strict: false
+  }));
+}
+function buildResponsesRequest(model, context, options, compat = getResponsesCompat(model)) {
+  const params = {
+    model: model.id,
+    input: buildResponsesInput(model, context)
+  };
+  if (context.systemPrompt !== void 0 && context.systemPrompt !== null && context.systemPrompt.length > 0) {
+    params.instructions = context.systemPrompt;
+  }
+  if (compat.supportsStore) {
+    params.store = compat.store;
+  }
+  if (options?.maxTokens !== void 0 && options.maxTokens > 0) {
+    params.max_output_tokens = options.maxTokens;
+  }
+  if (options?.temperature !== void 0) params.temperature = options.temperature;
+  if (options?.topP !== void 0) params.top_p = options.topP;
+  if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
+    params.reasoning = { effort: options.reasoningEffort };
+  }
+  if (compat.supportsEncryptedReasoning && model.reasoning) {
+    params.include = ["reasoning.encrypted_content"];
+  }
+  if (context.tools && context.tools.length > 0) {
+    params.tools = encodeTools(context.tools);
+    params.parallel_tool_calls = true;
+  }
+  if (options?.toolChoice !== void 0) {
+    params.tool_choice = options.toolChoice === "required" ? "required" : options.toolChoice;
+  }
+  return params;
+}
+function buildResponsesSSEPayload(model, context, options) {
+  return { ...buildResponsesRequest(model, context, options), stream: true };
+}
+function buildResponsesCreateEvent(model, context, options) {
+  const params = buildResponsesRequest(model, context, options);
+  delete params.stream;
+  return { type: "response.create", ...params };
+}
+
+// ../../packages/ai/src/providers/responses/responses-usage.ts
+function tokenCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return void 0;
+  return Math.floor(value);
+}
+function normalizeResponsesUsage(model, usage) {
+  const inputTokens = tokenCount(usage?.input_tokens);
+  const cachedTokens = tokenCount(usage?.input_tokens_details?.cached_tokens) ?? 0;
+  const cacheWriteTokens = tokenCount(usage?.input_tokens_details?.cache_write_tokens) ?? 0;
+  const outputTokens = tokenCount(usage?.output_tokens);
+  const reasoningTokens = tokenCount(usage?.output_tokens_details?.reasoning_tokens);
+  const totalTokens = tokenCount(usage?.total_tokens);
+  const input = inputTokens ?? (totalTokens !== void 0 && outputTokens !== void 0 ? Math.max(cachedTokens + cacheWriteTokens, totalTokens - outputTokens) : cachedTokens + cacheWriteTokens);
+  const output = outputTokens ?? (totalTokens !== void 0 ? Math.max(reasoningTokens ?? 0, totalTokens - input) : reasoningTokens ?? 0);
+  const cacheRead = Math.min(cachedTokens, input);
+  const cacheWrite = Math.min(cacheWriteTokens, input - cacheRead);
+  const inputExclusive = input - cacheRead - cacheWrite;
+  const partitionTotal = input + output;
+  const base = {
+    input: inputExclusive,
+    output,
+    cacheRead,
+    cacheWrite,
+    totalTokens: Math.max(totalTokens ?? 0, partitionTotal)
+  };
+  return { ...base, cost: calculateCost(model, base) };
+}
+
+// ../../packages/ai/src/providers/responses/responses-events.ts
+var ResponsesEventReducer = class {
+  output;
+  model;
+  started = false;
+  terminal = null;
+  items = /* @__PURE__ */ new Map();
+  toolCallStates = [];
+  diagnostics = { unknownEventTypes: /* @__PURE__ */ new Set(), ignoredItemTypes: /* @__PURE__ */ new Set(), terminalType: null };
+  constructor(model) {
+    this.model = model;
+    this.output = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usageReported: false,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      stopReason: "stop",
+      timestamp: Date.now()
+    };
+  }
+  get message() {
+    return this.output;
+  }
+  get isTerminal() {
+    return this.terminal !== null;
+  }
+  /** Terminal response object (present on completed/incomplete/failed). */
+  get terminalResponse() {
+    return this.terminal?.response;
+  }
+  /** Feed one raw wire event; returns the AssistantMessageEvents to emit. */
+  feed(raw) {
+    const events = [];
+    if (!isResponsesEventLike(raw)) {
+      throw new ResponsesProtocolError("Responses stream returned an event without a string type.");
+    }
+    if (this.terminal) return events;
+    switch (raw.type) {
+      case "response.created":
+      case "response.in_progress":
+      case "response.queued":
+        if (!this.started) {
+          this.started = true;
+          events.push({ type: "start", partial: this.output });
+        }
+        break;
+      case "response.output_item.added":
+        events.push(...this.onOutputItemAdded(raw));
+        break;
+      case "response.output_item.done":
+        events.push(...this.onOutputItemDone(raw));
+        break;
+      case "response.content_part.added":
+        events.push(...this.onContentPartAdded(raw));
+        break;
+      case "response.content_part.done":
+        break;
+      case "response.output_text.delta":
+        events.push(...this.appendTextDelta(raw, "text"));
+        break;
+      case "response.output_text.done":
+        this.validateTextDone(raw);
+        break;
+      case "response.refusal.delta":
+        events.push(...this.appendTextDelta(raw, "refusal"));
+        break;
+      case "response.refusal.done":
+        break;
+      case "response.reasoning_summary_text.delta":
+      case "response.reasoning_text.delta":
+        events.push(...this.appendReasoningDelta(raw));
+        break;
+      case "response.reasoning_summary_text.done":
+      case "response.reasoning_text.done":
+        break;
+      case "response.reasoning_summary_part.added":
+      case "response.reasoning_summary_part.done":
+        break;
+      case "response.function_call_arguments.delta":
+        events.push(...this.appendFunctionCallArgsDelta(raw));
+        break;
+      case "response.function_call_arguments.done":
+        this.onFunctionCallArgsDone(raw);
+        break;
+      case "response.completed":
+        events.push(...this.onTerminal(raw, "response.completed"));
+        break;
+      case "response.incomplete":
+        events.push(...this.onIncomplete(raw));
+        break;
+      case "response.failed":
+        events.push(...this.onTerminal(raw, "response.failed", "error", this.failedText(raw)));
+        break;
+      case "error":
+        events.push(...this.onTerminal(raw, "error", "error", formatResponsesErrorEvent(raw)));
+        break;
+      default:
+        this.diagnostics.unknownEventTypes.add(raw.type);
+        break;
+    }
+    return events;
+  }
+  /** Stream ended without a terminal event. Caller decides how to fail. */
+  finishWithoutTerminal() {
+    return new ResponsesProtocolError(
+      `Responses stream ended without a terminal event (${this.diagnostics.terminalType ?? "none"} seen).`
+    );
+  }
+  // ─── item lifecycle ─────────────────────────────────────────────────────
+  ensureStarted() {
+    if (this.started) return [];
+    this.started = true;
+    return [{ type: "start", partial: this.output }];
+  }
+  requireItemIndex(raw) {
+    const index = raw.output_index;
+    if (typeof index !== "number" || !Number.isInteger(index) || index < 0) {
+      throw new ResponsesProtocolError(`Responses event "${raw.type}" is missing a valid output_index.`);
+    }
+    return index;
+  }
+  onOutputItemAdded(raw) {
+    const outputIndex = this.requireItemIndex(raw);
+    const item = raw.item;
+    if (!isRecord2(item)) {
+      throw new ResponsesProtocolError(`response.output_item.added at index ${outputIndex} is missing the item.`);
+    }
+    if (this.items.has(outputIndex)) {
+      throw new ResponsesProtocolError(`Responses stream reused output_index ${outputIndex}.`);
+    }
+    const itemId = typeof item.id === "string" ? item.id : "";
+    if (item.type === "message") {
+      this.items.set(outputIndex, { kind: "message", itemId, blocks: /* @__PURE__ */ new Map() });
+      return this.ensureStarted();
+    }
+    if (item.type === "reasoning") {
+      const block = { type: "thinking", thinking: "" };
+      this.output.content.push(block);
+      this.items.set(outputIndex, { kind: "reasoning", itemId, block, lastSummaryIndex: null });
+      const startEvents = this.ensureStarted();
+      return [
+        ...startEvents,
+        { type: "thinking_start", contentIndex: this.output.content.length - 1, partial: this.output }
+      ];
+    }
+    if (item.type === "function_call") {
+      const callId = typeof item.call_id === "string" ? item.call_id : "";
+      if (!callId) {
+        throw new ResponsesProtocolError(`function_call output item at index ${outputIndex} is missing call_id.`);
+      }
+      const name = typeof item.name === "string" ? item.name : "";
+      if (!name || !itemId) throw new ResponsesProtocolError("function_call requires name and item id.");
+      const block = { type: "toolCall", id: callId, name, arguments: {} };
+      this.output.content.push(block);
+      const state = {
+        kind: "function_call",
+        itemId,
+        block,
+        partialArgs: "",
+        finalArgs: null,
+        completed: false,
+        contentIndex: this.output.content.length - 1
+      };
+      this.items.set(outputIndex, state);
+      this.toolCallStates.push(state);
+      const startEvents = this.ensureStarted();
+      return [
+        ...startEvents,
+        { type: "toolcall_start", contentIndex: state.contentIndex, partial: this.output }
+      ];
+    }
+    this.items.set(outputIndex, { kind: "ignored", itemType: String(item.type) });
+    this.diagnostics.ignoredItemTypes.add(String(item.type));
+    return [];
+  }
+  lookupItem(raw, kinds, label) {
+    const outputIndex = this.requireItemIndex(raw);
+    let state = this.items.get(outputIndex);
+    if (!state || !kinds.includes(state.kind)) {
+      throw new ResponsesProtocolError(
+        `Responses event "${raw.type ?? label}" references ${label} output_index ${outputIndex} that was never added (or is of the wrong item type).`
+      );
+    }
+    if (state.kind !== "ignored" && raw.item_id !== void 0 && raw.item_id !== state.itemId) throw new ResponsesProtocolError("Response item identity changed.");
+    return { state, outputIndex };
+  }
+  onContentPartAdded(raw) {
+    const part = raw.part;
+    const partType = isRecord2(part) ? part.type : void 0;
+    const kind = partType === "reasoning_text" ? "reasoning" : "message";
+    const { state } = this.lookupItem(raw, [kind], kind);
+    const partIndex = raw.content_index;
+    if (typeof partIndex !== "number" || !Number.isInteger(partIndex) || partIndex < 0) {
+      throw new ResponsesProtocolError("response.content_part.added is missing a valid content_index.");
+    }
+    if (state.kind !== "message") return [];
+    if (state.blocks.has(partIndex)) {
+      throw new ResponsesProtocolError(`Responses stream reused content_index ${partIndex} on one message item.`);
+    }
+    if (partType !== "output_text" && partType !== "refusal") {
+      return [];
+    }
+    const block = { type: "text", text: "" };
+    this.output.content.push(block);
+    state.blocks.set(partIndex, { block, contentIndex: this.output.content.length - 1 });
+    return [{ type: "text_start", contentIndex: this.output.content.length - 1, partial: this.output }];
+  }
+  messageBlockFor(raw) {
+    const { state } = this.lookupItem(raw, ["message"], "message");
+    if (state.kind !== "message") throw new ResponsesProtocolError("internal: expected message item");
+    const partIndex = raw.content_index;
+    if (typeof partIndex !== "number" || !Number.isInteger(partIndex) || partIndex < 0) {
+      throw new ResponsesProtocolError(`Responses event "${raw.type}" is missing a valid content_index.`);
+    }
+    const entry = state.blocks.get(partIndex);
+    if (!entry) {
+      throw new ResponsesProtocolError(
+        `Responses event "${raw.type}" references content_index ${partIndex} that was never added.`
+      );
+    }
+    return entry;
+  }
+  appendTextDelta(raw, kind) {
+    const delta = raw.delta;
+    if (typeof delta !== "string" || delta.length === 0) return [];
+    const entry = this.messageBlockFor(raw);
+    entry.block.text += delta;
+    return [{ type: "text_delta", contentIndex: entry.contentIndex, delta, partial: this.output }];
+  }
+  validateTextDone(raw) {
+    this.messageBlockFor(raw);
+  }
+  appendReasoningDelta(raw) {
+    const delta = raw.delta;
+    if (typeof delta !== "string" || delta.length === 0) return [];
+    const { state } = this.lookupItem(raw, ["reasoning"], "reasoning");
+    if (state.kind !== "reasoning") return [];
+    let text = delta;
+    const summaryIndex = raw.summary_index;
+    if (typeof summaryIndex === "number" && Number.isInteger(summaryIndex)) {
+      if (state.lastSummaryIndex !== null && summaryIndex !== state.lastSummaryIndex) {
+        text = `
+
+${delta}`;
+      }
+      state.lastSummaryIndex = summaryIndex;
+    }
+    state.block.thinking += text;
+    return [{ type: "thinking_delta", contentIndex: this.output.content.indexOf(state.block), delta: text, partial: this.output }];
+  }
+  appendFunctionCallArgsDelta(raw) {
+    const delta = raw.delta ?? raw.arguments;
+    if (typeof delta !== "string" || delta.length === 0) return [];
+    const { state } = this.lookupItem(raw, ["function_call"], "function_call");
+    if (state.kind !== "function_call") return [];
+    state.partialArgs += delta;
+    state.block.arguments = parseStreamingJson(state.partialArgs);
+    return [{ type: "toolcall_delta", contentIndex: state.contentIndex, delta, partial: this.output }];
+  }
+  onFunctionCallArgsDone(raw) {
+    const { state } = this.lookupItem(raw, ["function_call"], "function_call");
+    if (state.kind !== "function_call") return;
+    if (typeof raw.arguments === "string") {
+      state.finalArgs = raw.arguments;
+    }
+  }
+  onOutputItemDone(raw) {
+    const outputIndex = this.requireItemIndex(raw);
+    const item = raw.item;
+    if (!isRecord2(item)) {
+      throw new ResponsesProtocolError(`response.output_item.done at index ${outputIndex} is missing the item.`);
+    }
+    const state = this.items.get(outputIndex);
+    if (!state) {
+      throw new ResponsesProtocolError(`response.output_item.done references output_index ${outputIndex} that was never added.`);
+    }
+    if (state.kind !== "ignored" && (item.id !== state.itemId || item.type !== state.kind)) throw new ResponsesProtocolError("Response done item identity changed.");
+    switch (state.kind) {
+      case "message": {
+        const events = [];
+        for (const { block, contentIndex } of state.blocks.values()) {
+          events.push({ type: "text_end", contentIndex, content: block.text, partial: this.output });
+        }
+        return events;
+      }
+      case "reasoning": {
+        const events = [];
+        const encrypted = typeof item.encrypted_content === "string" ? item.encrypted_content : null;
+        const itemId = typeof item.id === "string" && item.id.length > 0 ? item.id : state.itemId;
+        if (itemId) {
+          state.block.thinkingSignature = JSON.stringify({ v: 1, id: itemId, encrypted_content: encrypted });
+        }
+        events.push({
+          type: "thinking_end",
+          contentIndex: this.output.content.indexOf(state.block),
+          content: state.block.thinking,
+          partial: this.output
+        });
+        return events;
+      }
+      case "function_call": {
+        const finalText = typeof item.arguments === "string" && item.arguments.length > 0 ? item.arguments : state.finalArgs ?? state.partialArgs;
+        if (typeof item.call_id === "string" && item.call_id.length > 0 && item.call_id !== state.block.id) {
+          throw new ResponsesProtocolError(`function_call item changed call_id from "${state.block.id}" to "${item.call_id}".`);
+        }
+        if (typeof item.name === "string" && item.name.length > 0 && item.name !== state.block.name) {
+          throw new ResponsesProtocolError(`function_call item changed name from "${state.block.name}" to "${item.name}".`);
+        }
+        state.completed = true;
+        state.finalArgs = finalText;
+        if (this.canParseArgs(state)) {
+          return this.finalizeFunctionCall(state, finalText);
+        }
+        return [];
+      }
+      case "ignored":
+        return [];
+    }
+  }
+  finalizeFunctionCall(state, argsText) {
+    const text = argsText.trim();
+    let parsed;
+    if (text.length === 0) {
+      parsed = {};
+    } else {
+      try {
+        const value = JSON.parse(text);
+        if (!isRecord2(value)) {
+          throw new ResponsesProtocolError(`function_call "${state.block.name || "unknown"}" arguments are not a JSON object.`);
+        }
+        parsed = value;
+      } catch (error) {
+        if (error instanceof ResponsesProtocolError) throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ResponsesProtocolError(
+          `function_call "${state.block.name || "unknown"}" returned incomplete or invalid JSON arguments: ${message}`
+        );
+      }
+    }
+    state.block.arguments = parsed;
+    return [{ type: "toolcall_end", contentIndex: state.contentIndex, toolCall: state.block, partial: this.output }];
+  }
+  // ─── terminals ──────────────────────────────────────────────────────────
+  requireTerminalResponse(raw) {
+    const response = raw.response;
+    const expected = raw.type.slice("response.".length);
+    if (!isRecord2(response) || typeof response.id !== "string" || !response.id || response.status !== expected) {
+      throw new ResponsesProtocolError(`Malformed ${raw.type}: requires response id and status ${expected}.`);
+    }
+    return response;
+  }
+  onTerminal(raw, type, reason = "stop", errorText) {
+    this.diagnostics.terminalType = type;
+    const response = type === "error" ? void 0 : this.requireTerminalResponse(raw);
+    this.terminal = { reason, response, errorText };
+    return this.closeResponse(type);
+  }
+  onIncomplete(raw) {
+    this.diagnostics.terminalType = "response.incomplete";
+    const response = this.requireTerminalResponse(raw);
+    const reason = response?.incomplete_details?.reason;
+    if (reason === "content_filter" || reason === "steered" || reason === void 0) {
+      this.terminal = {
+        reason: "error",
+        response,
+        errorText: reason === "steered" ? "Response ended incomplete with reason 'steered' but no steering was sent." : `Response ended incomplete${reason ? ` (${reason})` : " without a reason"}.`
+      };
+      return this.closeResponse("response.incomplete");
+    }
+    this.terminal = { reason: "length", response };
+    return this.closeResponse("response.incomplete");
+  }
+  failedText(raw) {
+    const response = isRecord2(raw.response) ? raw.response : void 0;
+    const error = isRecord2(response?.error) ? response?.error : void 0;
+    const message = typeof error?.message === "string" && error.message.length > 0 ? error.message : "Response failed";
+    const code = typeof error?.code === "string" && error.code.length > 0 ? ` (code=${error.code})` : "";
+    return `${message}${code}`;
+  }
+  /** Apply terminal semantics and produce the final event. */
+  closeResponse(terminalType) {
+    const terminal = this.terminal;
+    const response = terminal.response;
+    if (response && isRecord2(response.usage)) {
+      this.output.usage = normalizeResponsesUsage(this.model, response.usage);
+      this.output.usageReported = [response.usage.input_tokens, response.usage.output_tokens].every((value) => typeof value === "number" && Number.isFinite(value) && value >= 0);
+    }
+    if (terminal.reason === "error") {
+      this.output.stopReason = "error";
+      this.output.errorMessage = terminal.errorText ?? "Response failed";
+      return [{ type: "error", reason: "error", error: this.output }];
+    }
+    let stopReason = terminal.reason === "length" ? "length" : "stop";
+    if (this.toolCallStates.length > 0) {
+      stopReason = "toolUse";
+    }
+    if (terminal.reason === "length") {
+      const truncated = this.toolCallStates.filter((state) => !state.completed || !this.canParseArgs(state));
+      if (truncated.length > 0) {
+        const dropped = new Set(truncated.map((state) => state.block));
+        this.output.content = this.output.content.filter(
+          (block) => block.type !== "toolCall" || !dropped.has(block)
+        );
+        this.toolCallStates = this.toolCallStates.filter((state) => !dropped.has(state.block));
+        const names = truncated.map((state) => `"${state.block.name || "unnamed"}"`).sort().join(", ");
+        this.output.content.push({
+          type: "text",
+          text: `[output truncated: max_output_tokens cut ${truncated.length === 1 ? "a tool call" : `${truncated.length} tool calls`} mid-arguments (${names}); the call${truncated.length === 1 ? " was" : "s were"} dropped. Re-issue the call or continue with fewer/smaller requests.]`
+        });
+        if (this.toolCallStates.length === 0) {
+          stopReason = "length";
+        }
+      }
+    } else if (terminal.reason === "stop") {
+      const brokenCalls = this.toolCallStates.filter((state) => !state.completed || !this.canParseArgs(state));
+      if (brokenCalls.length > 0) {
+        const first = brokenCalls[0];
+        this.output.stopReason = "error";
+        this.output.errorMessage = `function_call "${first.block.name || "unknown"}" returned incomplete or invalid JSON arguments on a completed response.`;
+        return [{ type: "error", reason: "error", error: this.output }];
+      }
+    }
+    if (stopReason === "toolUse" && this.toolCallStates.length === 0) {
+      stopReason = "stop";
+    }
+    this.output.stopReason = stopReason;
+    void terminalType;
+    return [{ type: "done", reason: stopReason, message: this.output }];
+  }
+  canParseArgs(state) {
+    const text = (state.finalArgs ?? state.partialArgs).trim();
+    if (text.length === 0) return false;
+    try {
+      return isRecord2(JSON.parse(text));
+    } catch {
+      return false;
+    }
+  }
+};
+
+// ../../packages/ai/src/providers/responses/responses-diagnostics.ts
+function reportSubmission(options, body, details) {
+  if (!options?.onTransportDiagnostic) return;
+  let requestBytes = 0;
+  for (const character of body) {
+    const point = character.codePointAt(0);
+    requestBytes += point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
+  }
+  try {
+    options.onTransportDiagnostic({ ...details, requestBytes });
+  } 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;
+var DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS = 3 * 60 * 1e3;
+function parseSSEDataLine2(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith(":")) return null;
+  if (!trimmed.startsWith("data:")) return null;
+  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 = {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream",
+        Authorization: `Bearer ${apiKey}`,
+        ...model.headers || {},
+        ...options?.headers || {}
+      };
+      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: requestAbort.signal,
+        // The transport must not re-send a submitted generation.
+        retryPolicy: "never",
+        ...resolved.http,
+        label: `${model.provider}/${model.id}`
+      });
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => "");
+        throw new Error(`API error ${response.status}: ${errorBody}`);
+      }
+      if (!response.readSSELines) {
+        throw new Error("SSE streaming not supported on this platform");
+      }
+      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;
+        }
+        let event;
+        try {
+          event = JSON.parse(data);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          throw new ResponsesProtocolError(`Responses SSE stream returned malformed JSON: ${message}`);
+        }
+        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) {
+          terminalAccepted = true;
+          phase = "terminal_accepted";
+          clearTotalTimer();
+          lifecycle({ retryAllowed: reducer.message.retryable !== false, retryDecision: "terminal" });
+          break;
+        }
+      }
+      if (reducer.isTerminal) {
+        stream.end();
+        return;
+      }
+      if (requestAbort.signal.aborted) {
+        throw new Error(internalTimeout ? `Responses request timeout (${internalTimeout})` : "Request was aborted");
+      }
+      throw reducer.finishWithoutTerminal();
+    } catch (error) {
+      if (reducer.isTerminal) {
+        stream.end();
+        return;
+      }
+      const message = reducer.message;
+      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;
+}
+
+// ../../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();
+  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(), 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.");
+  return `${url.protocol === "https:" ? "wss:" : "ws:"}${url.toString().slice(url.protocol.length)}`;
+}
+function streamResponsesWS(model, context, options) {
+  const stream = new AssistantMessageEventStream();
+  const owner = options?.transportOwner ?? {};
+  const state = stateFor(owner);
+  const reducer = new ResponsesEventReducer(model);
+  if (state.busy) {
+    reducer.message.stopReason = "error";
+    reducer.message.errorMessage = "Responses owner already has an in-flight request.";
+    stream.push({ type: "error", reason: "error", error: reducer.message });
+    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");
+      }
+      const key = options?.apiKey || getEnvApiKey(model.provider, model.apiKeyEnv);
+      if (!key) throw new Error(`No API key for provider: ${model.provider}`);
+      const payload = buildResponsesCreateEvent(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") {
+        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") {
+          await runSSEFallback();
+          return;
+        }
+        throw new Error("WebSocket transport is not available on this host.");
+      }
+      let connection = state.connection;
+      if (!connection) {
+        try {
+          connection = await client.connect(websocketUrl(model.baseUrl), {
+            headers,
+            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) {
+            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) {
+        payload.previous_response_id = anchor.id;
+        payload.input = fullInput.slice(anchor.count);
+      }
+      state.anchor = void 0;
+      for (let attempt = 0; attempt < 2; attempt++) {
+        let rebuild = false;
+        options?.onPayload?.(payload);
+        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 });
+        lifecycle("submission_attempted", { submissionAttempted: true });
+        armPhaseTimer("first_response", budgets.firstResponseTimeoutMs);
+        await activeConnection.send(body, { signal: requestAbort.signal });
+        let started = false;
+        let responseId;
+        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;
+            }
+            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;
+            }
+            for (const e of events) publish(e);
+          }
+        } finally {
+          if (!receiveDone) await closeReceiveIterator(receiveIterator);
+        }
+        if (rebuild) {
+          retryDecision = "rebuild_previous_response";
+          continue;
+        }
+        if (!reducer.isTerminal) throw reducer.finishWithoutTerminal();
+        break;
+      }
+    } catch (error) {
+      if (!finished) {
+        const message = reducer.message;
+        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;
+      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();
+    }
+  })();
+  return stream;
+}
+
+// ../../packages/ai/src/providers/openai-responses.ts
+var streamResponses = (model, context, options) => {
+  const transport = options?.transport ?? model.transport ?? "sse";
+  if (transport === "websocket" || transport === "auto") return streamResponsesWS(model, context, { ...options, transport });
+  if (transport !== "sse") throw new Error(`Unsupported transport: ${transport}`);
+  return streamResponsesSSE(model, context, options);
+};
+var streamSimpleResponses = (model, context, options) => {
+  const apiKey = options?.apiKey || getEnvApiKey(model.provider, model.apiKeyEnv);
+  if (!apiKey) {
+    throw new Error(`No API key for provider: ${model.provider}`);
+  }
+  const base = buildBaseOptions(model, options, apiKey);
+  const needsThinkingAllowance = Boolean(model.reasoning) && options?.reasoning !== void 0;
+  let maxTokens = base.maxTokens;
+  if (needsThinkingAllowance) {
+    const adjusted = adjustMaxTokensForThinking(
+      base.maxTokens || 0,
+      model.maxTokens,
+      options.reasoning,
+      options?.thinkingBudgets
+    );
+    maxTokens = adjusted.maxTokens;
+  }
+  if (maxTokens === void 0) {
+    maxTokens = DEFAULT_MAX_TOKENS;
+  }
+  const reasoningEffort = model.reasoning ? options?.reasoning : void 0;
+  return streamResponses(model, context, {
+    ...base,
+    maxTokens,
+    // Responses accepts the full effort vocabulary verified in the SDK
+    // ("none" excluded from Pie's ThinkingLevel); pass through unchanged.
+    reasoningEffort
+  });
+};
+
 // ../../packages/ai/src/stream.ts
 function resolveApiProvider(api) {
   const provider = getApiProvider(api);
@@ -8079,6 +9806,11 @@ registerApiProvider({
   stream: streamAnthropic,
   streamSimple: streamSimpleAnthropic
 });
+registerApiProvider({
+  api: "openai-responses",
+  stream: streamResponses,
+  streamSimple: streamSimpleResponses
+});
 
 export {
   hashText,
@@ -8097,6 +9829,7 @@ export {
   getModelCacheCapability,
   EMPTY_ASSISTANT_CONTENT_ERROR,
   OPENAI_COMPAT_PROTOCOL_ERROR_CODE,
+  disposeModelTransports,
   streamSimple,
   completeSimple,
   MODEL_CLASS_FALLBACK_ORDER,