toad-eye 1.1.0 → 2.1.0

package/dist/drift/monitor.js

@@ -0,0 +1,47 @@
+/**
+ * Drift monitor — runtime semantic drift detection with sampling.
+ *
+ * Not every response is checked (embedding API calls cost money).
+ * By default, every 10th response is sampled. The drift value is
+ * recorded as a Prometheus histogram metric with provider/model labels.
+ */
+import { createOpenAIEmbeddingProvider } from "./openai-embeddings.js";
+import { cosineDrift } from "./cosine.js";
+import { loadBaseline } from "./baseline.js";
+import { recordSemanticDrift } from "../core/metrics.js";
+function createProvider(config) {
+    switch (config.provider) {
+        case "openai":
+            return createOpenAIEmbeddingProvider(config.apiKey, config.model);
+        case "custom":
+            return { name: "custom", embed: config.embed };
+    }
+}
+export function createDriftMonitor(config) {
+    const provider = createProvider(config.embedding);
+    const sampleRate = config.sampleRate ?? 10;
+    const baseline = loadBaseline(config.baselinePath);
+    let counter = 0;
+    if (baseline === undefined) {
+        console.warn(`[toad-eye] No baseline found at ${config.baselinePath}. Drift monitoring disabled until baseline is saved.`);
+    }
+    async function performCheck(response, providerName, model) {
+        if (baseline === undefined)
+            return undefined;
+        counter++;
+        if (counter % sampleRate !== 0)
+            return undefined;
+        const embedding = await provider.embed(response);
+        const drift = cosineDrift(embedding, baseline.embeddings);
+        recordSemanticDrift(drift, providerName, model);
+        return drift;
+    }
+    return {
+        check: performCheck,
+        checkInBackground(response, providerName, model) {
+            void performCheck(response, providerName, model).catch((err) => {
+                console.warn(`[toad-eye] Drift check failed (non-blocking): ${err instanceof Error ? err.message : String(err)}`);
+            });
+        },
+    };
+}

package/dist/drift/openai-embeddings.d.ts

@@ -0,0 +1,6 @@
+/**
+ * OpenAI embedding provider using text-embedding-3-small.
+ * Calls the OpenAI API directly via fetch — no SDK dependency.
+ */
+import type { EmbeddingProvider } from "./embedding-provider.js";
+export declare function createOpenAIEmbeddingProvider(apiKey: string, model?: string): EmbeddingProvider;

package/dist/drift/openai-embeddings.js

@@ -0,0 +1,26 @@
+/**
+ * OpenAI embedding provider using text-embedding-3-small.
+ * Calls the OpenAI API directly via fetch — no SDK dependency.
+ */
+const DEFAULT_MODEL = "text-embedding-3-small";
+const OPENAI_API_URL = "https://api.openai.com/v1/embeddings";
+export function createOpenAIEmbeddingProvider(apiKey, model = DEFAULT_MODEL) {
+    return {
+        name: `openai/${model}`,
+        async embed(text) {
+            const response = await fetch(OPENAI_API_URL, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ input: text, model }),
+            });
+            if (!response.ok) {
+                throw new Error(`OpenAI Embeddings API error: ${response.status} ${response.statusText}`);
+            }
+            const body = (await response.json());
+            return body.data[0].embedding;
+        },
+    };
+}

package/dist/export.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Trace-to-Dataset Export — converts production Jaeger traces into toad-eval test cases.
+ *
+ * Fetches a trace by ID from the Jaeger Query API, extracts LLM call data
+ * (prompt, model, provider, response), and generates a YAML file in toad-eval format
+ * with auto-generated assertions (max_length, not_contains, is_json).
+ */
+interface JaegerTag {
+    readonly key: string;
+    readonly type: string;
+    readonly value: string | number | boolean;
+}
+interface JaegerSpan {
+    readonly traceID: string;
+    readonly spanID: string;
+    readonly operationName: string;
+    readonly tags: readonly JaegerTag[];
+    readonly startTime: number;
+    readonly duration: number;
+}
+interface JaegerTrace {
+    readonly traceID: string;
+    readonly spans: readonly JaegerSpan[];
+}
+export interface ExportTraceOptions {
+    readonly jaegerUrl?: string | undefined;
+    readonly output?: string | undefined;
+}
+/**
+ * Fetch a trace from Jaeger by trace ID.
+ * Requires Jaeger to be running with the Query API available.
+ */
+export declare function fetchTrace(traceId: string, jaegerUrl?: string): Promise<JaegerTrace>;
+/**
+ * Convert a Jaeger trace to a toad-eval YAML string.
+ * Extracts LLM spans with prompt data, generates assertions from completions.
+ *
+ * Returns undefined if no exportable spans found (e.g. recordContent was false).
+ */
+export declare function traceToEvalYaml(trace: JaegerTrace): string | undefined;
+/**
+ * Full export pipeline: fetch trace from Jaeger → convert to toad-eval YAML.
+ * Returns the YAML string. Caller is responsible for writing to file.
+ */
+export declare function exportTrace(traceId: string, options?: ExportTraceOptions): Promise<string>;
+export {};

