@buoy-gg/agent-core 7.0.41 → 7.0.43

package/lib/module/providers/streamTimer.js

@@ -1,118 +1 @@
-"use strict";
-
-/**
- * The clock on a model request.
- *
- * There was none. A gateway that accepted the socket and then said nothing —
- * an overloaded proxy, a dropped VPN, a laptop that slept mid-answer — left
- * the turn running with the thinking strip animating until a person pressed
- * Stop. The 180s turn deadline did not help: it is read at the TOP of a step
- * (`runAgentTurn`), and a step parked inside `await fetch(...)` never reaches
- * the next one.
- *
- * Two clocks, because the two silences mean different things:
- *
- * - CONNECT covers "no headers yet". Nothing has been generated, so nothing is
- *   lost by giving up; 30s is already long for a gateway to acknowledge a POST.
- * - IDLE covers "headers arrived, then nothing". This one has to be generous.
- *   Anthropic sends `ping` frames, but an OpenAI-protocol reasoning model can
- *   legitimately emit nothing for a long stretch while it thinks, and cutting
- *   that off would look like a broken product. Any frame at all — a keepalive
- *   comment included — resets it, so only total silence trips it.
- *
- * A timeout is NOT a retry. Nothing is re-sent: the request may have reached
- * the model, and a duplicate turn is a duplicate bill and possibly duplicate
- * writes. The turn ends with an honest notice and a Continue button.
- */
-
-export const DEFAULT_CONNECT_TIMEOUT_MS = 30_000;
-export const DEFAULT_IDLE_TIMEOUT_MS = 90_000;
-/**
- * A timer over an optional caller signal.
- *
- * When no `AbortController` exists (a runtime old enough to lack it) this
- * degrades to passing the caller's signal straight through with no clocks,
- * rather than failing to send anything at all.
- */
-export function createStreamTimer(callerSignal, options = {}) {
-  const connectMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
-  const idleMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-  const Controller = typeof AbortController === "function" ? AbortController : undefined;
-  if (!Controller) {
-    return {
-      signal: callerSignal,
-      connected() {},
-      activity() {},
-      expired: undefined,
-      message: () => undefined,
-      dispose() {}
-    };
-  }
-  const controller = new Controller();
-  let expired;
-  let handle;
-  let disposed = false;
-  const clear = () => {
-    if (handle !== undefined) {
-      clearTimeout(handle);
-      handle = undefined;
-    }
-  };
-  const arm = (ms, which) => {
-    clear();
-    if (disposed || !Number.isFinite(ms) || ms <= 0) return;
-    handle = setTimeout(() => {
-      handle = undefined;
-      expired = which;
-      // The abort is what actually unblocks `fetch` / `reader.read()`. The
-      // reason is tracked here rather than read back off the signal because
-      // `AbortSignal.reason` is not reliably present on React Native.
-      try {
-        controller.abort();
-      } catch {
-        /* already aborted */
-      }
-    }, ms);
-  };
-  const onCallerAbort = () => {
-    clear();
-    try {
-      controller.abort();
-    } catch {
-      /* already aborted */
-    }
-  };
-  if (callerSignal) {
-    if (callerSignal.aborted) onCallerAbort();else callerSignal.addEventListener?.("abort", onCallerAbort);
-  }
-  arm(connectMs, "connect");
-  return {
-    signal: controller.signal,
-    connected() {
-      arm(idleMs, "idle");
-    },
-    activity() {
-      // Only rearm a clock that is already running: a provider that reports
-      // activity after `dispose` must not resurrect the timer.
-      if (!disposed) arm(idleMs, "idle");
-    },
-    get expired() {
-      return expired;
-    },
-    message() {
-      if (expired === "connect") {
-        return `The model endpoint did not respond within ${Math.round(connectMs / 1000)}s. Nothing was generated, and nothing was re-sent.`;
-      }
-      if (expired === "idle") {
-        return `The model endpoint stopped sending after ${Math.round(idleMs / 1000)}s of silence. Whatever arrived is above; nothing was re-sent.`;
-      }
-      return undefined;
-    },
-    dispose() {
-      disposed = true;
-      clear();
-      callerSignal?.removeEventListener?.("abort", onCallerAbort);
-    }
-  };
-}
-//# sourceMappingURL=streamTimer.js.map
+"use strict";import{realClearTimeout as T,realSetTimeout as m}from"../realNow";export const DEFAULT_CONNECT_TIMEOUT_MS=3e4;export const DEFAULT_IDLE_TIMEOUT_MS=9e4;export function createStreamTimer(e,u={}){const f=u.connectTimeoutMs??DEFAULT_CONNECT_TIMEOUT_MS;const r=u.idleTimeoutMs??DEFAULT_IDLE_TIMEOUT_MS;const l=typeof AbortController==="function"?AbortController:void 0;if(!l){return{signal:e,connected(){},activity(){},expired:void 0,message:()=>void 0,dispose(){}}}const o=new l;let n;let t;let i=false;const d=()=>{if(t!==void 0){T(t);t=void 0}};const s=(a,p)=>{d();if(i||!Number.isFinite(a)||a<=0)return;t=m(()=>{t=void 0;n=p;try{o.abort()}catch{}},a)};const c=()=>{d();try{o.abort()}catch{}};if(e){if(e.aborted)c();else e.addEventListener?.("abort",c)}s(f,"connect");return{signal:o.signal,connected(){s(r,"idle")},activity(){if(!i)s(r,"idle")},get expired(){return n},message(){if(n==="connect"){return`The model endpoint did not respond within ${Math.round(f/1e3)}s. Nothing was generated, and nothing was re-sent.`}if(n==="idle"){return`The model endpoint stopped sending after ${Math.round(r/1e3)}s of silence. Whatever arrived is above; nothing was re-sent.`}return void 0},dispose(){i=true;d();e?.removeEventListener?.("abort",c)}}}

