@stigg/agent-sdk-js 0.7.3 → 0.7.4

package/dist/bindings/orchestrator/vercel-ai/middleware.js

@@ -62,9 +62,11 @@ function stiggVercelMiddleware({ stigg, stiggContext, hooks, }) {
                 governance.abandon(runId);
                 throw err;
             }
-            // Awaited, so the agent's next step is checked against this one's spend. Never throws; no
-            // usage at all is reported as a metering failure.
-            await governance.endModel(runId, (0, usage_1.measurementOf)(result?.usage, result?.response?.id));
+            // Awaited, so the agent's next step is checked against this one's spend. Never throws. No
+            // usage stated: estimated from the reply, as a stream is, and counted as a metering failure.
+            const responseId = result?.response?.id;
+            const chars = (0, usage_1.contentChars)(result?.content);
+            await governance.endModel(runId, (0, usage_1.measurementOf)(result?.usage, responseId) ?? (chars ? (0, usage_1.estimated)(chars, usage_1.NO_USAGE, responseId) : undefined));
             return result;
         },
         async wrapStream({ doStream, params }) {
@@ -95,6 +97,24 @@ function stiggVercelMiddleware({ stigg, stiggContext, hooks, }) {
         },
     };
 }
+/** What `incomplete` says for a stream that ended without its usage, by how it ended. */
+const STREAM_GAPS = {
+    ended: usage_1.NO_USAGE,
+    failed: 'the stream failed before the model stated its usage, so its output was estimated',
+    timedOut: 'the call timed out before the model stated its usage, so its output was estimated',
+    stopped: 'the call was stopped before any output, so its input was not measured',
+};
+/** A timeout's abort is not the caller stopping. */
+const isTimeout = (reason) => reason?.name === 'TimeoutError';
+/**
+ * Why a reader cancelled: the AI SDK cancels an attempt it retries with the provider's error, which
+ * is a failure; any other reason is the caller stopping.
+ */
+function cancelEnd(reason) {
+    if (isTimeout(reason))
+        return 'timedOut';
+    return reason instanceof Error && reason.name !== 'AbortError' ? 'failed' : 'stopped';
+}
 /** What a stream has told us so far. */
 function streamTally() {
     let usage;
@@ -110,14 +130,19 @@ function streamTally() {
             else if (typeof part?.delta === 'string')
                 chars += part.delta.length;
         },
-        /** The usage the model stated; else an estimate; else nothing, for an attempt that produced nothing. */
-        measurement() {
+        /**
+         * The usage the model stated; else an estimate; else nothing, for an attempt that produced
+         * nothing. A stream the caller stopped is estimated without counting as a metering failure -
+         * unless there was nothing to estimate, while the provider still counted its input.
+         */
+        measurement(end) {
             const measured = (0, usage_1.measurementOf)(usage, responseId);
             if (measured)
                 return measured;
             if (chars === 0 && responseId === undefined)
                 return undefined;
-            return (0, usage_1.estimated)(chars);
+            const gap = end === 'stopped' && chars > 0 ? undefined : STREAM_GAPS[end];
+            return (0, usage_1.estimated)(chars, gap, responseId);
         },
     };
 }
@@ -134,27 +159,28 @@ function observeStream(result, signal, done) {
     }
     const tally = streamTally();
     let reported = false;
