@tokenrein/sdk 0.0.0-stage → 0.1.2

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,33 @@
-# Temporary Holding Version
+# @tokenrein/sdk (TypeScript)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Budgets, run tracing and spend reports for AI agents, in one line around your existing OpenAI
+or Anthropic client. By default (direct mode) the client keeps calling its provider and only
+token usage goes to [Tokenrein](https://tokenrein.com); `mode="proxy"` sends calls through the Tokenrein
+proxy instead. Errors: `BudgetExceeded`, `RunPaused`, `RunKilled`. Works with any
+OpenAI-compatible provider (Gemini, Groq, Mistral, DeepSeek, OpenRouter, Ollama, ...).
+
+```bash
+npm install @tokenrein/sdk openai   # or @anthropic-ai/sdk
+```
+
+```ts
+import OpenAI from 'openai';
+import { guard, BudgetExceeded } from '@tokenrein/sdk';
+
+const client = guard.openai(new OpenAI(), { agent: 'support-bot' }); // TOKENREIN_API_KEY, TOKENREIN_BASE_URL
+await guard.run({ runId: 'ticket-4812', budgetUsd: 5 }, async () => {
+  await guard.run({ budgetUsd: 1 }, () =>                            // sub-agent: parent set automatically
+    client.chat.completions.create({ model: 'gpt-4o-mini', messages: [{ role: 'user', content: 'hi' }] }),
+  );
+});
+```
+
+Node ≥ 20 (uses `AsyncLocalStorage`). See [the SDK guide](https://github.com/tokenrein/tokenrein/blob/main/sdk/README.md) for the full API.
+
+## Develop
+
+```bash
+npm install && npm run typecheck && npm test && npm run build
+```
+
+License: Apache-2.0.

package/dist/clients.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Wrap OpenAI / Anthropic SDK clients for Tokenrein.
+ *
+ * Two modes:
+ *  - **direct** (default): the client keeps calling its provider. Before each call it asks
+ *    Tokenrein whether the run may continue; after each response it reports token usage in the
+ *    background. Works with any provider the `openai` SDK reaches (Gemini, Groq, Mistral,
+ *    DeepSeek, OpenRouter, Ollama, ...). See `direct.ts`.
+ *  - **proxy**: the client calls the Tokenrein proxy, which checks every call before sending it.
+ *
+ * In proxy mode the guarded client is a `withOptions()` copy of the caller's client whose prototype is
+ * swapped for a subclass that:
+ *  - adds the `x-tr-*` headers of the current run to every request it builds, and counts
+ *    the call against any local `maxCalls` cap;
+ *  - re-labels the proxy's 402/403 responses as Tokenrein errors.
+ * Later `withOptions()` copies construct the same subclass, so they stay guarded.
+ */
+export declare const DEFAULT_BASE_URL = "http://127.0.0.1:8787";
+export interface GuardOptions {
+    /** Agent name sent as `x-tr-agent` (per-agent daily budget). */
+    agent?: string;
+    /** Person or service the agent works for, sent as `x-tr-user` (spend reports). */
+    user?: string;
+    /** Tokenrein virtual key; defaults to `process.env.TOKENREIN_API_KEY`. */
+    apiKey?: string;
+    /** Tokenrein URL; defaults to `process.env.TOKENREIN_BASE_URL` or `http://127.0.0.1:8787`. */
+    baseURL?: string;
+    /**
+     * `'direct'` (default, or `process.env.TOKENREIN_MODE`): the client keeps calling its provider;
+     * Tokenrein checks each call first and receives token usage afterwards, never prompts.
+     * `'proxy'`: calls go through the Tokenrein proxy, which checks every call before sending it.
+     */
+    mode?: 'direct' | 'proxy';
+    /**
+     * Direct mode only. Ask Tokenrein before each call (default). `false` skips the round trip
+     * and only stops runs that previous usage reports showed are over an enforced limit.
+     */
+    check?: boolean;
+}
+export declare function resolveBaseURL(baseURL?: string): string;
+export declare function resolveApiKey(apiKey?: string): string;
+export declare function wrap<T>(client: T, opts: GuardOptions, provider: 'openai' | 'anthropic'): T;
+/**
+ * A hash of the model and the last message, so Tokenrein can spot a run repeating itself. Only
+ * the hash is sent.
+ */
+export declare function fingerprint(body: Record<string, any>): string | undefined;
+interface DirectWrapOptions {
+    tokenreinURL: string;
+    apiKey: string;
+    agent: string | undefined;
+    user: string | undefined;
+    defaultProvider: string;
+    check: boolean;
+}
+export declare function wrapDirect<T>(client: T, o: DirectWrapOptions, kind: 'openai' | 'anthropic'): T;
+export {};

package/dist/clients.js

@@ -0,0 +1,357 @@
+/**
+ * Wrap OpenAI / Anthropic SDK clients for Tokenrein.
+ *
+ * Two modes:
+ *  - **direct** (default): the client keeps calling its provider. Before each call it asks
+ *    Tokenrein whether the run may continue; after each response it reports token usage in the
+ *    background. Works with any provider the `openai` SDK reaches (Gemini, Groq, Mistral,
+ *    DeepSeek, OpenRouter, Ollama, ...). See `direct.ts`.
+ *  - **proxy**: the client calls the Tokenrein proxy, which checks every call before sending it.
+ *
+ * In proxy mode the guarded client is a `withOptions()` copy of the caller's client whose prototype is
+ * swapped for a subclass that:
+ *  - adds the `x-tr-*` headers of the current run to every request it builds, and counts
+ *    the call against any local `maxCalls` cap;
+ *  - re-labels the proxy's 402/403 responses as Tokenrein errors.
+ * Later `withOptions()` copies construct the same subclass, so they stay guarded.
+ */
+import { createHash } from 'node:crypto';
+import { envVar } from './env.js';
+import { StreamUsage, providerFor, reporterFor, usageFrom, verdictError, } from './direct.js';
+import { BUDGET_EXCEEDED, RUN_KILLED, RUN_PAUSED, relabel } from './errors.js';
+import { currentRun, validateId, validateUser } from './run.js';
+export const DEFAULT_BASE_URL = 'http://127.0.0.1:8787';
+/** On a guarded class: the SDK class it extends (so re-wrapping does not stack guards). */
+const UNGUARDED = Symbol('tokenrein.unguarded');
+export function resolveBaseURL(baseURL) {
+    let url = (baseURL || envVar('BASE_URL') || DEFAULT_BASE_URL).replace(/\/+$/, '');
+    // Accept either the proxy root or its /v1 URL.
+    if (url.endsWith('/v1'))
+        url = url.slice(0, -'/v1'.length);
+    return url;
+}
+export function resolveApiKey(apiKey) {
+    const key = apiKey || envVar('API_KEY');
+    if (!key)
+        throw new TypeError('Tokenrein virtual key missing: pass apiKey or set TOKENREIN_API_KEY');
+    return key;
+}
+function hasHeader(h, name) {
+    if (typeof h.has === 'function')
+        return h.has(name);
+    return Object.keys(h).some((k) => k.toLowerCase() === name && h[k] != null);
+}
+function getHeader(h, name) {
+    if (!h)
+        return undefined;
+    if (typeof h.get === 'function')
+        return h.get(name) ?? undefined;
+    const k = Object.keys(h).find((k) => k.toLowerCase() === name);
+    return k ? (h[k] ?? undefined) : undefined;
+}
+function setHeader(h, name, value) {
+    if (typeof h.set === 'function')
+        h.set(name, value);
+    else
+        h[name] = value;
+}
+function deleteHeader(h, name) {
+    if (typeof h.delete === 'function') {
+        h.delete(name);
+        return;
+    }
+    for (const k of Object.keys(h))
+        if (k.toLowerCase() === name)
+            delete h[k];
+}
+function tlHeaders(agent, user) {
+    const run = currentRun();
+    const h = run ? run.headers() : {};
+    const name = agent ?? run?.agent;
+    if (name)
+        h['x-tr-agent'] = name;
+    const who = user ?? run?.user;
+    if (who)
+        h['x-tr-user'] = who;
+    return h;
+}
+function guardedClass(Base, agent, user, stripBearer) {
+    // Request options objects already counted. SDK retries reuse the options object; older
+    // SDKs (openai < 4.6x) do not pass `retryCount`, so this is how their retries are skipped.
+    const counted = new WeakSet();
+    const guardRequest = (built, options, opts) => {
+        const req = built.req;
+        req.headers ??= {};
+        for (const [name, value] of Object.entries(tlHeaders(agent, user))) {
+            // Headers the caller set explicitly (request headers / defaultHeaders) win.
+            if (!hasHeader(req.headers, name))
+                setHeader(req.headers, name, value);
+        }
+        if (stripBearer) {
+            // The proxy reads `Authorization: Bearer` before `x-api-key`; never forward a provider
+            // token (authToken, ANTHROPIC_AUTH_TOKEN, credential providers) in place of the Tokenrein key.
+            deleteHeader(req.headers, 'authorization');
+        }
+        const first = !opts.retryCount && !(typeof options === 'object' && options !== null && counted.has(options));
+        if (first) {
+            currentRun()?.recordCall();
+            if (typeof options === 'object' && options !== null)
+                counted.add(options);
+        }
+        return built;
+    };
+    return class Guarded extends Base {
+        static [UNGUARDED] = Base;
+        static get name() {
+            return Base.name;
+        }
+        // Newer SDKs build requests asynchronously, older ones (openai v4) synchronously.
+        buildRequest(options, opts = {}) {
+            const built = super.buildRequest(options, opts);
+            return built instanceof Promise
+                ? built.then((b) => guardRequest(b, options, opts))
+                : guardRequest(built, options, opts);
+        }
+        makeStatusError(status, error, message, headers) {
+            const err = super.makeStatusError(status, error, message, headers);
+            // The proxy echoes the run id; fall back to the one this request carried.
+            const runId = getHeader(headers, 'x-tr-run-id') ?? currentRun()?.runId;
+            return relabel(err, status, error, runId);
+        }
+    };
+}
+export function wrap(client, opts, provider) {
+    const c = client;
+    if (!c || typeof c.buildRequest !== 'function' || typeof c.makeStatusError !== 'function') {
+        throw new TypeError(`guard.${provider}() needs an ${provider === 'openai' ? 'OpenAI' : 'Anthropic'} client instance`);
+    }
+    if (opts.agent !== undefined)
+        validateId(opts.agent, 'agent');
+    if (opts.user !== undefined)
+        validateUser(opts.user);
+    const stripBearer = provider === 'anthropic';
+    const root = resolveBaseURL(opts.baseURL);
+    const overrides = {
+        apiKey: resolveApiKey(opts.apiKey),
+        baseURL: provider === 'openai' ? `${root}/v1` : root,
+        ...(stripBearer ? { authToken: null } : {}),
+    };
+    const Base = c.constructor[UNGUARDED] ?? c.constructor;
+    const Guarded = guardedClass(Base, opts.agent, opts.user, stripBearer);
+    if (typeof c.withOptions !== 'function') {
+        return new Guarded({ ...c._options, ...overrides });
+    }
+    const copy = c.withOptions(overrides);
+    Object.setPrototypeOf(copy, Guarded.prototype);
+    return copy;
+}
+// --- Direct mode ---------------------------------------------------------------------------
+/**
+ * A hash of the model and the last message, so Tokenrein can spot a run repeating itself. Only
+ * the hash is sent.
+ */
+export function fingerprint(body) {
+    const input = body.input;
+    const last = Array.isArray(body.messages) && body.messages.length ? body.messages.at(-1)
+        : Array.isArray(input) && input.length ? input.at(-1)
+            : typeof input === 'string' ? input : undefined;
+    if (last === undefined)
+        return undefined;
+    const h = createHash('sha256');
+    for (const part of [String(body.model ?? ''), JSON.stringify(last)])
+        h.update(part).update('\0');
+    return h.digest('hex').slice(0, 32);
+}
+const MAX_OUTPUT_FIELDS = ['max_tokens', 'max_completion_tokens', 'max_output_tokens'];
+function who(cfg) {
+    const run = currentRun();
+    const out = { source: 'typescript-sdk' };
+    if (run) {
+        out.run_id = run.runId;
+        if (run.parent)
+            out.parent_run_id = run.parent.runId;
+        if (run.budgetUsd !== undefined)
+            out.run_budget_usd = run.budgetUsd;
+    }
+    const agent = cfg.agent ?? run?.agent;
+    const user = cfg.user ?? run?.user;
+    if (agent)
+        out.agent = agent;
+    if (user)
+        out.user = user;
+    return out;
+}
+function denyIfOver(cfg) {
+    const run = currentRun();
+    const agent = cfg.agent ?? run?.agent;
+    for (const label of cfg.reporter.over.keys()) {
+        const [kind, rest = ''] = label.split(/:(.*)/s);
+        const hit = (kind === 'run' && rest === run?.runId) ||
+            (kind === 'agent_daily' && agent !== undefined && rest.endsWith(`/${agent}`)) ||
+            kind === 'project_monthly' ||
+            kind === 'org_monthly';
+        if (hit)
+            throw verdictError({ allowed: false, reason: `Tokenrein: the ${label} budget is used up` }, run?.runId);
+    }
+}
+function report(cfg, w, model, usage, started, stream) {
+    if (!usage)
+        return;
+    cfg.reporter.report({ ...w, ...usage, model: model ?? 'unknown', provider: cfg.provider, duration_ms: Date.now() - started, stream });
+}
+/** Read a response body (web ReadableStream or Node stream) chunk by chunk. */
+async function* bodyChunks(body) {
+    if (body && typeof body.getReader === 'function') {
+        const reader = body.getReader();
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            yield value;
+        }
+    }
+    else if (body && typeof body[Symbol.asyncIterator] === 'function') {
+        for await (const chunk of body)
+            yield typeof chunk === 'string' ? new TextEncoder().encode(chunk) : chunk;
+    }
+}
+/** A provider-shaped error response; the SDK raises it and `makeStatusError` relabels it. */
+function refusal(v, kind) {
+    const type = v.run_state === 'killed' ? RUN_KILLED : v.run_state === 'paused' ? RUN_PAUSED : BUDGET_EXCEEDED;
+    const error = { type, message: v.reason ?? 'Tokenrein refused the call' };
+    const body = kind === 'anthropic' ? { type: 'error', error } : { error: { ...error, code: type, param: null } };
+    const headers = { 'content-type': 'application/json' };
+    if (v.run_id)
+        headers['x-tr-run-id'] = v.run_id;
+    return new Response(JSON.stringify(body), { status: v.run_state ? 403 : 402, headers });
+}
+function overVerdict(cfg) {
+    try {
+        denyIfOver(cfg);
+        return undefined;
+    }
+    catch (e) {
+        return { allowed: false, reason: e.message, run_id: currentRun()?.runId };
+    }
+}
+/**
+ * Wraps the client's fetch, which every SDK version supports: checks the budget before the call
+ * (refusing with a provider-shaped 402/403 without calling the provider), asks OpenAI-style
+ * streams for usage, and reads usage from JSON bodies and event streams.
+ */
+function observingFetch(inner, cfg, kind) {
+    return async (input, init) => {
+        const w = who(cfg);
+        const url = String(typeof input === 'string' ? input : (input?.url ?? input));
+        let body;
+        if (typeof init?.body === 'string') {
+            try {
+                body = JSON.parse(init.body);
+            }
+            catch {
+                body = undefined;
+            }
+        }
+        if (cfg.provider !== 'anthropic' &&
+            body && body.stream === true && body.stream_options === undefined &&
+            new URL(url, 'http://x').pathname.endsWith('/chat/completions')) {
+            body.stream_options = { include_usage: true };
+            init = { ...init, body: JSON.stringify(body) };
+        }
+        if (body && typeof body.model === 'string') {
+            let v;
+            if (cfg.check) {
+                const req = { ...w, model: body.model, provider: cfg.provider };
+                const max = MAX_OUTPUT_FIELDS.map((f) => body[f]).find((x) => typeof x === 'number');
+                if (max !== undefined)
+                    req.max_output_tokens = max;
+                const fp = fingerprint(body);
+                if (fp)
+                    req.fingerprint = fp;
+                v = await cfg.reporter.check(req);
+            }
+            else {
+                v = overVerdict(cfg);
+            }
+            if (v && !v.allowed)
+                return refusal({ ...v, run_id: v.run_id ?? w.run_id }, kind);
+        }
+        const started = Date.now();
+        const res = await inner(input, init);
+        if (!res.ok || !res.body)
+            return res;
+        const ctype = res.headers.get('content-type') ?? '';
+        if (ctype.includes('text/event-stream')) {
+            const copy = res.clone();
+            const parser = new StreamUsage();
+            void (async () => {
+                const decoder = new TextDecoder();
+                try {
+                    for await (const chunk of bodyChunks(copy.body))
+                        parser.feed(decoder.decode(chunk, { stream: true }));
+                }
+                catch {
+                    // stream aborted; report what was seen
+                }
+                report(cfg, w, parser.model, parser.usage, started, true);
+            })();
+        }
+        else if (ctype.includes('json')) {
+            res
+                .clone()
+                .json()
+                .then((b) => report(cfg, w, b?.model, usageFrom(b), started, false))
+                .catch(() => { });
+        }
+        return res;
+    };
+}
+function directClass(Base) {
+    return class Direct extends Base {
+        static [UNGUARDED] = Base;
+        static get name() {
+            return Base.name;
+        }
+        buildRequest(options, opts = {}) {
+            const built = super.buildRequest(options, opts);
+            const count = (b) => {
+                if (!opts.retryCount)
+                    currentRun()?.recordCall();
+                return b;
+            };
+            return built instanceof Promise ? built.then(count) : count(built);
+        }
+        makeStatusError(status, error, message, headers) {
+            const err = super.makeStatusError(status, error, message, headers);
+            const runId = getHeader(headers, 'x-tr-run-id') ?? currentRun()?.runId;
+            return relabel(err, status, error, runId);
+        }
+    };
+}
+export function wrapDirect(client, o, kind) {
+    const c = client;
+    if (!c || typeof c.buildRequest !== 'function') {
+        throw new TypeError(`guard.${kind}() needs an ${kind === 'openai' ? 'OpenAI' : 'Anthropic'} client instance`);
+    }
+    if (o.agent !== undefined)
+        validateId(o.agent, 'agent');
+    if (o.user !== undefined)
+        validateUser(o.user);
+    const cfg = {
+        agent: o.agent,
+        user: o.user,
+        provider: providerFor(String(c.baseURL ?? ''), o.defaultProvider),
+        check: o.check,
+        reporter: reporterFor(o.tokenreinURL, o.apiKey),
+    };
+    const inner = (c.fetch ?? globalThis.fetch).bind(globalThis);
+    const fetchOverride = { fetch: observingFetch(inner, cfg, kind) };
+    const Base = c.constructor[UNGUARDED] ?? c.constructor;
+    const Direct = directClass(Base);
+    if (typeof c.withOptions !== 'function') {
+        return new Direct({ ...c._options, ...fetchOverride });
+    }
+    const copy = c.withOptions(fetchOverride);
+    Object.setPrototypeOf(copy, Direct.prototype);
+    return copy;
+}