graphile-llm 0.7.3 → 0.9.0

package/esm/__tests__/graphile-llm.test.js

@@ -1,16 +1,16 @@
-import { join } from 'path';
 import OllamaClient from '@agentic-kit/ollama';
-import { getConnections, seed } from 'graphile-test';
 import { ConnectionFilterPreset } from 'graphile-connection-filter';
+import { createPgvectorAdapter } from 'graphile-search/adapters/pgvector';
 import { VectorCodecPlugin } from 'graphile-search/codecs/vector-codec';
 import { createUnifiedSearchPlugin } from 'graphile-search/plugin';
-import { createPgvectorAdapter } from 'graphile-search/adapters/pgvector';
+import { getConnections, seed } from 'graphile-test';
+import { join } from 'path';
+import { buildChatCompleter, buildChatCompleterFromEnv, buildChatCompleterFromModule } from '../../src/chat';
+import { buildEmbedder, buildEmbedderFromEnv, buildEmbedderFromModule } from '../../src/embedder';
 import { createLlmModulePlugin } from '../../src/plugins/llm-module-plugin';
-import { createLlmTextSearchPlugin } from '../../src/plugins/text-search-plugin';
-import { createLlmTextMutationPlugin } from '../../src/plugins/text-mutation-plugin';
 import { createLlmRagPlugin } from '../../src/plugins/rag-plugin';
