@buoy-gg/agent-core 7.0.40 → 7.0.42

package/lib/module/providers/openai.js

@@ -1,323 +1,7 @@
-"use strict";
+"use strict";import{truncatedMessage as S,unparseableMessage as O}from"./sse";import{createStreamTimer as N}from"./streamTimer";import{createTransport as A}from"./transport";import{classifyProblem as J}from"./problem";function M(o,d){const e=[{role:"system",content:o}];for(const t of d){if(t.role==="user"){e.push({role:"user",content:t.text})}else if(t.role==="assistant"){e.push({role:"assistant",content:t.text||null,...t.toolCalls?.length?{tool_calls:t.toolCalls.map(i=>({id:i.id,type:"function",function:{name:i.name,arguments:JSON.stringify(i.input)}}))}:{}})}else{for(const i of t.results){e.push({role:"tool",tool_call_id:i.toolCallId,content:i.content})}}}return e}function T(o){const d=o.inputSchema.properties.action;return{...o.inputSchema,properties:{...o.inputSchema.properties,action:{...d,description:`Which action to run.
 
-/**
- * OpenAI chat-completions protocol.
- *
- * The differences from Anthropic that actually matter to the code:
- * - Tool results are their own `{role:"tool", tool_call_id, content}` MESSAGE,
- *   not blocks inside a user message.
- * - Tool arguments arrive as a JSON STRING, streamed in fragments, and are
- *   keyed by an `index` that is stable across deltas while `id`/`name` only
- *   appear on the first fragment.
- * - The stream DOES have a `data: [DONE]` sentinel, unlike Anthropic's.
- *
- * This adapter also serves Azure and any OpenAI-compatible org gateway, which
- * is the common shape for an internal LLM proxy. Note Anthropic's own
- * OpenAI-compatibility endpoint is explicitly not production-ready and silently
- * ignores several fields — use the native Anthropic adapter for Anthropic.
- *
- * THE 1024-CHAR TRAP. Azure caps a function description at 1024 chars, so
- * this adapter trims to fit. The catalog renders a tool's summary FIRST and
- * its `Actions:` list LAST, and every tool's full description is longer than
- * the cap — so trimming `t.description` silently removed every action line
- * for 23 of the 24 tools — the 24th kept one line of sixteen — measured
- * against the catalog as it is. A model on this protocol (api.openai.com, Azure,
- * OpenRouter, fal — every row of the model-floor sweep) saw a summary cut
- * mid-sentence and a bare `action` enum: no per-action summary, no
- * [DESTRUCTIVE] / [changes state] tag, no "prefer X over Y" guidance, and a
- * catalog wording change could not move its score. So the description is
- * the SUMMARY only, and the `Actions:` block goes into
- * `parameters.properties.action.description`, which nothing caps.
- */
+${o.actionsBlock}`}}}}export function createOpenAIProvider(o){const d=A(o);return{protocol:"openai",async*send(e){const t=N(e.signal,o);const i={truncated:false};try{const l={"content-type":"application/json",...await(o.headers?.()??{})};if(o.apiKey&&!l.Authorization&&!l["api-key"]){l.Authorization=`Bearer ${o.apiKey}`}const c=await d.open({headers:l,signal:t.signal,body:JSON.stringify({model:e.model,max_tokens:e.maxTokens,stream:true,stream_options:{include_usage:true},messages:M(e.systemVolatile?`${e.system}
 
-import { truncatedMessage, unparseableMessage } from "./sse";
-import { createStreamTimer } from "./streamTimer";
-import { createTransport } from "./transport";
-import { classifyProblem } from "./problem";
-function toWireMessages(system, messages) {
-  const out = [{
-    role: "system",
-    content: system
-  }];
-  for (const m of messages) {
-    if (m.role === "user") {
-      out.push({
-        role: "user",
-        content: m.text
-      });
-    } else if (m.role === "assistant") {
-      out.push({
-        role: "assistant",
-        content: m.text || null,
-        ...(m.toolCalls?.length ? {
-          tool_calls: m.toolCalls.map(c => ({
-            id: c.id,
-            type: "function",
-            function: {
-              name: c.name,
-              arguments: JSON.stringify(c.input)
-            }
-          }))
-        } : {})
-      });
-    } else {
-      // One message per result, not one message with many.
-      for (const r of m.results) {
-        out.push({
-          role: "tool",
-          tool_call_id: r.toolCallId,
-          content: r.content
-        });
-      }
-    }
-  }
-  return out;
-}
+---
 
-/**
- * The tool's input schema with the `Actions:` block on the `action`
- * property — the uncapped home for the per-action lines (header note).
- */
-function withActionsBlock(t) {
-  const action = t.inputSchema.properties.action;
-  return {
-    ...t.inputSchema,
-    properties: {
-      ...t.inputSchema.properties,
-      action: {
-        ...action,
-        description: `Which action to run.\n\n${t.actionsBlock}`
-      }
-    }
-  };
-}
-export function createOpenAIProvider(config) {
-  // One per provider, so the `auto` transport decision is made once and not
-  // re-learned (and re-buffered) at the start of every turn.
-  const transport = createTransport(config);
-  return {
-    protocol: "openai",
-    async *send(req) {
-      const timer = createStreamTimer(req.signal, config);
-      const status = {
-        truncated: false
-      };
-      try {
-        const headers = {
-          "content-type": "application/json",
-          ...(await (config.headers?.() ?? {}))
-        };
-        if (config.apiKey && !headers.Authorization && !headers["api-key"]) {
-          headers.Authorization = `Bearer ${config.apiKey}`;
-        }
-        const stream = await transport.open({
-          headers,
-          // The timer's signal, not the caller's: it aborts on the user's Stop
-          // AND on either clock running out. See providers/streamTimer.ts.
-          signal: timer.signal,
-          body: JSON.stringify({
-            model: req.model,
-            max_tokens: req.maxTokens,
-            stream: true,
-            stream_options: {
-              include_usage: true
-            },
-            messages: toWireMessages(req.systemVolatile ? `${req.system}\n\n---\n\n${req.systemVolatile}` : req.system, req.messages),
-            tools: req.tools.map(t => ({
-              type: "function",
-              function: {
-                name: t.name,
-                // Azure caps function descriptions at 1024 chars while Anthropic's
-                // guidance asks for several sentences. Trim rather than 400 — but
-                // trim the SUMMARY only: the action lines travel on `parameters`
-                // (withActionsBlock), where nothing is capped. See the header.
-                description: t.summaryDescription.slice(0, 1024),
-                parameters: withActionsBlock(t)
-              }
-            })),
-            ...config.requestOverrides
-          })
-        });
-
-        // Headers are in: the connect clock stops here and the idle one starts.
-        timer.connected();
-        if (stream.problem) {
-          yield {
-            type: "error",
-            message: stream.problem,
-            kind: "provider",
-            problem: stream.problemInfo
-          };
-          return;
-        }
-
-        // Keyed by the stream's `index`; id and name arrive only on the first
-        // fragment, arguments accumulate across all of them.
-        const pending = new Map();
-        let stopReason;
-        let usage;
-        // The served model id, from the first chunk that names one. A gateway
-        // resolves `gpt-4.1` to a dated snapshot, and that is the id a cost
-        // table or a benchmark has to attribute a drift to.
-        let model;
-        /** The `[DONE]` sentinel; ends the read. See `sawTerminal` below. */
-        let sawDone = false;
-        const flush = function* () {
-          for (const [, slot] of pending) {
-            let input = {};
-            try {
-              input = slot.args ? JSON.parse(slot.args) : {};
-            } catch {
-              yield {
-                type: "error",
-                kind: "provider",
-                // Carry the evidence. Without it this error says only THAT the
-                // arguments were bad, and diagnosing it needs a live repro of a
-                // model that may not be reachable any more — a Sonnet bench run
-                // produced 15 of these and left nothing to read. `length` here
-                // means the model was cut off mid-argument and `max_tokens` is
-                // the fix; anything else is a genuinely malformed stream.
-                message: unparseableMessage(slot.name, slot.args, stopReason)
-              };
-              continue;
-            }
-            yield {
-              type: "tool-call",
-              call: {
-                id: slot.id,
-                name: slot.name,
-                input
-              }
-            };
-          }
-          pending.clear();
-        };
-        for await (const ev of stream.frames({
-          status,
-          onFrame: timer.activity,
-          signal: timer.signal
-        })) {
-          if (ev.data === "[DONE]") {
-            sawDone = true;
-            break;
-          }
-          let payload;
-          try {
-            payload = JSON.parse(ev.data);
-          } catch {
-            continue;
-          }
-          if (payload.error) {
-            const err = payload.error;
-            const message = err.message ?? "Provider error";
-            const type = typeof err.code === "string" ? err.code : typeof err.type === "string" ? err.type : undefined;
-            yield {
-              type: "error",
-              message,
-              kind: "provider",
-              problem: classifyProblem({
-                type,
-                message
-              })
-            };
-            return;
-          }
-          if (!model && typeof payload.model === "string" && payload.model) model = payload.model;
-          const u = payload.usage;
-          if (u) {
-            // `prompt_tokens_details.cached_tokens` is this protocol's cache
-            // counter. Unlike Anthropic's it is INCLUDED in `prompt_tokens`
-            // rather than reported beside it; it is still carried as
-            // `cacheRead` so a cost table can price that slice at the
-            // discounted rate.
-            const details = u.prompt_tokens_details;
-            const cached = details?.cached_tokens;
-            usage = {
-              input: typeof u.prompt_tokens === "number" ? u.prompt_tokens : 0,
-              output: typeof u.completion_tokens === "number" ? u.completion_tokens : 0,
-              ...(typeof cached === "number" ? {
-                cacheRead: cached
-              } : {})
-            };
-          }
-          const choice = payload.choices?.[0];
-          if (!choice) continue;
-          if (choice.finish_reason) stopReason = choice.finish_reason;
-          const delta = choice.delta;
-          if (typeof delta?.content === "string" && delta.content) {
-            yield {
-              type: "text",
-              delta: delta.content
-            };
-          }
-          const calls = delta?.tool_calls;
-          for (const c of calls ?? []) {
-            const index = c.index ?? 0;
-            const fn = c.function;
-            const slot = pending.get(index) ?? {
-              id: "",
-              name: "",
-              args: ""
-            };
-            if (c.id) slot.id = c.id;
-            if (fn?.name) slot.name = fn.name;
-            if (typeof fn?.arguments === "string") slot.args += fn.arguments;
-            pending.set(index, slot);
-          }
-        }
-
-        /**
-         * Did the provider actually say it was finished?
-         *
-         * `[DONE]` is the transport sentinel. `finish_reason` counts too, and is
-         * the stronger claim: it is the model's own statement of why it stopped,
-         * while `[DONE]` only says the SSE stream closed. Plenty of
-         * OpenAI-compatible gateways send one and not the other, and refusing
-         * either shape would break working endpoints for no safety gain. NEITHER
-         * arriving is the case that matters — bare EOF, which used to be read as
-         * success, and which is how a complete-looking `storage.setItem` came out
-         * of a cut connection and ran.
-         */
-        const sawTerminal = sawDone || stopReason !== undefined;
-        if (!sawTerminal) {
-          // Nothing is flushed: the accumulated arguments may be a whole JSON
-          // object and still be half a plan. Text already yielded stays on
-          // screen; the engine shows it and offers Continue.
-          yield {
-            type: "error",
-            message: truncatedMessage(status.truncated),
-            kind: "truncated"
-          };
-          return;
-        }
-        yield* flush();
-        yield {
-          type: "done",
-          outcome: stopReason === "length" ? "output-limited" : "completed",
-          stopReason,
-          usage,
-          model
-        };
-      } catch (err) {
-        // The user's Stop wins the label even if a clock fired in the same
-        // tick: they know why the turn ended, and "timed out" would be a lie.
-        if (req.signal?.aborted) throw err;
-        const message = timer.message();
-        if (message) {
-          yield {
-            type: "error",
-            message,
-            kind: "timeout"
-          };
-          return;
-        }
-        // A genuine transport failure — DNS, refused connection, TLS. It has
-        // always propagated to the failed-turn card, and still does.
-        throw err;
-      } finally {
-        timer.dispose();
-      }
-    }
-  };
-}
-//# sourceMappingURL=openai.js.map
+${e.systemVolatile}`:e.system,e.messages),tools:e.tools.map(n=>({type:"function",function:{name:n.name,description:n.summaryDescription.slice(0,1024),parameters:T(n)}})),...o.requestOverrides})});t.connected();if(c.problem){yield{type:"error",message:c.problem,kind:"provider",problem:c.problemInfo};return}const f=new Map;let u;let _;let k;let b=false;const w=function*(){for(const[,n]of f){let r={};try{r=n.args?JSON.parse(n.args):{}}catch{yield{type:"error",kind:"provider",message:O(n.name,n.args,u)};continue}yield{type:"tool-call",call:{id:n.id,name:n.name,input:r}}}f.clear()};for await(const n of c.frames({status:i,onFrame:t.activity,signal:t.signal})){if(n.data==="[DONE]"){b=true;break}let r;try{r=JSON.parse(n.data)}catch{continue}if(r.error){const s=r.error;const a=s.message??"Provider error";const m=typeof s.code==="string"?s.code:typeof s.type==="string"?s.type:void 0;yield{type:"error",message:a,kind:"provider",problem:J({type:m,message:a})};return}if(!k&&typeof r.model==="string"&&r.model)k=r.model;const p=r.usage;if(p){const s=p.prompt_tokens_details;const a=s?.cached_tokens;_={input:typeof p.prompt_tokens==="number"?p.prompt_tokens:0,output:typeof p.completion_tokens==="number"?p.completion_tokens:0,...typeof a==="number"?{cacheRead:a}:{}}}const y=r.choices?.[0];if(!y)continue;if(y.finish_reason)u=y.finish_reason;const g=y.delta;if(typeof g?.content==="string"&&g.content){yield{type:"text",delta:g.content}}const x=g?.tool_calls;for(const s of x??[]){const a=s.index??0;const m=s.function;const h=f.get(a)??{id:"",name:"",args:""};if(s.id)h.id=s.id;if(m?.name)h.name=m.name;if(typeof m?.arguments==="string")h.args+=m.arguments;f.set(a,h)}}const v=b||u!==void 0;if(!v){yield{type:"error",message:S(i.truncated),kind:"truncated"};return}yield*w();yield{type:"done",outcome:u==="length"?"output-limited":"completed",stopReason:u,usage:_,model:k}}catch(l){if(e.signal?.aborted)throw l;const c=t.message();if(c){yield{type:"error",message:c,kind:"timeout"};return}throw l}finally{t.dispose()}}}}

