toad-eye 1.0.0 → 2.0.0

package/dist/alerts/types.d.ts

@@ -0,0 +1,46 @@
+export type AlertChannelConfig = {
+    readonly type: "telegram";
+    readonly token: string;
+    readonly chatId: string;
+} | {
+    readonly type: "slack_webhook";
+    readonly url: string;
+} | {
+    readonly type: "webhook";
+    readonly url: string;
+    readonly headers?: Record<string, string> | undefined;
+} | {
+    readonly type: "email";
+    readonly host: string;
+    readonly port: number;
+    readonly user: string;
+    readonly password: string;
+    readonly from: string;
+    readonly to: string | readonly string[];
+};
+export interface AlertRule {
+    readonly name: string;
+    readonly metric: string;
+    readonly condition: string;
+    readonly channels: readonly string[];
+    readonly cooldown?: number | undefined;
+}
+export interface AlertsConfig {
+    readonly prometheusUrl?: string | undefined;
+    readonly grafanaUrl?: string | undefined;
+    readonly grafanaApiKey?: string | undefined;
+    readonly evalIntervalSeconds?: number | undefined;
+    readonly cooldownMinutes?: number | undefined;
+    readonly channels?: Record<string, AlertChannelConfig> | undefined;
+    readonly alerts: readonly AlertRule[];
+}
+export interface FiredAlert {
+    readonly rule: AlertRule;
+    readonly value: number;
+    readonly threshold: number;
+    readonly topModels: ReadonlyArray<{
+        model: string;
+        value: number;
+    }>;
+    readonly firedAt: Date;
+}

package/dist/alerts/types.js

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