-    const report = () => {
+    const report = (end) => {
         if (reported)
             return;
         reported = true;
         // Every step of a loop shares the signal, which may live as long as the process.
-        signal?.removeEventListener('abort', report);
-        done(tally.measurement());
+        signal?.removeEventListener('abort', onAbort);
+        done(tally.measurement(end));
     };
-    signal?.addEventListener('abort', report, { once: true });
+    const onAbort = () => report(isTimeout(signal?.reason) ? 'timedOut' : 'stopped');
+    signal?.addEventListener('abort', onAbort, { once: true });
     if (signal?.aborted)
-        report();
+        onAbort();
     // A source of its own rather than a TransformStream, whose flush never runs on a cancel.
     const reader = source.getReader();
     result.stream = new ReadableStream({
         async pull(controller) {
             const next = await reader.read().catch((err) => {
-                report();
+                report('failed');
                 throw err;
             });
             if (next.done) {
-                report();
+                report('ended');
                 controller.close();
                 return;
             }
@@ -162,7 +188,7 @@ function observeStream(result, signal, done) {
             controller.enqueue(next.value);
         },
         async cancel(reason) {
-            report();
+            report(cancelEnd(reason));
             await reader.cancel(reason);
         },
     });

package/dist/bindings/orchestrator/vercel-ai/usage.d.ts

@@ -25,5 +25,12 @@ export type ModelUsage = {
 };
 /** One call's usage, or undefined when the model stated no counter - not a call that cost nothing. */
 export declare function measurementOf(usage: ModelUsage | undefined, responseId?: string): Measurement | undefined;
-/** A stream stopped before stating usage: its output, estimated from the text. Its input is unknown. */
-export declare function estimated(chars: number): Measurement;
+/** What `incomplete` says when the model never stated its usage: a gap in metering, not a stop. */
+export declare const NO_USAGE = "the model stated no usage, so its output was estimated";
+/**
+ * A call with no usage stated: its output, estimated from the text. Its input is unknown.
+ * `incomplete` is set only for a metering gap - a call the caller stopped is not one.
+ */
+export declare function estimated(chars: number, incomplete?: string, responseId?: string): Measurement;
+/** The characters a generated reply holds: its text, its reasoning and its tool calls' input. */
+export declare function contentChars(content: unknown): number;

package/dist/bindings/orchestrator/vercel-ai/usage.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERCEL_AI_METRICS = void 0;
+exports.NO_USAGE = exports.VERCEL_AI_METRICS = void 0;
 exports.measurementOf = measurementOf;
 exports.estimated = estimated;
+exports.contentChars = contentChars;
 exports.VERCEL_AI_METRICS = [
     'input_tokens',
     'output_tokens',
@@ -43,16 +44,35 @@ function measurementOf(usage, responseId) {
         ...(responseId ? { idempotencyKey: responseId } : {}),
     };
 }
-/** A stream stopped before stating usage: its output, estimated from the text. Its input is unknown. */
-function estimated(chars) {
+/** What `incomplete` says when the model never stated its usage: a gap in metering, not a stop. */
+exports.NO_USAGE = 'the model stated no usage, so its output was estimated';
+/**
+ * A call with no usage stated: its output, estimated from the text. Its input is unknown.
+ * `incomplete` is set only for a metering gap - a call the caller stopped is not one.
+ */
+function estimated(chars, incomplete, responseId) {
     const output = chars > 0 ? Math.max(1, Math.ceil(chars / CHARS_PER_OUTPUT_TOKEN)) : 0;
     return {
         metrics: output ? { output_tokens: output, total_tokens: output } : {},
         usage: { input: 0, output, cacheRead: 0, cacheCreate: 0 },
         ...(output ? { estimated: true } : {}),
-        incomplete: 'the stream ended before the model stated its usage',
+        ...(incomplete ? { incomplete } : {}),
+        // Keyed by the response, as a stated usage is: a replayed reply is still one report.
+        ...(responseId ? { idempotencyKey: responseId } : {}),
     };
 }
+/** The characters a generated reply holds: its text, its reasoning and its tool calls' input. */
+function contentChars(content) {
+    if (!Array.isArray(content))
+        return 0;
+    let chars = 0;
+    for (const part of content) {
+        const text = part?.type === 'tool-call' ? part.input : part?.text;
+        if (typeof text === 'string')
+            chars += text.length;
+    }
+    return chars;
+}
 function numbersOnly(stated) {
     const metrics = {};
     for (const [name, value] of Object.entries(stated)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stigg/agent-sdk-js",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "Stigg agent SDK (JS) - run-lifecycle governance for agentic stacks, with examples per layer",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -123,6 +123,7 @@
     "@opentelemetry/sdk-trace-node": "^2.0.1",
     "@typesafe-ai/sdk": "^0.6.0",
     "ai": "^7.0.153",
+    "ai-v6": "npm:ai@^6.0.320",
     "cloudflare": "^7.3.0",
     "dotenv": "^17.4.2",
     "groq-sdk": "^1.6.0",