package/lib/module/providers/problem.js

@@ -1,92 +1 @@
-"use strict";
-
-/**
- * What kind of failure a provider reported — decided once, from the status,
- * the error type and the message, so the engine can act on the KIND rather
- * than grep a string.
- *
- * Only two kinds are acted on, and both only when nothing has been generated:
- *
- * - `throttled` — 429 / 529 / 503, a `rate_limit_error` or `overloaded_error`
- *   frame, or a body that says so. Waiting and asking again is the right move;
- *   the request never reached a model.
- * - `overflow` — the provider refused the request as too big. Trimming older
- *   history and asking once more is the right move; the proactive budget is
- *   an estimate (chars ÷ 4) and JSON tokenizes worse than prose.
- *
- * Everything else — auth, a bad schema, an unknown model, a mid-answer
- * `api_error` — is reported and NOT retried. The phrase lists are the union
- * observed across provider responses by the Strands SDK (harness-sdk
- * `381ab48`, `models/anthropic.ts` + `models/openai/errors.ts`, Apache-2.0),
- * matched case-insensitively on the lowered message.
- */
-
-const THROTTLE_STATUSES = new Set([429, 503, 529]);
-const AUTH_STATUSES = new Set([401, 403]);
-
-/** Provider error `type` values (Anthropic frames, OpenAI `error.type` / `code`). */
-const THROTTLE_TYPES = new Set(["overloaded_error", "rate_limit_error", "rate_limit_exceeded", "insufficient_quota", "server_overloaded"]);
-const AUTH_TYPES = new Set(["authentication_error", "permission_error", "invalid_api_key"]);
-const OVERFLOW_TYPES = new Set(["request_too_large", "context_length_exceeded"]);
-const THROTTLE_PHRASES = ["rate_limit_exceeded", "rate limit", "too many requests", "overloaded", "capacity", "try again later"];
-const OVERFLOW_PHRASES = [
-// Anthropic
-"prompt is too long", "input too long", "input is too long", "input length exceeds context window", "input and output tokens exceed your context limit",
-// OpenAI and compatible gateways
-"maximum context length", "context_length_exceeded", "too many tokens", "context length", "input is too long for requested model", "input length and `max_tokens` exceed context limit", "too many total text bytes", "exceed customer model maximum"];
-export function classifyProblem(input) {
-  const lowered = input.message.toLowerCase();
-  const type = input.type?.toLowerCase();
-  const retryAfterMs = parseRetryAfter(input.retryAfter);
-  const withStatus = kind => ({
-    kind,
-    ...(input.status !== undefined ? {
-      status: input.status
-    } : {}),
-    ...(retryAfterMs !== undefined ? {
-      retryAfterMs
-    } : {})
-  });
-  if (input.status !== undefined && AUTH_STATUSES.has(input.status)) return withStatus("auth");
-  if (type && AUTH_TYPES.has(type)) return withStatus("auth");
-  if (input.status !== undefined && THROTTLE_STATUSES.has(input.status)) return withStatus("throttled");
-  if (type && THROTTLE_TYPES.has(type)) return withStatus("throttled");
-  if (type && OVERFLOW_TYPES.has(type)) return withStatus("overflow");
-  // Overflow before throttling on phrases: "context length" is more specific
-  // than "capacity", and a 400 that says both is about the size.
-  if (OVERFLOW_PHRASES.some(p => lowered.includes(p))) return withStatus("overflow");
-  if (THROTTLE_PHRASES.some(p => lowered.includes(p))) return withStatus("throttled");
-  return withStatus("other");
-}
-
-/**
- * `Retry-After` is either delay-seconds or an HTTP-date. Anything unparseable
- * or in the past is undefined, so the caller falls back to its own backoff.
- */
-export function parseRetryAfter(value) {
-  if (!value) return undefined;
-  const trimmed = value.trim();
-  if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1000;
-  const at = Date.parse(trimmed);
-  if (Number.isNaN(at)) return undefined;
-  const ms = at - Date.now();
-  return ms > 0 ? ms : undefined;
-}
-
-/**
- * Pull the provider's error `type` out of an error body, for the HTTP path
- * where the body is JSON like `{"error":{"type":"overloaded_error",…}}` or
- * `{"error":{"code":"context_length_exceeded",…}}`. Returns undefined for
- * anything that is not that shape; the message phrases still apply.
- */
-export function errorTypeOf(body) {
-  try {
-    const parsed = JSON.parse(body);
-    const err = typeof parsed.error === "object" && parsed.error ? parsed.error : undefined;
-    const type = err?.type ?? err?.code ?? parsed.type;
-    return typeof type === "string" ? type : undefined;
-  } catch {
-    return undefined;
-  }
-}
-//# sourceMappingURL=problem.js.map
+"use strict";import{realNow as i}from"../realNow";const d=new Set([429,503,529]);const a=new Set([401,403]);const u=new Set(["overloaded_error","rate_limit_error","rate_limit_exceeded","insufficient_quota","server_overloaded"]);const c=new Set(["authentication_error","permission_error","invalid_api_key"]);const f=new Set(["request_too_large","context_length_exceeded"]);const l=["rate_limit_exceeded","rate limit","too many requests","overloaded","capacity","try again later"];const m=["prompt is too long","input too long","input is too long","input length exceeds context window","input and output tokens exceed your context limit","maximum context length","context_length_exceeded","too many tokens","context length","input is too long for requested model","input length and `max_tokens` exceed context limit","too many total text bytes","exceed customer model maximum"];export function classifyProblem(e){const r=e.message.toLowerCase();const t=e.type?.toLowerCase();const o=parseRetryAfter(e.retryAfter);const n=s=>({kind:s,...e.status!==void 0?{status:e.status}:{},...o!==void 0?{retryAfterMs:o}:{}});if(e.status!==void 0&&a.has(e.status))return n("auth");if(t&&c.has(t))return n("auth");if(e.status!==void 0&&d.has(e.status))return n("throttled");if(t&&u.has(t))return n("throttled");if(t&&f.has(t))return n("overflow");if(m.some(s=>r.includes(s)))return n("overflow");if(l.some(s=>r.includes(s)))return n("throttled");return n("other")}export function parseRetryAfter(e){if(!e)return void 0;const r=e.trim();if(/^\d+$/.test(r))return Number(r)*1e3;const t=Date.parse(r);if(Number.isNaN(t))return void 0;const o=t-i();return o>0?o:void 0}export function errorTypeOf(e){try{const r=JSON.parse(e);const t=typeof r.error==="object"&&r.error?r.error:void 0;const o=t?.type??t?.code??r.type;return typeof o==="string"?o:void 0}catch{return void 0}}

