@stigg/agent-sdk-js 0.7.7 → 0.7.9

package/README.md

@@ -155,6 +155,7 @@ closed, and conflating them is how an outage takes an application down.
 | <img src="https://raw.githubusercontent.com/stiggio/stigg-agent-sdk-ts/main/docs/logos/bedrock.svg" width="18" alt=""> | Amazon Bedrock | <img src="https://raw.githubusercontent.com/stiggio/stigg-agent-sdk-ts/main/docs/logos/litellm.png" width="18" alt=""> | LiteLLM |
 | <img src="https://raw.githubusercontent.com/stiggio/stigg-agent-sdk-ts/main/docs/logos/cloudflare.svg" width="18" alt=""> | Cloudflare Workers AI | <img src="https://raw.githubusercontent.com/stiggio/stigg-agent-sdk-ts/main/docs/logos/openrouter.svg" width="18" alt=""> | OpenRouter |
 | <img src="https://raw.githubusercontent.com/stiggio/stigg-agent-sdk-ts/main/docs/logos/databricks.svg" width="18" alt=""> | Databricks | | agentgateway (incl. Solo.io Enterprise) |
+| | TrueFoundry AI Gateway | | |
 
 A gateway called with plain HTTP rather than through an SDK is governed the same way:
 `stigg.wrapFetch({ baseUrl, recipe })` hands back a `fetch` that is checked and metered per
