@lobstack-ai/mcp 0.1.0

package/dist/receipt.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The receipt, and the two rules about rendering one.
+ *
+ * These rules are not local style. They are the same rules as
+ * `cli/src/render.mjs` in the platform repo, and the reason there is one copy
+ * per client rather than one copy per renderer is that a rule about overstating
+ * savings drifts the moment it is restated.
+ */
+/** `baseline_reason` as the Gateway sends it. See `src/lib/gateway/stream.ts`. */
+export type BaselineReason = "named" | "plan_ceiling";
+export interface Receipt {
+    request_id: string | null;
+    served_model: string | null;
+    requested_model: string | null;
+    routed: boolean | null;
+    /** Null, never 0, for a call the Gateway could not price. */
+    cost_usd: number | null;
+    savings_usd: number | null;
+    priced: boolean;
+    baseline_model: string | null;
+    /** Missing is treated as unnamed. Never as the flattering case. */
+    baseline_reason: BaselineReason | null;
+    baseline_cost_usd: number | null;
+}
+/**
+ * A number, or null. Never a zero standing in for "we do not know".
+ *
+ * `cost_usd: null` means the Gateway could not price the call. A real zero —
+ * a request that produced no billable tokens — is a different fact and is kept
+ * as a zero. Collapsing the two is the bug this whole module exists to prevent.
+ */
+export declare function asMoney(v: unknown): number | null;
+/**
+ * Format money for a human.
+ *
+ * "unpriced" for null, never "$0.00". That exact substitution ran for three
+ * months in production and wrote off real charges as free.
+ */
+export declare function money(n: number | null | undefined): string;
+/** Coerce whatever came off the trailing frame into a receipt, or null. */
+export declare function parseReceipt(raw: unknown): Receipt | null;
+export interface Savings {
+    label: string;
+    named: boolean;
+    amount: number;
+    baseline_model: string | null;
+    baseline_reason: BaselineReason | null;
+}
+/**
+ * Whether a saving may be called a saving, in one place.
+ *
+ * `baseline_reason` decides.
+ *
+ *   "named"        the caller asked for a model and got something cheaper. A
+ *                  like-for-like comparison, and the only case that may be
+ *                  labelled `saved`.
+ *   "plan_ceiling" the caller sent `auto`, so the Gateway measured against the
+ *                  most expensive model their plan allows. Real, and not
+ *                  something anybody asked for: `vs ceiling`.
+ *   missing        treated as unnamed. A receipt that does not say where its
+ *                  baseline came from does not get the flattering reading.
+ *
+ * Matches `savingsLabel()` in `cli/src/render.mjs` exactly.
+ */
+export declare function savingsLabel(receipt: Receipt | null): Savings | null;
+export interface ReceiptLineInput {
+    receipt: Receipt | null;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+    } | null;
+    /** The model the stream frames named, when the receipt did not. */
+    model?: string | null;
+    /** Parameters the Gateway dropped, from `x-lobstack-dropped-params`. */
+    droppedParams?: string[];
+}
+/**
+ * The receipt as a human reads it: one line, then whatever needs saying.
+ *
+ * This is returned as its own content block, separate from the answer, for the
+ * same reason the CLI writes it to stderr — so the thing you asked for and the
+ * thing it cost do not end up concatenated in whatever consumes the answer.
+ */
+export declare function describeReceipt({ receipt, usage, model, droppedParams }: ReceiptLineInput): string;

package/dist/receipt.js

