@cydm/pie 2.6.11 → 2.7.0

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

@@ -474,12 +474,16 @@ 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 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 } : {},
+    total: input + output + cacheRead + cacheWrite + cacheWriteLong
   };
 }
 
@@ -3047,6 +3051,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;
@@ -3123,6 +3348,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 +3358,7 @@ function buildBaseOptions(model, options, apiKey) {
     headers: options?.headers,
     timeoutMs: options?.timeoutMs,
     onPayload: options?.onPayload,
+    onTransportDiagnostic: options?.onTransportDiagnostic,
     maxRetryDelayMs: options?.maxRetryDelayMs,
     metadata: options?.metadata
   };
@@ -3729,6 +3957,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 = {
@@ -4395,6 +4624,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 = {
@@ -4470,7 +4700,12 @@ var streamAnthropic = (model, context, options) => {
           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;
+          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);
         } else if (event.type === "content_block_start") {
           if (event.content_block.type === "text") {
@@ -4578,9 +4813,15 @@ var streamAnthropic = (model, context, options) => {
           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)
+          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;
+            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);
         }
       }
@@ -4619,6 +4860,1024 @@ 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 {
+  }
+}
+
+// ../../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 streamResponsesSSE(model, context, options) {
+  const stream = new AssistantMessageEventStream();
+  void (async () => {
+    const reducer = new ResponsesEventReducer(model);
+    try {
+      const apiKey = options?.apiKey || getEnvApiKey(model.provider, model.apiKeyEnv) || "";
+      if (!apiKey) {
+        throw new Error(`No API key for provider: ${model.provider}`);
+      }
+      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 });
+      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
+        },
+        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(options?.signal)) {
+        const data = parseSSEDataLine2(line);
+        if (data === null) continue;
+        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.");
+        }
+        for (const assistantEvent of reducer.feed(event)) {
+          stream.push(assistantEvent);
+        }
+        if (reducer.isTerminal) break;
+      }
+      if (reducer.isTerminal) {
+        stream.end();
+        return;
+      }
+      if (options?.signal?.aborted) {
+        throw new Error("Request was aborted");
+      }
+      if (!reducer.isTerminal) {
+        throw reducer.finishWithoutTerminal();
+      }
+      if (reducer.message.stopReason === "error" || reducer.message.stopReason === "aborted") {
+        throw new Error(reducer.message.errorMessage ?? "An unknown error occurred");
+      }
+      stream.end();
+    } 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);
+      stream.push({ type: "error", reason: message.stopReason, error: message });
+      stream.end();
+    }
+  })();
+  return stream;
+}
+
+// ../../packages/ai/src/providers/responses/responses-ws.ts
+var owners = /* @__PURE__ */ new WeakMap();
+var MAX_ANCHOR_BYTES = 1024 * 1024;
+function disposeModelTransports(owner) {
+  const state = owners.get(owner);
+  if (!state) return;
+  disposeState(owner, state);
+}
+function disposeState(owner, state) {
+  if (owners.get(owner) === state) owners.delete(owner);
+  state.anchor = void 0;
+  state.abort.abort();
+  void state.connection?.close().catch(() => {
+  });
+}
+function stateFor(owner) {
+  let state = owners.get(owner);
+  if (!state) {
+    state = { busy: false, abort: new AbortController() };
+    owners.set(owner, state);
+  }
+  return state;
+}
+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;
+  }
+  state.busy = true;
+  void (async () => {
+    let sent = false;
+    let finished = false;
+    let terminalEvents = [];
+    let fallback = false;
+    const publish = (event) => {
+      if (event.type === "done" || event.type === "error") terminalEvents.push(event);
+      else stream.push(event);
+    };
+    const abort = () => disposeState(owner, state);
+    options?.signal?.addEventListener("abort", abort, { once: true });
+    try {
+      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]);
+      if (state.identity !== identity || state.connection?.state() !== "open") {
+        await state.connection?.close();
+        state.connection = void 0;
+        state.anchor = void 0;
+        state.identity = identity;
+      }
+      if (state.abort.signal.aborted) throw new Error("Request aborted");
+      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;
+          return;
+        }
+        throw new Error("WebSocket transport is not available on this host.");
+      }
+      const reusedConnection = !!state.connection;
+      if (!state.connection) {
+        try {
+          state.connection = await client.connect(websocketUrl(model.baseUrl), {
+            headers,
+            signal: state.abort.signal,
+            connectTimeoutMs: options?.timeoutMs ?? 3e4,
+            idleTimeoutMs: options?.timeoutMs ?? 12e4
+          });
+        } catch (error) {
+          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;
+            return;
+          }
+          throw error;
+        }
+      }
+      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) 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 });
+        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.");
+            }
+            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;
+            for (const e of events) publish(e);
+            break;
+          }
+          for (const e of events) publish(e);
+        }
+        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;
+        stream.push({ type: "error", reason: message.stopReason, error: message });
+      }
+    } finally {
+      options?.signal?.removeEventListener("abort", abort);
+      state.busy = false;
+      if (fallback || !finished || !options?.transportOwner || reducer.message.stopReason === "error") disposeState(owner, state);
+      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 +9338,11 @@ registerApiProvider({
   stream: streamAnthropic,
   streamSimple: streamSimpleAnthropic
 });
+registerApiProvider({
+  api: "openai-responses",
+  stream: streamResponses,
+  streamSimple: streamSimpleResponses
+});
 
 export {
   hashText,
@@ -8097,6 +9361,7 @@ export {
   getModelCacheCapability,
   EMPTY_ASSISTANT_CONTENT_ERROR,
   OPENAI_COMPAT_PROTOCOL_ERROR_CODE,
+  disposeModelTransports,
   streamSimple,
   completeSimple,
   MODEL_CLASS_FALLBACK_ORDER,