@@ -165,7 +166,7 @@ request.
 | | Orchestrator | | Orchestrator |
 | --- | --- | --- | --- |
 | <img src="https://raw.githubusercontent.com/stiggio/stigg-agent-sdk-ts/main/docs/logos/langchain.svg" width="18" alt=""> | [LangChain](docs/langchain.md) | <img src="https://raw.githubusercontent.com/stiggio/stigg-agent-sdk-ts/main/docs/logos/langgraph.svg" width="18" alt=""> | [LangGraph](docs/langchain.md#a-hand-built-langgraph) |
-| <img src="https://raw.githubusercontent.com/stiggio/stigg-agent-sdk-ts/main/docs/logos/google-adk.png" width="18" alt=""> | [Google ADK](docs/guide.md#google-adk-one-plugin-per-runner) | <img src="https://raw.githubusercontent.com/stiggio/stigg-agent-sdk-ts/main/docs/logos/vercel.svg" width="18" alt=""> | [Vercel AI SDK](docs/vercel-ai.md) (model calls, for now) |
+| <img src="https://raw.githubusercontent.com/stiggio/stigg-agent-sdk-ts/main/docs/logos/google-adk.png" width="18" alt=""> | [Google ADK](docs/guide.md#google-adk-one-plugin-per-runner) | <img src="https://raw.githubusercontent.com/stiggio/stigg-agent-sdk-ts/main/docs/logos/vercel.svg" width="18" alt=""> | [Vercel AI SDK](docs/vercel-ai.md) |
 | | Your own harness, through `stigg.middleware()` | | |
 
 Each binding is written against the *shape a vendor returns*, not against its SDK — so installing
@@ -187,7 +188,7 @@ rather than handing back a client that quietly meters nothing.
 | Meter a gateway you operate | `client.stigg.headers()` out, `stigg.ingestFromHeaders(...)` back |
 | Govern a LangChain / LangGraph agent graph ([guide](docs/langchain.md)) | `new StiggLangChainCallbackHandler({ stigg, agents, tools })` from `@stigg/agent-sdk-js/langchain` |
 | Govern a Google ADK agent graph ([guide](docs/guide.md#google-adk-one-plugin-per-runner)) | `new StiggAdkPlugin({ stigg, agents, tools, stepContext })` from `@stigg/agent-sdk-js/adk`, in the Runner's `plugins` |
-| Govern a Vercel AI SDK model or agent ([guide](docs/vercel-ai.md)) | `wrapLanguageModel({ model, middleware: stiggVercelMiddleware({ stigg, stiggContext }) })`, a call's own in `providerOptions.stigg` |
+| Govern a Vercel AI SDK model or agent ([guide](docs/vercel-ai.md)) | `wrapLanguageModel({ model, middleware: stiggVercelMiddleware({ stigg, stiggContext, tools }) })`, a call's own in `providerOptions.stigg`; paid tools through `middleware.tools(...)` |
 | Govern a graph from your own harness | `stigg.middleware({ stiggContext, agents })` |
 
 One wrapped client serves every customer and every agent: the context is an argument, given once at

package/dist/bindings/client/core/wire-surface.d.ts

@@ -0,0 +1,29 @@
+import type { MethodRecipe, MeteredResponse } from './types';
+/** What the response body says about the call, buffered or streamed. */
+export type BodyFacts = {
+    model?: string;
+    id?: string;
+};
+/** What only the gateway knows, folded onto the wire reader's measurement. */
+export type GatewayFacts = {
+    /** The model that actually served, reported under the recipe's model dimension. */
+    model?: string;
+    /** The upstream's completion id: the idempotency key when the wire reader stated none. */
+    id?: string;
+    /** The gateway's own request id: the idempotency key ahead of anything the wire reader stated. */
+    requestId?: string;
+    /** Anything else the gateway states, as dimensions. */
+    dimensions?: Record<string, string>;
+};
+export type GatewaySurfaceOptions = {
+    estimate: NonNullable<MethodRecipe['estimate']>;
+    modelDimension: string;
+    /** The gateway's facts, from the body and the response. Defaults to the body's own. */
+    facts?: (body: BodyFacts, response: MeteredResponse | undefined) => GatewayFacts;
+    /** A call nobody was charged for (a cache hit), which reports nothing at all. */
+    skip?: (response: MeteredResponse | undefined) => boolean;
+};
+/** A response header, with an empty value read as absent. */
+export declare function headerOf(response: MeteredResponse | undefined, name: string): string | undefined;
+/** One wire's surface, answered through a gateway. */
+export declare function gatewaySurface(base: MethodRecipe, options: GatewaySurfaceOptions): MethodRecipe;

package/dist/bindings/client/core/wire-surface.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headerOf = headerOf;
+exports.gatewaySurface = gatewaySurface;
+/**
+ * A provider's wire, answered by a gateway - the wrapper agentgateway, TrueFoundry and Cloudflare
+ * AI Gateway share.
+ *
+ * Each of those gateways answers in the shape of the wire it was called on, so that wire's recipe
+ * already has the right reader - and Anthropic's streamed usage in particular accumulates across
+ * two event types, which is not logic worth having a second copy of. What the gateway adds is what
+ * only it knows: the model that actually served and the id a replay repeats, plus whatever a
+ * particular gateway states in its own headers. This file folds those onto the wire reader's
+ * measurement; each recipe supplies the facts.
+ */
+const meter_stream_1 = require("../../shared/meter-stream");
+const types_1 = require("../../../types");
+/** A response header, with an empty value read as absent. */
+function headerOf(response, name) {
+    const raw = response?.headers?.get(name);
+    return raw == null || raw === '' ? undefined : raw;
+}
+function withGatewayFacts(measured, facts, modelDimension) {
+    const dimensions = {
+        ...measured.dimensions,
+        ...facts.dimensions,
+    };
+    if (facts.model)
+        dimensions[modelDimension] = facts.model;
+    return {
+        ...measured,
+        dimensions: Object.keys(dimensions).length > 0 ? dimensions : undefined,
+        idempotencyKey: facts.requestId ?? measured.idempotencyKey ?? facts.id,
+    };
+}
+/** A non-empty string, or absent - an empty id would key every such call as one, the stream tap's rule too. */
+const stringOr = (value) => (typeof value === 'string' && value ? value : undefined);
+/** One wire's surface, answered through a gateway. */
+function gatewaySurface(base, options) {
+    const { estimate, modelDimension, skip } = options;
+    const facts = options.facts ?? ((body) => body);
+    return {
+        // Spread first so anything the base declares and this wrapper does not know about - like
+        // `contextArg` - survives being wrapped.
+        ...base,
+        estimate,
+        extractUsage: (result, response) => {
+            // Checked before the body is read, because the body of a cache hit looks like a real call.
+            if (skip?.(response))
+                return undefined;
+            const measured = base.extractUsage?.(result, response);
+            if (measured === undefined)
+                return undefined;
+            const body = { model: stringOr(result?.model), id: stringOr(result?.id) };
+            return withGatewayFacts((0, types_1.toMeasurement)(measured), facts(body, response), modelDimension);
+        },
+        attachStream: base.attachStream
+            ? (stream, ingest, response) => {
+                // Nothing attached at all: the consumer's stream is left untouched and nothing reported.
+                if (skip?.(response))
+                    return;
+                // A second tap for the body's model and id - the wire readers carry out counters and
+                // nothing else. Each wire states them in its own envelope: Anthropic on
+                // `message_start.message`, the Responses API on `response`, Chat Completions at the
+                // chunk root. `meterStream` captures what it patches before patching, so two observers
+                // each see every chunk exactly once.
+                const seen = {};
+                (0, meter_stream_1.meterStream)(stream, (chunk) => {
+                    const envelope = chunk?.message ?? chunk?.response ?? chunk;
+                    if (typeof envelope?.model === 'string' && envelope.model)
+                        seen.model = envelope.model;
+                    if (typeof envelope?.id === 'string' && envelope.id)
+                        seen.id = envelope.id;
+                }, () => { });
+                base.attachStream(stream, (measurement) => ingest(withGatewayFacts((0, types_1.toMeasurement)(measurement), facts({ ...seen }, response), modelDimension)), response);
+            }
+            : undefined,
+    };
+}

package/dist/bindings/client/gateways/agentgateway/agentgateway-recipe.d.ts

@@ -1,3 +1,36 @@
+/**
+ * The agentgateway recipe - the open-source AI gateway (and the builds on it: Solo.io's enterprise
+ * edition, Gloo AI Gateway), a gateway you call that states no price.
+ *
+ * Its OpenAI routes fit `openAIRecipe` by shape and its Anthropic route fits `anthropicRecipe`, so
+ * the recipe has to justify itself, and it does on two counts:
+ *
+ *  - **A vendor name of its own.** Without this, traffic through the gateway meters as `openai.*`
+ *    or `anthropic.*` - indistinguishable from a direct call, so no meter and no per-provider
+ *    budget can tell the gateway's traffic apart. Worse on the Anthropic wire: `anthropicRecipe`
+ *    has no base-URL guard, so an `Anthropic` client pointed here would be claimed by it and
+ *    reported as direct Anthropic traffic.
+ *  - **The model that actually served.** The gateway can rewrite the model a request named - an
+ *    alias, a provider prefix, a failover priority group - and the response body names the one
+ *    that answered. The bare recipes drop it; this one attributes it.
+ *
+ * One vendor across every wire, because the gateway is one deployment whichever client reached it,
+ * and the wire is already in the event name (`agentgateway.chat.completions.create` against
+ * `agentgateway.messages.create`). The gateway translates where it needs to, so each route reports
+ * in the vocabulary of the wire it answered on - OpenAI's names on the OpenAI routes, Anthropic's
+ * on Messages - and `metrics` is the union, which is what `metrics` is defined to be.
+ *
+ * No `cost`, and that is the defining fact rather than an oversight. The gateway is self-hosted and
+ * states no price on any response; whatever the upstream charged is invoiced by the upstream, out
+ * of band. Never declare a metric the platform cannot report.
+ *
+ * Self-hosted, so there is no public hostname to recognise. The base URL handed to
+ * `agentgatewayRecipe({ baseUrl })` is the reliable discriminator; without one the matcher falls
+ * back to a guess on the hostname - see {@link isAgentgateway} for what it claims.
+ *
+ * The same surfaces govern raw HTTP too: `stigg.wrapFetch` routes a request by its path to the
+ * method here that names it, so a `fetch` to the gateway is metered by exactly these readers.
+ */
 import { AGENTGATEWAY_METRICS } from '../../../shared/token-usage';
 import type { AgentgatewayRecipeOptions } from './types';
 import type { ClientRecipe, MetricsFor, MetricsOf } from '../../core/types';

package/dist/bindings/client/gateways/agentgateway/agentgateway-recipe.js

@@ -34,12 +34,11 @@ exports.agentgatewayRecipe = agentgatewayRecipe;
  * The same surfaces govern raw HTTP too: `stigg.wrapFetch` routes a request by its path to the
  * method here that names it, so a `fetch` to the gateway is metered by exactly these readers.
  */
-const meter_stream_1 = require("../../../shared/meter-stream");
 const token_usage_1 = require("../../../shared/token-usage");
 const base_url_1 = require("../../../shared/base-url");
 const openai_recipe_1 = require("../../providers/openai/openai-recipe");
 const anthropic_recipe_1 = require("../../providers/anthropic/anthropic-recipe");
-const types_1 = require("../../../../types");
+const wire_surface_1 = require("../../core/wire-surface");
 /**
  * The name that identifies the gateway in an ordinary deployment: the Kubernetes service or
  * namespace (`agentgateway-proxy.agentgateway-system.svc`) or a hostname an operator chose to say
@@ -54,58 +53,11 @@ const types_1 = require("../../../../types");
  * and out of the meters counting them. Solo's and Gloo's builds name the gateway by `baseUrl`.
  */
 const HOST_LABEL = 'agentgateway';
-/** What only the gateway knows, folded onto whatever the wire's own reader produced. */
-function withGatewayFacts(measured, result, modelDimension) {
-    const served = typeof result?.model === 'string' ? result.model : undefined;
-    return {
-        ...measured,
-        dimensions: served
-            ? { ...measured.dimensions, [modelDimension]: served }
-            : measured.dimensions,
-        // The upstream's completion id, carried back through the gateway. It is what a replayed
-        // response repeats, which a local step counter cannot be.
-        idempotencyKey: measured.idempotencyKey ?? (typeof result?.id === 'string' ? result.id : undefined),
-    };
-}
 function agentgatewayRecipe(options = {}) {
     const estimate = options.estimate ?? (() => 1);
     const modelDimension = options.modelDimension ?? 'model';
-    /**
-     * One wire's surface, wrapped.
-     *
-     * The wire recipes' own extractors are reused rather than reimplemented: the gateway answers in
-     * that wire's shape, so that wire's reader is by definition the right one - and Anthropic's
-     * streamed usage in particular accumulates across two event types, which is not logic worth
-     * having a second copy of.
-     */
-    const surfaceOf = (base) => ({
-        // Spread first so anything the base declares and this wrapper does not know about - like
-        // `contextArg` - survives being wrapped.
-        ...base,
-        estimate,
-        extractUsage: (result, response) => {
-            const measured = base.extractUsage?.(result, response);
-            return measured === undefined ? undefined : withGatewayFacts((0, types_1.toMeasurement)(measured), result, modelDimension);
-        },
-        attachStream: base.attachStream
-            ? (stream, ingest, response) => {
-                // A second tap, purely for attribution: the wire readers carry out counters and nothing
-                // else. Each wire states the model in its own envelope - Anthropic on
-                // `message_start.message`, the Responses API on `response`, Chat Completions at the chunk
-                // root. `meterStream` captures what it patches before patching, so two observers each
-                // see every chunk exactly once.
-                let seen = {};
-                (0, meter_stream_1.meterStream)(stream, (chunk) => {
-                    const envelope = chunk?.message ?? chunk?.response ?? chunk;
-                    if (envelope?.model)
-                        seen = { ...seen, model: envelope.model };
-                    if (envelope?.id)
-                        seen = { ...seen, id: envelope.id };
-                }, () => { });
-                base.attachStream(stream, (measurement) => ingest(withGatewayFacts((0, types_1.toMeasurement)(measurement), seen, modelDimension)), response);
-            }
-            : undefined,
-    });
+    // The gateway answers in each wire's shape, and the body's model and id are its facts.
+    const surfaceOf = (base) => (0, wire_surface_1.gatewaySurface)(base, { estimate, modelDimension });
     return {
         vendor: 'agentgateway',
         metrics: token_usage_1.AGENTGATEWAY_METRICS,

package/dist/bindings/client/gateways/cloudflare/cloudflare-recipe.js

@@ -32,7 +32,7 @@ const base_url_1 = require("../../../shared/base-url");
 const registry_1 = require("../../core/registry");
 const openai_recipe_1 = require("../../providers/openai/openai-recipe");
 const anthropic_recipe_1 = require("../../providers/anthropic/anthropic-recipe");
-const types_1 = require("../../../../types");
+const wire_surface_1 = require("../../core/wire-surface");
 /** Workers AI, both of its routes. */
 const CLOUDFLARE_API_HOST = 'api.cloudflare.com';
 /** AI Gateway's public endpoint. A custom domain needs `options.baseUrl` instead. */
@@ -47,10 +47,6 @@ const ROUTED_MODEL_HEADER = 'cf-aig-routed-model';
 const STEP_HEADER = 'cf-aig-step';
 /** The gateway's own request id, stable across its retries - unlike a local step counter. */
 const REQUEST_ID_HEADER = 'cf-aig-request-id';
-const headerOf = (response, name) => {
-    const raw = response?.headers?.get(name);
-    return raw == null || raw === '' ? undefined : raw;
-};
 /**
  * Whether the gateway served this from its cache.
  *
@@ -62,28 +58,26 @@ const headerOf = (response, name) => {
  * Absent on the Workers AI routes, which have no cache in front of them - so this reads `false`
  * there and the surfaces behave as ordinary metered calls.
  */
-const isCacheHit = (response) => headerOf(response, CACHE_STATUS_HEADER)?.toUpperCase() === 'HIT';
-/** What only the gateway knows, folded onto whatever the upstream's own reader produced. */
-function withGatewayFacts(measured, result, response, modelDimension) {
-    const dimensions = { ...measured.dimensions };
-    // The model that actually served: the router's own word for it, falling back to whatever the
-    // forwarded body said. Anthropic's Messages body carries `model` too, so this works on both wires.
-    const served = headerOf(response, ROUTED_MODEL_HEADER) ?? (typeof result?.model === 'string' ? result.model : undefined);
-    if (served)
-        dimensions[modelDimension] = served;
+const isCacheHit = (response) => (0, wire_surface_1.headerOf)(response, CACHE_STATUS_HEADER)?.toUpperCase() === 'HIT';
+/** What only the gateway knows, from its headers, with the forwarded body as the fallback. */
+function gatewayFacts(body, response) {
+    const dimensions = {};
     // The substitute for a cost metric: the key to the gateway's own record of what this call cost.
-    const logId = headerOf(response, LOG_ID_HEADER);
+    const logId = (0, wire_surface_1.headerOf)(response, LOG_ID_HEADER);
     if (logId)
         dimensions.cf_aig_log_id = logId;
     // Only when a fallback actually happened. Step `0` is the ordinary case and tagging every event
     // with it would add a dimension to all of them for no information.
-    const step = headerOf(response, STEP_HEADER);
+    const step = (0, wire_surface_1.headerOf)(response, STEP_HEADER);
     if (step !== undefined && step !== '0')
         dimensions.cf_aig_step = step;
     return {
-        ...measured,
-        dimensions: Object.keys(dimensions).length > 0 ? dimensions : undefined,
-        idempotencyKey: headerOf(response, REQUEST_ID_HEADER) ?? measured.idempotencyKey ?? result?.id,
+        // The model that actually served: the router's own word for it, falling back to whatever the
+        // forwarded body said. Anthropic's Messages body carries `model` too, so this works on both wires.
+        model: (0, wire_surface_1.headerOf)(response, ROUTED_MODEL_HEADER) ?? body.model,
+        id: body.id,
+        requestId: (0, wire_surface_1.headerOf)(response, REQUEST_ID_HEADER),
+        dimensions,
     };
 }
 /** The Workers AI reader: the three counters it states, under its own (OpenAI's) names. */
@@ -106,57 +100,13 @@ function cloudflareRecipe(options = {}) {
     const estimate = options.estimate ?? (() => 1);
     const modelDimension = options.modelDimension ?? 'model';
     /**
-     * One upstream surface, wrapped.
+     * One upstream surface, wrapped. Off the gateway the wrapper is inert: no `cf-aig-*` header is
+     * present, so no cache hit is seen and no gateway dimension is added.
      *
-     * The upstream recipes' own extractors are reused rather than reimplemented, which is the point:
-     * AI Gateway forwards the provider's body untouched, so the provider's reader is by definition
-     * the right one - and Anthropic's streamed usage in particular accumulates across two event
-     * types, which is not logic worth having a second copy of. Off the gateway the wrapper is inert:
-     * no `cf-aig-*` header is present, so no cache hit is seen and no gateway dimension is added.
+     * A cache hit reports nothing, buffered or streamed: nobody was invoiced for it, and the cache
+     * header arrives before any token does.
      */
-    const surfaceOf = (base) => ({
-        // Spread first so anything the base declares and this wrapper does not know about - like
-        // `contextArg`, which says where `stiggContext` rides - survives being wrapped. Rebuilding
-        // the object field by field silently dropped it.
-        ...base,
-        path: base.path,
-        estimate,
-        extractUsage: (result, response) => {
-            // Nobody was invoiced for a cache hit, so nothing is reported for one. Checked before the
-            // body is read at all, because the body of a hit looks exactly like the body of a real call.
-            if (isCacheHit(response))
-                return undefined;
-            const measured = base.extractUsage?.(result, response);
-            return measured === undefined
-                ? undefined
-                : withGatewayFacts((0, types_1.toMeasurement)(measured), result, response, modelDimension);
-        },
-        attachStream: base.attachStream
-            ? (stream, ingest, response) => {
-                // A cached reply can be streamed back too, and the cache header arrives in time to say so.
-                // Nothing is attached at all in that case: the consumer's stream is left untouched and no
-                // measurement is produced, which is what a free call should report.
-                if (isCacheHit(response))
-                    return;
-                // A second tap, purely for attribution. The upstream recipes' stream readers carry out
-                // counters and nothing else, so without this the streamed path had no `result` to fall
-                // back on and a turn with no `cf-aig-routed-model` header lost its model entirely -
-                // where the buffered path reads it straight off the body. Each wire states it in its own
-                // envelope: Anthropic on `message_start.message`, the Responses API on `response`, Chat
-                // Completions at the chunk root. `meterStream` captures what it patches before patching,
-                // so stacking two observers is safe and each sees every chunk exactly once.
-                let seen = {};
-                (0, meter_stream_1.meterStream)(stream, (chunk) => {
-                    const envelope = chunk?.message ?? chunk?.response ?? chunk;
-                    if (envelope?.model)
-                        seen = { ...seen, model: envelope.model };
-                    if (envelope?.id)
-                        seen = { ...seen, id: envelope.id };
-                }, () => { });
-                base.attachStream(stream, (measurement) => ingest(withGatewayFacts((0, types_1.toMeasurement)(measurement), seen, response, modelDimension)), response);
-            }
-            : undefined,
-    });
+    const surfaceOf = (base) => (0, wire_surface_1.gatewaySurface)(base, { estimate, modelDimension, facts: gatewayFacts, skip: isCacheHit });
     /**
      * Chat Completions, which both products answer on - Workers AI's OpenAI-compatible route and the
      * gateway's `/openai` one.

package/dist/bindings/client/gateways/truefoundry/truefoundry-recipe.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The TrueFoundry recipe - TrueFoundry's AI Gateway, hosted at `gateway.truefoundry.ai` or
+ * self-hosted in your cluster, a gateway you call that states no price.
+ *
+ * Apps reach it by pointing an existing `OpenAI` or `Anthropic` client at the gateway's base URL
+ * with a TrueFoundry key, and naming models as `provider_account/model` (`openai-main/gpt-5-mini`).
+ * Both wires fit `openAIRecipe` and `anthropicRecipe` by shape, so the recipe earns its place the
+ * way agentgateway's does:
+ *
+ *  - **A vendor name of its own.** Without this, gateway traffic meters as `openai.*` or
+ *    `anthropic.*`, indistinguishable from a direct call. `anthropicRecipe` has no base-URL guard,
+ *    so an `Anthropic` client pointed here would be claimed as direct Anthropic traffic.
+ *  - **The model that actually served.** TrueFoundry load-balances and falls back between provider
+ *    accounts, and names the one that answered in the `x-tfy-resolved-model` response header.
+ *    Headers go on the wire before the body, so a streamed call has it too. The body's `model` is
+ *    the fallback when the header is absent.
+ *
+ * No `cost`. TrueFoundry tracks spend in its own dashboard and puts no price on any response; the
+ * provider accounts behind it are the caller's own keys, so the upstream invoices the tokens.
+ *
+ * Not covered: TrueFoundry's Gemini (`/gemini/<account>/proxy`), Bedrock (`/bedrock/proxy`) and
+ * Azure OpenAI (`/azure-openai`) passthroughs. Each speaks its own provider's SDK and shape.
+ *
+ * `stigg.wrapFetch` governs raw HTTP to the gateway through these same methods.
+ */
+import { TRUEFOUNDRY_METRICS } from '../../../shared/token-usage';
+import type { TrueFoundryRecipeOptions } from './types';
+import type { ClientRecipe, MetricsFor, MetricsOf } from '../../core/types';
+type TrueFoundryMetric = (typeof TRUEFOUNDRY_METRICS)[number];
+export declare function truefoundryRecipe(options?: TrueFoundryRecipeOptions): ClientRecipe<TrueFoundryMetric>;
+/** One of the metric names TrueFoundry can report, across every wire it serves. */
+export type TrueFoundryMetricName = MetricsOf<ReturnType<typeof truefoundryRecipe>>;
+/** What a mapper reads off a call through TrueFoundry: those names, each possibly absent. */
+export type TrueFoundryMetrics = MetricsFor<ReturnType<typeof truefoundryRecipe>>;
+export {};

package/dist/bindings/client/gateways/truefoundry/truefoundry-recipe.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truefoundryRecipe = truefoundryRecipe;
+/**
+ * The TrueFoundry recipe - TrueFoundry's AI Gateway, hosted at `gateway.truefoundry.ai` or
+ * self-hosted in your cluster, a gateway you call that states no price.
+ *
+ * Apps reach it by pointing an existing `OpenAI` or `Anthropic` client at the gateway's base URL
+ * with a TrueFoundry key, and naming models as `provider_account/model` (`openai-main/gpt-5-mini`).
+ * Both wires fit `openAIRecipe` and `anthropicRecipe` by shape, so the recipe earns its place the
+ * way agentgateway's does:
+ *
+ *  - **A vendor name of its own.** Without this, gateway traffic meters as `openai.*` or
+ *    `anthropic.*`, indistinguishable from a direct call. `anthropicRecipe` has no base-URL guard,
+ *    so an `Anthropic` client pointed here would be claimed as direct Anthropic traffic.
+ *  - **The model that actually served.** TrueFoundry load-balances and falls back between provider
+ *    accounts, and names the one that answered in the `x-tfy-resolved-model` response header.
+ *    Headers go on the wire before the body, so a streamed call has it too. The body's `model` is
+ *    the fallback when the header is absent.
+ *
+ * No `cost`. TrueFoundry tracks spend in its own dashboard and puts no price on any response; the
+ * provider accounts behind it are the caller's own keys, so the upstream invoices the tokens.
+ *
+ * Not covered: TrueFoundry's Gemini (`/gemini/<account>/proxy`), Bedrock (`/bedrock/proxy`) and
+ * Azure OpenAI (`/azure-openai`) passthroughs. Each speaks its own provider's SDK and shape.
+ *
+ * `stigg.wrapFetch` governs raw HTTP to the gateway through these same methods.
+ */
+const token_usage_1 = require("../../../shared/token-usage");
+const base_url_1 = require("../../../shared/base-url");
+const openai_recipe_1 = require("../../providers/openai/openai-recipe");
+const anthropic_recipe_1 = require("../../providers/anthropic/anthropic-recipe");
+const wire_surface_1 = require("../../core/wire-surface");
+/** TrueFoundry's own domains: the hosted gateway, and the tenant control planes that serve one. */
+const TRUEFOUNDRY_HOSTS = ['truefoundry.ai', 'truefoundry.cloud', 'truefoundry.com'];
+/** Which model answered, after TrueFoundry's load balancing or fallback. */
+const RESOLVED_MODEL_HEADER = 'x-tfy-resolved-model';
+function truefoundryRecipe(options = {}) {
+    const estimate = options.estimate ?? (() => 1);
+    const modelDimension = options.modelDimension ?? 'model';
+    // The gateway answers in each wire's shape. The header names the model that served, ahead of
+    // the body's, and is on the wire before a streamed body is.
+    const surfaceOf = (base) => (0, wire_surface_1.gatewaySurface)(base, {
+        estimate,
+        modelDimension,
+        facts: (body, response) => ({ ...body, model: (0, wire_surface_1.headerOf)(response, RESOLVED_MODEL_HEADER) ?? body.model }),
+    });
+    return {
+        vendor: 'truefoundry',
+        metrics: token_usage_1.TRUEFOUNDRY_METRICS,
+        totalTokensMetric: token_usage_1.TOTAL_TOKENS,
+        matches: (client) => isTrueFoundry(client, options.baseUrl) && (openai_recipe_1.openAIRecipe.matches(client) || anthropic_recipe_1.anthropicRecipe.matches(client)),
+        // Every wire it serves. This recipe is matched ahead of both bare ones, so a surface left out
+        // here would be ungated rather than metered by them.
+        methods: [...openai_recipe_1.openAIRecipe.methods.map(surfaceOf), ...anthropic_recipe_1.anthropicRecipe.methods.map(surfaceOf)],
+    };
+}
+/**
+ * Given a `baseUrl`, the endpoint is compared one path segment at a time, so `.../v1` cannot claim
+ * `.../v10`, and TrueFoundry's own domains are no longer claimed. Without one, only TrueFoundry's own
+ * domains and their subdomains are claimed - a self-hosted install under your hostname needs the
+ * `baseUrl`.
+ *
+ * That claims every OpenAI- or Anthropic-shaped client on those domains, not only the gateway - a
+ * model TrueFoundry serves there directly reports under `truefoundry.*` too. Name
+ * `recipe: openAIRecipe` (or `anthropicRecipe`) at `wrap` to settle it.
+ */
+function isTrueFoundry(client, baseUrl) {
+    const clientBase = (0, base_url_1.baseUrlOf)(client);
+    if (clientBase === undefined)
+        return false;
+    if (baseUrl)
+        return (0, base_url_1.withinBaseUrl)(baseUrl, clientBase);
+    return (0, base_url_1.matchesAnyHost)(clientBase, TRUEFOUNDRY_HOSTS);
+}

package/dist/bindings/client/gateways/truefoundry/types.d.ts

@@ -0,0 +1,22 @@
+export type TrueFoundryRecipeOptions = {
+    /**
+     * How much to ask permission for before the call, in whatever unit `meter` bills.
+     *
+     * The default asks for 1 - "is there any budget left at all?" - and lets the ingest afterwards
+     * settle the balance. No `unitsPer…` beside it: TrueFoundry puts no price on any response, so a
+     * run here bills token counters, which arrive whole.
+     */
+    estimate?: (params: any) => number;
+    /**
+     * Dimension the model that actually served is attributed to, so routing drift is visible in
+     * Stigg. TrueFoundry load-balances and falls back between provider accounts, and says which one
+     * answered in the `x-tfy-resolved-model` response header.
+     */
+    modelDimension?: string;
+    /**
+     * The gateway this recipe is for, when it is not TrueFoundry's hosted one. A self-hosted install
+     * runs under your own hostname, so give it the same base URL the client was built with and
+     * `matches` compares against exactly that. Without it only TrueFoundry's own domains are claimed.
+     */
+    baseUrl?: string;
+};

package/dist/bindings/client/gateways/truefoundry/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -9,16 +9,26 @@
  * bindings. A call's own `stiggContext` rides `providerOptions.stigg`, and is taken out before the
  * provider sees the call. Nothing here imports `ai`: a middleware is a plain object. See
  * docs/vercel-ai.md.
+ *
+ * A model middleware never sees a tool run, so the paid tools are governed by `tools()`, which wraps
+ * each one's `execute`. A tool call is governed as the model step that asked for it.
  */
 import type { StiggAgentSDK } from '../../../stigg-agent-sdk';
 import type { SessionHooks } from '../../../core/session';
-import type { ClientContext, GovernedAgentMiddleware, Measurement } from '../../../types';
+import type { ClientContext, GovernedAgentMiddleware, Measurement, MiddlewareTools } from '../../../types';
+import { type ModelUsage } from './usage';
 export { VERCEL_AI_METRICS, measurementOf } from './usage';
 export type { VercelAIMetric, VercelAIMetrics } from './usage';
 export type StiggVercelMiddlewareOptions = {
     stigg: StiggAgentSDK;
     /** Every call's context - typically the agent's `agentId` and what it gates on. A call's `providerOptions.stigg` is laid over it. */
     stiggContext?: ClientContext;
+    /**
+     * The paid tools, by tool name - `'*'` for every tool not named, `false` to exempt one. Governed
+     * once wrapped by `tools()`. A sub-agent run inside a tool is metered by its own model calls, so
+     * give it `false` under `'*'`.
+     */
+    tools?: MiddlewareTools;
     hooks?: SessionHooks;
 };
 /**
@@ -40,13 +50,30 @@ export type StiggVercelMiddleware = {
         params: any;
         model?: any;
     }): Promise<any>;
+    /**
+     * The same tools, each paid one's `execute` wrapped: checked before it runs, and reported after it
+     * succeeds. A refused tool does not run; it fails with a message that names the tool and why, and
+     * `stigg.denial(error)` returns the decision. Tools with no `execute` are returned as they are.
+     */
+    tools<T extends Record<string, any>>(tools: T): T;
     /** What this middleware did, and what is still in flight. */
     readonly stigg: GovernedAgentMiddleware['stigg'];
 };
-export declare function stiggVercelMiddleware({ stigg, stiggContext, hooks, }: StiggVercelMiddlewareOptions): StiggVercelMiddleware;
+export declare function stiggVercelMiddleware({ stigg, stiggContext, tools: toolConfig, hooks, }: StiggVercelMiddlewareOptions): StiggVercelMiddleware;
+type StreamPart = {
+    type?: string;
+    id?: string;
+    modelId?: unknown;
+    delta?: unknown;
+    usage?: ModelUsage;
+};
 /**
  * Calls `done` once, when the stream ends: read to the end, failed, cancelled, or stopped by the
  * call's `abortSignal` - which is how the AI SDK stops a stream, without cancelling it.
  * ponytail: a reader that stops with no `abortSignal` is not reported; nothing tells this layer.
  */
-export declare function observeStream(result: any, signal: AbortSignal | undefined, done: (measurement: Measurement | undefined, modelId?: string) => void): void;
+export declare function observeStream(result: any, signal: AbortSignal | undefined, done: (measurement: Measurement | undefined, modelId?: string) => void, 
+/** Each part, before the AI SDK reads it - so a tool call is known before its tool can start. */
+onPart?: (part: StreamPart & {
+    toolCallId?: unknown;
+}) => void): void;

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

@@ -3,17 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.measurementOf = exports.VERCEL_AI_METRICS = void 0;
 exports.stiggVercelMiddleware = stiggVercelMiddleware;
 exports.observeStream = observeStream;
+const errors_1 = require("../../../errors");
+const hooks_1 = require("../../../core/hooks");
+const agent_middleware_1 = require("../core/agent-middleware");
 const usage_1 = require("./usage");
 var usage_2 = require("./usage");
 Object.defineProperty(exports, "VERCEL_AI_METRICS", { enumerable: true, get: function () { return usage_2.VERCEL_AI_METRICS; } });
 Object.defineProperty(exports, "measurementOf", { enumerable: true, get: function () { return usage_2.measurementOf; } });
 const MISSING_CUSTOMER = 'Name it on every call as `providerOptions: { stigg: { customerId } }`, ' +
     'or give the middleware a default in its `stiggContext: { customerId }`.';
-function stiggVercelMiddleware({ stigg, stiggContext, hooks, }) {
+/** How many asked-for tool calls are remembered. One that never runs - a client-side tool - is dropped past it. */
+const ISSUED_CALLS_LIMIT = 1_000;
+function stiggVercelMiddleware({ stigg, stiggContext, tools: toolConfig, hooks, }) {
     if (!stigg || typeof stigg.middleware !== 'function') {
         throw new Error('stiggVercelMiddleware needs `stigg`: the StiggAgentSDK instance to govern through.');
     }
-    const governance = stigg.middleware({ stiggContext, hooks, missingCustomer: MISSING_CUSTOMER });
+    const governance = stigg.middleware({ stiggContext, tools: toolConfig, hooks, missingCustomer: MISSING_CUSTOMER });
     // `doGenerate()` takes no arguments: the model is called with what `transformParams` returned.
     // So the context comes out there, and is found again by that params object.
     const contexts = new WeakMap();
@@ -27,11 +32,128 @@ function stiggVercelMiddleware({ stigg, stiggContext, hooks, }) {
     // of the same customer included - never queue behind it. A call with no context of its own falls
     // back to its customer and agent. `endModel` never rejects.
     const reporting = new Map();
-    const callOf = (params) => contexts.get(params) ?? JSON.stringify([stiggContext?.customerId, stiggContext?.agentId]);
+    const defaultCall = JSON.stringify([stiggContext?.customerId, stiggContext?.agentId]);
+    const callOf = (params) => contexts.get(params) ?? defaultCall;
+    /** Waits for a call's stream reports in flight, so its next check sees their spend. */
+    const settle = (call) => Promise.all(reporting.get(call) ?? []);
+    // A tool's `execute` is handed only the call id, so each tool call a model step asks for is kept
+    // by its id - before the AI SDK can start the tool - and taken when it runs.
+    // Only for tools `tools()` wrapped: another's call - client-side, run by the provider - never runs
+    // here, and would only fill the map.
+    // ponytail: keyed by the provider's id alone. First-party providers make each id unique; a
+    // backend that reuses ids (`call_0`) across concurrent calls would let one call's entry replace
+    // another's - scope the key by call if one shows up. A call `experimental_repairToolCall` renames
+    // is not kept either, and is governed as one no step asked for.
+    const issued = new Map();
+    const wrapped = new Set();
+    const ask = (params, part) => {
+        if (part?.type !== 'tool-call' || typeof part.toolCallId !== 'string' || part.providerExecuted)
+            return;
+        if (typeof part.toolName !== 'string' || !wrapped.has(part.toolName))
+            return;
+        issued.delete(part.toolCallId);
+        issued.set(part.toolCallId, { context: contexts.get(params), call: callOf(params) });
+        if (issued.size > ISSUED_CALLS_LIMIT)
+            issued.delete(issued.keys().next().value);
+    };
+    /**
+     * Said once per tool: a call no model step of this middleware asked for - approved after a pause
+     * (`needsApproval` runs it at the start of the next call, before any model step), answered on
+     * another instance, or asked by another middleware's model - and whose own context names no
+     * `stigg`, is governed by this middleware's own `stiggContext`, and reported for its customer.
+     */
+    const warned = new Set();
+    const warnOnce = (name) => {
+        if (warned.has(name))
+            return;
+        warned.add(name);
+        // A logger that throws must not fail the tool it only reports on.
+        (0, hooks_1.safely)(() => stigg.config?.logger?.warn(`[stigg] tool "${name}" ran without a model step this middleware saw asking for it, and its ` +
+            "context names no `stigg`, so it is governed by the middleware's own stiggContext. An approved " +
+            `tool does this: name its customer in \`toolsContext: { ${name}: { stigg: { customerId } } }\`.`), () => undefined);
+    };
+    /** Checks a tool call as the step that asked for it. Refused: an error the model may read. */
+    const startTool = async (name, input, options) => {
+        const callId = typeof options?.toolCallId === 'string' ? options.toolCallId : undefined;
+        const issuedCall = callId === undefined ? undefined : issued.get(callId);
+        if (callId !== undefined)
+            issued.delete(callId);
+        // No model step asked for it here - an approved tool runs at the start of the next call - so
+        // the tool's own context may name who it is for: `toolsContext` (ai 7), `experimental_context` (ai 6).
+        const stated = issuedCall ? undefined : toolContextOf(options);
+        const asked = issuedCall ?? (stated ? { context: stated, call: stated } : undefined);
+        if (!asked)
+            warnOnce(name);
+        // A stream reports when it ends, and the AI SDK runs its tools before that: the tool's check
+        // waits, so it sees the spend of the step that asked for it.
+        await settle(asked?.call ?? defaultCall);
+        const runId = `${prefix}:tool:${++steps}`;
+        try {
+            await governance.startTool(runId, { name, callId, input }, { stiggContexts: asked?.context ? [asked.context] : [] });
+        }
+        catch (err) {
+            const decision = (0, errors_1.isAccessDenied)(err);
+            if (!decision)
+                throw err;
+            // The AI SDK hands a failed tool's message to the model, so it says why, not who refused or
+            // what is left. The decision rides along as the cause, for `stigg.denial(error)`.
+            throw new Error(`${name} is not available: ${decision.reason ?? 'access denied'}.`, { cause: err });
+        }
+        return runId;
+    };
+    /**
+     * A tool whose `execute` is checked and reported. An `async function*` streams its results, and is
+     * reported by its last one, as the AI SDK takes it.
+     * ponytail: any other function returns a promise here, since the check is awaited first - so an
+     * async iterable it returns is run to its end and answered by its last value, without the
+     * preliminary results. Write it as `async function*` to stream them.
+     */
+    const governTool = (name, tool) => {
+        const execute = tool.execute;
+        if (Object.prototype.toString.call(execute) === '[object AsyncGeneratorFunction]') {
+            return async function* (input, options) {
+                const runId = await startTool(name, input, options);
+                let output;
+                let finished = false;
+                try {
+                    for await (const value of execute.call(tool, input, options)) {
+                        output = value;
+                        yield value;
+                    }
+                    finished = true;
+                }
+                finally {
+                    if (!finished)
+                        governance.abandon(runId);
+                }
+                await governance.endTool(runId, output, name);
+            };
+        }
+        return async (input, options) => {
+            const runId = await startTool(name, input, options);
+            let output;
+            try {
+                output = await execute.call(tool, input, options);
+                if (isAsyncIterable(output)) {
+                    let last;
+                    for await (const value of output)
+                        last = value;
+                    output = last;
+                }
+            }
+            catch (err) {
+                governance.abandon(runId);
+                throw err;
+            }
+            // Awaited, and the AI SDK waits for every tool before the next step: that step's check sees it.
+            await governance.endTool(runId, output, name);
+            return output;
+        };
+    };
     /** Checks the step, as the agent and customer this call names. Refused: `AccessDeniedError`. */
     const start = async (params, model, event) => {
         // Once: a call's steps run one after another, so nothing of its own lands while this waits.
-        await Promise.all(reporting.get(callOf(params)) ?? []);
+        await settle(callOf(params));
         const runId = `${prefix}:${++steps}`;
         const context = contexts.get(params);
         // Kept by the middleware until the step ends, so the model the reply names can still land on it.
@@ -42,6 +164,23 @@ function stiggVercelMiddleware({ stigg, stiggContext, hooks, }) {
     return {
         specificationVersion: 'v3',
         stigg: governance.stigg,
+        tools(tools) {
+            if (!toolConfig || Object.keys(toolConfig).length === 0) {
+                throw new Error("stiggVercelMiddleware's tools() needs a `tools` option: the paid tools by name, '*' for the rest.");
+            }
+            // Only a tool the config governs - by name, else through `'*'` - as the core looks it up. An
+            // exempt or unpriced one is left as it is: nothing would check it, so nothing should wait.
+            const governed = (name) => {
+                const entry = Object.hasOwn(toolConfig, name) ? toolConfig[name] : toolConfig[agent_middleware_1.ALL_TOOLS];
+                return entry !== undefined && entry !== false;
+            };
+            return Object.fromEntries(Object.entries(tools).map(([name, tool]) => {
+                if (typeof tool?.execute !== 'function' || !governed(name))
+                    return [name, tool];
+                wrapped.add(name);
+                return [name, { ...tool, execute: governTool(name, tool) }];
+            }));
+        },
         async transformParams({ params }) {
             const options = params?.providerOptions;
             if (!options || typeof options !== 'object' || !('stigg' in options))
@@ -71,6 +210,8 @@ function stiggVercelMiddleware({ stigg, stiggContext, hooks, }) {
             const responseId = result?.response?.id;
             const chars = (0, usage_1.contentChars)(result?.content);
             served(trace, result?.response?.modelId);
+            for (const part of Array.isArray(result?.content) ? result.content : [])
+                ask(params, part);
             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;
         },
@@ -98,7 +239,7 @@ function stiggVercelMiddleware({ stigg, stiggContext, hooks, }) {
                     if (pending.size === 0 && reporting.get(call) === pending)
                         reporting.delete(call);
                 });
-            });
+            }, (part) => ask(params, part));
             return result;
         },
     };
@@ -180,7 +321,9 @@ function streamTally() {
  * call's `abortSignal` - which is how the AI SDK stops a stream, without cancelling it.
  * ponytail: a reader that stops with no `abortSignal` is not reported; nothing tells this layer.
  */
-function observeStream(result, signal, done) {
+function observeStream(result, signal, done, 
+/** Each part, before the AI SDK reads it - so a tool call is known before its tool can start. */
+onPart) {
     const source = result?.stream;
     if (typeof source?.getReader !== 'function') {
         done(undefined);
@@ -214,6 +357,11 @@ function observeStream(result, signal, done) {
                 return;
             }
             tally.record(next.value);
+            onPart?.(next.value);
+            // The AI SDK starts a step's tools on its `finish` part, before the stream closes - which, from
+            // an HTTP provider, is a later read. So the step reports here, and its tools' checks see it.
+            if (next.value?.type === 'finish')
+                report('ended');
             controller.enqueue(next.value);
         },
         async cancel(reason) {
@@ -222,3 +370,17 @@ function observeStream(result, signal, done) {
         },
     });
 }
+const isAsyncIterable = (value) => typeof value?.[Symbol.asyncIterator] === 'function';
+/** The `stigg` a tool's own context states - its `toolsContext` entry on ai 7, `experimental_context` on ai 6. */
+function toolContextOf(options) {
+    const context = options?.context?.stigg ?? options?.experimental_context?.stigg;
+    if (context === undefined || context === null)
+        return undefined;
+    if (typeof context !== 'object' || Array.isArray(context)) {
+        throw new TypeError(`A tool's context \`stigg\` must be a stiggContext object - got ${typeof context}.`);
+    }
+    // On ai 6 the context is the whole app's, and `stigg` there may be the SDK instance itself: only
+    // a plain object is a stiggContext. Anything else names no one, and the SDK says so.
+    const proto = Object.getPrototypeOf(context);
+    return proto === Object.prototype || proto === null ? context : undefined;
+}

package/dist/bindings/shared/token-usage.d.ts

@@ -141,28 +141,24 @@ export declare const OPENAI_METRICS: readonly ["prompt_tokens", "completion_toke
 /** A gateway speaks the OpenAI shape and adds the price it charged, under its own field name. */
 export declare const GATEWAY_METRICS: readonly ["prompt_tokens", "completion_tokens", "input_tokens", "output_tokens", "cached_tokens", "total_tokens", "cost"];
 /**
- * A gateway that forwards the upstream body untouched, and so reports in two vocabularies.
- *
- * Unlike LiteLLM, which normalises every upstream to the OpenAI wire, Cloudflare AI Gateway's
- * provider-native routes pass the provider's own body straight through - so `/openai` returns
- * OpenAI's counter names and `/anthropic` returns Anthropic's. One recipe serves both wires, so
- * this is the union of what its surfaces can report, which is what `metrics` is defined to be.
- *
- * No `cost`, and that is the defining fact rather than an oversight. Cloudflare states no price on
- * any response: its figure lives in the gateway's own log, is explicitly an estimate, and is zero
- * on a cache hit. So the recipe carries the log id as a dimension and lets spend be reconciled out
- * of band, exactly as the gateway reference prescribes for a price that is only available
- * asynchronously.
+ * A gateway that answers on the OpenAI routes and on Anthropic Messages, each in its own wire's
+ * vocabulary - so the union of the two, which is what `metrics` is defined to be.
+ *
+ * No `cost` on any of the gateways that use it, and that is the defining fact rather than an
+ * oversight: none of them states a price on the response, so spend is reconciled out of band.
  */
-export declare const CLOUDFLARE_METRICS: readonly ["prompt_tokens", "completion_tokens", "input_tokens", "output_tokens", "cached_tokens", "total_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"];
+export declare const OPENAI_ANTHROPIC_METRICS: readonly ["prompt_tokens", "completion_tokens", "input_tokens", "output_tokens", "cached_tokens", "total_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"];
 /**
- * agentgateway, which answers on the OpenAI routes and on Anthropic Messages - each in its
- * own wire's vocabulary, so the union of the two, like Cloudflare's.
- *
- * No `cost`: the gateway is self-hosted and states no price on any response.
- * Whatever the upstream charged is invoiced by the upstream, out of band.
+ * Cloudflare AI Gateway's provider-native routes pass the provider's body straight through, unlike
+ * LiteLLM, which normalises every upstream to the OpenAI wire. Its price lives in the gateway's own
+ * log, is explicitly an estimate, and is zero on a cache hit - so the recipe carries the log id as
+ * a dimension instead.
  */
+export declare const CLOUDFLARE_METRICS: readonly ["prompt_tokens", "completion_tokens", "input_tokens", "output_tokens", "cached_tokens", "total_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"];
+/** agentgateway is self-hosted and states no price; the upstream invoices out of band. */
 export declare const AGENTGATEWAY_METRICS: readonly ["prompt_tokens", "completion_tokens", "input_tokens", "output_tokens", "cached_tokens", "total_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"];
+/** TrueFoundry tracks spend in its own dashboard; the provider accounts behind it are the caller's. */
+export declare const TRUEFOUNDRY_METRICS: readonly ["prompt_tokens", "completion_tokens", "input_tokens", "output_tokens", "cached_tokens", "total_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"];
 /**
  * Bedrock's five, under its own names and with no price among them.
  *

package/dist/bindings/shared/token-usage.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizedMetrics = exports.addMetrics = exports.METRIC_PATHS = exports.metricNamesMatchPaths = exports.COMPUTED_TOTALS = exports.metricName = exports.WORKERS_AI_METRICS = exports.WORKERS_AI_PATHS = exports.DATABRICKS_QUERY_METRIC_NAME_MAP = exports.DATABRICKS_METRICS = exports.DATABRICKS_RESPONSES_PATHS = exports.DATABRICKS_PATHS = exports.BEDROCK_METRICS = exports.BEDROCK_PATHS = exports.AGENTGATEWAY_METRICS = exports.CLOUDFLARE_METRICS = exports.GATEWAY_METRICS = exports.OPENAI_METRICS = exports.OLLAMA_METRICS = exports.OLLAMA_COMPONENT_METRICS = exports.TYPESAFE_METRICS = exports.TYPESAFE_COMPONENT_METRICS = exports.MISTRAL_METRICS = exports.MISTRAL_METRIC_NAME_MAP = exports.OPENAI_RESPONSES_METRICS = exports.OPENAI_CHAT_METRICS = exports.GEMINI_COMPONENT_METRICS = exports.GEMINI_METRICS = exports.ANTHROPIC_METRICS = exports.ANTHROPIC_COMPONENT_METRICS = exports.TOTAL_TOKENS = exports.addTokenUsage = void 0;
+exports.normalizedMetrics = exports.addMetrics = exports.METRIC_PATHS = exports.metricNamesMatchPaths = exports.COMPUTED_TOTALS = exports.metricName = exports.WORKERS_AI_METRICS = exports.WORKERS_AI_PATHS = exports.DATABRICKS_QUERY_METRIC_NAME_MAP = exports.DATABRICKS_METRICS = exports.DATABRICKS_RESPONSES_PATHS = exports.DATABRICKS_PATHS = exports.BEDROCK_METRICS = exports.BEDROCK_PATHS = exports.TRUEFOUNDRY_METRICS = exports.AGENTGATEWAY_METRICS = exports.CLOUDFLARE_METRICS = exports.OPENAI_ANTHROPIC_METRICS = exports.GATEWAY_METRICS = exports.OPENAI_METRICS = exports.OLLAMA_METRICS = exports.OLLAMA_COMPONENT_METRICS = exports.TYPESAFE_METRICS = exports.TYPESAFE_COMPONENT_METRICS = exports.MISTRAL_METRICS = exports.MISTRAL_METRIC_NAME_MAP = exports.OPENAI_RESPONSES_METRICS = exports.OPENAI_CHAT_METRICS = exports.GEMINI_COMPONENT_METRICS = exports.GEMINI_METRICS = exports.ANTHROPIC_METRICS = exports.ANTHROPIC_COMPONENT_METRICS = exports.TOTAL_TOKENS = exports.addTokenUsage = void 0;
 exports.fromFlatTokenUsage = fromFlatTokenUsage;
 exports.fromOpenAIUsage = fromOpenAIUsage;
 exports.fromResponsesUsage = fromResponsesUsage;
@@ -407,36 +407,28 @@ exports.OPENAI_METRICS = [
 /** A gateway speaks the OpenAI shape and adds the price it charged, under its own field name. */
 exports.GATEWAY_METRICS = [...exports.OPENAI_METRICS, 'cost'];
 /**
- * A gateway that forwards the upstream body untouched, and so reports in two vocabularies.
- *
- * Unlike LiteLLM, which normalises every upstream to the OpenAI wire, Cloudflare AI Gateway's
- * provider-native routes pass the provider's own body straight through - so `/openai` returns
- * OpenAI's counter names and `/anthropic` returns Anthropic's. One recipe serves both wires, so
- * this is the union of what its surfaces can report, which is what `metrics` is defined to be.
- *
- * No `cost`, and that is the defining fact rather than an oversight. Cloudflare states no price on
- * any response: its figure lives in the gateway's own log, is explicitly an estimate, and is zero
- * on a cache hit. So the recipe carries the log id as a dimension and lets spend be reconciled out
- * of band, exactly as the gateway reference prescribes for a price that is only available
- * asynchronously.
+ * A gateway that answers on the OpenAI routes and on Anthropic Messages, each in its own wire's
+ * vocabulary - so the union of the two, which is what `metrics` is defined to be.
+ *
+ * No `cost` on any of the gateways that use it, and that is the defining fact rather than an
+ * oversight: none of them states a price on the response, so spend is reconciled out of band.
  */
-exports.CLOUDFLARE_METRICS = [
+exports.OPENAI_ANTHROPIC_METRICS = [
     ...exports.OPENAI_METRICS,
     'cache_read_input_tokens',
     'cache_creation_input_tokens',
 ];
 /**
- * agentgateway, which answers on the OpenAI routes and on Anthropic Messages - each in its
- * own wire's vocabulary, so the union of the two, like Cloudflare's.
- *
- * No `cost`: the gateway is self-hosted and states no price on any response.
- * Whatever the upstream charged is invoiced by the upstream, out of band.
+ * Cloudflare AI Gateway's provider-native routes pass the provider's body straight through, unlike
+ * LiteLLM, which normalises every upstream to the OpenAI wire. Its price lives in the gateway's own
+ * log, is explicitly an estimate, and is zero on a cache hit - so the recipe carries the log id as
+ * a dimension instead.
  */
-exports.AGENTGATEWAY_METRICS = [
-    ...exports.OPENAI_METRICS,
-    'cache_read_input_tokens',
-    'cache_creation_input_tokens',
-];
+exports.CLOUDFLARE_METRICS = exports.OPENAI_ANTHROPIC_METRICS;
+/** agentgateway is self-hosted and states no price; the upstream invoices out of band. */
+exports.AGENTGATEWAY_METRICS = exports.OPENAI_ANTHROPIC_METRICS;
+/** TrueFoundry tracks spend in its own dashboard; the provider accounts behind it are the caller's. */
+exports.TRUEFOUNDRY_METRICS = exports.OPENAI_ANTHROPIC_METRICS;
 /**
  * Bedrock's five, under its own names and with no price among them.
  *

package/dist/index.d.ts

@@ -60,6 +60,9 @@ export type { CloudflareRecipeOptions } from './bindings/client/gateways/cloudfl
 export { agentgatewayRecipe } from './bindings/client/gateways/agentgateway/agentgateway-recipe';
 export type { AgentgatewayMetricName, AgentgatewayMetrics, } from './bindings/client/gateways/agentgateway/agentgateway-recipe';
 export type { AgentgatewayRecipeOptions } from './bindings/client/gateways/agentgateway/types';
+export { truefoundryRecipe } from './bindings/client/gateways/truefoundry/truefoundry-recipe';
+export type { TrueFoundryMetricName, TrueFoundryMetrics, } from './bindings/client/gateways/truefoundry/truefoundry-recipe';
+export type { TrueFoundryRecipeOptions } from './bindings/client/gateways/truefoundry/types';
 export type { FetchLike, FetchOptions, GovernedFetch, GovernedRequestInit } from './bindings/fetch/types';
 export { typesafeRecipe, estimateFromState } from './bindings/client/providers/typesafe/typesafe-recipe';
 export type { TypeSafeMetric, TypeSafeMetrics } from './bindings/client/providers/typesafe/typesafe-recipe';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeUsage = exports.normalizedMetrics = exports.stiggVercelMiddleware = exports.weightedMetrics = exports.estimateFromState = exports.typesafeRecipe = exports.agentgatewayRecipe = exports.cloudflareRecipe = exports.bedrockRecipe = exports.databricksExternalRecipe = exports.databricksRecipe = exports.ollamaRecipe = exports.mistralRecipe = exports.groqRecipe = exports.litellmRecipe = exports.openrouterRecipe = exports.estimateFromMaxOutputTokens = exports.geminiChatRecipe = exports.geminiRecipe = exports.openAIRecipe = exports.estimateFromMaxTokens = exports.anthropicRecipe = exports.hasMethod = exports.createClientRegistry = exports.wrapClient = exports.toMeasurement = exports.entitlementRef = exports.entitlementKind = exports.entitlementId = exports.emptyTokenUsage = exports.vendorMetrics = exports.unitsPerTokens = exports.looksLikeGovernanceNotEnabled = exports.isGovernanceNotEnabled = exports.isAccessDenied = exports.isEngineError = exports.GovernanceNotEnabledError = exports.AccessDeniedError = exports.EngineError = exports.STIGG_TRACER_NAME = exports.noopLogger = exports.consoleLogger = exports.parseGovernanceHeaders = exports.GOVERNANCE_HEADERS = exports.remedyMessage = exports.describeDecision = exports.flattenRaw = exports.RAW_PREFIX = exports.StiggAgentSDK = void 0;
+exports.normalizeUsage = exports.normalizedMetrics = exports.stiggVercelMiddleware = exports.weightedMetrics = exports.estimateFromState = exports.typesafeRecipe = exports.truefoundryRecipe = exports.agentgatewayRecipe = exports.cloudflareRecipe = exports.bedrockRecipe = exports.databricksExternalRecipe = exports.databricksRecipe = exports.ollamaRecipe = exports.mistralRecipe = exports.groqRecipe = exports.litellmRecipe = exports.openrouterRecipe = exports.estimateFromMaxOutputTokens = exports.geminiChatRecipe = exports.geminiRecipe = exports.openAIRecipe = exports.estimateFromMaxTokens = exports.anthropicRecipe = exports.hasMethod = exports.createClientRegistry = exports.wrapClient = exports.toMeasurement = exports.entitlementRef = exports.entitlementKind = exports.entitlementId = exports.emptyTokenUsage = exports.vendorMetrics = exports.unitsPerTokens = exports.looksLikeGovernanceNotEnabled = exports.isGovernanceNotEnabled = exports.isAccessDenied = exports.isEngineError = exports.GovernanceNotEnabledError = exports.AccessDeniedError = exports.EngineError = exports.STIGG_TRACER_NAME = exports.noopLogger = exports.consoleLogger = exports.parseGovernanceHeaders = exports.GOVERNANCE_HEADERS = exports.remedyMessage = exports.describeDecision = exports.flattenRaw = exports.RAW_PREFIX = exports.StiggAgentSDK = void 0;
 /**
  * Public surface.
  *
@@ -126,6 +126,12 @@ Object.defineProperty(exports, "cloudflareRecipe", { enumerable: true, get: func
 // and no `cost`, because the gateway states no price on any response.
 var agentgateway_recipe_1 = require("./bindings/client/gateways/agentgateway/agentgateway-recipe");
 Object.defineProperty(exports, "agentgatewayRecipe", { enumerable: true, get: function () { return agentgateway_recipe_1.agentgatewayRecipe; } });
+// TrueFoundry's AI Gateway, hosted at `gateway.truefoundry.ai` or self-hosted. A default, ahead of both
+// wires it serves, so its traffic reports as `truefoundry.*`. Self-hosted installs pass their base URL at
+// `wrap(client, { recipe: truefoundryRecipe({ baseUrl }) })`. Tokens and the model that served
+// (`x-tfy-resolved-model`), no `cost`.
+var truefoundry_recipe_1 = require("./bindings/client/gateways/truefoundry/truefoundry-recipe");
+Object.defineProperty(exports, "truefoundryRecipe", { enumerable: true, get: function () { return truefoundry_recipe_1.truefoundryRecipe; } });
 var typesafe_recipe_1 = require("./bindings/client/providers/typesafe/typesafe-recipe");
 Object.defineProperty(exports, "typesafeRecipe", { enumerable: true, get: function () { return typesafe_recipe_1.typesafeRecipe; } });
 Object.defineProperty(exports, "estimateFromState", { enumerable: true, get: function () { return typesafe_recipe_1.estimateFromState; } });

package/dist/stigg-agent-sdk.js

@@ -28,6 +28,7 @@ const litellm_recipe_1 = require("./bindings/client/gateways/litellm/litellm-rec
 const databricks_recipe_1 = require("./bindings/client/gateways/databricks/databricks-recipe");
 const cloudflare_recipe_1 = require("./bindings/client/gateways/cloudflare/cloudflare-recipe");
 const agentgateway_recipe_1 = require("./bindings/client/gateways/agentgateway/agentgateway-recipe");
+const truefoundry_recipe_1 = require("./bindings/client/gateways/truefoundry/truefoundry-recipe");
 const groq_recipe_1 = require("./bindings/client/providers/groq/groq-recipe");
 const mistral_recipe_1 = require("./bindings/client/providers/mistral/mistral-recipe");
 const ollama_recipe_1 = require("./bindings/client/providers/ollama/ollama-recipe");
@@ -71,6 +72,9 @@ exports.DEFAULT_RECIPES = [
     // Anthropic Messages wire too, and only the base URL tells its `Anthropic` client from a direct
     // one. Without a configured base URL it matches on a hostname label - see the recipe.
     (0, agentgateway_recipe_1.agentgatewayRecipe)(),
+    // Ahead of `anthropicRecipe` for the same reason again: TrueFoundry answers on both wires, and
+    // only its hostname (or a configured base URL) tells its clients from direct ones.
+    (0, truefoundry_recipe_1.truefoundryRecipe)(),
     anthropic_recipe_1.anthropicRecipe,
     (0, openrouter_recipe_1.openrouterRecipe)(),
     (0, litellm_recipe_1.litellmRecipe)(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stigg/agent-sdk-js",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "description": "Stigg agent SDK (JS) - run-lifecycle governance for agentic stacks, with examples per layer",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -64,6 +64,7 @@
     "example-gateway-openrouter": "tsx examples/gateway/openrouter.ts",
     "example-gateway-litellm": "tsx examples/gateway/litellm.ts",
     "example-gateway-agentgateway": "tsx examples/gateway/agentgateway.ts",
+    "example-gateway-truefoundry": "tsx examples/gateway/truefoundry.ts",
     "example-gateway-cloudflare": "tsx examples/gateway/cloudflare.ts",
     "example-gateway-bedrock": "tsx examples/gateway/bedrock.ts",
     "example-gateway-databricks": "tsx examples/gateway/databricks.ts"