tokenmeter 0.9.0

package/dist/integrations/vercel-ai/index.d.ts

@@ -0,0 +1,288 @@
+/**
+ * Vercel AI SDK Integration
+ *
+ * Provides a non-invasive integration with the Vercel AI SDK using
+ * the built-in experimental_telemetry feature. No import changes required.
+ *
+ * @example
+ * ```typescript
+ * import { generateText } from 'ai';
+ * import { openai } from '@ai-sdk/openai';
+ * import { telemetry } from 'tokenmeter/vercel-ai';
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello!',
+ *   experimental_telemetry: telemetry({
+ *     userId: 'user_123',
+ *     orgId: 'org_456',
+ *   }),
+ * });
+ * ```
+ */
+import { type Tracer } from "@opentelemetry/api";
+/**
+ * Telemetry settings expected by Vercel AI SDK
+ */
+export interface TelemetrySettings {
+    /**
+     * Enable telemetry collection.
+     * @default true
+     */
+    isEnabled?: boolean;
+    /**
+     * Identifier for this function call (appears in spans).
+     */
+    functionId?: string;
+    /**
+     * Custom metadata to include in telemetry.
+     * These become span attributes prefixed with `ai.telemetry.metadata.`
+     */
+    metadata?: Record<string, string | number | boolean>;
+    /**
+     * Whether to record input values (prompts, messages).
+     * Disable for privacy or performance.
+     * @default true
+     */
+    recordInputs?: boolean;
+    /**
+     * Whether to record output values (responses).
+     * Disable for privacy or performance.
+     * @default true
+     */
+    recordOutputs?: boolean;
+    /**
+     * Custom OpenTelemetry tracer to use.
+     * If not provided, uses the default tracer.
+     */
+    tracer?: Tracer;
+}
+/**
+ * Options for tokenmeter telemetry configuration
+ */
+export interface TokenMeterTelemetryOptions {
+    /**
+     * User ID for cost attribution.
+     * Will be added to span metadata as `userId`.
+     */
+    userId?: string;
+    /**
+     * Organization ID for cost attribution.
+     * Will be added to span metadata as `orgId`.
+     */
+    orgId?: string;
+    /**
+     * Workflow ID for grouping related calls.
+     * Will be added to span metadata as `workflowId`.
+     */
+    workflowId?: string;
+    /**
+     * Function identifier for the telemetry span.
+     */
+    functionId?: string;
+    /**
+     * Additional metadata to include.
+     */
+    metadata?: Record<string, string | number | boolean | undefined>;
+    /**
+     * Whether to record inputs (prompts/messages).
+     * @default true
+     */
+    recordInputs?: boolean;
+    /**
+     * Whether to record outputs (responses).
+     * @default true
+     */
+    recordOutputs?: boolean;
+}
+/**
+ * Create telemetry configuration for Vercel AI SDK with tokenmeter attributes.
+ *
+ * This is the recommended way to integrate tokenmeter with the Vercel AI SDK.
+ * It uses the SDK's built-in telemetry feature, requiring no import changes.
+ *
+ * The SDK will emit OpenTelemetry spans with usage data that can be processed
+ * by the TokenMeterProcessor to calculate costs.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { generateText } from 'ai';
+ * import { openai } from '@ai-sdk/openai';
+ * import { telemetry } from 'tokenmeter/vercel-ai';
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello!',
+ *   experimental_telemetry: telemetry(),
+ * });
+ * ```
+ *
+ * @example With user attribution
+ * ```typescript
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello!',
+ *   experimental_telemetry: telemetry({
+ *     userId: 'user_123',
+ *     orgId: 'org_456',
+ *     workflowId: 'chat-session-789',
+ *   }),
+ * });
+ * ```
+ *
+ * @example With custom metadata
+ * ```typescript
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello!',
+ *   experimental_telemetry: telemetry({
+ *     userId: currentUser.id,
+ *     metadata: {
+ *       feature: 'chat',
+ *       tier: 'premium',
+ *     },
+ *   }),
+ * });
+ * ```
+ *
+ * @example Disable input/output recording for privacy
+ * ```typescript
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: sensitivePrompt,
+ *   experimental_telemetry: telemetry({
+ *     userId: 'user_123',
+ *     recordInputs: false,
+ *     recordOutputs: false,
+ *   }),
+ * });
+ * ```
+ */
+export declare function telemetry(options?: TokenMeterTelemetryOptions): TelemetrySettings;
+/**
+ * Create a reusable telemetry configuration factory.
+ *
+ * Useful when you have common attributes across multiple calls.
+ *
+ * @example
+ * ```typescript
+ * import { createTelemetry } from 'tokenmeter/vercel-ai';
+ *
+ * // Create once with common options
+ * const withTelemetry = createTelemetry({
+ *   orgId: 'org_456',
+ *   recordInputs: false, // Privacy setting
+ * });
+ *
+ * // Use in multiple calls
+ * await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello!',
+ *   experimental_telemetry: withTelemetry({ userId: 'user_123' }),
+ * });
+ *
+ * await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Goodbye!',
+ *   experimental_telemetry: withTelemetry({ userId: 'user_456' }),
+ * });
+ * ```
+ */
+export declare function createTelemetry(defaultOptions?: TokenMeterTelemetryOptions): (options?: TokenMeterTelemetryOptions) => TelemetrySettings;
+/**
+ * Vercel AI SDK span attribute names.
+ *
+ * These are the attributes emitted by the Vercel AI SDK when telemetry is enabled.
+ * Use these constants when building custom processors or exporters.
+ */
+export declare const VERCEL_AI_ATTRIBUTES: {
+    /** Model identifier (e.g., "gpt-4o") */
+    readonly MODEL_ID: "ai.model.id";
+    /** Provider name (e.g., "openai") */
+    readonly MODEL_PROVIDER: "ai.model.provider";
+    /** Input/prompt tokens used */
+    readonly USAGE_PROMPT_TOKENS: "ai.usage.promptTokens";
+    /** Output/completion tokens used */
+    readonly USAGE_COMPLETION_TOKENS: "ai.usage.completionTokens";
+    /** Function identifier from telemetry config */
+    readonly FUNCTION_ID: "ai.telemetry.functionId";
+    /** Finish reason (e.g., "stop", "length") */
+    readonly FINISH_REASON: "ai.response.finishReason";
+    /** The prompt text (if recordInputs is true) */
+    readonly PROMPT: "ai.prompt";
+    /** The response text (if recordOutputs is true) */
+    readonly RESPONSE_TEXT: "ai.response.text";
+};
+/**
+ * Span names used by the Vercel AI SDK.
+ *
+ * Use these to filter/identify Vercel AI SDK spans in processors.
+ */
+export declare const VERCEL_AI_SPAN_NAMES: {
+    /** Top-level generateText span */
+    readonly GENERATE_TEXT: "ai.generateText";
+    /** Provider-level doGenerate span */
+    readonly GENERATE_TEXT_DO_GENERATE: "ai.generateText.doGenerate";
+    /** Top-level streamText span */
+    readonly STREAM_TEXT: "ai.streamText";
+    /** Provider-level doStream span */
+    readonly STREAM_TEXT_DO_STREAM: "ai.streamText.doStream";
+    /** Top-level generateObject span */
+    readonly GENERATE_OBJECT: "ai.generateObject";
+    /** Provider-level doGenerate span for objects */
+    readonly GENERATE_OBJECT_DO_GENERATE: "ai.generateObject.doGenerate";
+    /** Top-level streamObject span */
+    readonly STREAM_OBJECT: "ai.streamObject";
+    /** Tool call span */
+    readonly TOOL_CALL: "ai.toolCall";
+    /** Embedding span */
+    readonly EMBED: "ai.embed";
+    /** Batch embedding span */
+    readonly EMBED_MANY: "ai.embedMany";
+};
+/**
+ * Check if a span name is from the Vercel AI SDK.
+ *
+ * Useful in custom SpanProcessors to identify Vercel AI spans.
+ *
+ * @example
+ * ```typescript
+ * import { isVercelAISpan } from 'tokenmeter/vercel-ai';
+ *
+ * class MyProcessor implements SpanProcessor {
+ *   onEnd(span: ReadableSpan) {
+ *     if (isVercelAISpan(span.name)) {
+ *       // Process Vercel AI SDK span
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare function isVercelAISpan(spanName: string): boolean;
+/**
+ * Extract provider and model from Vercel AI SDK span attributes.
+ *
+ * @example
+ * ```typescript
+ * const { provider, model } = extractModelInfo(span.attributes);
+ * // provider: "openai", model: "gpt-4o"
+ * ```
+ */
+export declare function extractModelInfo(attributes: Record<string, unknown>): {
+    provider: string;
+    model: string;
+};
+/**
+ * Extract usage data from Vercel AI SDK span attributes.
+ *
+ * @example
+ * ```typescript
+ * const usage = extractUsage(span.attributes);
+ * // { promptTokens: 100, completionTokens: 50 }
+ * ```
+ */
+export declare function extractUsage(attributes: Record<string, unknown>): {
+    promptTokens: number | undefined;
+    completionTokens: number | undefined;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/integrations/vercel-ai/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/integrations/vercel-ai/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAS,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IAErD;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;IAEjE;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,SAAS,CACvB,OAAO,GAAE,0BAA+B,GACvC,iBAAiB,CAgCnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,eAAe,CAC7B,cAAc,GAAE,0BAA+B,GAC9C,CAAC,OAAO,CAAC,EAAE,0BAA0B,KAAK,iBAAiB,CAW7D;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;IAC/B,wCAAwC;;IAExC,qCAAqC;;IAErC,+BAA+B;;IAE/B,oCAAoC;;IAEpC,gDAAgD;;IAEhD,6CAA6C;;IAE7C,gDAAgD;;IAEhD,mDAAmD;;CAE3C,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;IAC/B,kCAAkC;;IAElC,qCAAqC;;IAErC,gCAAgC;;IAEhC,mCAAmC;;IAEnC,oCAAoC;;IAEpC,iDAAiD;;IAEjD,kCAAkC;;IAElC,qBAAqB;;IAErB,qBAAqB;;IAErB,2BAA2B;;CAEnB,CAAC;AAEX;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAMA;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACjE,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC,CASA"}

package/dist/integrations/vercel-ai/index.js

@@ -0,0 +1,260 @@
+/**
+ * Vercel AI SDK Integration
+ *
+ * Provides a non-invasive integration with the Vercel AI SDK using
+ * the built-in experimental_telemetry feature. No import changes required.
+ *
+ * @example
+ * ```typescript
+ * import { generateText } from 'ai';
+ * import { openai } from '@ai-sdk/openai';
+ * import { telemetry } from 'tokenmeter/vercel-ai';
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello!',
+ *   experimental_telemetry: telemetry({
+ *     userId: 'user_123',
+ *     orgId: 'org_456',
+ *   }),
+ * });
+ * ```
+ */
+import { trace } from "@opentelemetry/api";
+/**
+ * Create telemetry configuration for Vercel AI SDK with tokenmeter attributes.
+ *
+ * This is the recommended way to integrate tokenmeter with the Vercel AI SDK.
+ * It uses the SDK's built-in telemetry feature, requiring no import changes.
+ *
+ * The SDK will emit OpenTelemetry spans with usage data that can be processed
+ * by the TokenMeterProcessor to calculate costs.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { generateText } from 'ai';
+ * import { openai } from '@ai-sdk/openai';
+ * import { telemetry } from 'tokenmeter/vercel-ai';
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello!',
+ *   experimental_telemetry: telemetry(),
+ * });
+ * ```
+ *
+ * @example With user attribution
+ * ```typescript
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello!',
+ *   experimental_telemetry: telemetry({
+ *     userId: 'user_123',
+ *     orgId: 'org_456',
+ *     workflowId: 'chat-session-789',
+ *   }),
+ * });
+ * ```
+ *
+ * @example With custom metadata
+ * ```typescript
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello!',
+ *   experimental_telemetry: telemetry({
+ *     userId: currentUser.id,
+ *     metadata: {
+ *       feature: 'chat',
+ *       tier: 'premium',
+ *     },
+ *   }),
+ * });
+ * ```
+ *
+ * @example Disable input/output recording for privacy
+ * ```typescript
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: sensitivePrompt,
+ *   experimental_telemetry: telemetry({
+ *     userId: 'user_123',
+ *     recordInputs: false,
+ *     recordOutputs: false,
+ *   }),
+ * });
+ * ```
+ */
+export function telemetry(options = {}) {
+    // Build metadata object with tokenmeter attributes
+    const metadata = {};
+    // Copy user-provided metadata, filtering out undefined values
+    if (options.metadata) {
+        for (const [key, value] of Object.entries(options.metadata)) {
+            if (value !== undefined) {
+                metadata[key] = value;
+            }
+        }
+    }
+    // Add tokenmeter-specific attributes
+    if (options.userId) {
+        metadata["tokenmeter.user_id"] = options.userId;
+    }
+    if (options.orgId) {
+        metadata["tokenmeter.org_id"] = options.orgId;
+    }
+    if (options.workflowId) {
+        metadata["tokenmeter.workflow_id"] = options.workflowId;
+    }
+    return {
+        isEnabled: true,
+        functionId: options.functionId,
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        recordInputs: options.recordInputs ?? true,
+        recordOutputs: options.recordOutputs ?? true,
+        tracer: trace.getTracer("tokenmeter", "5.0.0"),
+    };
+}
+/**
+ * Create a reusable telemetry configuration factory.
+ *
+ * Useful when you have common attributes across multiple calls.
+ *
+ * @example
+ * ```typescript
+ * import { createTelemetry } from 'tokenmeter/vercel-ai';
+ *
+ * // Create once with common options
+ * const withTelemetry = createTelemetry({
+ *   orgId: 'org_456',
+ *   recordInputs: false, // Privacy setting
+ * });
+ *
+ * // Use in multiple calls
+ * await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello!',
+ *   experimental_telemetry: withTelemetry({ userId: 'user_123' }),
+ * });
+ *
+ * await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Goodbye!',
+ *   experimental_telemetry: withTelemetry({ userId: 'user_456' }),
+ * });
+ * ```
+ */
+export function createTelemetry(defaultOptions = {}) {
+    return (options) => {
+        return telemetry({
+            ...defaultOptions,
+            ...options,
+            metadata: {
+                ...defaultOptions.metadata,
+                ...options?.metadata,
+            },
+        });
+    };
+}
+/**
+ * Vercel AI SDK span attribute names.
+ *
+ * These are the attributes emitted by the Vercel AI SDK when telemetry is enabled.
+ * Use these constants when building custom processors or exporters.
+ */
+export const VERCEL_AI_ATTRIBUTES = {
+    /** Model identifier (e.g., "gpt-4o") */
+    MODEL_ID: "ai.model.id",
+    /** Provider name (e.g., "openai") */
+    MODEL_PROVIDER: "ai.model.provider",
+    /** Input/prompt tokens used */
+    USAGE_PROMPT_TOKENS: "ai.usage.promptTokens",
+    /** Output/completion tokens used */
+    USAGE_COMPLETION_TOKENS: "ai.usage.completionTokens",
+    /** Function identifier from telemetry config */
+    FUNCTION_ID: "ai.telemetry.functionId",
+    /** Finish reason (e.g., "stop", "length") */
+    FINISH_REASON: "ai.response.finishReason",
+    /** The prompt text (if recordInputs is true) */
+    PROMPT: "ai.prompt",
+    /** The response text (if recordOutputs is true) */
+    RESPONSE_TEXT: "ai.response.text",
+};
+/**
+ * Span names used by the Vercel AI SDK.
+ *
+ * Use these to filter/identify Vercel AI SDK spans in processors.
+ */
+export const VERCEL_AI_SPAN_NAMES = {
+    /** Top-level generateText span */
+    GENERATE_TEXT: "ai.generateText",
+    /** Provider-level doGenerate span */
+    GENERATE_TEXT_DO_GENERATE: "ai.generateText.doGenerate",
+    /** Top-level streamText span */
+    STREAM_TEXT: "ai.streamText",
+    /** Provider-level doStream span */
+    STREAM_TEXT_DO_STREAM: "ai.streamText.doStream",
+    /** Top-level generateObject span */
+    GENERATE_OBJECT: "ai.generateObject",
+    /** Provider-level doGenerate span for objects */
+    GENERATE_OBJECT_DO_GENERATE: "ai.generateObject.doGenerate",
+    /** Top-level streamObject span */
+    STREAM_OBJECT: "ai.streamObject",
+    /** Tool call span */
+    TOOL_CALL: "ai.toolCall",
+    /** Embedding span */
+    EMBED: "ai.embed",
+    /** Batch embedding span */
+    EMBED_MANY: "ai.embedMany",
+};
+/**
+ * Check if a span name is from the Vercel AI SDK.
+ *
+ * Useful in custom SpanProcessors to identify Vercel AI spans.
+ *
+ * @example
+ * ```typescript
+ * import { isVercelAISpan } from 'tokenmeter/vercel-ai';
+ *
+ * class MyProcessor implements SpanProcessor {
+ *   onEnd(span: ReadableSpan) {
+ *     if (isVercelAISpan(span.name)) {
+ *       // Process Vercel AI SDK span
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export function isVercelAISpan(spanName) {
+    return spanName.startsWith("ai.");
+}
+/**
+ * Extract provider and model from Vercel AI SDK span attributes.
+ *
+ * @example
+ * ```typescript
+ * const { provider, model } = extractModelInfo(span.attributes);
+ * // provider: "openai", model: "gpt-4o"
+ * ```
+ */
+export function extractModelInfo(attributes) {
+    return {
+        provider: attributes[VERCEL_AI_ATTRIBUTES.MODEL_PROVIDER] || "unknown",
+        model: attributes[VERCEL_AI_ATTRIBUTES.MODEL_ID] || "unknown",
+    };
+}
+/**
+ * Extract usage data from Vercel AI SDK span attributes.
+ *
+ * @example
+ * ```typescript
+ * const usage = extractUsage(span.attributes);
+ * // { promptTokens: 100, completionTokens: 50 }
+ * ```
+ */
+export function extractUsage(attributes) {
+    return {
+        promptTokens: attributes[VERCEL_AI_ATTRIBUTES.USAGE_PROMPT_TOKENS],
+        completionTokens: attributes[VERCEL_AI_ATTRIBUTES.USAGE_COMPLETION_TOKENS],
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/integrations/vercel-ai/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/integrations/vercel-ai/index.ts"],"names":[],"mappings":"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"}

package/dist/logger.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Configurable Logger
+ *
+ * Provides a centralized logging mechanism that can be configured or disabled.
+ * By default, logging is disabled in production to avoid polluting stdout.
+ */
+export type LogLevel = "debug" | "info" | "warn" | "error" | "none";
+export interface LoggerConfig {
+    /**
+     * Minimum log level to output. Set to "none" to disable all logging.
+     * @default "none"
+     */
+    level: LogLevel;
+    /**
+     * Custom logger implementation. If provided, all logs will be sent to this function.
+     * This allows integration with existing logging frameworks (winston, pino, etc.)
+     */
+    custom?: (level: LogLevel, message: string, ...args: unknown[]) => void;
+}
+/**
+ * Configure the tokenmeter logger.
+ *
+ * @example
+ * ```typescript
+ * import { configureLogger } from 'tokenmeter';
+ *
+ * // Enable warning and error logs
+ * configureLogger({ level: 'warn' });
+ *
+ * // Use custom logger
+ * configureLogger({
+ *   level: 'debug',
+ *   custom: (level, message, ...args) => {
+ *     myLogger[level](message, ...args);
+ *   }
+ * });
+ * ```
+ */
+export declare function configureLogger(newConfig: Partial<LoggerConfig>): void;
+/**
+ * Get the current logger configuration.
+ */
+export declare function getLoggerConfig(): LoggerConfig;
+/**
+ * Reset logger to default configuration (disabled).
+ */
+export declare function resetLogger(): void;
+/**
+ * Internal logger for tokenmeter.
+ * By default, all logging is disabled. Use configureLogger() to enable.
+ */
+export declare const logger: {
+    debug: (message: string, ...args: unknown[]) => void;
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAEpE,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,KAAK,EAAE,QAAQ,CAAC;IAEhB;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACzE;AAeD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,CAEtE;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAE9C;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAElC;AAkCD;;;GAGG;AACH,eAAO,MAAM,MAAM;qBACA,MAAM,WAAW,OAAO,EAAE;oBAC3B,MAAM,WAAW,OAAO,EAAE;oBAC1B,MAAM,WAAW,OAAO,EAAE;qBACzB,MAAM,WAAW,OAAO,EAAE;CAC5C,CAAC"}