@cydm/pie 2.7.4 → 2.7.5

package/dist/chunks/{chunk-Z4EIBY2E.js → chunk-SUPAWIKP.js}

@@ -512,6 +512,338 @@ function hashText(text) {
   return hasher.digest();
 }
 
+// ../../node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+var Hash = class {
+};
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// ../../node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE ? 4 : 0;
+  const l = isLE ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE);
+  view.setUint32(byteOffset + l, wl, isLE);
+}
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    super();
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    data = toBytes(data);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../../node_modules/@noble/hashes/esm/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD {
+  constructor(outputLen = 32) {
+    super(64, outputLen, 8, false);
+    this.A = SHA256_IV[0] | 0;
+    this.B = SHA256_IV[1] | 0;
+    this.C = SHA256_IV[2] | 0;
+    this.D = SHA256_IV[3] | 0;
+    this.E = SHA256_IV[4] | 0;
+    this.F = SHA256_IV[5] | 0;
+    this.G = SHA256_IV[6] | 0;
+    this.H = SHA256_IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
+
+// ../../packages/platform/src/sha256.ts
+function createSha256Hasher() {
+  const hash = sha256.create();
+  return {
+    update(bytes) {
+      hash.update(bytes);
+    },
+    digestHex() {
+      const bytes = hash.digest();
+      let hex = "";
+      for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+      return hex;
+    }
+  };
+}
+
 // ../../packages/platform/src/detector.ts
 function isPuerTS() {
   try {
@@ -3126,7 +3458,7 @@ var NodeConnection = class {
       this.resolveClosed = resolve;
     });
     socket.on("error", (error) => this.fail(failure(
-      error.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" ? "overflow" : this.opened ? "protocol" : "handshake",
+      error.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" ? "overflow" : !this.opened ? "handshake" : error.code?.startsWith("WS_ERR_") ? "protocol" : "closed",
       "WebSocket transport failed"
     )));
     socket.on("open", () => {
@@ -5626,12 +5958,21 @@ var DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
 var DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS = 3 * 60 * 1e3;
 var REASONING_STREAM_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
 var REASONING_FIRST_BYTE_TIMEOUT_MS = 5 * 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;
+async function* readSSEData(lines) {
+  let data = [];
+  let firstLine = true;
+  for await (const rawLine of lines) {
+    let line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (firstLine && line.startsWith("\uFEFF")) line = line.slice(1);
+    firstLine = false;
+    if (line === "") {
+      if (data.length > 0) yield data.join("\n");
+      data = [];
+    } else if (line === "data" || line.startsWith("data:")) {
+      const value = line === "data" ? "" : line.slice(5);
+      data.push(value.startsWith(" ") ? value.slice(1) : value);
+    }
+  }
 }
 function singleAttemptSupport() {
   let capabilities;
@@ -5687,8 +6028,11 @@ function streamResponsesSSE(model, context, options) {
     let budgets = {};
     let totalTimer;
     let internalTimeout;
-    let localFailure = false;
+    let localFailure = true;
     let providerRejected = false;
+    let providerErrorMessage;
+    let transportLost = false;
+    let endedWithoutTerminal = false;
     const requestAbort = new AbortController();
     const onUserAbort = () => requestAbort.abort();
     const clearTotalTimer = () => {
@@ -5767,6 +6111,7 @@ function streamResponsesSSE(model, context, options) {
       };
       const body = JSON.stringify(payload);
       reportSubmission(options, body, { transport: "sse", reusedConnection: false, continuation: false, attempt: 1 });
+      localFailure = false;
       submitted = true;
       phase = "submission_attempted";
       lifecycle();
@@ -5779,20 +6124,36 @@ function streamResponsesSSE(model, context, options) {
         retryPolicy: "never",
         ...resolved.http,
         label: `${model.provider}/${model.id}`
+      }).catch((error) => {
+        const status = error && typeof error === "object" ? error.status ?? error.statusCode : void 0;
+        if (typeof status === "number" && status >= 400) {
+          providerRejected = true;
+          providerErrorMessage = `API error ${status}: ${error instanceof Error ? error.message : "request rejected"}`;
+        }
+        transportLost = !providerRejected && !(error instanceof ResponsesProtocolError || error instanceof SyntaxError);
+        throw error;
       });
       if (!response.ok) {
-        const errorBody = await response.text().catch(() => "");
         providerRejected = true;
-        throw new Error(`API error ${response.status}: ${errorBody}`);
+        providerErrorMessage = `API error ${response.status}`;
+        const errorBody = await response.text().catch(() => "");
+        if (errorBody) providerErrorMessage += `: ${errorBody}`;
+        throw new Error(providerErrorMessage);
       }
       if (!response.readSSELines) {
-        throw new Error("SSE streaming not supported on this platform");
+        throw new ResponsesProtocolError("SSE streaming not supported on this platform");
+      }
+      async function* transportLines() {
+        try {
+          yield* response.readSSELines(requestAbort.signal);
+        } catch (error) {
+          transportLost = !(error instanceof ResponsesProtocolError || error instanceof SyntaxError);
+          throw error;
+        }
       }
-      for await (const line of response.readSSELines(requestAbort.signal)) {
+      for await (const data of readSSEData(transportLines())) {
         receivedMessageCount += 1;
         lastReceiveAt = monotonicNow();
-        const data = parseSSEDataLine2(line);
-        if (data === null) continue;
         if (phase === "submission_attempted") {
           phase = "first_application_message";
           lifecycle();
@@ -5813,7 +6174,9 @@ function streamResponsesSSE(model, context, options) {
         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)) {
+        const events = reducer.feed(event);
+        if (reducer.isTerminal && reducer.message.stopReason === "error") reducer.message.retryable = false;
+        for (const assistantEvent of events) {
           stream.push(assistantEvent);
         }
         if (reducer.isTerminal) {
@@ -5831,6 +6194,7 @@ function streamResponsesSSE(model, context, options) {
       if (requestAbort.signal.aborted) {
         throw new Error(internalTimeout ? `Responses request timeout (${internalTimeout})` : "Request was aborted");
       }
+      endedWithoutTerminal = true;
       throw reducer.finishWithoutTerminal();
     } catch (error) {
       if (reducer.isTerminal) {
@@ -5844,10 +6208,11 @@ function streamResponsesSSE(model, context, options) {
       if (!internalTimeout && (adapterTimeoutKind === "first_byte" || adapterTimeoutKind === "stream_idle")) {
         internalTimeout = adapterTimeoutKind === "first_byte" ? "first_response" : "stream_idle";
       }
-      message.errorMessage = internalTimeout ? `Responses request timeout (${internalTimeout}) after ${Math.round(monotonicNow() - startedAt)}ms` : error instanceof Error ? error.message : JSON.stringify(error);
+      const protocolFailure = !endedWithoutTerminal && (error instanceof ResponsesProtocolError || error instanceof SyntaxError || !transportLost && error instanceof TypeError);
+      message.errorMessage = providerErrorMessage ?? (internalTimeout && !protocolFailure ? `Responses request timeout (${internalTimeout}) after ${Math.round(monotonicNow() - startedAt)}ms` : error instanceof Error ? error.message : JSON.stringify(error));
       const compat = getResponsesCompat(model);
-      const streamLost = !internalTimeout && submitted && !localFailure && !providerRejected && message.stopReason === "error";
-      if (internalTimeout && compat.timeoutReplay) {
+      const streamLost = (endedWithoutTerminal || transportLost) && !protocolFailure && !internalTimeout && submitted && !localFailure && !providerRejected && message.stopReason === "error";
+      if (internalTimeout && !protocolFailure && submitted && !providerRejected && !localFailure && !userAborted && compat.timeoutReplay) {
         message.replayEligible = true;
         message.replayClass = internalTimeout;
       } else if (streamLost && compat.timeoutReplay) {
@@ -5873,9 +6238,112 @@ function streamResponsesSSE(model, context, options) {
   return stream;
 }
 
+// ../../packages/ai/src/providers/responses/responses-continuation.ts
+function jsonSha256(value) {
+  return hashJson(value);
+}
+function hashJson(value, parts) {
+  const hash = createSha256Hasher();
+  const bytes = new Uint8Array(8192);
+  let used = 0;
+  const byte = (n) => {
+    bytes[used++] = n;
+    if (used === bytes.length) {
+      hash.update(bytes);
+      used = 0;
+    }
+  };
+  const emit = (text) => {
+    for (let i = 0; i < text.length; i++) {
+      const cp = text.codePointAt(i);
+      if (cp < 128) byte(cp);
+      else if (cp < 2048) {
+        byte(192 | cp >> 6);
+        byte(128 | cp & 63);
+      } else if (cp < 65536) {
+        byte(224 | cp >> 12);
+        byte(128 | cp >> 6 & 63);
+        byte(128 | cp & 63);
+      } else {
+        byte(240 | cp >> 18);
+        byte(128 | cp >> 12 & 63);
+        byte(128 | cp >> 6 & 63);
+        byte(128 | cp & 63);
+        i++;
+      }
+    }
+  };
+  const string = (text) => {
+    emit('"');
+    for (let start = 0; start < text.length; ) {
+      let end = Math.min(start + 2048, text.length);
+      if (end < text.length && text.charCodeAt(end - 1) >= 55296 && text.charCodeAt(end - 1) <= 56319) end--;
+      const escaped = JSON.stringify(text.slice(start, end));
+      emit(escaped.slice(1, -1));
+      start = end;
+    }
+    emit('"');
+  };
+  const ancestors = /* @__PURE__ */ new Set();
+  const omitted = (v) => v === void 0 || typeof v === "function" || typeof v === "symbol";
+  const visit = (v) => {
+    if (typeof v === "string") {
+      string(v);
+      return;
+    }
+    if (v === null || typeof v !== "object") {
+      const encoded = JSON.stringify(v);
+      if (encoded === void 0) throw new TypeError("Not a JSON value");
+      emit(encoded);
+      return;
+    }
+    const prototype = Object.getPrototypeOf(v);
+    if (!Array.isArray(v) && prototype !== Object.prototype && prototype !== null || typeof v.toJSON === "function") throw new TypeError("Not a JSON snapshot");
+    if (ancestors.has(v)) throw new TypeError("Circular JSON snapshot");
+    ancestors.add(v);
+    if (Array.isArray(v)) {
+      emit("[");
+      for (let i = 0; i < v.length; i++) {
+        if (Object.getOwnPropertyDescriptor(v, i)?.get) throw new TypeError("Not a JSON snapshot");
+        if (i) emit(",");
+        visit(omitted(v[i]) ? null : v[i]);
+      }
+      emit("]");
+    } else {
+      emit("{");
+      let first = true;
+      for (const key of Object.keys(v)) {
+        if (Object.getOwnPropertyDescriptor(v, key)?.get) throw new TypeError("Not a JSON snapshot");
+        const entry = v[key];
+        if (omitted(entry)) continue;
+        if (!first) emit(",");
+        first = false;
+        string(key);
+        emit(":");
+        visit(entry);
+      }
+      emit("}");
+    }
+    ancestors.delete(v);
+  };
+  if (parts) {
+    emit("[");
+    for (let i = 0; i < parts.count + parts.output.length; i++) {
+      if (i) emit(",");
+      const item = i < parts.count ? parts.input[i] : parts.output[i - parts.count];
+      visit(omitted(item) ? null : item);
+    }
+    emit("]");
+  } else visit(value);
+  if (used) hash.update(bytes.subarray(0, used));
+  return hash.digestHex();
+}
+function inputSha256(input, count = input.length, output = []) {
+  return hashJson(void 0, { input, count, output });
+}
+
 // ../../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;
@@ -5991,9 +6459,22 @@ function streamResponsesWS(model, context, options) {
   void (async () => {
     let sent = false;
     let finished = false;
+    let candidateAnchor;
     let terminalEvents = [];
     let fallback = false;
     let timedOut;
+    let providerRejected = false;
+    let localFailure = true;
+    let transportLost = false;
+    let endedWithoutTerminal = false;
+    const transportIO = async (operation) => {
+      try {
+        return await operation();
+      } catch (error) {
+        transportLost = !(error instanceof ResponsesProtocolError || error instanceof SyntaxError) && (!(error instanceof WebSocketTransportError) || error.kind === "closed" || error.kind === "timeout");
+        throw error;
+      }
+    };
     let retryDecision = "none";
     let requestTimer;
     let totalTimer;
@@ -6160,12 +6641,23 @@ function streamResponsesWS(model, context, options) {
       }
       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 encoded = buildResponsesCreateEvent(model, context, options);
+      const { input, ...encodedSettings } = encoded;
+      const settings = JSON.parse(JSON.stringify(encodedSettings));
+      const payload = { ...settings, input };
       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]);
+      const endpoint = websocketUrl(model.baseUrl);
+      let continuationReason = "no_anchor";
+      const identityValue = [1, model.provider, model.api, model.id, endpoint, headers, settings, compat];
+      let identity;
+      try {
+        identity = jsonSha256(identityValue);
+      } catch {
+      }
+      if (!identity) state.anchor = void 0;
       clearConnectionIdleTimer(state);
-      if (state.identity !== identity || state.connection?.state() !== "open") {
+      if (!identity || state.identity !== identity || state.connection?.state() !== "open") {
+        if (state.anchor) continuationReason = state.identity !== identity ? "identity_changed" : "connection_changed";
         const stale = state.connection;
         state.connection = void 0;
         state.anchor = void 0;
@@ -6176,18 +6668,19 @@ function streamResponsesWS(model, context, options) {
       reusedConnection = !!state.connection;
       if (state.abort.signal.aborted) throw new Error("Request aborted");
       lifecycle("request_start");
+      localFailure = false;
       const client = getWebSocketClient();
       if (!client) {
         if (options?.transport === "auto") {
           await runSSEFallback();
           return;
         }
-        throw new Error("WebSocket transport is not available on this host.");
+        throw new ResponsesProtocolError("WebSocket transport is not available on this host.");
       }
       let connection = state.connection;
       if (!connection) {
         try {
-          connection = await client.connect(websocketUrl(model.baseUrl), {
+          connection = await client.connect(endpoint, {
             headers,
             signal: requestAbort.signal,
             connectTimeoutMs: budgets.connectTimeoutMs
@@ -6196,6 +6689,7 @@ function streamResponsesWS(model, context, options) {
           if (error instanceof WebSocketTransportError && error.kind === "timeout") timedOut = "connect";
           if (error instanceof WebSocketTransportError && error.kind === "handshake" && !options?.signal?.aborted && !state.abort.signal.aborted) {
             const status = error.status ?? 0;
+            providerRejected = status > 0;
             const endpointHasNoWebsockets = options?.transport === "auto" && [404, 405, 426, 501].includes(status);
             const wsEdgeRefused = status === 0 || status === 429 || status >= 500 && status <= 599;
             if (endpointHasNoWebsockets || wsEdgeRefused) {
@@ -6217,28 +6711,57 @@ function streamResponsesWS(model, context, options) {
       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);
+      let prefixHashMs = 0;
+      if (options?.onPayload) continuationReason = "payload_hook";
+      else if (!compat.responsesContinuation) continuationReason = "disabled";
+      else if (!identity) continuationReason = "hash_unavailable";
+      else if (anchor) continuationReason = fullInput.length <= anchor.confirmedItemCount ? "history_shortened" : "history_changed";
+      if (!options?.onPayload && compat.responsesContinuation && identity && anchor && anchor.connectionGeneration === connectionGeneration && anchor.requestIdentitySha256 === identity && fullInput.length > anchor.confirmedItemCount) {
+        const hashStarted = monotonicNow();
+        try {
+          if (inputSha256(fullInput, anchor.confirmedItemCount) === anchor.prefixSha256) {
+            continuationReason = "verified_prefix";
+            payload.previous_response_id = anchor.responseId;
+            payload.input = fullInput.slice(anchor.confirmedItemCount);
+          }
+        } catch {
+          continuationReason = "hash_unavailable";
+        }
+        prefixHashMs = monotonicNow() - hashStarted;
       }
       state.anchor = void 0;
       for (let attempt = 0; attempt < 2; attempt++) {
         let rebuild = false;
-        options?.onPayload?.(payload);
+        let body;
+        try {
+          options?.onPayload?.(payload);
+          body = JSON.stringify(payload);
+        } catch (error) {
+          localFailure = true;
+          throw error;
+        }
         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 });
+        reportSubmission(options, body, {
+          transport: "websocket",
+          reusedConnection: reusedConnection || attempt > 0,
+          continuation: !!payload.previous_response_id,
+          attempt: attempt + 1,
+          continuationReason,
+          fullInputItems: fullInput.length,
+          sentInputItems: Array.isArray(payload.input) ? payload.input.length : void 0,
+          prefixHashMs
+        });
         lifecycle("submission_attempted", { submissionAttempted: true });
         armPhaseTimer("first_response", budgets.firstResponseTimeoutMs);
-        await activeConnection.send(body, { signal: requestAbort.signal });
+        await transportIO(() => 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();
+            const step = await transportIO(() => receiveIterator.next());
             if (step.done) {
               receiveDone = true;
               break;
@@ -6261,6 +6784,7 @@ function streamResponsesWS(model, context, options) {
             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;
+              continuationReason = "previous_response_not_found";
               rebuild = true;
               break;
             }
@@ -6278,10 +6802,19 @@ function streamResponsesWS(model, context, options) {
               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 };
+              if (!options?.onPayload && compat.responsesContinuation && identity && response?.status === "completed" && reducer.message.stopReason !== "error") {
+                try {
+                  const output = buildResponsesOutput(reducer.message);
+                  candidateAnchor = {
+                    version: 1,
+                    responseId: response.id,
+                    confirmedItemCount: fullInput.length + output.length,
+                    prefixSha256: inputSha256(fullInput, fullInput.length, output),
+                    requestIdentitySha256: identity,
+                    connectionGeneration
+                  };
+                } catch {
+                }
               }
               finished = true;
               clearRequestTimers();
@@ -6302,7 +6835,10 @@ function streamResponsesWS(model, context, options) {
           retryDecision = "rebuild_previous_response";
           continue;
         }
-        if (!reducer.isTerminal) throw reducer.finishWithoutTerminal();
+        if (!reducer.isTerminal) {
+          endedWithoutTerminal = true;
+          throw reducer.finishWithoutTerminal();
+        }
         break;
       }
     } catch (error) {
@@ -6311,16 +6847,20 @@ function streamResponsesWS(model, context, options) {
         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);
+        const protocolFailure = !endedWithoutTerminal && (error instanceof ResponsesProtocolError || error instanceof SyntaxError || !transportLost && error instanceof TypeError || error instanceof WebSocketTransportError && (error.kind === "protocol" || error.kind === "overflow"));
+        const cause = providerRejected && error instanceof WebSocketTransportError ? `${error.message} (HTTP status ${error.status})` : timedOut && !protocolFailure ? `Responses request timeout (${timedOut}) after ${ageMs()}ms` : error instanceof Error ? error.message : String(error);
         message.errorMessage = cause;
-        const streamLost = !timedOut && message.stopReason === "error";
-        if (timedOut && compat.timeoutReplay) {
+        const streamLost = (endedWithoutTerminal || transportLost) && !protocolFailure && sent && !timedOut && !providerRejected && message.stopReason === "error";
+        if (timedOut && timedOut !== "connect" && !protocolFailure && !localFailure && sent && !providerRejected && !userAborted && !ownerDisposed && compat.timeoutReplay) {
           message.replayEligible = true;
           message.replayClass = timedOut;
         } else if (streamLost && compat.timeoutReplay) {
           message.replayEligible = true;
           message.replayClass = receivedMessageCount === 0 ? "stream_lost" : "stream_lost_partial";
         }
+        if (localFailure || providerRejected || protocolFailure) {
+          message.retryable = false;
+        }
         if (sent) {
           if (streamLost && receivedMessageCount === 0) {
             retryDecision = message.replayEligible ? "replay_exempt_stream_lost" : "stream_lost_no_evidence";
@@ -6339,9 +6879,10 @@ function streamResponsesWS(model, context, options) {
       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;
+      const retain = finished && !fallback && !receiveCleanupFailed && !!options?.transportOwner && reducer.message.stopReason !== "error" && !timedOut && state.connection?.state() === "open" && !state.abort.signal.aborted && owners.get(owner) === state && state.requestGeneration === requestGeneration && state.connectionGeneration === connectionGeneration;
       if (!retain) disposeState(owner, state);
       else if (state.connection) {
+        state.anchor = candidateAnchor;
         armConnectionIdleRecycle(state, state.connection, connectionGeneration, budgets.connectionIdleTimeoutMs);
       }
       const cleanupOutcome = receiveCleanupFailed ? "cleanup_failed" : retain ? "connection_reused" : finished ? "connection_closed" : "request_abandoned";
@@ -6743,7 +7284,7 @@ function FNV1A64(byte) {
   Accumulator = Accumulator ^ Bytes[byte];
   Accumulator = Accumulator * Prime % Size;
 }
-function Hash(value) {
+function Hash2(value) {
   Accumulator = BigInt("14695981039346656037");
   Visit(value);
   return Accumulator;
@@ -6784,7 +7325,7 @@ function FromArray(schema, references, value) {
   if (schema.uniqueItems === true && !(function() {
     const set = /* @__PURE__ */ new Set();
     for (const element of value) {
-      const hashed = Hash(element);
+      const hashed = Hash2(element);
       if (set.has(hashed)) {
         return false;
       } else {
@@ -7304,7 +7845,7 @@ function* FromArray2(schema, references, path, value) {
   if (schema.uniqueItems === true && !(function() {
     const set = /* @__PURE__ */ new Set();
     for (const element of value) {
-      const hashed = Hash(element);
+      const hashed = Hash2(element);
       if (set.has(hashed)) {
         return false;
       } else {
@@ -9783,7 +10324,7 @@ __export(value_exports, {
   Encode: () => Encode,
   Equal: () => Equal,
   Errors: () => Errors,
-  Hash: () => Hash,
+  Hash: () => Hash2,
   Mutate: () => Mutate,
   Parse: () => Parse,
   Patch: () => Patch,
@@ -9889,7 +10430,7 @@ export {
   modelSupportsToolPurpose,
   sortToolModelCandidatesByCapability,
   Deref,
-  Hash,
+  Hash2 as Hash,
   Errors,
   TransformDecodeCheckError,
   TransformDecode,