package/lib/module/providers/transport.js

@@ -1,119 +1 @@
-"use strict";
-
-/**
- * How a request is SENT, decided before it is sent.
- *
- * The obvious place to add XHR was inside `readSse`, once a missing
- * `response.body` had already proved that `fetch` could not stream. That is
- * the wrong boundary and would have been a real bug: the POST has already
- * happened by then, the reader has neither the URL nor the headers nor the
- * body to repeat it, and issuing a second one would ask the model to generate
- * the same answer twice — billed twice, and for a turn that writes, acted on
- * twice. Transport is chosen up front; a response that has started is consumed
- * exactly once, whatever it turns out to be.
- *
- * `auto` therefore learns rather than probes. The first request goes through
- * `fetch`; if that response has no reader, the answer is buffered (as it
- * always was on that runtime) and the SESSION remembers, so every later
- * request uses XHR and streams. One buffered reply at the start of a bare-RN
- * session, and nothing to configure.
- */
-
-import { errorBody, nonStreamProblem, readSse } from "./sse";
-import { xhrAvailable, xhrStream } from "./xhrStream";
-import { classifyProblem, errorTypeOf } from "./problem";
-const EMPTY = async function* () {};
-
-/**
- * One transport per provider instance, because the `auto` decision is worth
- * remembering: re-learning it would buffer the first reply of every turn.
- */
-export function createTransport(config) {
-  const requested = config.transport ?? "auto";
-  /**
-   * Set once a `fetch` response has come back with no reader. Only ever
-   * flipped one way: a runtime does not gain streaming mid-session.
-   */
-  let fetchCannotStream = false;
-  const useXhr = () => {
-    // A host-supplied `fetch` is never bypassed. It is how a harness keeps
-    // model traffic off the global (and out of the network interceptor), and
-    // routing around it would defeat the reason it was passed in.
-    if (config.fetch) return requested === "xhr" && xhrAvailable();
-    if (requested === "xhr") return xhrAvailable();
-    if (requested === "fetch") return false;
-    return fetchCannotStream && xhrAvailable();
-  };
-  return {
-    async open(req) {
-      if (useXhr()) {
-        const response = await xhrStream({
-          url: config.endpoint,
-          headers: req.headers,
-          body: req.body,
-          signal: req.signal
-        });
-        if (!response.ok) {
-          const detail = (await response.text()).slice(0, 600);
-          return {
-            problem: `HTTP ${response.status}${detail ? ` — ${detail}` : ""}`,
-            problemInfo: classifyProblem({
-              status: response.status,
-              type: errorTypeOf(detail),
-              message: detail,
-              retryAfter: response.retryAfter
-            }),
-            frames: EMPTY
-          };
-        }
-        const type = response.contentType.toLowerCase();
-        if (type && !type.includes("event-stream")) {
-          const detail = (await response.text()).slice(0, 600);
-          return {
-            problem: type.includes("json") ? `The endpoint answered with JSON instead of a stream — it may not support "stream": true.${detail ? ` — ${detail}` : ""}` : `The endpoint answered with ${response.contentType} instead of an event stream.${detail ? ` — ${detail}` : ""}`,
-            frames: EMPTY
-          };
-        }
-        return {
-          frames: options => response.frames(options)
-        };
-      }
-      const response = await (config.fetch ?? fetch)(config.endpoint, {
-        method: "POST",
-        headers: req.headers,
-        signal: req.signal,
-        body: req.body
-      });
-      if (!response.ok) {
-        const detail = await errorBody(response);
-        return {
-          problem: `HTTP ${response.status}${detail ? ` — ${detail}` : ""}`,
-          problemInfo: classifyProblem({
-            status: response.status,
-            type: errorTypeOf(detail),
-            message: detail,
-            retryAfter: response.headers?.get?.("retry-after") ?? null
-          }),
-          frames: EMPTY
-        };
-      }
-      const problem = await nonStreamProblem(response);
-      if (problem) return {
-        problem,
-        frames: EMPTY
-      };
-
-      // Learn, for the NEXT request. This one is already in flight and is read
-      // through the buffered path — re-sending it is what this file exists to
-      // avoid.
-      const body = response.body;
-      if ((!body || typeof body.getReader !== "function") && !config.fetch) {
-        fetchCannotStream = true;
-      }
-      return {
-        frames: options => readSse(response, options)
-      };
-    }
-  };
-}
-//# sourceMappingURL=transport.js.map
+"use strict";import{errorBody as y,nonStreamProblem as h,readSse as b}from"./sse";import{xhrAvailable as f,xhrStream as T}from"./xhrStream";import{classifyProblem as l,errorTypeOf as p}from"./problem";const n=async function*(){};export function createTransport(s){const o=s.transport??"auto";let m=false;const c=()=>{if(s.fetch)return o==="xhr"&&f();if(o==="xhr")return f();if(o==="fetch")return false;return m&&f()};return{async open(a){if(c()){const e=await T({url:s.endpoint,headers:a.headers,body:a.body,signal:a.signal});if(!e.ok){const t=(await e.text()).slice(0,600);return{problem:`HTTP ${e.status}${t?` \u2014 ${t}`:""}`,problemInfo:l({status:e.status,type:p(t),message:t,retryAfter:e.retryAfter}),frames:n}}const i=e.contentType.toLowerCase();if(i&&!i.includes("event-stream")){const t=(await e.text()).slice(0,600);return{problem:i.includes("json")?`The endpoint answered with JSON instead of a stream \u2014 it may not support "stream": true.${t?` \u2014 ${t}`:""}`:`The endpoint answered with ${e.contentType} instead of an event stream.${t?` \u2014 ${t}`:""}`,frames:n}}return{frames:t=>e.frames(t)}}const r=await(s.fetch??fetch)(s.endpoint,{method:"POST",headers:a.headers,signal:a.signal,body:a.body});if(!r.ok){const e=await y(r);return{problem:`HTTP ${r.status}${e?` \u2014 ${e}`:""}`,problemInfo:l({status:r.status,type:p(e),message:e,retryAfter:r.headers?.get?.("retry-after")??null}),frames:n}}const u=await h(r);if(u)return{problem:u,frames:n};const d=r.body;if((!d||typeof d.getReader!=="function")&&!s.fetch){m=true}return{frames:e=>b(r,e)}}}}