-import { buildEmbedder, buildEmbedderFromModule, buildEmbedderFromEnv, } from '../../src/embedder';
-import { buildChatCompleter, buildChatCompleterFromModule, buildChatCompleterFromEnv, } from '../../src/chat';
+import { createLlmTextMutationPlugin } from '../../src/plugins/text-mutation-plugin';
+import { createLlmTextSearchPlugin } from '../../src/plugins/text-search-plugin';
 // ─── @agentic-kit/ollama client ─────────────────────────────────────────────
 const ollamaClient = new OllamaClient('http://localhost:11434');
 async function ensureNomicModel() {
@@ -30,14 +30,14 @@ describe('Embedder abstraction', () => {
             const embedder = buildEmbedder({
                 provider: 'ollama',
                 model: 'nomic-embed-text',
-                baseUrl: 'http://localhost:11434',
+                baseUrl: 'http://localhost:11434'
             });
             expect(embedder).not.toBeNull();
             expect(typeof embedder).toBe('function');
         });
         it('returns null for unknown provider', () => {
             const embedder = buildEmbedder({
-                provider: 'unknown-provider',
+                provider: 'unknown-provider'
             });
             expect(embedder).toBeNull();
         });
@@ -52,7 +52,7 @@ describe('Embedder abstraction', () => {
             const moduleData = {
                 embedding_provider: 'ollama',
                 embedding_model: 'nomic-embed-text',
-                embedding_base_url: 'http://localhost:11434',
+                embedding_base_url: 'http://localhost:11434'
             };
             const embedder = buildEmbedderFromModule(moduleData);
             expect(embedder).not.toBeNull();
@@ -60,7 +60,7 @@ describe('Embedder abstraction', () => {
         });
         it('returns null for unsupported provider in module data', () => {
             const moduleData = {
-                embedding_provider: 'unsupported',
+                embedding_provider: 'unsupported'
             };
             const embedder = buildEmbedderFromModule(moduleData);
             expect(embedder).toBeNull();
@@ -71,18 +71,19 @@ describe('Embedder abstraction', () => {
         afterEach(() => {
             process.env = originalEnv;
         });
-        it('returns null when EMBEDDER_PROVIDER is not set', () => {
+        it('returns default ollama embedder when EMBEDDER_PROVIDER is not set', () => {
             process.env = { ...originalEnv };
             delete process.env.EMBEDDER_PROVIDER;
             const embedder = buildEmbedderFromEnv();
-            expect(embedder).toBeNull();
+            expect(embedder).not.toBeNull();
+            expect(typeof embedder).toBe('function');
         });
         it('builds embedder from environment variables', () => {
             process.env = {
                 ...originalEnv,
                 EMBEDDER_PROVIDER: 'ollama',
                 EMBEDDER_MODEL: 'nomic-embed-text',
-                EMBEDDER_BASE_URL: 'http://localhost:11434',
+                EMBEDDER_BASE_URL: 'http://localhost:11434'
             };
             const embedder = buildEmbedderFromEnv();
             expect(embedder).not.toBeNull();
@@ -100,7 +101,7 @@ describe('graphile-llm schema enrichment', () => {
     let query;
     beforeAll(async () => {
         const unifiedPlugin = createUnifiedSearchPlugin({
-            adapters: [createPgvectorAdapter()],
+            adapters: [createPgvectorAdapter()]
         });
         const testPreset = {
             extends: [ConnectionFilterPreset()],
@@ -113,18 +114,18 @@ describe('graphile-llm schema enrichment', () => {
                     defaultEmbedder: {
                         provider: 'ollama',
                         model: 'nomic-embed-text',
-                        baseUrl: 'http://localhost:11434',
-                    },
+                        baseUrl: 'http://localhost:11434'
+                    }
                 }),
                 createLlmTextSearchPlugin(),
-                createLlmTextMutationPlugin(),
-            ],
+                createLlmTextMutationPlugin()
+            ]
         };
         const connections = await getConnections({
             schemas: ['llm_test'],
             preset: testPreset,
             useRoot: true,
-            authRole: 'postgres',
+            authRole: 'postgres'
         }, [seed.sqlfile([join(__dirname, './setup.sql')])]);
         db = connections.db;
         teardown = connections.teardown;
@@ -253,33 +254,36 @@ describe('graphile-llm with real Ollama embedding', () => {
         const embedder = buildEmbedder({
             provider: 'ollama',
             model: 'nomic-embed-text',
-            baseUrl: 'http://localhost:11434',
+            baseUrl: 'http://localhost:11434'
         });
         expect(embedder).not.toBeNull();
-        const vector = await embedder('Machine learning is transforming AI');
+        const result = await embedder('Machine learning is transforming AI');
         // nomic-embed-text produces 768-dimensional vectors
-        expect(Array.isArray(vector)).toBe(true);
-        expect(vector.length).toBe(768);
+        expect(Array.isArray(result.embedding)).toBe(true);
+        expect(result.embedding.length).toBe(768);
+        expect(result.promptTokens).toBeGreaterThan(0);
         // All elements should be numbers
-        for (const v of vector) {
+        for (const v of result.embedding) {
             expect(typeof v).toBe('number');
             expect(Number.isFinite(v)).toBe(true);
         }
         // Vector should not be all zeros
-        const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+        const magnitude = Math.sqrt(result.embedding.reduce((sum, v) => sum + v * v, 0));
         expect(magnitude).toBeGreaterThan(0);
     });
     it('should produce different vectors for semantically different text', async () => {
         const embedder = buildEmbedder({
             provider: 'ollama',
             model: 'nomic-embed-text',
-            baseUrl: 'http://localhost:11434',
+            baseUrl: 'http://localhost:11434'
         });
         expect(embedder).not.toBeNull();
-        const [vecA, vecB] = await Promise.all([
+        const [resultA, resultB] = await Promise.all([
             embedder('Artificial intelligence and machine learning'),
-            embedder('Cooking recipes for Italian pasta dishes'),
+            embedder('Cooking recipes for Italian pasta dishes')
         ]);
+        const vecA = resultA.embedding;
+        const vecB = resultB.embedding;
         expect(vecA.length).toBe(768);
         expect(vecB.length).toBe(768);
         // Compute cosine similarity
@@ -299,13 +303,15 @@ describe('graphile-llm with real Ollama embedding', () => {
         const embedder = buildEmbedder({
             provider: 'ollama',
             model: 'nomic-embed-text',
-            baseUrl: 'http://localhost:11434',
+            baseUrl: 'http://localhost:11434'
         });
         expect(embedder).not.toBeNull();
-        const [vecA, vecB] = await Promise.all([
+        const [resultA, resultB] = await Promise.all([
             embedder('Machine learning and artificial intelligence'),
-            embedder('AI and ML are subfields of computer science'),
+            embedder('AI and ML are subfields of computer science')
         ]);
+        const vecA = resultA.embedding;
+        const vecB = resultB.embedding;
         expect(vecA.length).toBe(768);
         expect(vecB.length).toBe(768);
         // Compute cosine similarity
@@ -321,11 +327,14 @@ describe('graphile-llm with real Ollama embedding', () => {
         // Semantically similar texts should have high similarity
         expect(cosineSimilarity).toBeGreaterThan(0.5);
     });
-    it('should produce embeddings via @agentic-kit/ollama OllamaClient directly', async () => {
-        const vector = await ollamaClient.generateEmbedding('Testing the agentic-kit Ollama client directly', 'nomic-embed-text');
-        expect(Array.isArray(vector)).toBe(true);
-        expect(vector.length).toBe(768);
-        for (const v of vector) {
+    it('should produce embeddings with token count via @agentic-kit/ollama OllamaClient directly', async () => {
+        const result = await ollamaClient.generateEmbedding('Testing the agentic-kit Ollama client directly', 'nomic-embed-text');
+        expect(result).toHaveProperty('embedding');
+        expect(result).toHaveProperty('promptTokens');
+        expect(Array.isArray(result.embedding)).toBe(true);
+        expect(result.embedding.length).toBe(768);
+        expect(result.promptTokens).toBeGreaterThan(0);
+        for (const v of result.embedding) {
             expect(typeof v).toBe('number');
             expect(Number.isFinite(v)).toBe(true);
         }
@@ -340,14 +349,14 @@ describe('Chat completion abstraction', () => {
             const chat = buildChatCompleter({
                 provider: 'ollama',
                 model: 'llama3',
-                baseUrl: 'http://localhost:11434',
+                baseUrl: 'http://localhost:11434'
             });
             expect(chat).not.toBeNull();
             expect(typeof chat).toBe('function');
         });
         it('returns null for unknown provider', () => {
             const chat = buildChatCompleter({
-                provider: 'unknown-provider',
+                provider: 'unknown-provider'
             });
             expect(chat).toBeNull();
         });
@@ -363,7 +372,7 @@ describe('Chat completion abstraction', () => {
                 embedding_provider: 'ollama',
                 chat_provider: 'ollama',
                 chat_model: 'llama3',
-                chat_base_url: 'http://localhost:11434',
+                chat_base_url: 'http://localhost:11434'
             };
             const chat = buildChatCompleterFromModule(moduleData);
             expect(chat).not.toBeNull();
@@ -371,7 +380,7 @@ describe('Chat completion abstraction', () => {
         });
         it('returns null when chat_provider is not set', () => {
             const moduleData = {
-                embedding_provider: 'ollama',
+                embedding_provider: 'ollama'
             };
             const chat = buildChatCompleterFromModule(moduleData);
             expect(chat).toBeNull();
@@ -382,18 +391,19 @@ describe('Chat completion abstraction', () => {
         afterEach(() => {
             process.env = originalEnv;
         });
-        it('returns null when CHAT_PROVIDER is not set', () => {
+        it('returns default ollama chat completer when CHAT_PROVIDER is not set', () => {
             process.env = { ...originalEnv };
             delete process.env.CHAT_PROVIDER;
             const chat = buildChatCompleterFromEnv();
-            expect(chat).toBeNull();
+            expect(chat).not.toBeNull();
+            expect(typeof chat).toBe('function');
         });
         it('builds chat completer from environment variables', () => {
             process.env = {
                 ...originalEnv,
                 CHAT_PROVIDER: 'ollama',
                 CHAT_MODEL: 'llama3',
-                CHAT_BASE_URL: 'http://localhost:11434',
+                CHAT_BASE_URL: 'http://localhost:11434'
             };
             const chat = buildChatCompleterFromEnv();
             expect(chat).not.toBeNull();
@@ -432,10 +442,10 @@ function makeTestSmartTagsPlugin(tagsByTable) {
                             Object.assign(c.extensions.tags, tags);
                         }
                         return _;
-                    },
-                },
-            },
-        },
+                    }
+                }
+            }
+        }
     };
 }
 describe('RAG plugin schema enrichment', () => {
@@ -444,7 +454,7 @@ describe('RAG plugin schema enrichment', () => {
     let query;
     beforeAll(async () => {
         const unifiedPlugin = createUnifiedSearchPlugin({
-            adapters: [createPgvectorAdapter()],
+            adapters: [createPgvectorAdapter()]
         });
         const smartTagsPlugin = makeTestSmartTagsPlugin({
             articles: {
@@ -453,16 +463,22 @@ describe('RAG plugin schema enrichment', () => {
                     parentFk: 'parent_id',
                     parentPk: 'id',
                     embeddingField: 'embedding',
-                    contentField: 'content',
-                },
-            },
+                    contentField: 'content'
+                }
+            }
+        });
+        // Mock embedder that returns a fixed 3-dim vector with token count
+        const mockEmbedder = async (_text) => ({
+            embedding: [1, 0, 0],
+            promptTokens: 5
         });
-        // Mock embedder that returns a fixed 3-dim vector
-        const mockEmbedder = async (_text) => [1, 0, 0];
-        // Mock chat completer that returns a canned response
+        // Mock chat completer that returns a canned response with usage
         const mockChatCompleter = async (messages) => {
             const userMessage = messages.find((m) => m.role === 'user');
-            return `Mock answer for: ${userMessage?.content || 'unknown'}`;
+            return {
+                content: `Mock answer for: ${userMessage?.content || 'unknown'}`,
+                usage: { input: 10, output: 15, reasoning: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 25 }
+            };
         };
         const testPreset = {
             extends: [ConnectionFilterPreset()],
@@ -474,13 +490,13 @@ describe('RAG plugin schema enrichment', () => {
                     defaultEmbedder: {
                         provider: 'ollama',
                         model: 'nomic-embed-text',
-                        baseUrl: 'http://localhost:11434',
-                    },
+                        baseUrl: 'http://localhost:11434'
+                    }
                 }),
                 createLlmTextSearchPlugin(),
                 createLlmTextMutationPlugin(),
-                createLlmRagPlugin(),
-            ],
+                createLlmRagPlugin()
+            ]
         };
         // Override the embedder and chat completer on the build context
         // by wrapping the LlmModulePlugin's build hook
@@ -493,20 +509,20 @@ describe('RAG plugin schema enrichment', () => {
                     build(build) {
                         return build.extend(build, {
                             llmEmbedder: mockEmbedder,
-                            llmChatCompleter: mockChatCompleter,
+                            llmChatCompleter: mockChatCompleter
                         }, 'TestOverridePlugin overriding embedder and chat completer');
-                    },
-                },
-            },
+                    }
+                }
+            }
         };
         const connections = await getConnections({
             schemas: ['llm_test'],
             preset: {
                 ...testPreset,
-                plugins: [...testPreset.plugins, overridePlugin],
+                plugins: [...testPreset.plugins, overridePlugin]
             },
             useRoot: true,
-            authRole: 'postgres',
+            authRole: 'postgres'
         }, [seed.sqlfile([join(__dirname, './setup.sql')])]);
         db = connections.db;
         teardown = connections.teardown;
@@ -630,7 +646,7 @@ describe('GraphileLlmPreset toggles', () => {
     it('enableRag=false excludes RAG plugin (no ragQuery field)', async () => {
         const { GraphileLlmPreset } = await import('../../src/preset');
         const preset = GraphileLlmPreset({
-            enableRag: false,
+            enableRag: false
         });
         const pluginNames = preset.plugins.map((p) => p.name);
         expect(pluginNames).not.toContain('LlmRagPlugin');
@@ -638,7 +654,7 @@ describe('GraphileLlmPreset toggles', () => {
     it('enableRag=true includes RAG plugin', async () => {
         const { GraphileLlmPreset } = await import('../../src/preset');
         const preset = GraphileLlmPreset({
-            enableRag: true,
+            enableRag: true
         });
         const pluginNames = preset.plugins.map((p) => p.name);
         expect(pluginNames).toContain('LlmRagPlugin');
@@ -646,7 +662,7 @@ describe('GraphileLlmPreset toggles', () => {
     it('enableTextSearch=false excludes text search plugin', async () => {
         const { GraphileLlmPreset } = await import('../../src/preset');
         const preset = GraphileLlmPreset({
-            enableTextSearch: false,
+            enableTextSearch: false
         });
         const pluginNames = preset.plugins.map((p) => p.name);
         expect(pluginNames).not.toContain('LlmTextSearchPlugin');
@@ -656,7 +672,7 @@ describe('GraphileLlmPreset toggles', () => {
     it('enableTextMutations=false excludes text mutation plugin', async () => {
         const { GraphileLlmPreset } = await import('../../src/preset');
         const preset = GraphileLlmPreset({
-            enableTextMutations: false,
+            enableTextMutations: false
         });
         const pluginNames = preset.plugins.map((p) => p.name);
         expect(pluginNames).not.toContain('LlmTextMutationPlugin');
@@ -666,7 +682,7 @@ describe('GraphileLlmPreset toggles', () => {
         const preset = GraphileLlmPreset({
             enableTextSearch: false,
             enableTextMutations: false,
-            enableRag: false,
+            enableRag: false
         });
         const pluginNames = preset.plugins.map((p) => p.name);
         expect(pluginNames).toEqual(['LlmModulePlugin']);

package/esm/chat.d.ts

@@ -26,12 +26,12 @@ export declare function buildChatCompleter(config: ChatConfig): ChatFunction | n
  */
 export declare function buildChatCompleterFromModule(data: LlmModuleData): ChatFunction | null;
 /**
- * Resolve a chat completer from environment variables via getEnvOptions().
+ * Resolve a chat completer from environment variables.
  * This is a fallback for development when no llm_module or defaultChatCompleter is configured.
  *
- * Environment variables (parsed by @constructive-io/graphql-env):
- *   CHAT_PROVIDER - Provider name ('ollama')
- *   CHAT_MODEL    - Model identifier (e.g. 'llama3')
- *   CHAT_BASE_URL - Provider base URL
+ * Environment variables (with defaults from env.ts):
+ *   CHAT_PROVIDER  - Provider name (default: 'ollama')
+ *   CHAT_MODEL     - Model identifier (default: 'llama3')
+ *   CHAT_BASE_URL  - Provider base URL (default: 'http://localhost:11434')
  */
 export declare function buildChatCompleterFromEnv(): ChatFunction | null;

package/esm/chat.js

@@ -11,38 +11,51 @@
  *   2. The preset's `defaultChatCompleter` option (fallback for dev/testing)
  *   3. Environment variables (CHAT_PROVIDER, CHAT_MODEL, CHAT_BASE_URL)
  */
-import OllamaClient from '@agentic-kit/ollama';
-import { getEnvOptions } from '@constructive-io/graphql-env';
+import { OllamaAdapter } from '@agentic-kit/ollama';
+import { getLlmEnvOptions } from './env';
 // ─── Built-in Providers ─────────────────────────────────────────────────────
 /**
  * Create an Ollama-based chat completion function.
  *
- * Uses OllamaClient.generate() with a messages array, which internally
- * routes to the /api/chat endpoint.
+ * Uses OllamaAdapter.stream() to get both response content and real token
+ * usage counts from the provider (prompt_eval_count, eval_count).
  */
 function createOllamaChatCompleter(baseUrl = 'http://localhost:11434', model = 'llama3') {
-    const client = new OllamaClient(baseUrl);
+    const adapter = new OllamaAdapter(baseUrl);
     return async (messages, options) => {
-        // Build the input for OllamaClient.generate() in chat mode
-        const input = {
-            model,
-            messages: messages.filter((m) => m.role !== 'system'),
-        };
-        // Extract system message if present
         const systemMsg = messages.find((m) => m.role === 'system');
-        if (systemMsg) {
-            input.system = systemMsg.content;
-        }
-        if (options?.temperature !== undefined) {
-            input.temperature = options.temperature;
-        }
-        const startTime = Date.now();
-        const response = await client.generate(input);
-        const latencyMs = Date.now() - startTime;
-        // Token count logging (metering deferred to billing system)
-        console.log(`[graphile-llm] Chat completion: model=${model}, latency=${latencyMs}ms, ` +
-            `messages=${messages.length}`);
-        return response;
+        const nonSystem = messages.filter((m) => m.role !== 'system');
+        const modelDesc = adapter.createModel(model, {
+            maxOutputTokens: options?.maxTokens
+        });
+        const context = {
+            systemPrompt: systemMsg?.content,
+            messages: nonSystem.map((m) => ({
+                role: m.role,
+                content: m.content,
+                timestamp: Date.now()
+            }))
+        };
+        const stream = adapter.stream(modelDesc, context, {
+            temperature: options?.temperature,
+            maxTokens: options?.maxTokens
+        });
+        const result = await stream.result();
+        const content = result.content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('');
+        return {
+            content,
+            usage: {
+                input: result.usage.input,
+                output: result.usage.output,
+                reasoning: result.usage.reasoning,
+                cacheRead: result.usage.cacheRead,
+                cacheWrite: result.usage.cacheWrite,
+                totalTokens: result.usage.totalTokens
+            }
+        };
     };
 }
 // ─── Chat Completer Construction ────────────────────────────────────────────
@@ -73,27 +86,19 @@ export function buildChatCompleterFromModule(data) {
     return buildChatCompleter({
         provider: data.chat_provider,
         model: data.chat_model,
-        baseUrl: data.chat_base_url,
-        apiKey: data.api_key_ref,
+        baseUrl: data.chat_base_url
     });
 }
 /**
- * Resolve a chat completer from environment variables via getEnvOptions().
+ * Resolve a chat completer from environment variables.
  * This is a fallback for development when no llm_module or defaultChatCompleter is configured.
  *
- * Environment variables (parsed by @constructive-io/graphql-env):
- *   CHAT_PROVIDER - Provider name ('ollama')
- *   CHAT_MODEL    - Model identifier (e.g. 'llama3')
- *   CHAT_BASE_URL - Provider base URL
+ * Environment variables (with defaults from env.ts):
+ *   CHAT_PROVIDER  - Provider name (default: 'ollama')
+ *   CHAT_MODEL     - Model identifier (default: 'llama3')
+ *   CHAT_BASE_URL  - Provider base URL (default: 'http://localhost:11434')
  */
 export function buildChatCompleterFromEnv() {
-    const { llm } = getEnvOptions();
-    const provider = llm?.chat?.provider;
-    if (!provider)
-        return null;
-    return buildChatCompleter({
-        provider,
-        model: llm?.chat?.model,
-        baseUrl: llm?.chat?.baseUrl,
-    });
+    const { chat } = getLlmEnvOptions();
+    return buildChatCompleter(chat);
 }

package/esm/config-cache.d.ts

@@ -0,0 +1,77 @@
+/**
+ * config-cache — Per-database LLM billing configuration cache
+ *
+ * Caches resolved billing function names per database_id.
+ * Uses an LRU cache with TTL so config changes propagate within a bounded window
+ * without requiring a server restart.
+ *
+ * Resolution flow:
+ *   Billing config from `metaschema_modules_public.billing_module`
+ *   (schema name + function names for record_usage, check_billing_quota)
+ *
+ * All queries run through the Graphile `withPgClient` callback, which gives us
+ * a client connected to the tenant database with proper role settings.
+ *
+ * The LLM module config (provider, model, etc.) is already resolved by the
+ * LlmModulePlugin at schema-build time. This cache handles the runtime-only
+ * billing piece.
+ */
+/**
+ * Generic pg client interface matching what Graphile's withPgClient provides.
+ * Avoids a hard dependency on the `pg` package.
+ */
+export interface PgClient {
+    query(sql: string, values?: unknown[]): Promise<{
+        rows: Record<string, unknown>[];
+    }>;
+}
+/**
+ * Billing function metadata resolved from the billing_module metaschema table.
+ */
+export interface BillingConfig {
+    /** Private schema containing the billing functions */
+    privateSchema: string;
+    /** Name of the record_usage function */
+    recordUsageFunction: string;
+    /** Name of the check_billing_quota function */
+    checkBillingQuotaFunction: string;
+    /** Public schema containing meters table */
+    publicSchema: string;
+}
+/**
+ * Inference log table metadata resolved from the inference_log_module.
+ */
+export interface InferenceLogConfig {
+    /** Schema containing the usage_log_inference table */
+    schema: string;
+    /** Name of the inference log table */
+    tableName: string;
+}
+/**
+ * Per-database cached configuration for the LLM billing integration.
+ */
+export interface LlmBillingCacheEntry {
+    /** Billing function references (null if billing_module not provisioned) */
+    billing: BillingConfig | null;
+    /** Inference log table references (null if inference_log_module not provisioned) */
+    inferenceLog: InferenceLogConfig | null;
+}
+/**
+ * Resolve billing config for a database.
+ * Results are cached per database_id with a 5-minute TTL.
+ *
+ * @param pgClient - A client connected to the tenant database (from withPgClient)
+ * @param databaseId - The database UUID
+ */
+export declare function getLlmBillingConfig(pgClient: PgClient, databaseId: string): Promise<LlmBillingCacheEntry>;
+/**
+ * Invalidate the cached config for a specific database (or all).
+ */
+export declare function invalidateLlmBillingConfig(databaseId?: string): void;
+/**
+ * Get cache stats for diagnostics.
+ */
+export declare function getLlmBillingCacheStats(): {
+    size: number;
+    max: number;
+};