@buoy-gg/agent-core 7.0.34 → 7.0.36

package/lib/commonjs/providers/openai.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createOpenAIProvider = createOpenAIProvider;
 var _sse = require("./sse");
+var _streamTimer = require("./streamTimer");
+var _transport = require("./transport");
 /**
  * OpenAI chat-completions protocol.
  *
@@ -20,6 +22,19 @@ var _sse = require("./sse");
  * 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.
  */
 
 function toWireMessages(system, messages) {
@@ -61,132 +76,243 @@ function toWireMessages(system, messages) {
   }
   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}`
+      }
+    }
+  };
+}
 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 = (0, _transport.createTransport)(config);
   return {
     protocol: "openai",
     async *send(req) {
-      const headers = {
-        "content-type": "application/json",
-        ...(await (config.headers?.() ?? {}))
+      const timer = (0, _streamTimer.createStreamTimer)(req.signal, config);
+      const status = {
+        truncated: false
       };
-      if (config.apiKey && !headers.Authorization && !headers["api-key"]) {
-        headers.Authorization = `Bearer ${config.apiKey}`;
-      }
-      const response = await fetch(config.endpoint, {
-        method: "POST",
-        headers,
-        signal: req.signal,
-        body: JSON.stringify({
-          model: req.model,
-          max_tokens: req.maxTokens,
-          stream: true,
-          stream_options: {
-            include_usage: true
-          },
-          messages: toWireMessages(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.
-              description: t.description.slice(0, 1024),
-              parameters: t.inputSchema
-            }
-          })),
-          ...config.requestOverrides
-        })
-      });
-      if (!response.ok) {
-        yield {
-          type: "error",
-          message: await (0, _sse.errorBody)(response)
+      try {
+        const headers = {
+          "content-type": "application/json",
+          ...(await (config.headers?.() ?? {}))
         };
-        return;
-      }
+        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"
+          };
+          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;
-      const flush = function* () {
-        for (const [, slot] of pending) {
-          let input = {};
+        // 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: (0, _sse.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 {
-            input = slot.args ? JSON.parse(slot.args) : {};
+            payload = JSON.parse(ev.data);
           } catch {
+            continue;
+          }
+          if (payload.error) {
+            const err = payload.error;
             yield {
               type: "error",
-              message: `Model sent unparseable arguments for ${slot.name}`
+              message: err.message ?? "Provider error",
+              kind: "provider"
             };
-            continue;
+            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);
           }
-          yield {
-            type: "tool-call",
-            call: {
-              id: slot.id,
-              name: slot.name,
-              input
-            }
-          };
-        }
-        pending.clear();
-      };
-      for await (const ev of (0, _sse.readSse)(response)) {
-        if (ev.data === "[DONE]") break;
-        let payload;
-        try {
-          payload = JSON.parse(ev.data);
-        } catch {
-          continue;
         }
-        if (payload.error) {
-          const err = payload.error;
+
+        /**
+         * 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: err.message ?? "Provider error"
+            message: (0, _sse.truncatedMessage)(status.truncated),
+            kind: "truncated"
           };
           return;
         }
-        const u = payload.usage;
-        if (u) {
-          usage = {
-            input: u.prompt_tokens ?? 0,
-            output: u.completion_tokens ?? 0
-          };
-        }
-        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* 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: "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: ""
+            type: "error",
+            message,
+            kind: "timeout"
           };
-          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);
+          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();
       }
-      yield* flush();
-      yield {
-        type: "done",
-        stopReason,
-        usage
-      };
     }
   };
 }

package/lib/commonjs/providers/openai.js.map

@@ -1 +1 @@
-{"version":3,"names":["_sse","require","toWireMessages","system","messages","out","role","content","m","push","text","toolCalls","length","tool_calls","map","c","id","type","function","name","arguments","JSON","stringify","input","r","results","tool_call_id","toolCallId","createOpenAIProvider","config","protocol","send","req","headers","apiKey","Authorization","response","fetch","endpoint","method","signal","body","model","max_tokens","maxTokens","stream","stream_options","include_usage","tools","t","description","slice","parameters","inputSchema","requestOverrides","ok","message","errorBody","pending","Map","stopReason","usage","flush","slot","args","parse","call","clear","ev","readSse","data","payload","error","err","u","prompt_tokens","output","completion_tokens","choice","choices","finish_reason","delta","calls","index","fn","get","set"],"sourceRoot":"../../../src","sources":["providers/openai.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_sse","require","_streamTimer","_transport","toWireMessages","system","messages","out","role","content","m","push","text","toolCalls","length","tool_calls","map","c","id","type","function","name","arguments","JSON","stringify","input","r","results","tool_call_id","toolCallId","withActionsBlock","t","action","inputSchema","properties","description","actionsBlock","createOpenAIProvider","config","transport","createTransport","protocol","send","req","timer","createStreamTimer","signal","status","truncated","headers","apiKey","Authorization","stream","open","body","model","max_tokens","maxTokens","stream_options","include_usage","systemVolatile","tools","summaryDescription","slice","parameters","requestOverrides","connected","problem","message","kind","pending","Map","stopReason","usage","sawDone","flush","slot","args","parse","unparseableMessage","call","clear","ev","frames","onFrame","activity","data","payload","error","err","u","details","prompt_tokens_details","cached","cached_tokens","prompt_tokens","output","completion_tokens","cacheRead","choice","choices","finish_reason","delta","calls","index","fn","get","set","sawTerminal","undefined","truncatedMessage","outcome","aborted","dispose"],"sourceRoot":"../../../src","sources":["providers/openai.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/providers/sse.js

@@ -4,7 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.errorBody = errorBody;
+exports.framesFrom = framesFrom;
+exports.nonStreamProblem = nonStreamProblem;
 exports.readSse = readSse;
+exports.truncatedMessage = truncatedMessage;
+exports.unparseableMessage = unparseableMessage;
 /**
  * SSE reading, with the React Native reality baked in.
  *
@@ -14,15 +18,24 @@ exports.readSse = readSse;
  * 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) {
+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/)) {
@@ -36,53 +49,124 @@ function* parseChunk(buffer) {
   }
   return rest;
 }
-async function* readSse(response) {
+
+/**
+ * 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.
+ */
+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;
+}
+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.
+    // 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();
-    let rest = "";
-    const gen = parseChunk(text + "\n\n");
-    let next = gen.next();
-    while (!next.done) {
-      yield next.value;
-      next = gen.next();
-    }
-    rest = next.value;
-    if (rest.trim()) {
-      const tail = parseChunk(rest + "\n\n");
-      let t = tail.next();
-      while (!t.done) {
-        yield t.value;
-        t = tail.next();
-      }
-    }
+    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
-      } = await reader.read();
+      } = aborted ? await Promise.race([read, aborted]) : await read;
       if (done) break;
       buffer += decoder.decode(value, {
         stream: true
       });
-      const gen = parseChunk(buffer);
-      let next = gen.next();
-      while (!next.done) {
-        yield next.value;
-        next = gen.next();
-      }
-      buffer = next.value;
+      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 {
-    // Cancelling on abort keeps the socket from lingering after the user
-    // closes the sheet mid-answer.
+    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 {
@@ -91,6 +175,33 @@ async function* readSse(response) {
   }
 }
 
+/**
+ * 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.
+ */
+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. */
 async function errorBody(response) {
   let detail = "";
@@ -101,4 +212,28 @@ async function errorBody(response) {
   }
   return `HTTP ${response.status}${detail ? ` — ${detail}` : ""}`;
 }
+
+/**
+ * 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.
+ */
+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.
+ */
+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