package/lib/module/providers/types.js

@@ -1,4 +1 @@
-"use strict";
-
-export {};
-//# sourceMappingURL=types.js.map
+"use strict";export{};

package/lib/module/providers/xhrStream.js

@@ -1,207 +1 @@
-"use strict";
-
-/**
- * Streaming over `XMLHttpRequest`, for the runtimes where `fetch` cannot.
- *
- * React Native core still has no `response.body`: its `fetch` is the whatwg
- * polyfill over XHR and resolves inside `xhr.onload`, i.e. after the ENTIRE
- * body. Under Expo the global is `expo/fetch`, which does stream — but
- * `EXPO_PUBLIC_USE_RN_FETCH=1` reverts that, and the bare-RN CLI, TV CLI and
- * NativeScript lanes never had it at all. On those, every Ask Buoy answer
- * appeared in one lump, however long the model took.
- *
- * XHR itself has streamed the whole time. `responseText` grows as bytes arrive
- * and `onprogress` fires as it does, so slicing from the last offset gives the
- * same incremental text a reader would. Two conditions, both easy to miss:
- * the progress handler must be installed BEFORE `send()`, and `responseType`
- * must stay text — anything else stops RN emitting progress at all.
- *
- * WHAT THIS IS NOT. It is not a second SSE parser: framing, the truncation
- * rule and the terminal-marker contract all live in `sse.ts` and are shared
- * verbatim. This file only produces text chunks.
- */
-import { framesFrom } from "./sse";
-
-/** Beyond this the answer is not an answer any more; stop reading. */
-const MAX_RESPONSE_CHARS = 8_000_000;
-export function xhrAvailable() {
-  return typeof XMLHttpRequest === "function";
-}
-
-/**
- * Send the request and resolve once the HEADERS are in, so the caller can
- * check the status and content type before deciding to read a stream — the
- * same shape `fetch` offers, and the reason this can slot in beside it.
- */
-export function xhrStream(req) {
-  return new Promise((resolveHeaders, rejectHeaders) => {
-    const xhr = new XMLHttpRequest();
-
-    /** Text seen but not yet handed to a consumer. */
-    const queue = [];
-    /** Resolvers for a consumer parked on an empty queue. */
-    const waiters = [];
-    let offset = 0;
-    let done = false;
-    let failure;
-    let headersSeen = false;
-    let capped = false;
-    const wake = () => {
-      while (waiters.length) waiters.shift()();
-    };
-    const pull = () => {
-      // `responseText` is the WHOLE body so far, so the delta is everything
-      // past what was already taken. RN keeps the full string either way;
-      // the offset bounds the work, not the memory.
-      let text;
-      try {
-        text = xhr.responseText ?? "";
-      } catch {
-        return; // Not readable yet on some runtimes; the next event will do.
-      }
-      if (text.length <= offset) return;
-      if (text.length > MAX_RESPONSE_CHARS) {
-        capped = true;
-        failure = new Error("The endpoint sent more than this tool will read.");
-        done = true;
-        try {
-          xhr.abort();
-        } catch {
-          /* already gone */
-        }
-        wake();
-        return;
-      }
-      queue.push(text.slice(offset));
-      offset = text.length;
-      wake();
-    };
-    const settleHeaders = () => {
-      if (headersSeen) return;
-      headersSeen = true;
-      let contentType = "";
-      let retryAfter = null;
-      try {
-        contentType = xhr.getResponseHeader("content-type") ?? "";
-        retryAfter = xhr.getResponseHeader("retry-after");
-      } catch {
-        contentType = "";
-      }
-      resolveHeaders({
-        status: xhr.status,
-        ok: xhr.status >= 200 && xhr.status < 300,
-        contentType,
-        retryAfter,
-        async text() {
-          // Whatever has arrived. For a non-2xx that is the error body; the
-          // request is over by the time anyone asks.
-          await new Promise(r => {
-            if (done) return r();
-            waiters.push(() => r());
-          });
-          try {
-            return xhr.responseText ?? "";
-          } catch {
-            return "";
-          }
-        },
-        frames(options) {
-          return framesFrom(chunks(), options);
-        }
-      });
-    };
-    async function* chunks() {
-      try {
-        for (;;) {
-          while (queue.length) yield queue.shift();
-          if (done) break;
-          await new Promise(r => waiters.push(r));
-        }
-        while (queue.length) yield queue.shift();
-        if (failure) throw failure;
-      } finally {
-        if (!done) {
-          // The consumer left early — a completed turn, a Stop, a timeout.
-          // Nothing else will read this socket.
-          try {
-            xhr.abort();
-          } catch {
-            /* already gone */
-          }
-        }
-      }
-    }
-    const onAbort = () => {
-      try {
-        xhr.abort();
-      } catch {
-        /* already gone */
-      }
-    };
-    xhr.onreadystatechange = () => {
-      // HEADERS_RECEIVED. Status and content type are known here, long before
-      // the body finishes — which is the whole point of using XHR directly.
-      if (xhr.readyState === 2) settleHeaders();
-    };
-    xhr.onprogress = () => {
-      settleHeaders();
-      pull();
-    };
-    xhr.onload = () => {
-      settleHeaders();
-      if (!capped) pull();
-      done = true;
-      wake();
-    };
-    xhr.onerror = () => {
-      failure = new Error("The request failed before it finished.");
-      done = true;
-      if (!headersSeen) {
-        headersSeen = true;
-        rejectHeaders(failure);
-      }
-      wake();
-    };
-    xhr.onabort = () => {
-      const err = new Error("Aborted");
-      err.name = "AbortError";
-      failure = err;
-      done = true;
-      if (!headersSeen) {
-        headersSeen = true;
-        rejectHeaders(err);
-      }
-      wake();
-    };
-    xhr.ontimeout = () => {
-      failure = new Error("The request timed out.");
-      done = true;
-      if (!headersSeen) {
-        headersSeen = true;
-        rejectHeaders(failure);
-      }
-      wake();
-    };
-    try {
-      xhr.open("POST", req.url, true);
-      // Text, and nothing else: RN emits no progress events for any other
-      // response type, which turns this back into a buffered read in silence.
-      xhr.responseType = "text";
-      for (const [k, v] of Object.entries(req.headers)) {
-        try {
-          xhr.setRequestHeader(k, v);
-        } catch {
-          /* a header the runtime forbids is not worth failing the turn over */
-        }
-      }
-      if (req.signal) {
-        if (req.signal.aborted) onAbort();else req.signal.addEventListener?.("abort", onAbort);
-      }
-      xhr.send(req.body);
-    } catch (err) {
-      headersSeen = true;
-      rejectHeaders(err instanceof Error ? err : new Error(String(err)));
-    }
-  });
-}
-//# sourceMappingURL=xhrStream.js.map
+"use strict";import{framesFrom as m}from"./sse";const x=8e6;export function xhrAvailable(){return typeof XMLHttpRequest==="function"}export function xhrStream(s){return new Promise((b,u)=>{const t=new XMLHttpRequest;const i=[];const l=[];let h=0;let n=false;let o;let r=false;let y=false;const a=()=>{while(l.length)l.shift()()};const d=()=>{let e;try{e=t.responseText??""}catch{return}if(e.length<=h)return;if(e.length>x){y=true;o=new Error("The endpoint sent more than this tool will read.");n=true;try{t.abort()}catch{}a();return}i.push(e.slice(h));h=e.length;a()};const p=()=>{if(r)return;r=true;let e="";let f=null;try{e=t.getResponseHeader("content-type")??"";f=t.getResponseHeader("retry-after")}catch{e=""}b({status:t.status,ok:t.status>=200&&t.status<300,contentType:e,retryAfter:f,async text(){await new Promise(c=>{if(n)return c();l.push(()=>c())});try{return t.responseText??""}catch{return""}},frames(c){return m(g(),c)}})};async function*g(){try{for(;;){while(i.length)yield i.shift();if(n)break;await new Promise(e=>l.push(e))}while(i.length)yield i.shift();if(o)throw o}finally{if(!n){try{t.abort()}catch{}}}}const w=()=>{try{t.abort()}catch{}};t.onreadystatechange=()=>{if(t.readyState===2)p()};t.onprogress=()=>{p();d()};t.onload=()=>{p();if(!y)d();n=true;a()};t.onerror=()=>{o=new Error("The request failed before it finished.");n=true;if(!r){r=true;u(o)}a()};t.onabort=()=>{const e=new Error("Aborted");e.name="AbortError";o=e;n=true;if(!r){r=true;u(e)}a()};t.ontimeout=()=>{o=new Error("The request timed out.");n=true;if(!r){r=true;u(o)}a()};try{t.open("POST",s.url,true);t.responseType="text";for(const[e,f]of Object.entries(s.headers)){try{t.setRequestHeader(e,f)}catch{}}if(s.signal){if(s.signal.aborted)w();else s.signal.addEventListener?.("abort",w)}t.send(s.body)}catch(e){r=true;u(e instanceof Error?e:new Error(String(e)))}})}

package/lib/module/realNow.js

@@ -0,0 +1 @@
+"use strict";export function realNow(){const e=globalThis.__buoyRealNow;return typeof e==="function"?e():Date.now()}function t(){const e=globalThis.__buoyRealTimers;return e??globalThis}export function realSetTimeout(e,o){return t().setTimeout(e,o)}export function realClearTimeout(e){t().clearTimeout(e)}