package/dist/cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { execSync } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import { cpSync, existsSync, mkdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { initObservability, traceLLMCall, shutdown, calculateCost, } from "./index.js";
 const INFRA_DIR = "infra/toad-eye";
 const SERVICES = [
     { name: "Grafana", url: "http://localhost:3100", login: "admin / admin" },
@@ -84,6 +85,72 @@ function status() {
         console.log("Could not check container status. Is Docker running?");
     }
 }
+const DEMO_MODELS = [
+    { provider: "anthropic", model: "claude-sonnet-4-20250514" },
+    { provider: "gemini", model: "gemini-2.5-flash" },
+    { provider: "openai", model: "gpt-4o" },
+];
+function randomBetween(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+const DEMO_PROMPTS = [
+    "Explain quantum computing",
+    "Write a haiku about frogs",
+    "What is the capital of Uruguay?",
+    "How does TCP work?",
+    "Translate hello to Japanese",
+];
+function pickRandom(arr) {
+    return arr[randomBetween(0, arr.length - 1)];
+}
+async function simulateLLMCall(provider, model, prompt) {
+    await new Promise((r) => setTimeout(r, randomBetween(200, 2000)));
+    if (Math.random() < 0.1) {
+        throw new Error(`${provider} API error: rate limit exceeded`);
+    }
+    const inputTokens = randomBetween(50, 500);
+    const outputTokens = randomBetween(20, 300);
+    return {
+        completion: `Mock response for: "${prompt}"`,
+        inputTokens,
+        outputTokens,
+        cost: calculateCost(model, inputTokens, outputTokens),
+    };
+}
+async function demo() {
+    const composeFile = getComposeFile();
+    if (!existsSync(composeFile)) {
+        console.error(`\u274c ${INFRA_DIR}/ not found. Run \`npx toad-eye init\` first.`);
+        process.exit(1);
+    }
+    initObservability({
+        serviceName: "toad-eye-demo",
+        endpoint: "http://localhost:4318",
+    });
+    console.log("\u{1f438}\u{1f441}\u{fe0f} toad-eye demo — sending mock LLM traffic");
+    console.log("    Press Ctrl+C to stop\n");
+    process.on("SIGINT", async () => {
+        console.log("\n\u{1f44b} Shutting down...");
+        await shutdown();
+        process.exit(0);
+    });
+    const tick = async () => {
+        const { provider, model } = pickRandom(DEMO_MODELS);
+        const prompt = pickRandom(DEMO_PROMPTS);
+        try {
+            await traceLLMCall({ provider, model, prompt, temperature: 0.7 }, () => simulateLLMCall(provider, model, prompt));
+            console.log(`  \u2705 [${provider}/${model}] ${prompt}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(`  \u274c [${provider}/${model}] ${msg}`);
+        }
+    };
+    const run = () => {
+        tick().then(() => setTimeout(run, 2000));
+    };
+    run();
+}
 function help() {
     console.log(`
 \u{1f438} toad-eye CLI — observability stack for LLM services
@@ -93,6 +160,7 @@ Commands:
   up       Start the stack (OTel Collector + Prometheus + Jaeger + Grafana)
   down     Stop the stack
   status   Show running services and URLs
+  demo     Send mock LLM traffic to see data in Grafana
   help     Show this message
 `);
 }
@@ -110,6 +178,9 @@ switch (command) {
     case "status":
         status();
         break;
+    case "demo":
+        demo();
+        break;
     case "help":
     case "--help":
     case "-h":

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 export { initObservability, shutdown, getConfig } from "./tracer.js";
+export { AlertManager, startAlertsFromFile, parseCondition, } from "./alerts/index.js";
+export type { AlertsConfig, AlertRule, AlertChannelConfig, FiredAlert, } from "./alerts/index.js";
 export { traceLLMCall } from "./spans.js";
+export { calculateCost, setCustomPricing, getModelPricing } from "./pricing.js";
+export type { ModelPricing } from "./pricing.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 type { ToadEyeConfig, LLMSpanAttributes, LLMProvider, SpanStatus, MetricName, } 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,5 @@
 export { initObservability, shutdown, getConfig } from "./tracer.js";
+export { AlertManager, startAlertsFromFile, parseCondition, } from "./alerts/index.js";
 export { traceLLMCall } from "./spans.js";
-export { LLM_METRICS, LLM_ATTRS } from "./types.js";
+export { calculateCost, setCustomPricing, getModelPricing } from "./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,54 @@
+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",
+    shouldSkip: (body) => !!body?.stream,
+    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,
+        };
+    },
+};
+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,67 @@
+import { createRequire } from "node:module";
+import { diag } from "@opentelemetry/api";
+import { traceLLMCall } from "../spans.js";
+import { calculateCost } from "../pricing.js";
+const require = createRequire(import.meta.url);
+/**
+ * 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() {
+            try {
+                require.resolve(config.moduleName);
+            }
+            catch {
+                return false;
+            }
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const sdk = require(config.moduleName);
+                const mod = sdk.default ?? sdk;
+                for (const patch of config.patches) {
+                    const proto = patch.getPrototype(mod);
+                    if (!proto?.[patch.method])
+                        continue;
+                    const original = proto[patch.method];
+                    proto[patch.method] = function patchedMethod(body, ...rest) {
+                        if (patch.shouldSkip?.(body)) {
+                            return original.call(this, body, ...rest);
+                        }
+                        const req = patch.extractRequest(body);
+                        return traceLLMCall({
+                            provider: config.name,
+                            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),
+                            };
+                        });
+                    };
+                    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 {};

package/dist/instrumentations/openai.js

@@ -0,0 +1,58 @@
+import { register } from "./registry.js";
+import { createInstrumentation } from "./create.js";
+function extractMessages(messages) {
+    if (!Array.isArray(messages))
+        return "";
+    return messages
+        .map((m) => typeof m.content === "string" ? m.content : "")
+        .filter(Boolean)
+        .join("\n");
+}
+const chatCompletions = {
+    getPrototype: (sdk) => (sdk?.Chat?.Completions ?? sdk?.Completions)?.prototype,
+    method: "create",
+    shouldSkip: (body) => !!body?.stream,
+    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: r?.choices?.[0]?.message?.content ?? "",
+            inputTokens: r?.usage?.prompt_tokens ?? 0,
+            outputTokens: r?.usage?.completion_tokens ?? 0,
+        };
+    },
+};
+const embeddings = {
+    getPrototype: (sdk) => sdk?.Embeddings?.prototype,
+    method: "create",
+    extractRequest: (body) => {
+        const b = body;
+        const input = b?.input;
+        const prompt = typeof input === "string"
+            ? input
+            : Array.isArray(input)
+                ? input.join("\n")
+                : "";
+        return { prompt, model: b?.model ?? "unknown" };
+    },
+    extractResponse: (response) => {
+        const r = response;
+        return {
+            completion: "[embedding]",
+            inputTokens: r?.usage?.prompt_tokens ?? 0,
+            outputTokens: 0,
+        };
+    },
+};
+register(createInstrumentation({
+    name: "openai",
+    moduleName: "openai",
+    patches: [chatCompletions, embeddings],
+}));

package/dist/instrumentations/registry.d.ts

@@ -0,0 +1,5 @@
+import type { LLMProvider } from "../types/index.js";
+import type { Instrumentation } from "./types.js";
+export declare function register(inst: Instrumentation): void;
+export declare function enableAll(providers: readonly LLMProvider[]): void;
+export declare function disableAll(): void;

package/dist/instrumentations/registry.js

@@ -0,0 +1,31 @@
+import { diag } from "@opentelemetry/api";
+const instrumentations = new Map();
+const active = new Set();
+export function register(inst) {
+    instrumentations.set(inst.name, inst);
+}
+export function enableAll(providers) {
+    for (const name of providers) {
+        if (active.has(name))
+            continue;
+        const inst = instrumentations.get(name);
+        if (!inst) {
+            diag.warn(`toad-eye: unknown provider "${name}", skipping`);
+            continue;
+        }
+        const patched = inst.enable();
+        if (patched) {
+            active.add(name);
+            diag.debug(`toad-eye: auto-instrumented ${name}`);
+        }
+        else {
+            diag.debug(`toad-eye: ${name} SDK not found, skipping`);
+        }
+    }
+}
+export function disableAll() {
+    for (const name of active) {
+        instrumentations.get(name)?.disable();
+    }
+    active.clear();
+}

package/dist/instrumentations/types.d.ts

@@ -0,0 +1,29 @@
+import type { LLMProvider } from "../types/index.js";
+export interface Instrumentation {
+    readonly name: LLMProvider;
+    /** Try to find and patch the SDK. Returns true if patched, false if SDK not found. */
+    enable(): boolean;
+    /** Restore original methods. */
+    disable(): void;
+}
+/** Describes a single method to monkey-patch on an SDK prototype. */
+export interface PatchTarget {
+    /** How to find the prototype from the loaded SDK module */
+    getPrototype: (sdk: any) => any | undefined;
+    /** Method name on the prototype to patch */
+    method: string;
+    /** Extract LLMCallInput fields from the request arguments */
+    extractRequest: (body: unknown) => {
+        prompt: string;
+        model: string;
+        temperature?: number;
+    };
+    /** Extract LLMCallOutput fields from the SDK response */
+    extractResponse: (response: unknown, model: string) => {
+        completion: string;
+        inputTokens: number;
+        outputTokens: number;
+    };
+    /** Return true if this call should skip patching (e.g. streaming) */
+    shouldSkip?: (body: unknown) => boolean;
+}

package/dist/instrumentations/types.js

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

package/dist/metrics.js

@@ -1,8 +1,8 @@
 import { metrics } from "@opentelemetry/api";
-import { LLM_METRICS, INSTRUMENTATION_NAME } from "./types.js";
+import { GEN_AI_ATTRS, GEN_AI_METRICS, INSTRUMENTATION_NAME, } from "./types/index.js";
 let requestDuration;
 let requestCost;
-let tokensTotal;
+let tokenUsage;
 let requestsTotal;
 let errorsTotal;
 let initialized = false;
@@ -10,37 +10,52 @@ export function initMetrics() {
     if (initialized)
         return;
     const meter = metrics.getMeter(INSTRUMENTATION_NAME);
-    requestDuration = meter.createHistogram(LLM_METRICS.REQUEST_DURATION, {
-        description: "LLM request duration in milliseconds",
+    requestDuration = meter.createHistogram(GEN_AI_METRICS.REQUEST_DURATION, {
+        description: "GenAI operation duration in milliseconds",
         unit: "ms",
     });
-    requestCost = meter.createHistogram(LLM_METRICS.REQUEST_COST, {
-        description: "LLM request cost in USD",
+    requestCost = meter.createHistogram(GEN_AI_METRICS.REQUEST_COST, {
+        description: "GenAI request cost in USD",
         unit: "USD",
     });
-    tokensTotal = meter.createCounter(LLM_METRICS.TOKENS, {
+    tokenUsage = meter.createCounter(GEN_AI_METRICS.TOKEN_USAGE, {
         description: "Total tokens consumed",
     });
-    requestsTotal = meter.createCounter(LLM_METRICS.REQUESTS, {
-        description: "Total LLM requests",
+    requestsTotal = meter.createCounter(GEN_AI_METRICS.REQUESTS, {
+        description: "Total GenAI requests",
     });
-    errorsTotal = meter.createCounter(LLM_METRICS.ERRORS, {
-        description: "Total failed LLM requests",
+    errorsTotal = meter.createCounter(GEN_AI_METRICS.ERRORS, {
+        description: "Total failed GenAI requests",
     });
     initialized = true;
 }
 export function recordRequestDuration(ms, provider, model) {
-    requestDuration.record(ms, { provider, model });
+    requestDuration.record(ms, {
+        [GEN_AI_ATTRS.PROVIDER]: provider,
+        [GEN_AI_ATTRS.REQUEST_MODEL]: model,
+    });
 }
 export function recordRequestCost(usd, provider, model) {
-    requestCost.record(usd, { provider, model });
+    requestCost.record(usd, {
+        [GEN_AI_ATTRS.PROVIDER]: provider,
+        [GEN_AI_ATTRS.REQUEST_MODEL]: model,
+    });
 }
 export function recordTokens(count, provider, model) {
-    tokensTotal.add(count, { provider, model });
+    tokenUsage.add(count, {
+        [GEN_AI_ATTRS.PROVIDER]: provider,
+        [GEN_AI_ATTRS.REQUEST_MODEL]: model,
+    });
 }
 export function recordRequest(provider, model) {
-    requestsTotal.add(1, { provider, model });
+    requestsTotal.add(1, {
+        [GEN_AI_ATTRS.PROVIDER]: provider,
+        [GEN_AI_ATTRS.REQUEST_MODEL]: model,
+    });
 }
 export function recordError(provider, model) {
-    errorsTotal.add(1, { provider, model });
+    errorsTotal.add(1, {
+        [GEN_AI_ATTRS.PROVIDER]: provider,
+        [GEN_AI_ATTRS.REQUEST_MODEL]: model,
+    });
 }

package/dist/pricing.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Built-in pricing table for major LLM models.
+ * Prices in USD per 1M tokens (input / output).
+ * Updated: March 2026.
+ */
+export interface ModelPricing {
+    readonly inputPer1M: number;
+    readonly outputPer1M: number;
+}
+/**
+ * Set custom pricing for models (overrides built-in prices).
+ * Useful for enterprise contracts or custom/fine-tuned models.
+ */
+export declare function setCustomPricing(pricing: Record<string, ModelPricing>): void;
+/**
+ * Get pricing for a model. Custom pricing takes precedence.
+ * Returns undefined if model is not in any pricing table.
+ */
+export declare function getModelPricing(model: string): ModelPricing | undefined;
+/**
+ * Calculate cost for a given model and token counts.
+ * Returns 0 if model pricing is not found.
+ */
+export declare function calculateCost(model: string, inputTokens: number, outputTokens: number): number;

package/dist/pricing.js

@@ -0,0 +1,52 @@
+/**
+ * Built-in pricing table for major LLM models.
+ * Prices in USD per 1M tokens (input / output).
+ * Updated: March 2026.
+ */
+const BUILT_IN_PRICING = {
+    // OpenAI
+    "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10 },
+    "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6 },
+    "gpt-4-turbo": { inputPer1M: 10, outputPer1M: 30 },
+    "gpt-4.1": { inputPer1M: 2, outputPer1M: 8 },
+    "gpt-4.1-mini": { inputPer1M: 0.4, outputPer1M: 1.6 },
+    "gpt-4.1-nano": { inputPer1M: 0.1, outputPer1M: 0.4 },
+    o3: { inputPer1M: 10, outputPer1M: 40 },
+    "o3-mini": { inputPer1M: 1.1, outputPer1M: 4.4 },
+    "o4-mini": { inputPer1M: 1.1, outputPer1M: 4.4 },
+    // Anthropic
+    "claude-opus-4-20250514": { inputPer1M: 15, outputPer1M: 75 },
+    "claude-sonnet-4-20250514": { inputPer1M: 3, outputPer1M: 15 },
+    "claude-haiku-3-5-20241022": { inputPer1M: 0.8, outputPer1M: 4 },
+    // Google Gemini
+    "gemini-2.5-pro": { inputPer1M: 1.25, outputPer1M: 10 },
+    "gemini-2.5-flash": { inputPer1M: 0.15, outputPer1M: 0.6 },
+    "gemini-2.0-flash": { inputPer1M: 0.1, outputPer1M: 0.4 },
+};
+let customPricing = {};
+/**
+ * Set custom pricing for models (overrides built-in prices).
+ * Useful for enterprise contracts or custom/fine-tuned models.
+ */
+export function setCustomPricing(pricing) {
+    customPricing = { ...pricing };
+}
+/**
+ * Get pricing for a model. Custom pricing takes precedence.
+ * Returns undefined if model is not in any pricing table.
+ */
+export function getModelPricing(model) {
+    return customPricing[model] ?? BUILT_IN_PRICING[model];
+}
+/**
+ * Calculate cost for a given model and token counts.
+ * Returns 0 if model pricing is not found.
+ */
+export function calculateCost(model, inputTokens, outputTokens) {
+    const pricing = getModelPricing(model);
+    if (!pricing)
+        return 0;
+    const cost = (inputTokens / 1_000_000) * pricing.inputPer1M +
+        (outputTokens / 1_000_000) * pricing.outputPer1M;
+    return Math.round(cost * 1_000_000) / 1_000_000;
+}

package/dist/spans.d.ts

@@ -1,4 +1,4 @@
-import type { LLMSpanAttributes } from "./types.js";
+import type { LLMSpanAttributes } from "./types/index.js";
 /** Input for traceLLMCall — what the user knows before calling the LLM */
 export interface LLMCallInput {
     readonly provider: LLMSpanAttributes["provider"];