@convex-dev/ai-budget 0.0.2-alpha.10 → 0.0.2-alpha.13

package/README.md

@@ -205,6 +205,84 @@ const result = await agent.generateText(ctx, { threadId }, { prompt });
 Every generation is now tracked and budgeted, attributed to `userId` and the
 calling action. See `example/convex/agentDemo.ts`.
 
+### `ai.meter` — budget *any* provider call
+
+`chat`/`languageModel` go through the gateway. When you need something the
+gateway can't serve (Anthropic web search, computer-use, a different provider,
+a raw `fetch`), `meter` brings that call under the *same* caps, audit log, and
+cost tracking. It reserves before your `run` (throwing over a hard cap), runs
+it, and records the actual usage:
+
+```ts
+await ai.meter(ctx, { userId, model: "anthropic/claude-…", messages }, async () => {
+  const res = await anthropic.messages.create({
+    messages,
+    tools: [{ type: "web_search_20250305", name: "web_search", max_uses: 3 }],
+  });
+  return {
+    text: extractText(res),
+    promptTokens: res.usage.input_tokens,
+    completionTokens: res.usage.output_tokens,
+    cachedTokens: res.usage.cache_read_input_tokens ?? 0,
+    serverToolUses: { web_search: res.usage.server_tool_use?.web_search_requests ?? 0 },
+    // costNanos? — pass an authoritative total to skip token/tool pricing
+  };
+});
+```
+
+`chat` is sugar over `meter`. Return either a raw provider `usage` (auto-
+normalized) or explicit `promptTokens`/`completionTokens`/`cachedTokens`, plus
+optional `serverToolUses` (see [pricing](#pricing--cost)) and `costNanos`.
+
+**Cost known up front (image gen, per-call APIs).** When you know the price
+before the call — image generation (`n` × per-image), audio, anything per-call —
+pass `estimatedCostNanos` so the *reservation* holds the real amount and a hard
+cap is exact (the token estimate is meaningless for these). Price the units with
+`serverToolUses` + [`setServerTool`](#pricing--cost):
+
+```ts
+const IMG = 130_000_000; // $0.13/image
+await ai.meter(ctx,
+  { userId, model: "openai/gpt-image-1", messages: [{ role: "user", content: prompt }],
+    estimatedCostNanos: IMG * n },
+  async () => {
+    const res = await openrouter.images.generate({ model: "openai/gpt-image-1", prompt, n });
+    return { serverToolUses: { image: n } };   // priced via setServerTool({ tool: "image", … })
+  });
+```
+
+### `ai.begin` / `ai.settle` — long async jobs (video)
+
+A video job is submit → wait minutes → poll/webhook → done, spanning multiple
+Convex functions, so the synchronous `meter` bracket doesn't fit. Reserve with
+`begin` at submit, `settle` from the later context. Set `reserveTtlMs` to the
+job's max duration so the reconciler doesn't reap the hold mid-flight:
+
+```ts
+// submit (action): reserve, then kick off the job
+const started = await ai.begin(ctx, {
+  userId, model: "openai/sora",
+  estimatedCostNanos: perSecond * seconds,
+  reserveTtlMs: 20 * 60 * 1000,          // hold up to 20 min
+});
+if (!started.allowed) throw new ConvexError(started.reason);
+const job = await sora.videos.create({ … });
+await ctx.db.insert("videoJobs", { requestId: started.requestId, jobId: job.id });
+
+// later — settle from a poll, or a provider webhook:
+ai.registerWebhook(http, {
+  path: "/aibudget/video-done",
+  resolve: async (ctx, request, body) => {
+    if (!verifySignature(request, body)) return null;             // 202, ignored
+    const job = await lookupJob(ctx, body.id);                    // → { requestId }
+    return { requestId: job.requestId, serverToolUses: { video_seconds: body.seconds } };
+  },
+});
+```
+
+`begin` returns the admission result (it doesn't throw — check `allowed`).
+`settle` is idempotent (exactly-once server-side), so a retried webhook is safe.
+
 ### Replay
 
 ```ts
@@ -390,6 +468,17 @@ ai.prices.set(ctx, { model, inputNanosPerMTok, outputNanosPerMTok, cachedNanosPe
 ai.prices.list(ctx)
 ```
 
+**Server tools.** Provider server-side tools bill a per-call fee on top of
+tokens (e.g. Anthropic web search). Report them from `meter` as
+`serverToolUses: { web_search: 3 }` and they're priced per call (default
+$0.01/`web_search`) — unless you pass an authoritative `costNanos`, which already
+includes them. Override the rate:
+
+```ts
+ai.prices.setServerTool(ctx, { tool: "web_search", nanosPerCall: 12_000_000 })
+ai.prices.listServerTools(ctx)
+```
+
 The gateway's `provider/model` ids match OpenRouter's, whose public models
 endpoint returns per-token pricing — so you can keep prices current from your own
 action (see `example/convex/ai.ts` → `syncPrices`):
@@ -529,22 +618,31 @@ npm run dev         # terminal 2 — Vite app
 
 ### What's in the component vs. the demo
 
-The component (`src/`) is **only** the metering/budget primitive — it knows
-nothing about chat or evaluation. Everything below lives in `example/` as
-**application code that uses the component**, not part of the published API:
-
-- The real features being metered — `sendMessage`, `summarize`, the agent.
-- An **eval playground** (🧪 Experiment tab): **Matrix** (one prompt across a
+The published AI Budget component (`src/`) is **only** the metering/budget
+primitive — it knows nothing about agents or evaluation. The example composes
+three isolated pieces:
+
+- The **Agent component** owns agent threads, messages, tools, and generation.
+- The local **Evaluation component** (`example/convex/evaluations/`) owns immutable
+  case snapshots, run lifecycle, and results. It does not call Agent or AI Budget.
+- App-level adapters in `example/convex/ai.ts` compose the siblings: they obtain
+  source traffic, run candidate/judge model calls through AI Budget, attach an
+  `evalRun` budget tag, and persist outcomes into Evaluation.
+- The **eval playground** (🧪 Experiment tab) exposes **Matrix** (one prompt across a
   system-prompt × model grid, ranked by an LLM judge on *your* criteria),
   **Backtest** (replay a candidate prompt against an action's real historical
   requests and judge each), and **Evolve** (an LLM iteratively improves a prompt
   toward a goal on real traffic, **stopping when it hits a spend budget**).
 
-These are built on two primitives — `ai.chat(...)` (every eval call is budgeted)
-and `ai.requests.list(...)` (the audit log *is* the eval dataset) — a "how to
-build on it" reference, not the component's surface. If you productize this it
-belongs in your app or a component that *composes* `@convex-dev/ai-budget`, never
-folded back into it.
+The demo currently snapshots AI Budget audit traffic as its corpus. An Agent-based
+product should instead make the app adapter snapshot cases through Agent's public
+API; Evaluation must never inspect Agent's private tables. The same Evaluation
+component works with either source because its inputs are explicit snapshots.
+
+This local component is a proof of the reusable boundary, not part of the
+`@convex-dev/ai-budget` package. If productized, it should ship independently
+(for example, `@convex-dev/evals`) and accept application adapters/function
+handles rather than taking a dependency on either sibling component.
 
 ---
 
@@ -566,7 +664,9 @@ npm run build       # emit dist/ (client + component) for publishing
 - `src/client/` — **the client** (published): the `AIBudget` class — `chat`,
   `languageModel`, `registerRoutes`, and the namespaced admin API.
 - `example/` — **the demo app** (not published): real features, the eval
-  playground, and the UI, all built on the two directories above.
+  playground, and the UI. `example/convex/evaluations/` is a separate local
+  component for datasets, runs, and results; `example/convex/ai.ts` is the
+  composition layer.
 
 ## License
 

package/dist/client/index.d.ts

@@ -113,8 +113,87 @@ export declare class AIBudget {
     private fireBudgetEvents;
     private fireLimitReached;
     /**
-     * One-shot chat through the AI Gateway with tracking + limits.
-     * Call from an action. `userId` defaults to the authenticated caller.
+     * Reserve budget for a call WITHOUT running it — the async half of the
+     * lifecycle. Use for long-running jobs (video generation) where the result
+     * arrives minutes later via a poll or webhook: `begin` here, then `settle`
+     * from that later context with the request's `requestId`. Returns the
+     * admission result (does NOT throw over a cap — check `allowed`). Set
+     * `reserveTtlMs` to the job's max duration so the hold isn't reaped mid-flight.
+     */
+    begin(ctx: RunMutationCtx, opts: {
+        model: string;
+        messages?: Message[];
+        userId?: string;
+        action?: string;
+        tags?: Tag[];
+        /** Reserve this exact amount (nanodollars) when the cost is known up front. */
+        estimatedCostNanos?: number;
+        /** Hold the reservation up to this long (ms) for long async jobs. */
+        reserveTtlMs?: number;
+        rerunOf?: string;
+    }): Promise<{
+        allowed: true;
+        requestId: string;
+        warnings: string[];
+        notices: string[];
+    } | {
+        allowed: false;
+        code: string;
+        reason: string;
+    }>;
+    /**
+     * Record the actual usage/cost of a `begin`-reserved request and release its
+     * reservation. Idempotent (exactly-once server-side). Pass a raw provider
+     * `usage` (auto-normalized) or explicit token counts, plus optional
+     * `serverToolUses` and an authoritative `costNanos`.
+     */
+    settle(ctx: RunMutationCtx, args: {
+        requestId: string;
+        responseText?: string;
+        error?: string;
+        usage?: any;
+        promptTokens?: number;
+        completionTokens?: number;
+        cachedTokens?: number;
+        serverToolUses?: Record<string, number>;
+        costNanos?: number;
+        latencyMs?: number;
+    }): Promise<{
+        costNanos: number;
+    }>;
+    /**
+     * Meter ANY synchronous LLM call — gateway, a provider SDK, a raw fetch — with
+     * the same budgets, audit log, and cost tracking. Reserves before your `run`
+     * (throwing a ConvexError over a hard cap), runs it, then records the actual
+     * usage/cost. The provider-agnostic core; `chat` is sugar over it. (For async
+     * jobs that settle later, use `begin`/`settle` instead.)
+     *
+     * `run` returns what happened. Pass a raw provider `usage` object (auto-
+     * normalized) OR explicit `promptTokens`/`completionTokens`/`cachedTokens`,
+     * plus optional `serverToolUses` (e.g. `{ web_search: 3 }`) and an
+     * authoritative `costNanos` (used verbatim if present).
+     */
+    meter(ctx: RunMutationCtx, opts: {
+        model: string;
+        messages: Message[];
+        userId?: string;
+        action?: string;
+        tags?: Tag[];
+        rerunOf?: string;
+        /** Reserve this exact amount (nanodollars) instead of the token estimate. */
+        estimatedCostNanos?: number;
+    }, run: () => Promise<{
+        text?: string;
+        usage?: any;
+        promptTokens?: number;
+        completionTokens?: number;
+        cachedTokens?: number;
+        serverToolUses?: Record<string, number>;
+        costNanos?: number;
+    }>): Promise<ChatResult>;
+    /**
+     * One-shot chat through the AI Gateway with tracking + limits — sugar over
+     * `meter`. Call from an action. `userId` defaults to the authenticated caller.
      */
     chat(ctx: RunMutationCtx, args?: {
         /** Whom to bill. Defaults to the authenticated user (ctx.auth). */
@@ -168,6 +247,10 @@ export declare class AIBudget {
             promptTokens?: number | undefined;
             completionTokens?: number | undefined;
             cachedTokens?: number | undefined;
+            serverToolUses?: {
+                [x: string]: number;
+            } | undefined;
+            reserveTtlMs?: number | undefined;
             costNanos?: number | undefined;
             latencyMs?: number | undefined;
             rerunOf?: string | undefined;
@@ -200,6 +283,10 @@ export declare class AIBudget {
             promptTokens?: number | undefined;
             completionTokens?: number | undefined;
             cachedTokens?: number | undefined;
+            serverToolUses?: {
+                [x: string]: number;
+            } | undefined;
+            reserveTtlMs?: number | undefined;
             costNanos?: number | undefined;
             latencyMs?: number | undefined;
             rerunOf?: string | undefined;
@@ -233,6 +320,10 @@ export declare class AIBudget {
                 promptTokens?: number | undefined;
                 completionTokens?: number | undefined;
                 cachedTokens?: number | undefined;
+                serverToolUses?: {
+                    [x: string]: number;
+                } | undefined;
+                reserveTtlMs?: number | undefined;
                 costNanos?: number | undefined;
                 latencyMs?: number | undefined;
                 rerunOf?: string | undefined;
@@ -262,6 +353,10 @@ export declare class AIBudget {
                 promptTokens?: number | undefined;
                 completionTokens?: number | undefined;
                 cachedTokens?: number | undefined;
+                serverToolUses?: {
+                    [x: string]: number;
+                } | undefined;
+                reserveTtlMs?: number | undefined;
                 costNanos?: number | undefined;
                 latencyMs?: number | undefined;
                 rerunOf?: string | undefined;
@@ -742,7 +837,7 @@ export declare class AIBudget {
             models: string[];
         }) => Promise<null>;
     };
-    /** Per-model prices (cents per million tokens). */
+    /** Per-model prices (nanodollars per million tokens) + server-tool fees. */
     get prices(): {
         list: (ctx: RunQueryCtx) => Promise<{
             [x: string]: {
@@ -759,6 +854,15 @@ export declare class AIBudget {
             /** Cache-read rate; defaults to a discount off input if omitted. */
             cachedNanosPerMTok?: number;
         }) => Promise<null>;
+        /** Per-call fees for provider server tools (web search, etc.). */
+        listServerTools: (ctx: RunQueryCtx) => Promise<{
+            [x: string]: number;
+        }>;
+        /** Set a server-tool's per-call price, e.g. { tool: "web_search", nanosPerCall }. */
+        setServerTool: (ctx: RunMutationCtx, args: {
+            tool: string;
+            nanosPerCall: number;
+        }) => Promise<null>;
     };
     /**
      * Mount the built-in admin dashboard on your app's HTTP router with one call.
@@ -786,6 +890,37 @@ export declare class AIBudget {
         /** Return true to allow the request. Runs on the HTML page and every API call. */
         authorize?: (ctx: any, request: Request) => boolean | Promise<boolean>;
     }): void;
+    /**
+     * Mount a POST webhook that settles a `begin`-reserved request from a
+     * provider's completion callback (async image/video jobs). You supply
+     * `resolve` — verify the payload's signature and map the provider's job id to
+     * your stored `requestId` + final usage/cost; the helper calls `settle`.
+     * Return `null` to ignore an unrecognized/duplicate callback (HTTP 202).
+     *
+     *   ai.registerWebhook(http, {
+     *     path: "/aibudget/video-done",
+     *     resolve: async (ctx, request, body) => {
+     *       if (!verifySignature(request, body)) return null;
+     *       const job = await lookupJob(ctx, body.id);   // your table: { requestId }
+     *       return { requestId: job.requestId, serverToolUses: { video_seconds: body.seconds } };
+     *     },
+     *   });
+     */
+    registerWebhook(http: HttpRouter, opts: {
+        path?: string;
+        resolve: (ctx: any, request: Request, body: any) => Promise<({
+            requestId: string;
+        } & {
+            responseText?: string;
+            error?: string;
+            usage?: any;
+            promptTokens?: number;
+            completionTokens?: number;
+            cachedTokens?: number;
+            serverToolUses?: Record<string, number>;
+            costNanos?: number;
+        }) | null>;
+    }): void;
 }
 /** @deprecated Renamed to `AIBudget`. */
 export declare const WorryFreeAI: typeof AIBudget;

package/dist/client/index.js

@@ -155,45 +155,136 @@ export class AIBudget {
         }
     }
     /**
-     * One-shot chat through the AI Gateway with tracking + limits.
-     * Call from an action. `userId` defaults to the authenticated caller.
+     * Reserve budget for a call WITHOUT running it — the async half of the
+     * lifecycle. Use for long-running jobs (video generation) where the result
+     * arrives minutes later via a poll or webhook: `begin` here, then `settle`
+     * from that later context with the request's `requestId`. Returns the
+     * admission result (does NOT throw over a cap — check `allowed`). Set
+     * `reserveTtlMs` to the job's max duration so the hold isn't reaped mid-flight.
      */
-    async chat(ctx, args = {}) {
-        const model = args.model ?? this.defaultModel;
-        const userId = await resolveUserId(ctx, args.userId);
-        const actionName = await resolveActionName(ctx, args.action);
-        const messages = args.messages ?? [{ role: "user", content: args.prompt ?? "" }];
+    async begin(ctx, opts) {
+        const userId = await resolveUserId(ctx, opts.userId);
+        const actionName = await resolveActionName(ctx, opts.action);
         const started = await ctx.runMutation(this.component.lib.startRequest, {
             userId,
             actionName,
-            tags: args.tags,
-            model,
-            messages,
-            rerunOf: args.rerunOf,
+            tags: opts.tags,
+            model: opts.model,
+            messages: opts.messages ?? [],
+            estimatedCostNanos: opts.estimatedCostNanos,
+            reserveTtlMs: opts.reserveTtlMs,
+            rerunOf: opts.rerunOf,
         });
-        if (!started.allowed) {
+        if (started.allowed) {
+            await this.fireBudgetEvents({ userId, action: actionName, tags: opts.tags, requestId: started.requestId }, started.warnings, started.notices);
+        }
+        else {
             await this.fireLimitReached({
                 userId,
                 action: actionName,
-                tags: args.tags,
+                tags: opts.tags,
                 messages: [started.reason],
                 code: started.code,
                 reason: started.reason,
             });
+        }
+        return started;
+    }
+    /**
+     * Record the actual usage/cost of a `begin`-reserved request and release its
+     * reservation. Idempotent (exactly-once server-side). Pass a raw provider
+     * `usage` (auto-normalized) or explicit token counts, plus optional
+     * `serverToolUses` and an authoritative `costNanos`.
+     */
+    async settle(ctx, args) {
+        const { requestId, usage, promptTokens, completionTokens, cachedTokens, ...rest } = args;
+        const tokens = promptTokens !== undefined ||
+            completionTokens !== undefined ||
+            cachedTokens !== undefined
+            ? {
+                promptTokens: promptTokens ?? 0,
+                completionTokens: completionTokens ?? 0,
+                cachedTokens: cachedTokens ?? 0,
+            }
+            : usage !== undefined
+                ? extractUsage(usage)
+                : {};
+        return ctx.runMutation(this.component.lib.finishRequest, {
+            requestId: requestId,
+            ...tokens,
+            ...rest,
+        });
+    }
+    /**
+     * Meter ANY synchronous LLM call — gateway, a provider SDK, a raw fetch — with
+     * the same budgets, audit log, and cost tracking. Reserves before your `run`
+     * (throwing a ConvexError over a hard cap), runs it, then records the actual
+     * usage/cost. The provider-agnostic core; `chat` is sugar over it. (For async
+     * jobs that settle later, use `begin`/`settle` instead.)
+     *
+     * `run` returns what happened. Pass a raw provider `usage` object (auto-
+     * normalized) OR explicit `promptTokens`/`completionTokens`/`cachedTokens`,
+     * plus optional `serverToolUses` (e.g. `{ web_search: 3 }`) and an
+     * authoritative `costNanos` (used verbatim if present).
+     */
+    async meter(ctx, opts, run) {
+        const started = await this.begin(ctx, opts);
+        if (!started.allowed) {
             throw new ConvexError({
                 kind: "AIBudgetLimit",
                 code: started.code,
                 reason: started.reason,
             });
         }
-        const requestId = started.requestId;
-        const warnings = started.warnings;
-        const notices = started.notices;
-        await this.fireBudgetEvents({ userId, action: actionName, tags: args.tags, requestId }, warnings, notices);
+        const { requestId, warnings, notices } = started;
         const start = Date.now();
         try {
-            // The full chain (incl. system) is stored on the request for audit/replay,
-            // but the AI SDK wants system prompts in the `system` option, not messages.
+            const out = await run();
+            const { costNanos } = await this.settle(ctx, {
+                requestId,
+                responseText: out.text,
+                usage: out.usage,
+                promptTokens: out.promptTokens,
+                completionTokens: out.completionTokens,
+                cachedTokens: out.cachedTokens,
+                serverToolUses: out.serverToolUses,
+                costNanos: out.costNanos,
+                latencyMs: Date.now() - start,
+            });
+            // Re-derive the recorded usage for the return value.
+            const usage = out.promptTokens !== undefined ||
+                out.completionTokens !== undefined ||
+                out.cachedTokens !== undefined
+                ? {
+                    promptTokens: out.promptTokens ?? 0,
+                    completionTokens: out.completionTokens ?? 0,
+                    cachedTokens: out.cachedTokens ?? 0,
+                }
+                : extractUsage(out.usage);
+            return { text: out.text ?? "", requestId, costNanos, warnings, notices, ...usage };
+        }
+        catch (e) {
+            await this.settle(ctx, { requestId, error: String(e), latencyMs: Date.now() - start });
+            throw e;
+        }
+    }
+    /**
+     * One-shot chat through the AI Gateway with tracking + limits — sugar over
+     * `meter`. Call from an action. `userId` defaults to the authenticated caller.
+     */
+    async chat(ctx, args = {}) {
+        const model = args.model ?? this.defaultModel;
+        const messages = args.messages ?? [{ role: "user", content: args.prompt ?? "" }];
+        return this.meter(ctx, {
+            model,
+            messages,
+            userId: args.userId,
+            action: args.action,
+            tags: args.tags,
+            rerunOf: args.rerunOf,
+        }, async () => {
+            // The full chain (incl. system) is stored for audit/replay, but the AI
+            // SDK wants system prompts in the `system` option, not messages.
             const system = messages
                 .filter((m) => m.role === "system")
                 .map((m) => m.content)
@@ -204,24 +295,12 @@ export class AIBudget {
                 ...(system ? { system } : {}),
                 messages: convo,
             });
-            const usage = extractUsage(result.usage);
-            const { costNanos } = await ctx.runMutation(this.component.lib.finishRequest, {
-                requestId,
-                responseText: result.text,
-                ...usage,
+            return {
+                text: result.text,
+                usage: result.usage,
                 costNanos: extractGatewayCostNanos(result),
-                latencyMs: Date.now() - start,
-            });
-            return { text: result.text, requestId, costNanos, warnings, notices, ...usage };
-        }
-        catch (e) {
-            await ctx.runMutation(this.component.lib.finishRequest, {
-                requestId,
-                error: String(e),
-                latencyMs: Date.now() - start,
-            });
-            throw e;
-        }
+            };
+        });
     }
     /**
      * An AI SDK LanguageModel that enforces limits and records usage/cost for
@@ -467,12 +546,16 @@ export class AIBudget {
             setPolicy: (ctx, args) => ctx.runMutation(c.lib.setModelPolicy, args),
         };
     }
-    /** Per-model prices (cents per million tokens). */
+    /** Per-model prices (nanodollars per million tokens) + server-tool fees. */
     get prices() {
         const c = this.component;
         return {
             list: (ctx) => ctx.runQuery(c.lib.listPrices, {}),
             set: (ctx, args) => ctx.runMutation(c.lib.setPrice, args),
+            /** Per-call fees for provider server tools (web search, etc.). */
+            listServerTools: (ctx) => ctx.runQuery(c.lib.listServerToolPrices, {}),
+            /** Set a server-tool's per-call price, e.g. { tool: "web_search", nanosPerCall }. */
+            setServerTool: (ctx, args) => ctx.runMutation(c.lib.setServerToolPrice, args),
         };
     }
     /**
@@ -586,6 +669,38 @@ export class AIBudget {
         http.route({ pathPrefix: `${prefix}/`, method: "GET", handler });
         http.route({ pathPrefix: `${prefix}/`, method: "POST", handler });
     }
+    /**
+     * Mount a POST webhook that settles a `begin`-reserved request from a
+     * provider's completion callback (async image/video jobs). You supply
+     * `resolve` — verify the payload's signature and map the provider's job id to
+     * your stored `requestId` + final usage/cost; the helper calls `settle`.
+     * Return `null` to ignore an unrecognized/duplicate callback (HTTP 202).
+     *
+     *   ai.registerWebhook(http, {
+     *     path: "/aibudget/video-done",
+     *     resolve: async (ctx, request, body) => {
+     *       if (!verifySignature(request, body)) return null;
+     *       const job = await lookupJob(ctx, body.id);   // your table: { requestId }
+     *       return { requestId: job.requestId, serverToolUses: { video_seconds: body.seconds } };
+     *     },
+     *   });
+     */
+    registerWebhook(http, opts) {
+        const path = opts.path ?? "/aibudget/webhook";
+        const self = this;
+        http.route({
+            path,
+            method: "POST",
+            handler: httpActionGeneric(async (ctx, request) => {
+                const body = await request.json().catch(() => ({}));
+                const settle = await opts.resolve(ctx, request, body);
+                if (!settle)
+                    return new Response("ignored", { status: 202 });
+                await self.settle(ctx, settle);
+                return new Response("ok");
+            }),
+        });
+    }
 }
 /** @deprecated Renamed to `AIBudget`. */
 export const WorryFreeAI = AIBudget;

package/dist/component/_generated/component.d.ts

@@ -55,6 +55,7 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
             promptTokens?: number;
             requestId: string;
             responseText?: string;
+            serverToolUses?: Record<string, number>;
         }, {
             costNanos: number;
         }, Name>;
@@ -96,6 +97,7 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
             userId?: string;
             value?: string;
         }, any, Name>;
+        listServerToolPrices: FunctionReference<"query", "internal", {}, any, Name>;
         setAlertDefaults: FunctionReference<"mutation", "internal", {
             warnAtPct?: number;
         }, null, Name>;
@@ -132,14 +134,20 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         setRetention: FunctionReference<"mutation", "internal", {
             retentionMs: number;
         }, null, Name>;
+        setServerToolPrice: FunctionReference<"mutation", "internal", {
+            nanosPerCall: number;
+            tool: string;
+        }, null, Name>;
         startRequest: FunctionReference<"mutation", "internal", {
             actionName?: string;
+            estimatedCostNanos?: number;
             messages: Array<{
                 content: string;
                 role: string;
             }>;
             model: string;
             rerunOf?: string;
+            reserveTtlMs?: number;
             tags?: Array<{
                 dimension: string;
                 value: string;