@cubicecho/agent-core 2.2.0 → 2.2.2

package/dist/retry.d.ts

@@ -33,8 +33,11 @@ export declare const compact: (tokens: number) => string;
  * built the entire transcript into a string on every call and threw it away having read nothing
  * but its `.length` — against a transcript that grows by a turn each turn, and one the SDK is
  * about to serialise again to send. What the walk misses is JSON's own punctuation and the keys,
- * which `ENVELOPE` puts back approximately; the difference is a rounding error against an
- * estimate that is already characters over four.
+ * which the envelope constants put back — one per key and one per content part, rather than one
+ * per message, since the keys only some shapes carry and the parts a client appends block by
+ * block are most of what a tool-using transcript is made of. What is left is a message's
+ * escaping, which is not a constant and is small against an estimate that is already characters
+ * over four.
  *
  * @param body The request as it will be sent, tools included.
  */

package/dist/retry.js

@@ -29,9 +29,28 @@ export const compact = (tokens) => tokens >= 1000 ? `${(tokens / 1000).toFixed(1
 const ENVELOPE = 25;
 /** The same for `{"id":"","type":"function","function":{"name":"","arguments":""}},` in a call. */
 const CALL_ENVELOPE = 66;
+// `ENVELOPE` is the two keys every message has. These are the three that only some do, and each
+// is the key with its punctuation and the comma after the value it holds — the value's own
+// length is counted where the value is read. Applying `ENVELOPE` alone to these shapes left the
+// keys out, which cost 4.5 tokens on every tool result: the message a tool-using run has most
+// of, and short in the direction that lets an overflow through the guard meant to catch it.
+/** What `"name":"",` costs around a message's name. */
+const NAME_KEY = 10;
+/** The same for `"tool_call_id":"",` around a tool result's call id. */
+const TOOL_CALL_ID_KEY = 18;
+/** The same for `"tool_calls":[]` around the calls; each call's own comma is in `CALL_ENVELOPE`. */
+const TOOL_CALLS_KEY = 15;
+// A content part is an object in the body the same way a message is, and its two keys are in the
+// request exactly as `tool_call_id` was. Charging only `part.text` left them out, which is 6.5
+// tokens per part — short in proportion to how finely the content is split rather than to how
+// much it says, so a transcript a client appends block by block is worst hit.
+/** What `{"type":"text","text":""},` costs around a text part. */
+const TEXT_PART = 26;
+/** The same for `{"type":"refusal","refusal":""},` around a refusal part. */
+const REFUSAL_PART = 32;
 /** The divisor behind `estimateTokens`, applied here to a character count rather than a string. */
 const CHARS_PER_TOKEN = 4;
-/** How many characters one message is worth, whichever of the shapes its content is in. */
+/** How many characters one message is worth: its keys, and its content in whichever shape. */
 function messageChars(message) {
     let chars = message.role.length + ENVELOPE;
     const { content } = message;
@@ -40,22 +59,26 @@ function messageChars(message) {
     else if (Array.isArray(content))
         for (const part of content) {
             // Text and refusal parts carry their own strings; an image or an audio part carries a URL
-            // or a blob, and neither is priced by its length anyway.
+            // or a blob, and neither is priced by its length anyway — a vision model does not charge
+            // an image by its base64 length, so counting the data URL would overshoot by more than
+            // leaving the part out undershoots.
             if (part.type === "text")
-                chars += part.text.length;
+                chars += TEXT_PART + part.text.length;
             else if (part.type === "refusal")
-                chars += part.refusal.length;
+                chars += REFUSAL_PART + part.refusal.length;
         }
     if ("name" in message && typeof message.name === "string")
-        chars += message.name.length;
+        chars += NAME_KEY + message.name.length;
     if ("tool_call_id" in message && typeof message.tool_call_id === "string")
-        chars += message.tool_call_id.length;
-    if ("tool_calls" in message && Array.isArray(message.tool_calls))
+        chars += TOOL_CALL_ID_KEY + message.tool_call_id.length;
+    if ("tool_calls" in message && Array.isArray(message.tool_calls)) {
+        chars += TOOL_CALLS_KEY;
         for (const call of message.tool_calls) {
             chars += CALL_ENVELOPE + call.id.length;
             if (call.type === "function")
                 chars += call.function.name.length + call.function.arguments.length;
         }
+    }
     return chars;
 }
 /**
@@ -92,8 +115,11 @@ function toolsCost(tools) {
  * built the entire transcript into a string on every call and threw it away having read nothing
  * but its `.length` — against a transcript that grows by a turn each turn, and one the SDK is
  * about to serialise again to send. What the walk misses is JSON's own punctuation and the keys,
- * which `ENVELOPE` puts back approximately; the difference is a rounding error against an
- * estimate that is already characters over four.
+ * which the envelope constants put back — one per key and one per content part, rather than one
+ * per message, since the keys only some shapes carry and the parts a client appends block by
+ * block are most of what a tool-using transcript is made of. What is left is a message's
+ * escaping, which is not a constant and is small against an estimate that is already characters
+ * over four.
  *
  * @param body The request as it will be sent, tools included.
  */

package/dist/side-task.d.ts

@@ -12,6 +12,11 @@ export interface SideTaskOptions {
     /**
      * Told what was given up on, the same way `runTurn` and `negotiate` tell a caller.
      *
+     * The one notice `ask` raises itself opens with the model's name, as `negotiate`'s do for the
+     * refusals that are the model's: what it announces is latched on the (endpoint, model) pair,
+     * so on a consumer reaching several models through one base URL the name is the only thing
+     * separating one announcement from the next.
+     *
      * There is no default, and nothing is printed without one. A library that writes to the
      * console decides for its consumer where operator text goes — which a server embedding this
      * cannot then route to its own logger, attach to the run it belongs to, or silence in tests.

package/dist/side-task.js

@@ -125,7 +125,7 @@ export async function ask(config, model, system, user, { maxTokens = 512, temper
         // does not offer as `none`.
         if (!hints || !rejectedTheRequest(error))
             throw error;
-        onNotice?.("server rejected the no-thinking hints; retrying without them");
+        onNotice?.(`${model} rejected the no-thinking hints; retrying without them`);
         noHints.add(key);
         response = await attempt(false);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubicecho/agent-core",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "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",