package/dist/export.js

@@ -0,0 +1,108 @@
+/**
+ * Trace-to-Dataset Export — converts production Jaeger traces into toad-eval test cases.
+ *
+ * Fetches a trace by ID from the Jaeger Query API, extracts LLM call data
+ * (prompt, model, provider, response), and generates a YAML file in toad-eval format
+ * with auto-generated assertions (max_length, not_contains, is_json).
+ */
+import { stringify } from "yaml";
+import { GEN_AI_ATTRS } from "./types/index.js";
+const DEFAULT_JAEGER_URL = "http://localhost:16686";
+const LENGTH_BUFFER_MULTIPLIER = 1.5;
+const REFUSAL_MARKER = "i cannot";
+function getTagValue(tags, key) {
+    const tag = tags.find((t) => t.key === key);
+    return tag !== undefined ? String(tag.value) : undefined;
+}
+function isJson(text) {
+    try {
+        JSON.parse(text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function buildAssertions(completion) {
+    const assertions = [];
+    if (completion !== undefined) {
+        assertions.push({
+            type: "max_length",
+            value: Math.ceil(completion.length * LENGTH_BUFFER_MULTIPLIER),
+        });
+        if (!completion.toLowerCase().includes(REFUSAL_MARKER)) {
+            assertions.push({ type: "not_contains", value: "I cannot" });
+        }
+        if (isJson(completion)) {
+            assertions.push({ type: "is_json", value: true });
+        }
+    }
+    return assertions;
+}
+function spanToEvalCase(span, index) {
+    const prompt = getTagValue(span.tags, GEN_AI_ATTRS.PROMPT);
+    if (prompt === undefined)
+        return undefined;
+    const completion = getTagValue(span.tags, GEN_AI_ATTRS.COMPLETION);
+    return {
+        id: `production-case-${index + 1}`,
+        variables: { input: prompt },
+        assertions: buildAssertions(completion),
+    };
+}
+/**
+ * Fetch a trace from Jaeger by trace ID.
+ * Requires Jaeger to be running with the Query API available.
+ */
+export async function fetchTrace(traceId, jaegerUrl = DEFAULT_JAEGER_URL) {
+    const url = `${jaegerUrl}/api/traces/${traceId}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch trace ${traceId}: ${response.status} ${response.statusText}`);
+    }
+    const body = (await response.json());
+    if (body.data.length === 0) {
+        throw new Error(`Trace ${traceId} not found`);
+    }
+    return body.data[0];
+}
+/**
+ * Convert a Jaeger trace to a toad-eval YAML string.
+ * Extracts LLM spans with prompt data, generates assertions from completions.
+ *
+ * Returns undefined if no exportable spans found (e.g. recordContent was false).
+ */
+export function traceToEvalYaml(trace) {
+    const cases = trace.spans
+        .map((span, i) => spanToEvalCase(span, i))
+        .filter((c) => c !== undefined);
+    if (cases.length === 0)
+        return undefined;
+    // Pick model/provider from first span that has them
+    const firstSpanWithMeta = trace.spans.find((s) => getTagValue(s.tags, GEN_AI_ATTRS.REQUEST_MODEL) !== undefined);
+    const dataset = {
+        name: `exported-trace-${trace.traceID.slice(0, 8)}`,
+        source: "toad-eye-export",
+        metadata: {
+            trace_id: trace.traceID,
+            exported_at: new Date().toISOString(),
+            model: getTagValue(firstSpanWithMeta?.tags ?? [], GEN_AI_ATTRS.REQUEST_MODEL) ?? "unknown",
+            provider: getTagValue(firstSpanWithMeta?.tags ?? [], GEN_AI_ATTRS.PROVIDER) ??
+                "unknown",
+        },
+        cases,
+    };
+    return stringify(dataset);
+}
+/**
+ * Full export pipeline: fetch trace from Jaeger → convert to toad-eval YAML.
+ * Returns the YAML string. Caller is responsible for writing to file.
+ */
+export async function exportTrace(traceId, options = {}) {
+    const trace = await fetchTrace(traceId, options.jaegerUrl);
+    const yaml = traceToEvalYaml(trace);
+    if (yaml === undefined) {
+        throw new Error(`No exportable spans in trace ${traceId}. Was recordContent enabled?`);
+    }
+    return yaml;
+}

package/dist/guard.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shadow Guardrails integration — records toad-guard validation results
+ * as span attributes and metrics without blocking LLM responses.
+ *
+ * toad-guard validates each LLM response and passes the result here.
+ * In shadow mode, validation runs but never throws — results are recorded
+ * for observability only, letting you tune guardrail thresholds on
+ * production traffic before switching to enforce mode.
+ *
+ * Usage from toad-guard:
+ * ```ts
+ * import { recordGuardResult } from "toad-eye";
+ *
+ * const result = guard.validate(response);
+ * recordGuardResult(result); // records as span attrs + metrics
+ * ```
+ */
+import type { GuardResult } from "./types/index.js";
+/**
+ * Record a guard validation result as span attributes and metrics.
+ *
+ * Attaches guard attributes to a child span and increments counters.
+ * If the guard failed, also increments the `would_block` counter —
+ * useful for measuring how often shadow guardrails would have blocked.
+ */
+export declare function recordGuardResult(result: GuardResult): void;

package/dist/guard.js

@@ -0,0 +1,45 @@
+/**
+ * Shadow Guardrails integration — records toad-guard validation results
+ * as span attributes and metrics without blocking LLM responses.
+ *
+ * toad-guard validates each LLM response and passes the result here.
+ * In shadow mode, validation runs but never throws — results are recorded
+ * for observability only, letting you tune guardrail thresholds on
+ * production traffic before switching to enforce mode.
+ *
+ * Usage from toad-guard:
+ * ```ts
+ * import { recordGuardResult } from "toad-eye";
+ *
+ * const result = guard.validate(response);
+ * recordGuardResult(result); // records as span attrs + metrics
+ * ```
+ */
+import { trace } from "@opentelemetry/api";
+import { GEN_AI_ATTRS, INSTRUMENTATION_NAME } from "./types/index.js";
+import { recordGuardEvaluation, recordGuardWouldBlock, } from "./core/metrics.js";
+const tracer = trace.getTracer(INSTRUMENTATION_NAME);
+/**
+ * Record a guard validation result as span attributes and metrics.
+ *
+ * Attaches guard attributes to a child span and increments counters.
+ * If the guard failed, also increments the `would_block` counter —
+ * useful for measuring how often shadow guardrails would have blocked.
+ */
+export function recordGuardResult(result) {
+    const span = tracer.startSpan(`guard.evaluate.${result.ruleName}`);
+    span.setAttributes({
+        [GEN_AI_ATTRS.GUARD_MODE]: result.mode,
+        [GEN_AI_ATTRS.GUARD_PASSED]: result.passed,
+        [GEN_AI_ATTRS.GUARD_RULE_NAME]: result.ruleName,
+        ...(!result.passed &&
+            result.failureReason !== undefined && {
+            [GEN_AI_ATTRS.GUARD_FAILURE_REASON]: result.failureReason,
+        }),
+    });
+    span.end();
+    recordGuardEvaluation(result.ruleName);
+    if (!result.passed) {
+        recordGuardWouldBlock(result.ruleName);
+    }
+}

package/dist/index.d.ts

@@ -1,5 +1,17 @@
-export { initObservability, shutdown, getConfig } from "./tracer.js";
-export { traceLLMCall } from "./spans.js";
-export type { LLMCallInput, LLMCallOutput } from "./spans.js";
-export type { ToadEyeConfig, LLMSpanAttributes, LLMProvider, SpanStatus, MetricName, } from "./types.js";
-export { LLM_METRICS, LLM_ATTRS } from "./types.js";
+export { initObservability, shutdown, getConfig, getBudgetTracker, } from "./core/tracer.js";
+export { BudgetTracker, ToadBudgetExceededError } from "./budget/index.js";
+export type { BudgetConfig, BudgetExceededMode, BudgetExceededInfo, DowngradeCallback, } from "./budget/index.js";
+export { AlertManager, startAlertsFromFile, parseCondition, } from "./alerts/index.js";
+export type { AlertsConfig, AlertRule, AlertChannelConfig, FiredAlert, } from "./alerts/index.js";
+export { traceLLMCall } from "./core/spans.js";
+export { traceAgentStep, traceAgentQuery } from "./agent.js";
+export { recordGuardResult } from "./guard.js";
+export { createDriftMonitor, createOpenAIEmbeddingProvider, cosineSimilarity, cosineDrift, saveBaseline, loadBaseline, } from "./drift/index.js";
+export type { DriftMonitor, DriftMonitorConfig, EmbeddingProvider, EmbeddingConfig, DriftBaseline, } from "./drift/index.js";
+export { exportTrace, fetchTrace, traceToEvalYaml } from "./export.js";
+export type { ExportTraceOptions } from "./export.js";
+export { calculateCost, setCustomPricing, getModelPricing, } from "./core/pricing.js";
+export type { ModelPricing } from "./core/pricing.js";
+export type { LLMCallInput, LLMCallOutput } from "./core/spans.js";
+export type { ToadEyeConfig, LLMSpanAttributes, LLMProvider, SpanStatus, MetricName, AgentStepType, AgentStepInput, GuardMode, GuardResult, } from "./types/index.js";
+export { GEN_AI_METRICS, GEN_AI_ATTRS, LLM_METRICS, LLM_ATTRS, } from "./types/index.js";

package/dist/index.js

@@ -1,3 +1,10 @@
-export { initObservability, shutdown, getConfig } from "./tracer.js";
-export { traceLLMCall } from "./spans.js";
-export { LLM_METRICS, LLM_ATTRS } from "./types.js";
+export { initObservability, shutdown, getConfig, getBudgetTracker, } from "./core/tracer.js";
+export { BudgetTracker, ToadBudgetExceededError } from "./budget/index.js";
+export { AlertManager, startAlertsFromFile, parseCondition, } from "./alerts/index.js";
+export { traceLLMCall } from "./core/spans.js";
+export { traceAgentStep, traceAgentQuery } from "./agent.js";
+export { recordGuardResult } from "./guard.js";
+export { createDriftMonitor, createOpenAIEmbeddingProvider, cosineSimilarity, cosineDrift, saveBaseline, loadBaseline, } from "./drift/index.js";
+export { exportTrace, fetchTrace, traceToEvalYaml } from "./export.js";
+export { calculateCost, setCustomPricing, getModelPricing, } from "./core/pricing.js";
+export { GEN_AI_METRICS, GEN_AI_ATTRS, LLM_METRICS, LLM_ATTRS, } from "./types/index.js";

package/dist/instrumentations/anthropic.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/instrumentations/anthropic.js

@@ -0,0 +1,73 @@
+import { register } from "./registry.js";
+import { createInstrumentation } from "./create.js";
+function extractMessages(messages) {
+    if (!Array.isArray(messages))
+        return "";
+    return messages
+        .map((m) => {
+        if (typeof m.content === "string")
+            return m.content;
+        if (Array.isArray(m.content)) {
+            return m.content
+                .filter((b) => b.type === "text")
+                .map((b) => b.text)
+                .join("");
+        }
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function extractCompletion(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((b) => b.type === "text")
+        .map((b) => b.text ?? "")
+        .join("");
+}
+const messagesCreate = {
+    getPrototype: (sdk) => sdk?.Messages?.prototype,
+    method: "create",
+    extractRequest: (body) => {
+        const b = body;
+        return {
+            prompt: extractMessages(b?.messages),
+            model: b?.model ?? "unknown",
+            temperature: b?.temperature ?? 1.0,
+        };
+    },
+    extractResponse: (response) => {
+        const r = response;
+        return {
+            completion: extractCompletion(r?.content),
+            inputTokens: r?.usage?.input_tokens ?? 0,
+            outputTokens: r?.usage?.output_tokens ?? 0,
+        };
+    },
+    isStreaming: (body) => !!body?.stream,
+    extractStreamResponse: (chunks) => {
+        // Anthropic stream events: message_start, content_block_delta, message_delta, message_stop
+        let completion = "";
+        let inputTokens = 0;
+        let outputTokens = 0;
+        for (const chunk of chunks) {
+            const event = chunk;
+            if (event.type === "content_block_delta" && event.delta?.text) {
+                completion += event.delta.text;
+            }
+            if (event.type === "message_start" && event.message?.usage) {
+                inputTokens = event.message.usage.input_tokens ?? 0;
+            }
+            if (event.type === "message_delta" && event.usage) {
+                outputTokens = event.usage.output_tokens ?? 0;
+            }
+        }
+        return { completion, inputTokens, outputTokens };
+    },
+};
+register(createInstrumentation({
+    name: "anthropic",
+    moduleName: "@anthropic-ai/sdk",
+    patches: [messagesCreate],
+}));

package/dist/instrumentations/create.d.ts

@@ -0,0 +1,11 @@
+import type { LLMProvider } from "../types/index.js";
+import type { Instrumentation, PatchTarget } from "./types.js";
+/**
+ * Factory for creating SDK instrumentations.
+ * Eliminates boilerplate: SDK resolution, prototype patching, error handling, cleanup.
+ */
+export declare function createInstrumentation(config: {
+    name: LLMProvider;
+    moduleName: string;
+    patches: PatchTarget[];
+}): Instrumentation;

package/dist/instrumentations/create.js

@@ -0,0 +1,165 @@
+import { createRequire } from "node:module";
+import { trace, diag, SpanStatusCode } from "@opentelemetry/api";
+import { traceLLMCall } from "../core/spans.js";
+import { calculateCost } from "../core/pricing.js";
+import { recordRequestDuration, recordRequestCost, recordTokens, recordRequest, recordError, } from "../core/metrics.js";
+import { GEN_AI_ATTRS, INSTRUMENTATION_NAME } from "../types/index.js";
+const require = createRequire(import.meta.url);
+function isModuleInstalled(moduleName) {
+    try {
+        require.resolve(moduleName);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function loadModule(moduleName) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const sdk = require(moduleName);
+    return sdk.default ?? sdk;
+}
+/**
+ * Wrap an async iterable stream to intercept chunks.
+ * Yields every chunk transparently to the caller while collecting them.
+ * On stream end, calls onComplete with all accumulated chunks.
+ */
+async function* wrapAsyncIterable(stream, onChunk, onComplete, onError) {
+    const chunks = [];
+    try {
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+            onChunk(chunk);
+            yield chunk;
+        }
+        onComplete(chunks);
+    }
+    catch (err) {
+        onError(err);
+        throw err;
+    }
+}
+function createStreamingHandler(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+original, patch, providerName) {
+    const tracer = trace.getTracer(INSTRUMENTATION_NAME);
+    return async function handleStreaming(thisArg, body, rest) {
+        const req = patch.extractRequest(body);
+        const start = performance.now();
+        const response = await original.call(thisArg, body, ...rest);
+        // The response should be an async iterable (Stream, MessageStream, etc.)
+        // We wrap it to intercept chunks
+        const span = tracer.startSpan(`gen_ai.${providerName}.${req.model}`);
+        span.setAttributes({
+            [GEN_AI_ATTRS.PROVIDER]: providerName,
+            [GEN_AI_ATTRS.REQUEST_MODEL]: req.model,
+            [GEN_AI_ATTRS.TEMPERATURE]: req.temperature ?? 1.0,
+            [GEN_AI_ATTRS.OPERATION]: "chat",
+        });
+        const wrapped = wrapAsyncIterable(response, () => { }, (chunks) => {
+            const duration = performance.now() - start;
+            const res = patch.extractStreamResponse(chunks);
+            const cost = calculateCost(req.model, res.inputTokens, res.outputTokens);
+            span.setAttributes({
+                [GEN_AI_ATTRS.RESPONSE_MODEL]: req.model,
+                [GEN_AI_ATTRS.INPUT_TOKENS]: res.inputTokens,
+                [GEN_AI_ATTRS.OUTPUT_TOKENS]: res.outputTokens,
+                [GEN_AI_ATTRS.COST]: cost,
+                [GEN_AI_ATTRS.STATUS]: "success",
+            });
+            span.setStatus({ code: SpanStatusCode.OK });
+            span.end();
+            recordRequest(providerName, req.model);
+            recordRequestDuration(duration, providerName, req.model);
+            recordRequestCost(cost, providerName, req.model);
+            recordTokens(res.inputTokens + res.outputTokens, providerName, req.model);
+        }, (err) => {
+            const duration = performance.now() - start;
+            const message = err instanceof Error ? err.message : String(err);
+            span.setAttributes({
+                [GEN_AI_ATTRS.STATUS]: "error",
+                [GEN_AI_ATTRS.ERROR]: message,
+            });
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            span.end();
+            recordRequest(providerName, req.model);
+            recordRequestDuration(duration, providerName, req.model);
+            recordError(providerName, req.model);
+        });
+        // Return an object that looks like the original stream but with our wrapper
+        // Preserve the original object shape — SDKs may have extra methods/properties
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const proxy = Object.create(response);
+        proxy[Symbol.asyncIterator] = () => wrapped[Symbol.asyncIterator]();
+        return proxy;
+    };
+}
+function createPatchedMethod(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+original, patch, providerName) {
+    const streamHandler = patch.isStreaming && patch.extractStreamResponse
+        ? createStreamingHandler(original, patch, providerName)
+        : null;
+    return function patchedMethod(body, ...rest) {
+        if (patch.shouldSkip?.(body)) {
+            return original.call(this, body, ...rest);
+        }
+        // Handle streaming calls
+        if (streamHandler && patch.isStreaming?.(body)) {
+            return streamHandler(this, body, rest);
+        }
+        const req = patch.extractRequest(body);
+        return traceLLMCall({
+            provider: providerName,
+            model: req.model,
+            prompt: req.prompt,
+            temperature: req.temperature,
+        }, async () => {
+            const response = await original.call(this, body, ...rest);
+            const res = patch.extractResponse(response, req.model);
+            return {
+                completion: res.completion,
+                inputTokens: res.inputTokens,
+                outputTokens: res.outputTokens,
+                cost: calculateCost(req.model, res.inputTokens, res.outputTokens),
+            };
+        });
+    };
+}
+/**
+ * Factory for creating SDK instrumentations.
+ * Eliminates boilerplate: SDK resolution, prototype patching, error handling, cleanup.
+ */
+export function createInstrumentation(config) {
+    const activePatches = [];
+    return {
+        name: config.name,
+        enable() {
+            if (!isModuleInstalled(config.moduleName))
+                return false;
+            try {
+                const mod = loadModule(config.moduleName);
+                for (const patch of config.patches) {
+                    const proto = patch.getPrototype(mod);
+                    if (!proto?.[patch.method])
+                        continue;
+                    const original = proto[patch.method];
+                    proto[patch.method] = createPatchedMethod(original, patch, config.name);
+                    activePatches.push({ proto, method: patch.method, original });
+                }
+                return activePatches.length > 0;
+            }
+            catch (err) {
+                diag.warn(`toad-eye: failed to patch ${config.name}: ${err}`);
+                return false;
+            }
+        },
+        disable() {
+            for (const { proto, method, original } of activePatches) {
+                proto[method] = original;
+            }
+            activePatches.length = 0;
+        },
+    };
+}

package/dist/instrumentations/gemini.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/instrumentations/gemini.js

@@ -0,0 +1,48 @@
+import { register } from "./registry.js";
+import { createInstrumentation } from "./create.js";
+function extractPrompt(request) {
+    if (typeof request === "string")
+        return request;
+    if (typeof request === "object" && request !== null) {
+        const req = request;
+        if (Array.isArray(req.contents)) {
+            return req.contents
+                .flatMap((c) => c.parts ?? [])
+                .map((p) => p.text ?? "")
+                .filter(Boolean)
+                .join("\n");
+        }
+    }
+    return "";
+}
+const generateContent = {
+    getPrototype: (sdk) => sdk?.GenerativeModel?.prototype,
+    method: "generateContent",
+    extractRequest(body) {
+        return {
+            prompt: extractPrompt(body),
+            // model comes from `this.model` — injected by create.ts via the patched function's `this`
+            model: "unknown",
+        };
+    },
+    extractResponse: (response) => {
+        const r = response;
+        let completion = "";
+        try {
+            completion = r?.response?.text?.() ?? "";
+        }
+        catch {
+            // text() may throw if response is blocked
+        }
+        return {
+            completion,
+            inputTokens: r?.response?.usageMetadata?.promptTokenCount ?? 0,
+            outputTokens: r?.response?.usageMetadata?.candidatesTokenCount ?? 0,
+        };
+    },
+};
+register(createInstrumentation({
+    name: "gemini",
+    moduleName: "@google/generative-ai",
+    patches: [generateContent],
+}));

package/dist/instrumentations/openai.d.ts

@@ -0,0 +1 @@
+export {};