@cubicecho/agent-core 2.2.2 → 2.2.4

package/README.md

@@ -46,7 +46,7 @@ the exports rather than a second description of them; CI fails if the committed
 
 `negotiate` wrapping `streamTurn` is the whole of one turn against an endpoint: the request is
 re-sent for as long as the answer is this server refusing something the request can do without,
-and nothing is re-sent once it has started answering.
+and nothing is re-sent once the model has started answering.
 
 ```ts
 import {
@@ -82,6 +82,12 @@ again, with the setting still reading `high` and nothing anywhere saying it had
 So they hang off the endpoint under the name the endpoint knows the model by. Pass `model` and
 the same loop answers both levels; leave it out and nothing changes.
 
+A refusal of the *value* is not one of these, however alike the two read: an effort off a list
+this package does not know, a `max_tokens` larger than the model's ceiling, a temperature out of
+range. Dropping the field answers those too — at the model's own default, latched for the rest of
+the process, with the settings row still reading what was typed and nothing saying it had stopped
+meaning it. They are passed to the caller instead, where whoever typed the number can see it.
+
 ```ts
 const turn = await negotiate(supports, (supports, produced, model) =>
   streamTurn(
@@ -116,9 +122,12 @@ OpenAI and `gpt-4o` behind a proxy need not be the same weights, and one that re
 effort must not speak for the other.
 
 `send` takes a callback rather than a body because the body has to be rebuilt from the latched
-flags. `produced` is one box per attempt — `streamTurn` sets it as soon as the server says
-anything, and the re-send reads it — so a caller with its own retry budget passes one in
-(`{ produced }`) and reads it afterwards to decide whether the failure is worth another attempt.
+flags. `produced` is one box per attempt — `streamTurn` sets it on the first chunk that carries
+text, reasoning or a piece of a tool call, and the re-send reads it — so a caller with its own
+retry budget passes one in (`{ produced }`) and reads it afterwards to decide whether the failure
+is worth another attempt. The content-free `{"role":"assistant"}` most servers open a stream with
+does not set it: nothing has been shown to anybody yet, so an endpoint that primes the stream and
+then wedges is retried like one that never answered at all.
 
 `idleMs` is silence, not a deadline: the timer is rearmed on every chunk, so a model that is
 still talking is never cut off however long it takes, and one that has stopped answering raises

package/dist/capabilities.js

@@ -94,13 +94,37 @@ const rejectsEffort = (detail) => /reasoning_effort/i.test(detail) && !REFUSED_V
  * whoever typed the number can see it.
  */
 const wantsCompletionLimit = (detail) => /max_tokens/i.test(detail) && /max_completion_tokens/i.test(detail);
+/**
+ * Temperature named as the field being refused, rather than mentioned in passing.
+ *
+ * A bare search of the message is not that question. `Unsupported value: 'top_p' does not
+ * support 3 with this model. Adjust temperature instead.` refuses another field and merely says
+ * the word, and it disabled ours — the word is ordinary English about a model, so any advice,
+ * aside or list that reaches for it counted. OpenAI quotes the field it is refusing, which is
+ * the anchor; the second half is a server that writes the same clause without the quotes.
+ */
+const NAMES_TEMPERATURE = /(['"`])temperature\1|\btemperature\s+(?:is|does|must|can)\b/i;
 /**
  * `'temperature' does not support 0.7 with this model. Only the default (1) is supported.`
  *
- * The qualifier is load-bearing. A temperature out of range is the caller's mistake to see
- * rather than ours to work around, and dropping the field would hide it.
+ * The qualifier is load-bearing, and `does not support` is not the qualifier: that is how a
+ * server words a refusal of the *value* — `Invalid value: 'temperature' does not support 5.
+ * Supported values are between 0 and 2.` — which is the caller's mistake to see rather than
+ * ours to work around. Dropping the field there succeeds, at the model's own default, so a
+ * number the operator typed and can still read on a settings row is silently replaced by one
+ * nobody chose, for the life of the process. `only the default` is the whole of what separates
+ * the two: it says the field takes one value, where the generic phrasing says only that this
+ * value was the wrong one.
+ *
+ * `REFUSED_VALUE` cannot be borrowed from `rejectsEffort` to draw that line, which is why this
+ * has no such guard rather than having lost one — the genuine refusal above opens with
+ * `Unsupported value:` too, so the guard would reject the one message that has to latch.
+ *
+ * It under-matches an endpoint that refuses the field in some third wording, which is the
+ * direction this file argues for on `max_tokens` and on `reasoning_effort`: a false negative
+ * costs one visible error, and a false positive quietly changes what every later request means.
  */
-const refusesChosenTemperature = (detail) => /temperature/i.test(detail) && /only the default|does not support/i.test(detail);
+const refusesChosenTemperature = (detail) => NAMES_TEMPERATURE.test(detail) && /only the default/i.test(detail);
 /**
  * Sends a request, re-sending it each time the answer is this endpoint refusing something the
  * request can do without. Returns once the endpoint has answered, or throws if the refusal is

package/dist/run-turn.d.ts

@@ -12,9 +12,11 @@ import { type StreamTurnOptions, type Turn } from "./stream.ts";
  * The outer one is the endpoint being unreachable, busy or silent, which is not about this
  * request at all and is worth simply waiting out.
  *
- * Both are bounded by the same rule: nothing is sent again once the server has started
+ * Both are bounded by the same rule: nothing is sent again once the model has started
  * answering. The tokens are already out and on their way to whoever is watching, and a second
- * attempt would say everything twice. That is what `produced` is, one box per attempt.
+ * attempt would say everything twice. That is what `produced` is, one box per attempt — set by
+ * a chunk that carried something rather than by a chunk arriving, so the empty opening chunk
+ * most servers send does not cost the retry.
  */
 /** A retry is not the same event as a downgrade, but a watcher wants to be told about both. */
 export interface RunTurnOptions extends Omit<StreamTurnOptions, "produced"> {

package/dist/stream.d.ts

@@ -22,13 +22,19 @@ export interface Turn {
     usage: TurnUsage;
 }
 /**
- * Whether the server has started answering.
+ * Whether the model has said anything a second attempt would say twice.
  *
  * A box rather than a return value because it has to be readable *while* the request is in
  * flight: the rules in `retry.ts` are built on the premise that a stream which has already
  * emitted tokens must never be replayed, and by the time a rejected promise is in hand the turn
  * is over. There is one of these per attempt, shared by everything that has a say in whether
  * the attempt is repeated. See `negotiate`.
+ *
+ * What sets it is a chunk that carried something — text, reasoning, or a piece of a tool call —
+ * rather than a chunk arriving. Those read as the same sentence until a server puts an empty
+ * chunk between them, and most of them do: a stream usually opens with a content-free
+ * `{"role":"assistant"}` that shows nobody anything, and a turn that latched on it could never
+ * be retried however early it then died.
  */
 export interface Produced {
     any: boolean;
@@ -43,7 +49,7 @@ export interface StreamTurnOptions {
      * needs.
      */
     idleMs?: number;
-    /** Set as soon as the server has said anything, so a failed call knows if it can be retried. */
+    /** Set by the first chunk that carries anything, so a failed call knows if it can be retried. */
     produced?: Produced;
     /** The model's scratchpad, as it arrives. */
     onThinking?: (delta: string) => void;

package/dist/stream.js

@@ -52,8 +52,8 @@ export async function streamTurn(client, body, { signal, idleMs, produced, onThi
         const calls = new Map();
         const usage = { prompt: 0, completion: 0, total: 0 };
         for await (const chunk of stream) {
-            if (produced)
-                produced.any = true;
+            // Rearmed on every chunk, latched below on only some: a priming chunk is the endpoint
+            // being alive, which is all the watchdog is asking about.
             rearm();
             // Assigned rather than accumulated. `stream_options.include_usage` sends one final chunk
             // and the two agree there, but a server that reports cumulatively per chunk makes a sum
@@ -68,6 +68,15 @@ export async function streamTurn(client, body, { signal, idleMs, produced, onThi
             if (!delta)
                 continue;
             const thinking = delta.reasoning_content || delta.reasoning || "";
+            // Latched on what the chunk carried, not on its having arrived. Most OpenAI-compatible
+            // servers open a stream with a content-free `{"role":"assistant"}` before the first
+            // token; latching on that made an endpoint that primes and then wedges unrepeatable,
+            // which is exactly the case the watchdog raises `EndpointSilent` for. Tool-call
+            // fragments count even though no callback reports them: a partial call is state the turn
+            // has accumulated, and losing a retry is the safer half of that trade. Set before the
+            // callbacks, so a watcher that throws mid-token cannot be told the same token twice.
+            if (produced && (thinking || delta.content || delta.tool_calls?.length))
+                produced.any = true;
             if (thinking)
                 onThinking?.(thinking);
             if (delta.content) {

package/llms.txt

@@ -115,7 +115,7 @@ One-shot calls that support a run without being one: picking tools, naming a ses
 
 Reading one streamed turn back into a message.
 
-- `Produced` (type) — Whether the server has started answering.
+- `Produced` (type) — Whether the model has said anything a second attempt would say twice.
 - `StreamTurnOptions` (type) — What `streamTurn` takes besides the request body.
 - `streamTurn` — Runs one turn as a stream, reporting tokens as they arrive and assembling them back into a message.
 - `Turn` (type) — One streamed turn, put back together into the shape a loop and a transcript work with.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubicecho/agent-core",
-  "version": "2.2.2",
+  "version": "2.2.4",
   "description": "The endpoint-agnostic half of an OpenAI-compatible agent loop: tool-schema compatibility, on-demand tool loading, one-shot side tasks, run events, and a pooled client.",
   "keywords": [
     "openai",