package/lib/module/providers/sse.js

@@ -1,231 +1 @@
-"use strict";
-
-/**
- * SSE reading, with the React Native reality baked in.
- *
- * RN's built-in `fetch` does not implement `response.body`. Under Expo you get
- * a real `ReadableStream` because `expo/fetch` is the global — but
- * `EXPO_PUBLIC_USE_RN_FETCH=1` reverts that, and the bare-RN, NativeScript and
- * TV-CLI lanes never had it. So `readSse` degrades to reading the whole body
- * and replaying it as events rather than failing: a non-streaming answer is a
- * slower chat, while a hard failure is no chat at all.
- *
- * THE TWO PATHS MUST AGREE. They did not. The buffered path appended "\n\n" to
- * the body before parsing, which turns an unterminated final frame — the exact
- * signature of a cut connection — into a well-formed event. The streaming path
- * discarded that same frame, as the SSE spec requires. So one lane invented a
- * complete answer where the other saw a broken one. Now both discard it and
- * both RECORD it (`SseReadStatus.truncated`), because "was this reply whole?"
- * is a question the engine has to answer before it runs anything.
- */
-
-function* parseChunk(buffer, onFrame) {
-  let rest = buffer;
-  let idx;
-  // Frames are separated by a blank line. \r\n\r\n is legal too.
-  while ((idx = rest.search(/\r?\n\r?\n/)) !== -1) {
-    const raw = rest.slice(0, idx);
-    rest = rest.slice(idx + (rest[idx] === "\r" ? 4 : 2));
-    onFrame?.();
-    let event;
-    const dataLines = [];
-    for (const line of raw.split(/\r?\n/)) {
-      if (line.startsWith(":")) continue; // comment / keepalive
-      if (line.startsWith("event:")) event = line.slice(6).trim();else if (line.startsWith("data:")) dataLines.push(line.slice(5).replace(/^ /, ""));
-    }
-    if (dataLines.length) yield {
-      event,
-      data: dataLines.join("\n")
-    };
-  }
-  return rest;
-}
-
-/**
- * Drain complete frames out of `buffer`, returning what is left over.
- *
- * Shared by both paths so a framing fix can only ever be made in one place.
- */
-function* drain(buffer, out, onFrame) {
-  const gen = parseChunk(buffer, onFrame);
-  let next = gen.next();
-  while (!next.done) {
-    yield next.value;
-    next = gen.next();
-  }
-  out.rest = next.value;
-}
-
-/**
- * Turn a stream of TEXT chunks into SSE frames.
- *
- * The one place framing happens, whatever produced the bytes: a `fetch` body
- * reader, an `XMLHttpRequest` progress slice, or a whole body read at once on
- * a runtime that cannot stream. Splitting it out is what lets the XHR
- * transport exist without a second parser to keep in step with this one.
- */
-export async function* framesFrom(chunks, options = {}) {
-  const {
-    status,
-    onFrame
-  } = options;
-  const leftover = {
-    rest: ""
-  };
-  let buffer = "";
-  for await (const chunk of chunks) {
-    buffer += chunk;
-    yield* drain(buffer, leftover, onFrame);
-    buffer = leftover.rest;
-  }
-  if (status && leftover.rest.trim()) status.truncated = true;
-}
-export async function* readSse(response, options = {}) {
-  const {
-    status,
-    onFrame,
-    signal
-  } = options;
-  const body = response.body;
-  const leftover = {
-    rest: ""
-  };
-  if (!body || typeof body.getReader !== "function") {
-    // No streaming on this platform — read it all, then replay. Note there is
-    // no "\n\n" here any more: an unterminated tail is discarded exactly as
-    // the streaming path discards it (see the header).
-    const text = await response.text();
-    yield* drain(text, leftover, onFrame);
-    if (status && leftover.rest.trim()) status.truncated = true;
-    return;
-  }
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let finished = false;
-  /**
-   * One promise for the whole read, not one per chunk.
-   *
-   * It never resolves — only rejects — so racing it is free apart from the
-   * `Promise.race` allocation, and an answer of a few hundred frames pays far
-   * more for `JSON.parse` than for this.
-   */
-  const aborted = signal ? new Promise((_resolve, reject) => {
-    const fail = () => {
-      const err = new Error("Aborted");
-      err.name = "AbortError";
-      reject(err);
-    };
-    if (signal.aborted) fail();else signal.addEventListener?.("abort", fail, {
-      once: true
-    });
-  }) : undefined;
-  // Nothing awaits this until the race below, and a rejection with no handler
-  // is an unhandled rejection on some runtimes. This is the handler.
-  aborted?.catch(() => {});
-  try {
-    for (;;) {
-      const read = reader.read();
-      const {
-        done,
-        value
-      } = aborted ? await Promise.race([read, aborted]) : await read;
-      if (done) break;
-      buffer += decoder.decode(value, {
-        stream: true
-      });
-      yield* drain(buffer, leftover, onFrame);
-      buffer = leftover.rest;
-    }
-    // Flush the decoder: a multi-byte character split across the last two
-    // chunks is only completed here, and an INCOMPLETE one at EOF is itself
-    // evidence the connection was cut.
-    buffer += decoder.decode();
-    yield* drain(buffer, leftover, onFrame);
-    if (status && leftover.rest.trim()) status.truncated = true;
-    finished = true;
-  } finally {
-    if (!finished) {
-      // The consumer left early — an abort, a timeout, or a `break` in the
-      // provider. `releaseLock` alone leaves the socket open; only `cancel`
-      // tears the request down, and it must come first because cancelling a
-      // locked reader is the only way to reach the underlying stream.
-      try {
-        // Not awaited: the consumer is already leaving, and a cancel that
-        // rejects (an errored stream) must not become an unhandled rejection.
-        void Promise.resolve(reader.cancel()).catch(() => {});
-      } catch {
-        /* already cancelled or errored */
-      }
-    }
-    try {
-      reader.releaseLock();
-    } catch {
-      /* already released */
-    }
-  }
-}
-
-/**
- * A 200 that is not a stream at all.
- *
- * Gateways in front of a model do this: an auth proxy that has lost its
- * upstream serves an HTML error page, a misrouted path serves an SPA shell,
- * and a gateway that ignored `stream: true` serves one JSON object. Every one
- * of those parses to zero SSE frames, so the old code read it as a model that
- * had nothing to say and ended the turn with a blank bubble.
- *
- * Returns a message when the body should be treated as an error, and undefined
- * when it looks like something the SSE reader can work with. Consumes the body
- * only in the failing case.
- */
-export async function nonStreamProblem(response) {
-  const type = response.headers?.get?.("content-type") ?? "";
-  if (!type) return undefined; // No header to judge by — let the parser try.
-  const lowered = type.toLowerCase();
-  if (lowered.includes("event-stream")) return undefined;
-  // A JSON body is either a non-streaming reply or a structured error; both
-  // are worth reporting with their own text rather than guessing.
-  const detail = (await response.text().catch(() => "")).slice(0, 600);
-  if (lowered.includes("json")) {
-    return `The endpoint answered with JSON instead of a stream — it may not support "stream": true.${detail ? ` — ${detail}` : ""}`;
-  }
-  return `The endpoint answered with ${type} instead of an event stream.${detail ? ` — ${detail}` : ""}`;
-}
-
-/**
- * Body text for a failed response, trimmed to something a user can read.
- * The detail alone — the transport prefixes the status and classifies it.
- */
-export async function errorBody(response) {
-  try {
-    return (await response.text()).slice(0, 600);
-  } catch {
-    return ""; // body already consumed or unreadable
-  }
-}
-
-/**
- * The message for a stream that stopped before the provider said it was done.
- *
- * `truncated` distinguishes the two shapes: cut mid-frame (a dropped
- * connection) versus a clean frame boundary with no terminal marker (a gateway
- * that closes the socket instead of sending one). The second is a
- * compatibility problem worth naming, because retrying it will not help.
- */
-export function truncatedMessage(truncated) {
-  return truncated ? "The connection dropped before the answer finished." : "The endpoint closed the stream without saying the answer was finished.";
-}
-
-/**
- * The message for arguments that would not parse, with enough in it to act on.
- * `stopReason` "length" is the common cause — a reasoning model spends its
- * budget thinking and the tool call is truncated mid-JSON — and the tail of
- * the raw arguments says immediately whether that is what happened.
- */
-export function unparseableMessage(name, args, stopReason) {
-  const truncated = stopReason === "length";
-  const tail = args.length > 160 ? `…${args.slice(-160)}` : args;
-  return `Model sent unparseable arguments for ${name}` + (truncated ? " (cut off at max_tokens — raise it or reduce thinking budget)" : "") + ` [stop: ${stopReason ?? "none"}, ${args.length} chars] ${tail}`;
-}
-//# sourceMappingURL=sse.js.map
+"use strict";function*p(n,r){let e=n;let t;while((t=e.search(/\r?\n\r?\n/))!==-1){const s=e.slice(0,t);e=e.slice(t+(e[t]==="\r"?4:2));r?.();let a;const o=[];for(const i of s.split(/\r?\n/)){if(i.startsWith(":"))continue;if(i.startsWith("event:"))a=i.slice(6).trim();else if(i.startsWith("data:"))o.push(i.slice(5).replace(/^ /,""))}if(o.length)yield{event:a,data:o.join("\n")}}return e}function*l(n,r,e){const t=p(n,e);let s=t.next();while(!s.done){yield s.value;s=t.next()}r.rest=s.value}export async function*framesFrom(n,r={}){const{status:e,onFrame:t}=r;const s={rest:""};let a="";for await(const o of n){a+=o;yield*l(a,s,t);a=s.rest}if(e&&s.rest.trim())e.truncated=true}export async function*readSse(n,r={}){const{status:e,onFrame:t,signal:s}=r;const a=n.body;const o={rest:""};if(!a||typeof a.getReader!=="function"){const d=await n.text();yield*l(d,o,t);if(e&&o.rest.trim())e.truncated=true;return}const i=a.getReader();const m=new TextDecoder;let c="";let y=false;const f=s?new Promise((d,h)=>{const u=()=>{const w=new Error("Aborted");w.name="AbortError";h(w)};if(s.aborted)u();else s.addEventListener?.("abort",u,{once:true})}):void 0;f?.catch(()=>{});try{for(;;){const d=i.read();const{done:h,value:u}=f?await Promise.race([d,f]):await d;if(h)break;c+=m.decode(u,{stream:true});yield*l(c,o,t);c=o.rest}c+=m.decode();yield*l(c,o,t);if(e&&o.rest.trim())e.truncated=true;y=true}finally{if(!y){try{void Promise.resolve(i.cancel()).catch(()=>{})}catch{}}try{i.releaseLock()}catch{}}}export async function nonStreamProblem(n){const r=n.headers?.get?.("content-type")??"";if(!r)return void 0;const e=r.toLowerCase();if(e.includes("event-stream"))return void 0;const t=(await n.text().catch(()=>"")).slice(0,600);if(e.includes("json")){return`The endpoint answered with JSON instead of a stream \u2014 it may not support "stream": true.${t?` \u2014 ${t}`:""}`}return`The endpoint answered with ${r} instead of an event stream.${t?` \u2014 ${t}`:""}`}export async function errorBody(n){try{return(await n.text()).slice(0,600)}catch{return""}}export function truncatedMessage(n){return n?"The connection dropped before the answer finished.":"The endpoint closed the stream without saying the answer was finished."}export function unparseableMessage(n,r,e){const t=e==="length";const s=r.length>160?`\u2026${r.slice(-160)}`:r;return`Model sent unparseable arguments for ${n}`+(t?" (cut off at max_tokens \u2014 raise it or reduce thinking budget)":"")+` [stop: ${e??"none"}, ${r.length} chars] ${s}`}