@@ -0,0 +1,122 @@
+/**
+ * The receipt, and the two rules about rendering one.
+ *
+ * These rules are not local style. They are the same rules as
+ * `cli/src/render.mjs` in the platform repo, and the reason there is one copy
+ * per client rather than one copy per renderer is that a rule about overstating
+ * savings drifts the moment it is restated.
+ */
+/**
+ * A number, or null. Never a zero standing in for "we do not know".
+ *
+ * `cost_usd: null` means the Gateway could not price the call. A real zero —
+ * a request that produced no billable tokens — is a different fact and is kept
+ * as a zero. Collapsing the two is the bug this whole module exists to prevent.
+ */
+export function asMoney(v) {
+    if (typeof v === "number" && Number.isFinite(v))
+        return v;
+    // A JSON number that arrived as a string still prices; "" and null do not.
+    if (typeof v === "string" && v.trim() !== "") {
+        const n = Number(v);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return null;
+}
+/**
+ * Format money for a human.
+ *
+ * "unpriced" for null, never "$0.00". That exact substitution ran for three
+ * months in production and wrote off real charges as free.
+ */
+export function money(n) {
+    if (typeof n !== "number" || !Number.isFinite(n))
+        return "unpriced";
+    return n >= 0.01 ? `$${n.toFixed(4)}` : `$${n.toFixed(6)}`;
+}
+/** Coerce whatever came off the trailing frame into a receipt, or null. */
+export function parseReceipt(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const r = raw;
+    const reason = r.baseline_reason;
+    return {
+        request_id: typeof r.request_id === "string" ? r.request_id : null,
+        served_model: typeof r.served_model === "string" ? r.served_model : null,
+        requested_model: typeof r.requested_model === "string" ? r.requested_model : null,
+        routed: typeof r.routed === "boolean" ? r.routed : null,
+        cost_usd: asMoney(r.cost_usd),
+        savings_usd: asMoney(r.savings_usd),
+        // `priced` is an assertion the seller makes. Absent, assume nothing: a
+        // receipt with no price is not a priced receipt.
+        priced: r.priced === true,
+        baseline_model: typeof r.baseline_model === "string" ? r.baseline_model : null,
+        baseline_reason: reason === "named" || reason === "plan_ceiling" ? reason : null,
+        baseline_cost_usd: asMoney(r.baseline_cost_usd),
+    };
+}
+/**
+ * Whether a saving may be called a saving, in one place.
+ *
+ * `baseline_reason` decides.
+ *
+ *   "named"        the caller asked for a model and got something cheaper. A
+ *                  like-for-like comparison, and the only case that may be
+ *                  labelled `saved`.
+ *   "plan_ceiling" the caller sent `auto`, so the Gateway measured against the
+ *                  most expensive model their plan allows. Real, and not
+ *                  something anybody asked for: `vs ceiling`.
+ *   missing        treated as unnamed. A receipt that does not say where its
+ *                  baseline came from does not get the flattering reading.
+ *
+ * Matches `savingsLabel()` in `cli/src/render.mjs` exactly.
+ */
+export function savingsLabel(receipt) {
+    const amount = receipt?.savings_usd;
+    if (typeof amount !== "number" || !(amount > 0))
+        return null;
+    const named = receipt?.baseline_reason === "named";
+    return {
+        label: named ? "saved" : "vs ceiling",
+        named,
+        amount,
+        baseline_model: receipt?.baseline_model ?? null,
+        baseline_reason: receipt?.baseline_reason ?? null,
+    };
+}
+/**
+ * The receipt as a human reads it: one line, then whatever needs saying.
+ *
+ * This is returned as its own content block, separate from the answer, for the
+ * same reason the CLI writes it to stderr — so the thing you asked for and the
+ * thing it cost do not end up concatenated in whatever consumes the answer.
+ */
+export function describeReceipt({ receipt, usage, model, droppedParams }) {
+    const served = receipt?.served_model || model || "unknown";
+    const parts = [`model ${served}`];
+    if (receipt?.requested_model && receipt.routed)
+        parts.push(`asked ${receipt.requested_model}`);
+    if (usage)
+        parts.push(`tokens ${usage.prompt_tokens}/${usage.completion_tokens}`);
+    parts.push(`cost ${money(receipt?.cost_usd ?? null)}`);
+    const saving = savingsLabel(receipt);
+    if (saving)
+        parts.push(`${saving.label} ${money(saving.amount)}`);
+    const lines = [`— ${parts.join("  ·  ")}`];
+    if (saving && !saving.named && saving.baseline_reason === "plan_ceiling" && saving.baseline_model) {
+        lines.push(`  measured against ${saving.baseline_model}, the priciest model your plan allows — you sent auto, not that model`);
+    }
+    if (receipt && !receipt.priced) {
+        lines.push("  the gateway could not price this model, so no cost is claimed");
+    }
+    if (!receipt) {
+        lines.push("  no receipt on this response — the endpoint did not send one");
+    }
+    if (droppedParams?.length) {
+        lines.push(`  the served model does not accept ${droppedParams.join(", ")}; it was dropped`);
+    }
+    if (receipt?.request_id)
+        lines.push(`  request ${receipt.request_id}`);
+    return lines.join("\n");
+}

package/dist/server.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The MCP server: four tools over the Lobstack Gateway.
+ *
+ * Exported as a factory rather than wired straight to stdio so the tests can
+ * drive it over an in-memory transport with a real MCP client on the other end,
+ * against a fake gateway speaking real HTTP. What breaks in a thing like this
+ * is at the seams — a frame split by the network, a receipt read off the wrong
+ * field, a redirect quietly eating the key — and none of that shows up when you
+ * call your own parser with a string you wrote.
+ *
+ * THE TOOL SET, AND WHY IT IS THIS ONE
+ *
+ *   lobstack_route_preview  scores a prompt and names the model that would
+ *                           serve it. No key. The only tool that works on a
+ *                           fresh install, which makes it the one that shows
+ *                           what the product does before anybody has signed up.
+ *   lobstack_models         the catalogue, with per-token prices and tiers.
+ *   lobstack_chat           the actual completion, and the receipt for it.
+ *   lobstack_spend          the ledger over a range.
+ *
+ * Nothing here mints, rotates or reads API keys, and nothing accepts a base URL
+ * as an argument. This process holds a live credential for as long as the MCP
+ * client runs; the two ways that credential gets away from you are a tool that
+ * can redirect it somewhere and a tool that can hand out another one. Neither
+ * exists here.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const SERVER_NAME = "lobstack";
+/**
+ * Read from package.json, not typed here.
+ *
+ * This is the version the server announces over MCP `initialize`, and it was a
+ * literal sitting beside a `version` field in the manifest — two places to bump
+ * and one to forget. `npm version` writes the manifest and nothing else, so a
+ * release would have shipped announcing the previous version to every client.
+ */
+export declare const SERVER_VERSION: string;
+export interface CreateServerOptions {
+    /** Overrides LOBSTACK_BASE_URL. Process configuration; never a tool argument. */
+    baseUrl?: string | null;
+    /** Overrides LOBSTACK_API_KEY. */
+    apiKey?: string | null;
+}
+export declare function createServer(options?: CreateServerOptions): McpServer;

package/dist/server.js

@@ -0,0 +1,106 @@
+/**
+ * The MCP server: four tools over the Lobstack Gateway.
+ *
+ * Exported as a factory rather than wired straight to stdio so the tests can
+ * drive it over an in-memory transport with a real MCP client on the other end,
+ * against a fake gateway speaking real HTTP. What breaks in a thing like this
+ * is at the seams — a frame split by the network, a receipt read off the wrong
+ * field, a redirect quietly eating the key — and none of that shows up when you
+ * call your own parser with a string you wrote.
+ *
+ * THE TOOL SET, AND WHY IT IS THIS ONE
+ *
+ *   lobstack_route_preview  scores a prompt and names the model that would
+ *                           serve it. No key. The only tool that works on a
+ *                           fresh install, which makes it the one that shows
+ *                           what the product does before anybody has signed up.
+ *   lobstack_models         the catalogue, with per-token prices and tiers.
+ *   lobstack_chat           the actual completion, and the receipt for it.
+ *   lobstack_spend          the ledger over a range.
+ *
+ * Nothing here mints, rotates or reads API keys, and nothing accepts a base URL
+ * as an argument. This process holds a live credential for as long as the MCP
+ * client runs; the two ways that credential gets away from you are a tool that
+ * can redirect it somewhere and a tool that can hand out another one. Neither
+ * exists here.
+ */
+import { readFileSync } from "node:fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { loadConfig } from "./config.js";
+import { chatInput, chatOutput, runChat } from "./tools/chat.js";
+import { modelsInput, modelsOutput, runModels } from "./tools/models.js";
+import { routePreviewInput, routePreviewOutput, runRoutePreview } from "./tools/route-preview.js";
+import { spendInput, spendOutput, runSpend } from "./tools/spend.js";
+export const SERVER_NAME = "lobstack";
+/**
+ * Read from package.json, not typed here.
+ *
+ * This is the version the server announces over MCP `initialize`, and it was a
+ * literal sitting beside a `version` field in the manifest — two places to bump
+ * and one to forget. `npm version` writes the manifest and nothing else, so a
+ * release would have shipped announcing the previous version to every client.
+ */
+export const SERVER_VERSION = (() => {
+    try {
+        return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+})();
+const INSTRUCTIONS = `Lobstack is a metered LLM gateway: one key reaches every major model, and every call
+comes back with a receipt saying which model served it and what it cost.
+
+- lobstack_route_preview needs NO API key. It scores a prompt against the same
+  router the paid path uses and reports the model that would serve it and the
+  estimated cost. Use it to choose a model, or to show what routing does.
+- lobstack_chat runs the completion. Send model "auto" to let the router pick
+  the cheapest model that can handle the prompt.
+- Costs are reported as the gateway priced them. A null cost means the gateway
+  could not price the call — it does not mean the call was free.
+- A saving labelled "saved" is like-for-like: the caller named a model and got
+  something cheaper. A saving labelled "vs ceiling" is measured against the most
+  expensive model the plan allows, which nobody asked for. Do not describe the
+  second as if it were the first.`;
+export function createServer(options = {}) {
+    const cfg = loadConfig(options);
+    const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} }, instructions: INSTRUCTIONS });
+    server.registerTool("lobstack_route_preview", {
+        title: "Preview routing and cost",
+        description: "Score a prompt and report which model the Lobstack router would serve it with, and what that would cost. " +
+            "Runs no inference, spends nothing, and NEEDS NO API KEY — use it to pick a model before calling lobstack_chat, " +
+            "or to show what the gateway does on a machine with no key configured. Token counts are estimates; the billed " +
+            "figure comes from the provider's usage block on the real call.",
+        inputSchema: routePreviewInput,
+        outputSchema: routePreviewOutput,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (args) => runRoutePreview(cfg, args));
+    server.registerTool("lobstack_models", {
+        title: "List gateway models",
+        description: "The models the Lobstack Gateway serves, with capability tier, provider, context window and USD price per " +
+            "million input and output tokens. A model the registry cannot price shows a null price, not zero.",
+        inputSchema: modelsInput,
+        outputSchema: modelsOutput,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (args) => runModels(cfg, args));
+    server.registerTool("lobstack_chat", {
+        title: "Chat through the gateway",
+        description: "Send a prompt or conversation through the Lobstack Gateway and get the reply plus a receipt: the model that " +
+            'actually served it, token counts, USD cost, and any saving with the reason it may be claimed. Model "auto" ' +
+            "(the default) lets the router pick the cheapest model that can handle the prompt. This call spends money " +
+            "against the configured key's allowance.",
+        inputSchema: chatInput,
+        outputSchema: chatOutput,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (args) => runChat(cfg, args));
+    server.registerTool("lobstack_spend", {
+        title: "Read spend and usage",
+        description: "What this organization has spent through the gateway over a range, broken down by day, model, key or agent, " +
+            "with request counts, tokens, error counts and latency percentiles. Requires an API key with the usage:read " +
+            "scope. Reports how many requests could not be priced, because a total that includes them is a floor.",
+        inputSchema: spendInput,
+        outputSchema: spendOutput,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (args) => runSpend(cfg, args));
+    return server;
+}

package/dist/sse.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Read an OpenAI-compatible SSE stream, and keep the receipt.
+ *
+ * Three things here are load-bearing, and all three are the same rule as
+ * `cli/src/stream.mjs` in the platform repo — deliberately, because two
+ * different readers for one wire format is two chances to disagree about what
+ * the seller said a call cost.
+ *
+ * The splitter buffers across chunk boundaries. A JSON frame can be cut in the
+ * middle by the network, and parsing per chunk instead of per frame drops
+ * tokens — which surfaces as answers that end mid-sentence and that nobody can
+ * reproduce.
+ *
+ * The trailing buffer is flushed at end of stream. A server that closes without
+ * a final blank line still owes us its last event, and the last event is the
+ * one carrying the price.
+ *
+ * `\r\n\r\n` is accepted alongside `\n\n`. Our gateway emits `\n\n`; a proxy in
+ * between is entitled to normalise line endings, and a reader that only knows
+ * one of the two spellings loses every frame when it does.
+ */
+/** Yield each `data:` payload from an SSE body, whole. */
+export declare function sseFrames(body: ReadableStream<Uint8Array>): AsyncGenerator<string>;
+export interface StreamUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+export interface ConsumedStream {
+    text: string;
+    usage: StreamUsage | null;
+    /** `x_lobstack` off the trailing frame, verbatim. Null if it never arrived. */
+    receipt: unknown;
+    /** The model the frames named, which is the model that actually served. */
+    model: string | null;
+    finishReason: string | null;
+}
+export declare class StreamError extends Error {
+    constructor(message: string);
+}
+/**
+ * Consume a completion stream to the end.
+ *
+ * The whole answer is accumulated rather than forwarded: an MCP tool result is
+ * one message, so there is nowhere to stream it to. The request is still made
+ * with `stream: true` and `include_usage`, because the trailing SSE frame is the
+ * only place the Gateway reports a streamed call's price — headers are written
+ * before the provider has counted a token.
+ */
+export declare function consume(body: ReadableStream<Uint8Array>, onText?: (delta: string) => void): Promise<ConsumedStream>;

package/dist/sse.js

@@ -0,0 +1,112 @@
+/**
+ * Read an OpenAI-compatible SSE stream, and keep the receipt.
+ *
+ * Three things here are load-bearing, and all three are the same rule as
+ * `cli/src/stream.mjs` in the platform repo — deliberately, because two
+ * different readers for one wire format is two chances to disagree about what
+ * the seller said a call cost.
+ *
+ * The splitter buffers across chunk boundaries. A JSON frame can be cut in the
+ * middle by the network, and parsing per chunk instead of per frame drops
+ * tokens — which surfaces as answers that end mid-sentence and that nobody can
+ * reproduce.
+ *
+ * The trailing buffer is flushed at end of stream. A server that closes without
+ * a final blank line still owes us its last event, and the last event is the
+ * one carrying the price.
+ *
+ * `\r\n\r\n` is accepted alongside `\n\n`. Our gateway emits `\n\n`; a proxy in
+ * between is entitled to normalise line endings, and a reader that only knows
+ * one of the two spellings loses every frame when it does.
+ */
+/** Yield each `data:` payload from an SSE body, whole. */
+export async function* sseFrames(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let idx;
+            while ((idx = buffer.search(/\r?\n\r?\n/)) !== -1) {
+                const rawEvent = buffer.slice(0, idx);
+                buffer = buffer.slice(idx + (buffer[idx] === "\r" ? 4 : 2));
+                for (const line of rawEvent.split(/\r?\n/)) {
+                    if (!line.startsWith("data:"))
+                        continue;
+                    const payload = line.slice(5).trim();
+                    if (payload)
+                        yield payload;
+                }
+            }
+        }
+        for (const line of buffer.split(/\r?\n/)) {
+            if (!line.startsWith("data:"))
+                continue;
+            const payload = line.slice(5).trim();
+            if (payload)
+                yield payload;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+export class StreamError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "StreamError";
+    }
+}
+/**
+ * Consume a completion stream to the end.
+ *
+ * The whole answer is accumulated rather than forwarded: an MCP tool result is
+ * one message, so there is nowhere to stream it to. The request is still made
+ * with `stream: true` and `include_usage`, because the trailing SSE frame is the
+ * only place the Gateway reports a streamed call's price — headers are written
+ * before the provider has counted a token.
+ */
+export async function consume(body, onText) {
+    let text = "";
+    let usage = null;
+    let receipt = null;
+    let model = null;
+    let finishReason = null;
+    for await (const payload of sseFrames(body)) {
+        if (payload === "[DONE]")
+            break;
+        let frame;
+        try {
+            frame = JSON.parse(payload);
+        }
+        catch {
+            continue; // a half-frame is not worth ending a turn over
+        }
+        if (frame.error) {
+            const e = frame.error;
+            // A 200 whose stream carries an error. Headers are long gone by then, so
+            // this is the only place the gateway can report a mid-stream failure.
+            throw new StreamError(e?.message || "the gateway reported an error mid-stream");
+        }
+        if (typeof frame.model === "string")
+            model = frame.model;
+        if (frame.usage && typeof frame.usage === "object")
+            usage = frame.usage;
+        if (frame.x_lobstack !== undefined && frame.x_lobstack !== null)
+            receipt = frame.x_lobstack;
+        const choices = frame.choices;
+        const first = choices?.[0];
+        if (first?.finish_reason)
+            finishReason = first.finish_reason;
+        const delta = first?.delta?.content;
+        if (typeof delta === "string" && delta.length) {
+            text += delta;
+            onText?.(delta);
+        }
+    }
+    return { text, usage, receipt, model, finishReason };
+}

package/dist/tools/chat.d.ts

@@ -0,0 +1,133 @@
+/**
+ * lobstack_chat — one completion, and what it cost.
+ *
+ * WHY THIS STREAMS WHEN NOTHING IS STREAMED TO
+ *
+ * An MCP tool result is a single message; there is no partial delivery to an
+ * agent mid-call. So the whole answer is accumulated here before it is
+ * returned, and `stream: true` looks pointless.
+ *
+ * It is not. On the buffered path the Gateway reports the price in response
+ * HEADERS, and on the streamed path it reports it in the trailing SSE frame as
+ * `x_lobstack`. The frame is the better source: the streaming path meters
+ * *before* emitting that frame, so the figure is the ledger's, not an estimate,
+ * and it arrives as one structured object rather than eight headers, three of
+ * which encode "unpriced" as an empty string. Requesting SSE and reading it to
+ * the end is how this tool returns a receipt it did not compute itself.
+ *
+ * `stream_options.include_usage` is not optional: without it the Gateway has no
+ * trailing frame to attach `x_lobstack` to, and the price never arrives.
+ */
+import { z } from "zod";
+import type { Config } from "../config.js";
+import { type ToolResult } from "./shared.js";
+export declare const chatInput: {
+    prompt: z.ZodOptional<z.ZodString>;
+    messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["system", "user", "assistant"]>;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        role: "system" | "user" | "assistant";
+    }, {
+        content: string;
+        role: "system" | "user" | "assistant";
+    }>, "many">>;
+    model: z.ZodOptional<z.ZodString>;
+    system: z.ZodOptional<z.ZodString>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+};
+export declare const chatOutput: {
+    text: z.ZodString;
+    model: z.ZodObject<{
+        requested: z.ZodNullable<z.ZodString>;
+        served: z.ZodNullable<z.ZodString>;
+        routed: z.ZodNullable<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        routed: boolean | null;
+        requested: string | null;
+        served: string | null;
+    }, {
+        routed: boolean | null;
+        requested: string | null;
+        served: string | null;
+    }>;
+    usage: z.ZodNullable<z.ZodObject<{
+        prompt_tokens: z.ZodNumber;
+        completion_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    }, {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    }>>;
+    receipt: z.ZodNullable<z.ZodObject<{
+        request_id: z.ZodNullable<z.ZodString>;
+        cost_usd: z.ZodNullable<z.ZodNumber>;
+        cost_display: z.ZodString;
+        priced: z.ZodBoolean;
+        savings: z.ZodNullable<z.ZodObject<{
+            amount_usd: z.ZodNumber;
+            label: z.ZodString;
+            named: z.ZodBoolean;
+            baseline_model: z.ZodNullable<z.ZodString>;
+            baseline_reason: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            named: boolean;
+            baseline_reason: string | null;
+            baseline_model: string | null;
+            amount_usd: number;
+            label: string;
+        }, {
+            named: boolean;
+            baseline_reason: string | null;
+            baseline_model: string | null;
+            amount_usd: number;
+            label: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        request_id: string | null;
+        cost_usd: number | null;
+        priced: boolean;
+        cost_display: string;
+        savings: {
+            named: boolean;
+            baseline_reason: string | null;
+            baseline_model: string | null;
+            amount_usd: number;
+            label: string;
+        } | null;
+    }, {
+        request_id: string | null;
+        cost_usd: number | null;
+        priced: boolean;
+        cost_display: string;
+        savings: {
+            named: boolean;
+            baseline_reason: string | null;
+            baseline_model: string | null;
+            amount_usd: number;
+            label: string;
+        } | null;
+    }>>;
+    quota: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dropped_params: z.ZodArray<z.ZodString, "many">;
+};
+type ChatArgs = {
+    prompt?: string;
+    messages?: Array<{
+        role: "system" | "user" | "assistant";
+        content: string;
+    }>;
+    model?: string;
+    system?: string;
+    max_tokens?: number;
+    temperature?: number;
+};
+export declare function runChat(cfg: Config, args: ChatArgs): Promise<ToolResult>;
+export {};