graphile-llm 0.8.0 → 0.10.0

package/esm/metering.js

@@ -9,9 +9,9 @@
  * When the quota check fails, the wrapper returns null (graceful degradation)
  * instead of throwing, so the search pipeline can fall back to text-only.
  *
- * Token counts are estimated from text length (~4 chars per token). No
- * tokenizer needed — the billing system uses tokens as abstract units
- * and the credit_cost on each model's meter normalizes the relative expense.
+ * Token counts:
+ *   - Chat: real provider counts via ChatResult.usage (from OllamaAdapter.stream())
+ *   - Embedding: real provider counts via EmbeddingResult.promptTokens (from /api/embed)
  *
  * The billing functions live in the tenant database and are called via the
  * Graphile `withPgClient` callback. Function locations (schema, names) are
@@ -88,7 +88,7 @@ export async function logInferenceUsage(ctx, entry) {
                 entry.latencyMs, entry.ragEnabled, entry.chunksRetrieved,
                 entry.embeddingModel, entry.embeddingLatencyMs,
                 entry.status, entry.errorType,
-                entry.rawUsage ? JSON.stringify(entry.rawUsage) : null,
+                entry.rawUsage ? JSON.stringify(entry.rawUsage) : null
             ]);
         });
     }
@@ -108,31 +108,31 @@ export async function meteredEmbed(embedder, text, ctx, options = {}) {
     const startTime = Date.now();
     // No billing context → just embed without metering
     if (!ctx) {
-        const result = await embedder(text);
+        const { embedding } = await embedder(text);
         return {
-            result,
+            result: embedding,
             metered: false,
             quotaExceeded: false,
-            latencyMs: Date.now() - startTime,
+            latencyMs: Date.now() - startTime
         };
     }
     const meterSlug = options.embeddingMeterSlug;
     if (!meterSlug) {
-        const result = await embedder(text);
+        const { embedding } = await embedder(text);
         return {
-            result,
+            result: embedding,
             metered: false,
             quotaExceeded: false,
-            latencyMs: Date.now() - startTime,
+            latencyMs: Date.now() - startTime
         };
     }
     if (options.skipMetering) {
-        const result = await embedder(text);
+        const { embedding } = await embedder(text);
         return {
-            result,
+            result: embedding,
             metered: false,
             quotaExceeded: false,
-            latencyMs: Date.now() - startTime,
+            latencyMs: Date.now() - startTime
         };
     }
     // Pre-check: can this entity afford this call?
@@ -146,8 +146,6 @@ export async function meteredEmbed(embedder, text, ctx, options = {}) {
         allowed = true;
     }
     if (!allowed) {
-        // Placeholder: replace with actual provider token counts once generateWithUsage() is approved
-        const placeholderAmountTokens = Math.ceil(text.length / 4);
         logInferenceUsage(ctx, {
             databaseId: ctx.databaseId,
             entityId: ctx.entityId,
@@ -156,9 +154,9 @@ export async function meteredEmbed(embedder, text, ctx, options = {}) {
             provider: options.provider ?? null,
             service: 'embedding',
             operation: 'create',
-            inputTokens: placeholderAmountTokens,
+            inputTokens: 0,
             outputTokens: 0,
-            totalTokens: placeholderAmountTokens,
+            totalTokens: 0,
             cacheReadTokens: null,
             cacheWriteTokens: null,
             latencyMs: Date.now() - startTime,
@@ -168,26 +166,25 @@ export async function meteredEmbed(embedder, text, ctx, options = {}) {
             embeddingLatencyMs: null,
             status: 'quota_exceeded',
             errorType: null,
-            rawUsage: null,
+            rawUsage: null
         }).catch(() => { });
         return {
             result: null,
             metered: true,
             quotaExceeded: true,
-            latencyMs: Date.now() - startTime,
+            latencyMs: Date.now() - startTime
         };
     }
-    // Execute embedding
-    const result = await embedder(text);
+    // Execute embedding — real token count from provider via EmbeddingResult
+    const { embedding, promptTokens } = await embedder(text);
     const latencyMs = Date.now() - startTime;
-    // Placeholder: replace with actual provider token counts once generateWithUsage() is approved
-    const placeholderAmountTokens = Math.ceil(text.length / 4);
     ctx.withPgClient(ctx.pgSettings, async (pgClient) => {
-        await recordUsage(pgClient, ctx.billing, ctx.entityId, meterSlug, text.length, {
+        await recordUsage(pgClient, ctx.billing, ctx.entityId, meterSlug, promptTokens, {
             request_id: ctx.requestId,
             input_chars: text.length,
-            dims: result.length,
-            latency_ms: latencyMs,
+            prompt_tokens: promptTokens,
+            dims: embedding.length,
+            latency_ms: latencyMs
         });
     }).catch(() => { });
     // Log to inference usage table
@@ -199,9 +196,9 @@ export async function meteredEmbed(embedder, text, ctx, options = {}) {
         provider: options.provider ?? null,
         service: 'embedding',
         operation: 'create',
-        inputTokens: placeholderAmountTokens,
+        inputTokens: promptTokens,
         outputTokens: 0,
-        totalTokens: placeholderAmountTokens,
+        totalTokens: promptTokens,
         cacheReadTokens: null,
         cacheWriteTokens: null,
         latencyMs,
@@ -211,13 +208,13 @@ export async function meteredEmbed(embedder, text, ctx, options = {}) {
         embeddingLatencyMs: latencyMs,
         status: 'success',
         errorType: null,
-        rawUsage: null,
+        rawUsage: { prompt_tokens: promptTokens }
     }).catch(() => { });
     return {
-        result,
+        result: embedding,
         metered: true,
         quotaExceeded: false,
-        latencyMs,
+        latencyMs
     };
 }
 // ─── Metered Chat ───────────────────────────────────────────────────────────
@@ -227,31 +224,31 @@ export async function meteredEmbed(embedder, text, ctx, options = {}) {
 export async function meteredChat(chat, messages, ctx, chatOptions, meteringOptions = {}) {
     const startTime = Date.now();
     if (!ctx) {
-        const result = await chat(messages, chatOptions);
+        const chatResult = await chat(messages, chatOptions);
         return {
-            result,
+            result: chatResult.content,
             metered: false,
             quotaExceeded: false,
-            latencyMs: Date.now() - startTime,
+            latencyMs: Date.now() - startTime
         };
     }
     const meterSlug = meteringOptions.chatMeterSlug;
     if (!meterSlug) {
-        const result = await chat(messages, chatOptions);
+        const chatResult = await chat(messages, chatOptions);
         return {
-            result,
+            result: chatResult.content,
             metered: false,
             quotaExceeded: false,
-            latencyMs: Date.now() - startTime,
+            latencyMs: Date.now() - startTime
         };
     }
     if (meteringOptions.skipMetering) {
-        const result = await chat(messages, chatOptions);
+        const chatResult = await chat(messages, chatOptions);
         return {
-            result,
+            result: chatResult.content,
             metered: false,
             quotaExceeded: false,
-            latencyMs: Date.now() - startTime,
+            latencyMs: Date.now() - startTime
         };
     }
     // Pre-check: can this entity afford this call?
@@ -265,8 +262,7 @@ export async function meteredChat(chat, messages, ctx, chatOptions, meteringOpti
         allowed = true;
     }
     if (!allowed) {
-        // Placeholder: replace with actual provider token counts once generateWithUsage() is approved
-        const placeholderInputTokens = Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
+        const estimatedInputTokens = Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
         logInferenceUsage(ctx, {
             databaseId: ctx.databaseId,
             entityId: ctx.entityId,
@@ -275,9 +271,9 @@ export async function meteredChat(chat, messages, ctx, chatOptions, meteringOpti
             provider: meteringOptions.provider ?? null,
             service: 'llm',
             operation: 'chat',
-            inputTokens: placeholderInputTokens,
+            inputTokens: estimatedInputTokens,
             outputTokens: 0,
-            totalTokens: placeholderInputTokens,
+            totalTokens: estimatedInputTokens,
             cacheReadTokens: null,
             cacheWriteTokens: null,
             latencyMs: Date.now() - startTime,
@@ -287,33 +283,31 @@ export async function meteredChat(chat, messages, ctx, chatOptions, meteringOpti
             embeddingLatencyMs: null,
             status: 'quota_exceeded',
             errorType: null,
-            rawUsage: null,
+            rawUsage: null
         }).catch(() => { });
         return {
             result: null,
             metered: true,
             quotaExceeded: true,
-            latencyMs: Date.now() - startTime,
+            latencyMs: Date.now() - startTime
         };
     }
-    // Execute chat completion
-    const result = await chat(messages, chatOptions);
+    // Execute chat completion — returns real token usage from provider
+    const chatResult = await chat(messages, chatOptions);
     const latencyMs = Date.now() - startTime;
-    // Placeholder: replace with actual provider token counts once generateWithUsage() is approved
-    const inputChars = messages.reduce((sum, m) => sum + m.content.length, 0);
-    const placeholderInputTokens = Math.ceil(inputChars / 4);
-    const placeholderOutputTokens = Math.ceil(result.length / 4);
-    const placeholderTotalTokens = placeholderInputTokens + placeholderOutputTokens;
+    const usage = chatResult.usage;
     ctx.withPgClient(ctx.pgSettings, async (pgClient) => {
-        await recordUsage(pgClient, ctx.billing, ctx.entityId, meterSlug, inputChars + result.length, {
+        await recordUsage(pgClient, ctx.billing, ctx.entityId, meterSlug, usage.totalTokens, {
             request_id: ctx.requestId,
-            input_chars: inputChars,
-            output_chars: result.length,
+            input_tokens: usage.input,
+            output_tokens: usage.output,
+            cache_read_tokens: usage.cacheRead,
+            cache_write_tokens: usage.cacheWrite,
             messages_count: messages.length,
-            latency_ms: latencyMs,
+            latency_ms: latencyMs
         });
     }).catch(() => { });
-    // Log to inference usage table
+    // Log to inference usage table with real provider token counts
     logInferenceUsage(ctx, {
         databaseId: ctx.databaseId,
         entityId: ctx.entityId,
@@ -322,11 +316,11 @@ export async function meteredChat(chat, messages, ctx, chatOptions, meteringOpti
         provider: meteringOptions.provider ?? null,
         service: 'llm',
         operation: 'chat',
-        inputTokens: placeholderInputTokens,
-        outputTokens: placeholderOutputTokens,
-        totalTokens: placeholderTotalTokens,
-        cacheReadTokens: null,
-        cacheWriteTokens: null,
+        inputTokens: usage.input,
+        outputTokens: usage.output,
+        totalTokens: usage.totalTokens,
+        cacheReadTokens: usage.cacheRead || null,
+        cacheWriteTokens: usage.cacheWrite || null,
         latencyMs,
         ragEnabled: false,
         chunksRetrieved: null,
@@ -334,13 +328,13 @@ export async function meteredChat(chat, messages, ctx, chatOptions, meteringOpti
         embeddingLatencyMs: null,
         status: 'success',
         errorType: null,
-        rawUsage: null,
+        rawUsage: { reasoning: usage.reasoning }
     }).catch(() => { });
     return {
-        result,
+        result: chatResult.content,
         metered: true,
         quotaExceeded: false,
-        latencyMs,
+        latencyMs
     };
 }
 // ─── Error Types ────────────────────────────────────────────────────────────

package/esm/plugins/agent-discovery-plugin.js

@@ -12,7 +12,7 @@ import { ModuleConfigCache } from 'graphile-cache';
 // ─── Cache ──────────────────────────────────────────────────────────────────
 const agentDiscoveryCache = new ModuleConfigCache({
     name: 'agent-discovery',
-    ttlMs: 60_000,
+    ttlMs: 60_000
 });
 /** Clear all cached discovery results (for testing) */
 export function clearAgentDiscoveryCache() {
@@ -53,7 +53,7 @@ export async function getAgentDiscovery(pool, dbname) {
                     : null,
                 task: row.task_table_name
                     ? { schemaName, tableName: row.task_table_name }
-                    : null,
+                    : null
             };
         }
     }

package/esm/plugins/llm-module-plugin.d.ts

@@ -21,7 +21,7 @@
  * if loaded (it runs after this plugin and before the consumer plugins).
  */
 import type { GraphileConfig } from 'graphile-config';
-import type { EmbedderFunction, ChatFunction, GraphileLlmOptions } from '../types';
+import type { ChatFunction, EmbedderFunction, GraphileLlmOptions } from '../types';
 declare global {
     namespace GraphileBuild {
         interface Build {

package/esm/plugins/llm-module-plugin.js

@@ -20,8 +20,8 @@
  * The optional LlmMeteringPlugin wraps the embedder with billing integration
  * if loaded (it runs after this plugin and before the consumer plugins).
  */
-import { buildEmbedder, buildEmbedderFromEnv } from '../embedder';
 import { buildChatCompleter, buildChatCompleterFromEnv } from '../chat';
+import { buildEmbedder, buildEmbedderFromEnv } from '../embedder';
 import { getLlmEnvOptions } from '../env';
 /**
  * Creates the LlmModulePlugin with the given options.
@@ -81,10 +81,10 @@ export function createLlmModulePlugin(options = {}) {
                         llmEmbedder: embedder,
                         llmChatCompleter: chat,
                         llmEmbeddingModel: defaultEmbedder?.model ?? getLlmEnvOptions().embedding.model,
-                        llmChatModel: defaultChatCompleter?.model ?? getLlmEnvOptions().chat.model,
+                        llmChatModel: defaultChatCompleter?.model ?? getLlmEnvOptions().chat.model
                     }, 'LlmModulePlugin adding llmEmbedder, llmChatCompleter, and model names to build');
-                },
-            },
-        },
+                }
+            }
+        }
     };
 }

package/esm/plugins/metering-plugin.js

@@ -31,8 +31,8 @@
  * - quota exceeded → embedder returns null
  */
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { meteredEmbed } from '../metering';
 import { getLlmBillingConfig } from '../config-cache';
+import { meteredEmbed } from '../metering';
 // ─── Request-scoped context via AsyncLocalStorage ───────────────────────────
 const meteringStore = new AsyncLocalStorage();
 // ─── Helpers ────────────────────────────────────────────────────────────────
@@ -72,7 +72,7 @@ async function buildMeteringContext(graphqlContext, resolveEntityId) {
         requestId,
         databaseId,
         actorId,
-        inferenceLog: inferenceLogConfig,
+        inferenceLog: inferenceLogConfig
     };
 }
 /**
@@ -89,10 +89,10 @@ function wrapEmbedderWithMetering(embedder, meteringOptions) {
         if (!ctx) {
             // No metering context in scope — call original embedder directly
             const startTime = Date.now();
-            const result = await embedder(text);
+            const { embedding } = await embedder(text);
             const latencyMs = Date.now() - startTime;
-            console.log(`[graphile-llm] Embed (unmetered): dims=${result?.length ?? 0}, latency=${latencyMs}ms`);
-            return result;
+            console.log(`[graphile-llm] Embed (unmetered): dims=${embedding?.length ?? 0}, latency=${latencyMs}ms`);
+            return embedding;
         }
         const result = await meteredEmbed(embedder, text, ctx, meteringOptions);
         if (result.quotaExceeded) {
@@ -103,7 +103,7 @@ function wrapEmbedderWithMetering(embedder, meteringOptions) {
 }
 // ─── Plugin ─────────────────────────────────────────────────────────────────
 export function createLlmMeteringPlugin(meteringConfig = {}) {
-    const { embeddingMeterSlug: configEmbeddingSlug, chatMeterSlug: configChatSlug, skipMetering, resolveEntityId = defaultResolveEntityId, } = meteringConfig;
+    const { embeddingMeterSlug: configEmbeddingSlug, chatMeterSlug: configChatSlug, skipMetering, resolveEntityId = defaultResolveEntityId } = meteringConfig;
     return {
         name: 'LlmMeteringPlugin',
         version: '0.2.0',
@@ -134,13 +134,13 @@ export function createLlmMeteringPlugin(meteringConfig = {}) {
                         chatMeterSlug: chatSlug,
                         skipMetering,
                         embeddingModel: embeddingModel ?? undefined,
-                        chatModel: chatModel ?? undefined,
+                        chatModel: chatModel ?? undefined
                     };
                     // Replace the embedder with a metered version.
                     // Same signature except it can return null (quota exceeded).
                     const meteredEmbedder = wrapEmbedderWithMetering(originalEmbedder, meteringOptions);
                     return build.extend(build, {
-                        llmEmbedder: meteredEmbedder,
+                        llmEmbedder: meteredEmbedder
                     }, 'LlmMeteringPlugin replacing llmEmbedder with metered version');
                 },
                 /**
@@ -148,7 +148,7 @@ export function createLlmMeteringPlugin(meteringConfig = {}) {
                  * request-scoped metering context via AsyncLocalStorage.
                  */
                 GraphQLObjectType_fields_field(field, build, context) {
-                    const { scope: { isRootQuery, isRootMutation }, } = context;
+                    const { scope: { isRootQuery, isRootMutation } } = context;
                     if (!isRootQuery && !isRootMutation)
                         return field;
                     // Only wrap if we actually replaced the embedder
@@ -166,10 +166,10 @@ export function createLlmMeteringPlugin(meteringConfig = {}) {
                             return meteringStore.run(ctx, () => {
                                 return oldResolve(source, args, graphqlContext, info);
                             });
-                        },
+                        }
                     };
-                },
-            },
-        },
+                }
+            }
+        }
     };
 }

package/esm/plugins/rag-plugin.js

@@ -62,7 +62,7 @@ function parseHasChunksTag(raw, codec) {
         parentFkField: parsed.parentFk || 'parent_id',
         parentPkField: parsed.parentPk || 'id',
         embeddingField: parsed.embeddingField || 'embedding',
-        contentField: parsed.contentField || 'content',
+        contentField: parsed.contentField || 'content'
     };
 }
 /**
@@ -222,10 +222,10 @@ export function createLlmRagPlugin(ragDefaults = {}) {
                             minSimilarity: $minSimilarity,
                             systemPrompt: $systemPrompt,
                             withPgClient: $withPgClient,
-                            pgSettings: $pgSettings,
+                            pgSettings: $pgSettings
                         });
                         return lambda($combined, async (input) => {
-                            const { prompt, contextLimit: queryContextLimit, minSimilarity: queryMinSimilarity, systemPrompt: querySystemPrompt, withPgClient, pgSettings, } = input;
+                            const { prompt, contextLimit: queryContextLimit, minSimilarity: queryMinSimilarity, systemPrompt: querySystemPrompt, withPgClient, pgSettings } = input;
                             if (!prompt || typeof prompt !== 'string') {
                                 throw new Error('RAG_INVALID_PROMPT: prompt is required');
                             }
@@ -244,7 +244,7 @@ export function createLlmRagPlugin(ragDefaults = {}) {
                             const systemPromptTemplate = querySystemPrompt ?? ragDefaults.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
                             // Step 1: Embed the prompt
                             const startEmbed = Date.now();
-                            const vector = await embedder(prompt);
+                            const { embedding: vector } = await embedder(prompt);
                             const embedLatency = Date.now() - startEmbed;
                             const vectorString = `[${vector.join(',')}]`;
                             console.log(`[graphile-llm] RAG embed: dims=${vector.length}, latency=${embedLatency}ms`);
@@ -260,7 +260,7 @@ export function createLlmRagPlugin(ragDefaults = {}) {
                                                 content: row.content,
                                                 parent_id: row.parent_id,
                                                 distance: parseFloat(row.distance),
-                                                table_name: table.parentCodecName,
+                                                table_name: table.parentCodecName
                                             });
                                         }
                                     }
@@ -274,31 +274,31 @@ export function createLlmRagPlugin(ragDefaults = {}) {
                                     answer: 'No relevant context found for your query. ' +
                                         'Try broadening your search or lowering the minimum similarity threshold.',
                                     sources: [],
-                                    tokensUsed: null,
+                                    tokensUsed: null
                                 };
                             }
                             // Step 3: Assemble context
                             const contextText = assembleContext(topChunks);
                             // Step 4: Call chat completion
                             const startChat = Date.now();
-                            const answer = await chatCompleter([
+                            const chatResult = await chatCompleter([
                                 { role: 'system', content: systemPromptTemplate + contextText },
-                                { role: 'user', content: prompt },
+                                { role: 'user', content: prompt }
                             ], {
-                                maxTokens: ragDefaults.maxTokens ?? DEFAULT_MAX_TOKENS,
+                                maxTokens: ragDefaults.maxTokens ?? DEFAULT_MAX_TOKENS
                             });
                             const chatLatency = Date.now() - startChat;
-                            console.log(`[graphile-llm] RAG chat: sources=${topChunks.length}, latency=${chatLatency}ms`);
+                            console.log(`[graphile-llm] RAG chat: sources=${topChunks.length}, tokens=${chatResult.usage.totalTokens}, latency=${chatLatency}ms`);
                             // Step 5: Return response
                             return {
-                                answer,
+                                answer: chatResult.content,
                                 sources: topChunks.map((chunk) => ({
                                     content: chunk.content,
                                     similarity: 1 - chunk.distance,
                                     tableName: chunk.table_name,
-                                    parentId: chunk.parent_id,
+                                    parentId: chunk.parent_id
                                 })),
-                                tokensUsed: null, // Deferred to metering system
+                                tokensUsed: chatResult.usage.totalTokens
                             };
                         });
                     },
@@ -313,17 +313,17 @@ export function createLlmRagPlugin(ragDefaults = {}) {
                                     'to use embedText. Set defaultEmbedder in GraphileLlmPreset options.');
                             }
                             const startTime = Date.now();
-                            const vector = await embedder(text);
+                            const { embedding: vector } = await embedder(text);
                             const latencyMs = Date.now() - startTime;
                             console.log(`[graphile-llm] embedText: dims=${vector.length}, latency=${latencyMs}ms`);
                             return {
                                 vector,
-                                dimensions: vector.length,
+                                dimensions: vector.length
                             };
                         });
-                    },
-                },
-            },
+                    }
+                }
+            }
         };
     });
     return {
@@ -335,7 +335,7 @@ export function createLlmRagPlugin(ragDefaults = {}) {
         after: [
             'LlmModulePlugin',
             'UnifiedSearchPlugin',
-            'VectorCodecPlugin',
-        ],
+            'VectorCodecPlugin'
+        ]
     };
 }

package/esm/plugins/text-mutation-plugin.js

@@ -45,7 +45,7 @@ function getTextToVectorMapping(pgCodec, build) {
         if (isVectorCodec(attribute.codec)) {
             const fieldName = build.inflection.attribute({
                 codec: pgCodec,
-                attributeName,
+                attributeName
             });
             mapping[`${fieldName}Text`] = fieldName;
         }
@@ -73,7 +73,7 @@ export function createLlmTextMutationPlugin() {
             'PgAttributesPlugin',
             'PgMutationCreatePlugin',
             'PgMutationUpdateDeletePlugin',
-            'VectorCodecPlugin',
+            'VectorCodecPlugin'
         ],
         schema: {
             hooks: {
@@ -82,12 +82,12 @@ export function createLlmTextMutationPlugin() {
                  * for tables that have vector columns.
                  */
                 GraphQLInputObjectType_fields(fields, build, context) {
-                    const { scope: { isPgPatch, isPgBaseInput, isMutationInput, pgCodec, }, } = context;
+                    const { scope: { isPgPatch, isPgBaseInput, isMutationInput, pgCodec } } = context;
                     // Only intercept create/update input types for table rows
                     if (!pgCodec?.attributes || (!isPgPatch && !isPgBaseInput && !isMutationInput)) {
                         return fields;
                     }
-                    const { graphql: { GraphQLString }, } = build;
+                    const { graphql: { GraphQLString } } = build;
                     // Find vector columns on this table
                     const vectorColumns = [];
                     for (const [attributeName, attribute] of Object.entries(pgCodec.attributes)) {
@@ -103,7 +103,7 @@ export function createLlmTextMutationPlugin() {
                         // Convert snake_case column name to camelCase field name
                         const fieldName = build.inflection.attribute({
                             codec: pgCodec,
-                            attributeName: columnName,
+                            attributeName: columnName
                         });
                         const textFieldName = `${fieldName}Text`;
                         newFields = build.extend(newFields, {
@@ -111,8 +111,8 @@ export function createLlmTextMutationPlugin() {
                                 type: GraphQLString,
                                 description: `Natural language text to embed server-side into the \`${fieldName}\` vector column. ` +
                                     `Mutually exclusive with \`${fieldName}\` — provide one or the other. ` +
-                                    'Requires the LLM plugin to be configured with an embedding provider.',
-                            },
+                                    'Requires the LLM plugin to be configured with an embedding provider.'
+                            }
                         }, `LlmTextMutationPlugin adding ${textFieldName} companion field for vector column '${columnName}'`);
                     }
                     return newFields;
@@ -129,7 +129,7 @@ export function createLlmTextMutationPlugin() {
                  * If the embedder returns null (e.g. quota exceeded), throws an error.
                  */
                 GraphQLObjectType_fields_field(field, build, context) {
-                    const { scope: { isRootMutation, fieldName, pgCodec }, } = context;
+                    const { scope: { isRootMutation, fieldName, pgCodec } } = context;
                     // Only wrap root mutation fields on tables with attributes
                     if (!isRootMutation || !pgCodec || !pgCodec.attributes) {
                         return field;
@@ -192,10 +192,10 @@ export function createLlmTextMutationPlugin() {
                             }
                             await embedTextFields(args);
                             return oldResolve(source, args, graphqlContext, info);
-                        },
+                        }
                     };
-                },
-            },
-        },
+                }
+            }
+        }
     };
 }