@constructive-io/graphql-server 4.32.0 → 4.34.0

package/esm/middleware/llm-api.js

@@ -19,91 +19,32 @@
  *
  * Auth: JWT from the auth middleware (req.token) → pg SET LOCAL context for RLS
  * Metering: check_billing_quota → LLM call → record_usage with real token counts
+ *
+ * Context: Uses `req.constructive` from @constructive-io/express-context
+ * for tenant-scoped database access, pgSettings, and withPgClient.
  */
 import express, { Router } from 'express';
 import { Logger } from '@pgpmjs/logger';
-import { getPgPool } from 'pg-cache';
-import OllamaClient from '@agentic-kit/ollama';
+import { OllamaAdapter } from '@agentic-kit/ollama';
 import { ModuleConfigCache } from 'graphile-cache';
 import { getLlmEnvOptions, getAgentDiscovery, getLlmBillingConfig, } from 'graphile-llm';
 const log = new Logger('llm-api');
-/**
- * Placeholder: replace with actual provider token counts once generateWithUsage() is approved.
- * Estimates ~4 chars per token for English text.
- */
-function placeholderAmountTokens(text) {
-    return Math.ceil(text.length / 4);
-}
-/**
- * Call generate() and estimate token counts from text length.
- * When a provider-native token counting API is approved, swap the
- * estimation logic here without changing call sites.
- */
-async function callWithUsage(client, input, onChunk) {
-    const promptText = input.messages.map((m) => m.content).join(' ');
-    let content;
-    if (onChunk || input.stream) {
-        await client.generate(input, onChunk);
-        content = '';
-    }
-    else {
-        content = await client.generate(input);
-    }
-    const inputTokens = placeholderAmountTokens(promptText);
-    const outputTokens = placeholderAmountTokens(content);
-    return {
-        content,
-        usage: { input: inputTokens, output: outputTokens, totalTokens: inputTokens + outputTokens },
-    };
-}
 // ─── Helpers ────────────────────────────────────────────────────────────────
-function getPgSettings(req) {
-    const settings = {};
-    if (req.token?.user_id) {
-        settings['jwt.claims.user_id'] = req.token.user_id;
-        settings['role'] = 'authenticated';
-    }
-    if (req.databaseId) {
-        settings['jwt.claims.database_id'] = req.databaseId;
-    }
-    if (req.requestId) {
-        settings['request.id'] = req.requestId;
-    }
-    return settings;
-}
-async function withRlsClient(pool, pgSettings, fn) {
-    const client = await pool.connect();
-    try {
-        await client.query('BEGIN');
-        for (const [key, value] of Object.entries(pgSettings)) {
-            await client.query('SELECT set_config($1, $2, true)', [key, value]);
-        }
-        const result = await fn(client);
-        await client.query('COMMIT');
-        return result;
-    }
-    catch (err) {
-        await client.query('ROLLBACK').catch(() => { });
-        throw err;
-    }
-    finally {
-        client.release();
-    }
-}
-function resolveOllamaClient() {
+function resolveOllamaAdapter() {
     const { chat } = getLlmEnvOptions();
     if (chat.provider === 'ollama') {
         return {
-            client: new OllamaClient(chat.baseUrl),
+            adapter: new OllamaAdapter(chat.baseUrl),
             model: chat.model,
+            baseUrl: chat.baseUrl,
         };
     }
     return null;
 }
 // ─── Billing Helpers ────────────────────────────────────────────────────────
-async function checkQuota(pool, pgSettings, billing, entityId, meterSlug) {
+async function checkQuota(ctx, billing, entityId, meterSlug) {
     try {
-        return await withRlsClient(pool, pgSettings, async (client) => {
+        return await ctx.withPgClient(async (client) => {
             const sql = `SELECT "${billing.privateSchema}"."${billing.checkBillingQuotaFunction}"($1, $2::uuid, $3) AS allowed`;
             const result = await client.query(sql, [meterSlug, entityId, 1]);
             return result.rows[0]?.allowed !== false;
@@ -115,9 +56,9 @@ async function checkQuota(pool, pgSettings, billing, entityId, meterSlug) {
         return true;
     }
 }
-async function recordUsage(pool, pgSettings, billing, entityId, meterSlug, amount, metadata) {
+async function recordUsage(ctx, billing, entityId, meterSlug, amount, metadata) {
     try {
-        await withRlsClient(pool, pgSettings, async (client) => {
+        await ctx.withPgClient(async (client) => {
             const sql = `SELECT "${billing.privateSchema}"."${billing.recordUsageFunction}"($1, $2::uuid, $3, $4::jsonb)`;
             await client.query(sql, [meterSlug, entityId, amount, JSON.stringify(metadata)]);
         });
@@ -127,11 +68,13 @@ async function recordUsage(pool, pgSettings, billing, entityId, meterSlug, amoun
         log.warn(`[llm-api] record_usage failed (non-fatal): ${message}`);
     }
 }
-async function resolveBilling(pool, pgSettings, databaseId) {
+async function resolveBilling(ctx) {
+    if (!ctx.databaseId)
+        return null;
     try {
         let billing = null;
-        await withRlsClient(pool, pgSettings, async (client) => {
-            const entry = await getLlmBillingConfig(client, databaseId);
+        await ctx.withPgClient(async (client) => {
+            const entry = await getLlmBillingConfig(client, ctx.databaseId);
             billing = entry.billing;
         });
         return billing;
@@ -170,9 +113,9 @@ async function getInferenceLogInfo(pool, dbname) {
     inferenceLogCache.set(dbname, info);
     return info;
 }
-async function logInference(pool, pgSettings, logInfo, data) {
+async function logInference(ctx, logInfo, data) {
     try {
-        await withRlsClient(pool, pgSettings, async (client) => {
+        await ctx.withPgClient(async (client) => {
             await client.query(`INSERT INTO "${logInfo.schemaName}"."${logInfo.tableName}"
          (entity_id, actor_id, model, provider, service, operation, input_tokens, output_tokens, total_tokens, latency_ms, status)
          VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, [
@@ -197,31 +140,29 @@ async function logInference(pool, pgSettings, logInfo, data) {
 }
 // ─── Route Handlers ─────────────────────────────────────────────────────────
 async function handleCreateThread(req, res, entityId) {
-    if (!req.token?.user_id) {
+    const ctx = req.constructive;
+    if (!ctx?.userId) {
         res.status(401).json({ error: 'Authentication required' });
         return;
     }
-    const dbname = req.api?.dbname;
-    if (!dbname) {
+    if (!ctx.api.dbname) {
         res.status(400).json({ error: 'Database not resolved' });
         return;
     }
-    const pool = getPgPool({ database: dbname });
-    const discovery = await getAgentDiscovery(pool, dbname);
+    const discovery = await getAgentDiscovery(ctx.pool, ctx.api.dbname);
     if (!discovery?.thread) {
         res.status(404).json({ error: 'Agent module not provisioned for this database' });
         return;
     }
     const body = req.body || {};
     const { thread } = discovery;
-    const pgSettings = getPgSettings(req);
-    const result = await withRlsClient(pool, pgSettings, async (client) => {
+    const result = await ctx.withPgClient(async (client) => {
         const { rows } = await client.query(`INSERT INTO "${thread.schemaName}"."${thread.tableName}"
        (entity_id, owner_id, mode, model, system_prompt, title)
        VALUES ($1, $2, $3, $4, $5, $6)
        RETURNING id, mode, model, system_prompt, status, created_at`, [
             entityId,
-            req.token.user_id,
+            ctx.userId,
             body.mode ?? 'ask',
             body.model ?? null,
             body.system_prompt ?? null,
@@ -239,17 +180,16 @@ async function handleCreateThread(req, res, entityId) {
     });
 }
 async function handleSendMessage(req, res, entityId) {
-    if (!req.token?.user_id) {
+    const ctx = req.constructive;
+    if (!ctx?.userId) {
         res.status(401).json({ error: 'Authentication required' });
         return;
     }
-    const dbname = req.api?.dbname;
-    if (!dbname) {
+    if (!ctx.api.dbname) {
         res.status(400).json({ error: 'Database not resolved' });
         return;
     }
-    const pool = getPgPool({ database: dbname });
-    const discovery = await getAgentDiscovery(pool, dbname);
+    const discovery = await getAgentDiscovery(ctx.pool, ctx.api.dbname);
     if (!discovery?.thread || !discovery?.message) {
         res.status(404).json({ error: 'Agent module not provisioned for this database' });
         return;
@@ -260,12 +200,10 @@ async function handleSendMessage(req, res, entityId) {
         return;
     }
     const { thread, message: msgTable } = discovery;
-    const pgSettings = getPgSettings(req);
     const threadId = req.params.thread_id;
-    const userId = req.token.user_id;
-    const databaseId = req.databaseId;
+    const userId = ctx.userId;
     // 1. Verify thread exists and user owns it (RLS enforced)
-    const threadRow = await withRlsClient(pool, pgSettings, async (client) => {
+    const threadRow = await ctx.withPgClient(async (client) => {
         const { rows } = await client.query(`SELECT id, mode, model, system_prompt, status
        FROM "${thread.schemaName}"."${thread.tableName}"
        WHERE id = $1`, [threadId]);
@@ -276,11 +214,9 @@ async function handleSendMessage(req, res, entityId) {
         return;
     }
     // 2. Resolve billing config + inference log discovery
-    const billing = databaseId
-        ? await resolveBilling(pool, pgSettings, databaseId)
-        : null;
-    const inferenceLog = await getInferenceLogInfo(pool, dbname);
-    const ollama = resolveOllamaClient();
+    const billing = await resolveBilling(ctx);
+    const inferenceLog = await getInferenceLogInfo(ctx.pool, ctx.api.dbname);
+    const ollama = resolveOllamaAdapter();
     if (!ollama) {
         res.status(503).json({ error: 'No LLM provider configured' });
         return;
@@ -288,7 +224,7 @@ async function handleSendMessage(req, res, entityId) {
     const model = body.model ?? threadRow.model ?? ollama.model;
     const meterSlug = model;
     if (billing) {
-        const allowed = await checkQuota(pool, pgSettings, billing, entityId, meterSlug);
+        const allowed = await checkQuota(ctx, billing, entityId, meterSlug);
         if (!allowed) {
             res.status(429).json({
                 error: 'Token quota exceeded',
@@ -299,7 +235,7 @@ async function handleSendMessage(req, res, entityId) {
         }
     }
     // 3. Persist user message(s)
-    await withRlsClient(pool, pgSettings, async (client) => {
+    await ctx.withPgClient(async (client) => {
         for (const msg of body.messages) {
             if (msg.role === 'user') {
                 await client.query(`INSERT INTO "${msgTable.schemaName}"."${msgTable.tableName}"
@@ -314,7 +250,7 @@ async function handleSendMessage(req, res, entityId) {
         }
     });
     // 4. Load full thread history for context
-    const history = await withRlsClient(pool, pgSettings, async (client) => {
+    const history = await ctx.withPgClient(async (client) => {
         const { rows } = await client.query(`SELECT author_role, parts, created_at
        FROM "${msgTable.schemaName}"."${msgTable.tableName}"
        WHERE thread_id = $1
@@ -343,7 +279,7 @@ async function handleSendMessage(req, res, entityId) {
     const shouldStream = body.stream !== false;
     const startTime = Date.now();
     if (shouldStream) {
-        // ── SSE Streaming ──────────────────────────────────────────────────
+        // ── SSE Streaming via OllamaAdapter ─────────────────────────────────
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
             'Cache-Control': 'no-cache',
@@ -352,38 +288,55 @@ async function handleSendMessage(req, res, entityId) {
         });
         const messageId = `msg_${Date.now()}`;
         try {
-            let streamedContent = '';
-            const result = await callWithUsage(ollama.client, {
-                model,
-                messages: llmMessages,
-                stream: true,
+            const systemMsg = llmMessages.find(m => m.role === 'system');
+            const nonSystem = llmMessages.filter(m => m.role !== 'system');
+            const modelDesc = ollama.adapter.createModel(model, {
+                maxOutputTokens: undefined,
+            });
+            const context = {
+                systemPrompt: systemMsg?.content,
+                messages: nonSystem.map((m) => ({
+                    role: m.role,
+                    content: m.content,
+                    timestamp: Date.now(),
+                })),
+            };
+            const stream = ollama.adapter.stream(modelDesc, context, {
                 temperature: body.temperature,
-            }, (chunk) => {
-                streamedContent += chunk;
-                const event = {
-                    id: messageId,
-                    choices: [{
-                            index: 0,
-                            delta: { content: chunk, role: 'assistant' },
-                            finish_reason: null,
-                        }],
-                    model,
-                };
-                res.write(`data: ${JSON.stringify(event)}\n\n`);
             });
-            // Streaming generate() returns void; use accumulated chunks
+            let streamedContent = '';
+            for await (const event of stream) {
+                if (event.type === 'text_delta') {
+                    streamedContent += event.delta;
+                    const sseEvent = {
+                        id: messageId,
+                        choices: [{
+                                index: 0,
+                                delta: { content: event.delta, role: 'assistant' },
+                                finish_reason: null,
+                            }],
+                        model,
+                    };
+                    res.write(`data: ${JSON.stringify(sseEvent)}\n\n`);
+                }
+            }
+            const result = await stream.result();
             const content = streamedContent;
-            const promptText = llmMessages.map(m => m.content).join(' ');
             const latencyMs = Date.now() - startTime;
-            const inputTokens = placeholderAmountTokens(promptText);
-            const outputTokens = placeholderAmountTokens(content);
-            const totalTokens = inputTokens + outputTokens;
+            const 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,
+            };
             // Send [DONE] marker
             res.write('data: [DONE]\n\n');
             res.end();
             // 6. Persist assistant message with model (fire-and-forget)
             if (content) {
-                withRlsClient(pool, pgSettings, async (client) => {
+                ctx.withPgClient(async (client) => {
                     await client.query(`INSERT INTO "${msgTable.schemaName}"."${msgTable.tableName}"
              (thread_id, owner_id, entity_id, author_role, parts, model)
              VALUES ($1, $2, (SELECT entity_id FROM "${thread.schemaName}"."${thread.tableName}" WHERE id = $1), $3, $4, $5)`, [
@@ -398,10 +351,12 @@ async function handleSendMessage(req, res, entityId) {
                 });
             }
             // 7. Record billing usage (fire-and-forget)
-            if (billing && totalTokens > 0) {
-                recordUsage(pool, pgSettings, billing, entityId, meterSlug, totalTokens, {
-                    input_tokens: inputTokens,
-                    output_tokens: outputTokens,
+            if (billing && usage.totalTokens > 0) {
+                recordUsage(ctx, billing, entityId, meterSlug, usage.totalTokens, {
+                    input_tokens: usage.input,
+                    output_tokens: usage.output,
+                    cache_read_tokens: usage.cacheRead,
+                    cache_write_tokens: usage.cacheWrite,
                     model,
                     latency_ms: latencyMs,
                     stream: true,
@@ -409,16 +364,16 @@ async function handleSendMessage(req, res, entityId) {
             }
             // 8. Inference log (fire-and-forget)
             if (inferenceLog) {
-                logInference(pool, pgSettings, inferenceLog, {
+                logInference(ctx, inferenceLog, {
                     entityId,
                     actorId: userId,
                     model,
                     provider: 'ollama',
                     service: 'llm',
                     operation: 'chat',
-                    inputTokens,
-                    outputTokens,
-                    totalTokens,
+                    inputTokens: usage.input,
+                    outputTokens: usage.output,
+                    totalTokens: usage.totalTokens,
                     latencyMs,
                     status: 'ok',
                 }).catch(() => { });
@@ -433,34 +388,56 @@ async function handleSendMessage(req, res, entityId) {
         }
     }
     else {
-        // ── Non-streaming (batch) ──────────────────────────────────────────
-        const result = await callWithUsage(ollama.client, {
-            model,
-            messages: llmMessages,
-            stream: false,
+        // ── Non-streaming (batch) via OllamaAdapter ─────────────────────────
+        const systemMsg = llmMessages.find(m => m.role === 'system');
+        const nonSystem = llmMessages.filter(m => m.role !== 'system');
+        const modelDesc = ollama.adapter.createModel(model, {
+            maxOutputTokens: undefined,
+        });
+        const context = {
+            systemPrompt: systemMsg?.content,
+            messages: nonSystem.map((m) => ({
+                role: m.role,
+                content: m.content,
+                timestamp: Date.now(),
+            })),
+        };
+        const stream = ollama.adapter.stream(modelDesc, context, {
             temperature: body.temperature,
         });
+        const result = await stream.result();
+        const content = result.content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('');
         const latencyMs = Date.now() - startTime;
-        const inputTokens = result.usage.input;
-        const outputTokens = result.usage.output;
-        const totalTokens = result.usage.totalTokens;
+        const 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,
+        };
         // Persist assistant message with model
-        await withRlsClient(pool, pgSettings, async (client) => {
+        await ctx.withPgClient(async (client) => {
             await client.query(`INSERT INTO "${msgTable.schemaName}"."${msgTable.tableName}"
          (thread_id, owner_id, entity_id, author_role, parts, model)
          VALUES ($1, $2, (SELECT entity_id FROM "${thread.schemaName}"."${thread.tableName}" WHERE id = $1), $3, $4, $5)`, [
                 threadId,
                 userId,
                 'assistant',
-                JSON.stringify([{ type: 'text', text: result.content }]),
+                JSON.stringify([{ type: 'text', text: content }]),
                 model,
             ]);
         });
         // Record billing usage
-        if (billing && totalTokens > 0) {
-            recordUsage(pool, pgSettings, billing, entityId, meterSlug, totalTokens, {
-                input_tokens: inputTokens,
-                output_tokens: outputTokens,
+        if (billing && usage.totalTokens > 0) {
+            recordUsage(ctx, billing, entityId, meterSlug, usage.totalTokens, {
+                input_tokens: usage.input,
+                output_tokens: usage.output,
+                cache_read_tokens: usage.cacheRead,
+                cache_write_tokens: usage.cacheWrite,
                 model,
                 latency_ms: latencyMs,
                 stream: false,
@@ -468,16 +445,16 @@ async function handleSendMessage(req, res, entityId) {
         }
         // Inference log
         if (inferenceLog) {
-            logInference(pool, pgSettings, inferenceLog, {
+            logInference(ctx, inferenceLog, {
                 entityId,
                 actorId: userId,
                 model,
                 provider: 'ollama',
                 service: 'llm',
                 operation: 'chat',
-                inputTokens,
-                outputTokens,
-                totalTokens,
+                inputTokens: usage.input,
+                outputTokens: usage.output,
+                totalTokens: usage.totalTokens,
                 latencyMs,
                 status: 'ok',
             }).catch(() => { });
@@ -486,14 +463,14 @@ async function handleSendMessage(req, res, entityId) {
             id: `msg_${Date.now()}`,
             choices: [{
                     index: 0,
-                    message: { role: 'assistant', content: result.content },
+                    message: { role: 'assistant', content },
                     finish_reason: 'stop',
                 }],
             model,
             usage: {
-                prompt_tokens: inputTokens,
-                completion_tokens: outputTokens,
-                total_tokens: totalTokens,
+                prompt_tokens: usage.input,
+                completion_tokens: usage.output,
+                total_tokens: usage.totalTokens,
             },
         });
     }
@@ -528,7 +505,7 @@ export function createLlmApiRouter() {
     // ── Global routes (no entity_id — bills to actor_id from JWT) ────────────
     router.post('/v1/threads', async (req, res) => {
         try {
-            const userId = req.token?.user_id;
+            const userId = req.constructive?.userId;
             if (!userId) {
                 res.status(401).json({ error: 'Authentication required' });
                 return;
@@ -544,7 +521,7 @@ export function createLlmApiRouter() {
     });
     router.post('/v1/threads/:thread_id/messages', async (req, res) => {
         try {
-            const userId = req.token?.user_id;
+            const userId = req.constructive?.userId;
             if (!userId) {
                 res.status(401).json({ error: 'Authentication required' });
                 return;

package/esm/server.js

@@ -28,6 +28,7 @@ import { createCaptchaMiddleware } from './middleware/captcha';
 import { parseCookieValue, SESSION_COOKIE_NAME } from './middleware/cookie';
 import { createUploadAuthenticateMiddleware, uploadRoute } from './middleware/upload';
 import { createLlmApiRouter } from './middleware/llm-api';
+import { createContextMiddleware, requestIdMiddleware } from '@constructive-io/express-context';
 import { startDebugSampler } from './diagnostics/debug-sampler';
 const log = new Logger('server');
 /**
@@ -135,10 +136,12 @@ class Server {
         app.use('/graphql', multipartBridge);
         app.use(parseDomains());
         app.use(requestIp.mw());
+        app.use(requestIdMiddleware());
         app.use(requestLogger);
         app.use(api);
         app.post('/upload', uploadAuthenticate, ...uploadRoute);
         app.use(authenticate);
+        app.use(createContextMiddleware({ pg: effectiveOpts.pg }));
         app.use(createCaptchaMiddleware());
         // CSRF protection for cookie-authenticated requests
         // Skip CSRF for Bearer token auth (not vulnerable to CSRF) and anonymous requests

package/middleware/llm-api.d.ts

@@ -19,6 +19,9 @@
  *
  * Auth: JWT from the auth middleware (req.token) → pg SET LOCAL context for RLS
  * Metering: check_billing_quota → LLM call → record_usage with real token counts
+ *
+ * Context: Uses `req.constructive` from @constructive-io/express-context
+ * for tenant-scoped database access, pgSettings, and withPgClient.
  */
 import { Router } from 'express';
 export declare function createLlmApiRouter(): Router;

package/middleware/llm-api.js

@@ -20,6 +20,9 @@
  *
  * Auth: JWT from the auth middleware (req.token) → pg SET LOCAL context for RLS
  * Metering: check_billing_quota → LLM call → record_usage with real token counts
+ *
+ * Context: Uses `req.constructive` from @constructive-io/express-context
+ * for tenant-scoped database access, pgSettings, and withPgClient.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -54,95 +57,30 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLlmApiRouter = createLlmApiRouter;
 const express_1 = __importStar(require("express"));
 const logger_1 = require("@pgpmjs/logger");
-const pg_cache_1 = require("pg-cache");
-const ollama_1 = __importDefault(require("@agentic-kit/ollama"));
+const ollama_1 = require("@agentic-kit/ollama");
 const graphile_cache_1 = require("graphile-cache");
 const graphile_llm_1 = require("graphile-llm");
 const log = new logger_1.Logger('llm-api');
-/**
- * Placeholder: replace with actual provider token counts once generateWithUsage() is approved.
- * Estimates ~4 chars per token for English text.
- */
-function placeholderAmountTokens(text) {
-    return Math.ceil(text.length / 4);
-}
-/**
- * Call generate() and estimate token counts from text length.
- * When a provider-native token counting API is approved, swap the
- * estimation logic here without changing call sites.
- */
-async function callWithUsage(client, input, onChunk) {
-    const promptText = input.messages.map((m) => m.content).join(' ');
-    let content;
-    if (onChunk || input.stream) {
-        await client.generate(input, onChunk);
-        content = '';
-    }
-    else {
-        content = await client.generate(input);
-    }
-    const inputTokens = placeholderAmountTokens(promptText);
-    const outputTokens = placeholderAmountTokens(content);
-    return {
-        content,
-        usage: { input: inputTokens, output: outputTokens, totalTokens: inputTokens + outputTokens },
-    };
-}
 // ─── Helpers ────────────────────────────────────────────────────────────────
-function getPgSettings(req) {
-    const settings = {};
-    if (req.token?.user_id) {
-        settings['jwt.claims.user_id'] = req.token.user_id;
-        settings['role'] = 'authenticated';
-    }
-    if (req.databaseId) {
-        settings['jwt.claims.database_id'] = req.databaseId;
-    }
-    if (req.requestId) {
-        settings['request.id'] = req.requestId;
-    }
-    return settings;
-}
-async function withRlsClient(pool, pgSettings, fn) {
-    const client = await pool.connect();
-    try {
-        await client.query('BEGIN');
-        for (const [key, value] of Object.entries(pgSettings)) {
-            await client.query('SELECT set_config($1, $2, true)', [key, value]);
-        }
-        const result = await fn(client);
-        await client.query('COMMIT');
-        return result;
-    }
-    catch (err) {
-        await client.query('ROLLBACK').catch(() => { });
-        throw err;
-    }
-    finally {
-        client.release();
-    }
-}
-function resolveOllamaClient() {
+function resolveOllamaAdapter() {
     const { chat } = (0, graphile_llm_1.getLlmEnvOptions)();
     if (chat.provider === 'ollama') {
         return {
-            client: new ollama_1.default(chat.baseUrl),
+            adapter: new ollama_1.OllamaAdapter(chat.baseUrl),
             model: chat.model,
+            baseUrl: chat.baseUrl,
         };
     }
     return null;
 }
 // ─── Billing Helpers ────────────────────────────────────────────────────────
-async function checkQuota(pool, pgSettings, billing, entityId, meterSlug) {
+async function checkQuota(ctx, billing, entityId, meterSlug) {
     try {
-        return await withRlsClient(pool, pgSettings, async (client) => {
+        return await ctx.withPgClient(async (client) => {
             const sql = `SELECT "${billing.privateSchema}"."${billing.checkBillingQuotaFunction}"($1, $2::uuid, $3) AS allowed`;
             const result = await client.query(sql, [meterSlug, entityId, 1]);
             return result.rows[0]?.allowed !== false;
@@ -154,9 +92,9 @@ async function checkQuota(pool, pgSettings, billing, entityId, meterSlug) {
         return true;
     }
 }
-async function recordUsage(pool, pgSettings, billing, entityId, meterSlug, amount, metadata) {
+async function recordUsage(ctx, billing, entityId, meterSlug, amount, metadata) {
     try {
-        await withRlsClient(pool, pgSettings, async (client) => {
+        await ctx.withPgClient(async (client) => {
             const sql = `SELECT "${billing.privateSchema}"."${billing.recordUsageFunction}"($1, $2::uuid, $3, $4::jsonb)`;
             await client.query(sql, [meterSlug, entityId, amount, JSON.stringify(metadata)]);
         });
@@ -166,11 +104,13 @@ async function recordUsage(pool, pgSettings, billing, entityId, meterSlug, amoun
         log.warn(`[llm-api] record_usage failed (non-fatal): ${message}`);
     }
 }
-async function resolveBilling(pool, pgSettings, databaseId) {
+async function resolveBilling(ctx) {
+    if (!ctx.databaseId)
+        return null;
     try {
         let billing = null;
-        await withRlsClient(pool, pgSettings, async (client) => {
-            const entry = await (0, graphile_llm_1.getLlmBillingConfig)(client, databaseId);
+        await ctx.withPgClient(async (client) => {
+            const entry = await (0, graphile_llm_1.getLlmBillingConfig)(client, ctx.databaseId);
             billing = entry.billing;
         });
         return billing;
@@ -209,9 +149,9 @@ async function getInferenceLogInfo(pool, dbname) {
     inferenceLogCache.set(dbname, info);
     return info;
 }
-async function logInference(pool, pgSettings, logInfo, data) {
+async function logInference(ctx, logInfo, data) {
     try {
-        await withRlsClient(pool, pgSettings, async (client) => {
+        await ctx.withPgClient(async (client) => {
             await client.query(`INSERT INTO "${logInfo.schemaName}"."${logInfo.tableName}"
          (entity_id, actor_id, model, provider, service, operation, input_tokens, output_tokens, total_tokens, latency_ms, status)
          VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, [
@@ -236,31 +176,29 @@ async function logInference(pool, pgSettings, logInfo, data) {
 }
 // ─── Route Handlers ─────────────────────────────────────────────────────────
 async function handleCreateThread(req, res, entityId) {
-    if (!req.token?.user_id) {
+    const ctx = req.constructive;
+    if (!ctx?.userId) {
         res.status(401).json({ error: 'Authentication required' });
         return;
     }
-    const dbname = req.api?.dbname;
-    if (!dbname) {
+    if (!ctx.api.dbname) {
         res.status(400).json({ error: 'Database not resolved' });
         return;
     }
-    const pool = (0, pg_cache_1.getPgPool)({ database: dbname });
-    const discovery = await (0, graphile_llm_1.getAgentDiscovery)(pool, dbname);
+    const discovery = await (0, graphile_llm_1.getAgentDiscovery)(ctx.pool, ctx.api.dbname);
     if (!discovery?.thread) {
         res.status(404).json({ error: 'Agent module not provisioned for this database' });
         return;
     }
     const body = req.body || {};
     const { thread } = discovery;
-    const pgSettings = getPgSettings(req);
-    const result = await withRlsClient(pool, pgSettings, async (client) => {
+    const result = await ctx.withPgClient(async (client) => {
         const { rows } = await client.query(`INSERT INTO "${thread.schemaName}"."${thread.tableName}"
        (entity_id, owner_id, mode, model, system_prompt, title)
        VALUES ($1, $2, $3, $4, $5, $6)
        RETURNING id, mode, model, system_prompt, status, created_at`, [
             entityId,
-            req.token.user_id,
+            ctx.userId,
             body.mode ?? 'ask',
             body.model ?? null,
             body.system_prompt ?? null,
@@ -278,17 +216,16 @@ async function handleCreateThread(req, res, entityId) {
     });
 }
 async function handleSendMessage(req, res, entityId) {
-    if (!req.token?.user_id) {
+    const ctx = req.constructive;
+    if (!ctx?.userId) {
         res.status(401).json({ error: 'Authentication required' });
         return;
     }
-    const dbname = req.api?.dbname;
-    if (!dbname) {
+    if (!ctx.api.dbname) {
         res.status(400).json({ error: 'Database not resolved' });
         return;
     }
-    const pool = (0, pg_cache_1.getPgPool)({ database: dbname });
-    const discovery = await (0, graphile_llm_1.getAgentDiscovery)(pool, dbname);
+    const discovery = await (0, graphile_llm_1.getAgentDiscovery)(ctx.pool, ctx.api.dbname);
     if (!discovery?.thread || !discovery?.message) {
         res.status(404).json({ error: 'Agent module not provisioned for this database' });
         return;
@@ -299,12 +236,10 @@ async function handleSendMessage(req, res, entityId) {
         return;
     }
     const { thread, message: msgTable } = discovery;
-    const pgSettings = getPgSettings(req);
     const threadId = req.params.thread_id;
-    const userId = req.token.user_id;
-    const databaseId = req.databaseId;
+    const userId = ctx.userId;
     // 1. Verify thread exists and user owns it (RLS enforced)
-    const threadRow = await withRlsClient(pool, pgSettings, async (client) => {
+    const threadRow = await ctx.withPgClient(async (client) => {
         const { rows } = await client.query(`SELECT id, mode, model, system_prompt, status
        FROM "${thread.schemaName}"."${thread.tableName}"
        WHERE id = $1`, [threadId]);
@@ -315,11 +250,9 @@ async function handleSendMessage(req, res, entityId) {
         return;
     }
     // 2. Resolve billing config + inference log discovery
-    const billing = databaseId
-        ? await resolveBilling(pool, pgSettings, databaseId)
-        : null;
-    const inferenceLog = await getInferenceLogInfo(pool, dbname);
-    const ollama = resolveOllamaClient();
+    const billing = await resolveBilling(ctx);
+    const inferenceLog = await getInferenceLogInfo(ctx.pool, ctx.api.dbname);
+    const ollama = resolveOllamaAdapter();
     if (!ollama) {
         res.status(503).json({ error: 'No LLM provider configured' });
         return;
@@ -327,7 +260,7 @@ async function handleSendMessage(req, res, entityId) {
     const model = body.model ?? threadRow.model ?? ollama.model;
     const meterSlug = model;
     if (billing) {
-        const allowed = await checkQuota(pool, pgSettings, billing, entityId, meterSlug);
+        const allowed = await checkQuota(ctx, billing, entityId, meterSlug);
         if (!allowed) {
             res.status(429).json({
                 error: 'Token quota exceeded',
@@ -338,7 +271,7 @@ async function handleSendMessage(req, res, entityId) {
         }
     }
     // 3. Persist user message(s)
-    await withRlsClient(pool, pgSettings, async (client) => {
+    await ctx.withPgClient(async (client) => {
         for (const msg of body.messages) {
             if (msg.role === 'user') {
                 await client.query(`INSERT INTO "${msgTable.schemaName}"."${msgTable.tableName}"
@@ -353,7 +286,7 @@ async function handleSendMessage(req, res, entityId) {
         }
     });
     // 4. Load full thread history for context
-    const history = await withRlsClient(pool, pgSettings, async (client) => {
+    const history = await ctx.withPgClient(async (client) => {
         const { rows } = await client.query(`SELECT author_role, parts, created_at
        FROM "${msgTable.schemaName}"."${msgTable.tableName}"
        WHERE thread_id = $1
@@ -382,7 +315,7 @@ async function handleSendMessage(req, res, entityId) {
     const shouldStream = body.stream !== false;
     const startTime = Date.now();
     if (shouldStream) {
-        // ── SSE Streaming ──────────────────────────────────────────────────
+        // ── SSE Streaming via OllamaAdapter ─────────────────────────────────
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
             'Cache-Control': 'no-cache',
@@ -391,38 +324,55 @@ async function handleSendMessage(req, res, entityId) {
         });
         const messageId = `msg_${Date.now()}`;
         try {
-            let streamedContent = '';
-            const result = await callWithUsage(ollama.client, {
-                model,
-                messages: llmMessages,
-                stream: true,
+            const systemMsg = llmMessages.find(m => m.role === 'system');
+            const nonSystem = llmMessages.filter(m => m.role !== 'system');
+            const modelDesc = ollama.adapter.createModel(model, {
+                maxOutputTokens: undefined,
+            });
+            const context = {
+                systemPrompt: systemMsg?.content,
+                messages: nonSystem.map((m) => ({
+                    role: m.role,
+                    content: m.content,
+                    timestamp: Date.now(),
+                })),
+            };
+            const stream = ollama.adapter.stream(modelDesc, context, {
                 temperature: body.temperature,
-            }, (chunk) => {
-                streamedContent += chunk;
-                const event = {
-                    id: messageId,
-                    choices: [{
-                            index: 0,
-                            delta: { content: chunk, role: 'assistant' },
-                            finish_reason: null,
-                        }],
-                    model,
-                };
-                res.write(`data: ${JSON.stringify(event)}\n\n`);
             });
-            // Streaming generate() returns void; use accumulated chunks
+            let streamedContent = '';
+            for await (const event of stream) {
+                if (event.type === 'text_delta') {
+                    streamedContent += event.delta;
+                    const sseEvent = {
+                        id: messageId,
+                        choices: [{
+                                index: 0,
+                                delta: { content: event.delta, role: 'assistant' },
+                                finish_reason: null,
+                            }],
+                        model,
+                    };
+                    res.write(`data: ${JSON.stringify(sseEvent)}\n\n`);
+                }
+            }
+            const result = await stream.result();
             const content = streamedContent;
-            const promptText = llmMessages.map(m => m.content).join(' ');
             const latencyMs = Date.now() - startTime;
-            const inputTokens = placeholderAmountTokens(promptText);
-            const outputTokens = placeholderAmountTokens(content);
-            const totalTokens = inputTokens + outputTokens;
+            const 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,
+            };
             // Send [DONE] marker
             res.write('data: [DONE]\n\n');
             res.end();
             // 6. Persist assistant message with model (fire-and-forget)
             if (content) {
-                withRlsClient(pool, pgSettings, async (client) => {
+                ctx.withPgClient(async (client) => {
                     await client.query(`INSERT INTO "${msgTable.schemaName}"."${msgTable.tableName}"
              (thread_id, owner_id, entity_id, author_role, parts, model)
              VALUES ($1, $2, (SELECT entity_id FROM "${thread.schemaName}"."${thread.tableName}" WHERE id = $1), $3, $4, $5)`, [
@@ -437,10 +387,12 @@ async function handleSendMessage(req, res, entityId) {
                 });
             }
             // 7. Record billing usage (fire-and-forget)
-            if (billing && totalTokens > 0) {
-                recordUsage(pool, pgSettings, billing, entityId, meterSlug, totalTokens, {
-                    input_tokens: inputTokens,
-                    output_tokens: outputTokens,
+            if (billing && usage.totalTokens > 0) {
+                recordUsage(ctx, billing, entityId, meterSlug, usage.totalTokens, {
+                    input_tokens: usage.input,
+                    output_tokens: usage.output,
+                    cache_read_tokens: usage.cacheRead,
+                    cache_write_tokens: usage.cacheWrite,
                     model,
                     latency_ms: latencyMs,
                     stream: true,
@@ -448,16 +400,16 @@ async function handleSendMessage(req, res, entityId) {
             }
             // 8. Inference log (fire-and-forget)
             if (inferenceLog) {
-                logInference(pool, pgSettings, inferenceLog, {
+                logInference(ctx, inferenceLog, {
                     entityId,
                     actorId: userId,
                     model,
                     provider: 'ollama',
                     service: 'llm',
                     operation: 'chat',
-                    inputTokens,
-                    outputTokens,
-                    totalTokens,
+                    inputTokens: usage.input,
+                    outputTokens: usage.output,
+                    totalTokens: usage.totalTokens,
                     latencyMs,
                     status: 'ok',
                 }).catch(() => { });
@@ -472,34 +424,56 @@ async function handleSendMessage(req, res, entityId) {
         }
     }
     else {
-        // ── Non-streaming (batch) ──────────────────────────────────────────
-        const result = await callWithUsage(ollama.client, {
-            model,
-            messages: llmMessages,
-            stream: false,
+        // ── Non-streaming (batch) via OllamaAdapter ─────────────────────────
+        const systemMsg = llmMessages.find(m => m.role === 'system');
+        const nonSystem = llmMessages.filter(m => m.role !== 'system');
+        const modelDesc = ollama.adapter.createModel(model, {
+            maxOutputTokens: undefined,
+        });
+        const context = {
+            systemPrompt: systemMsg?.content,
+            messages: nonSystem.map((m) => ({
+                role: m.role,
+                content: m.content,
+                timestamp: Date.now(),
+            })),
+        };
+        const stream = ollama.adapter.stream(modelDesc, context, {
             temperature: body.temperature,
         });
+        const result = await stream.result();
+        const content = result.content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('');
         const latencyMs = Date.now() - startTime;
-        const inputTokens = result.usage.input;
-        const outputTokens = result.usage.output;
-        const totalTokens = result.usage.totalTokens;
+        const 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,
+        };
         // Persist assistant message with model
-        await withRlsClient(pool, pgSettings, async (client) => {
+        await ctx.withPgClient(async (client) => {
             await client.query(`INSERT INTO "${msgTable.schemaName}"."${msgTable.tableName}"
          (thread_id, owner_id, entity_id, author_role, parts, model)
          VALUES ($1, $2, (SELECT entity_id FROM "${thread.schemaName}"."${thread.tableName}" WHERE id = $1), $3, $4, $5)`, [
                 threadId,
                 userId,
                 'assistant',
-                JSON.stringify([{ type: 'text', text: result.content }]),
+                JSON.stringify([{ type: 'text', text: content }]),
                 model,
             ]);
         });
         // Record billing usage
-        if (billing && totalTokens > 0) {
-            recordUsage(pool, pgSettings, billing, entityId, meterSlug, totalTokens, {
-                input_tokens: inputTokens,
-                output_tokens: outputTokens,
+        if (billing && usage.totalTokens > 0) {
+            recordUsage(ctx, billing, entityId, meterSlug, usage.totalTokens, {
+                input_tokens: usage.input,
+                output_tokens: usage.output,
+                cache_read_tokens: usage.cacheRead,
+                cache_write_tokens: usage.cacheWrite,
                 model,
                 latency_ms: latencyMs,
                 stream: false,
@@ -507,16 +481,16 @@ async function handleSendMessage(req, res, entityId) {
         }
         // Inference log
         if (inferenceLog) {
-            logInference(pool, pgSettings, inferenceLog, {
+            logInference(ctx, inferenceLog, {
                 entityId,
                 actorId: userId,
                 model,
                 provider: 'ollama',
                 service: 'llm',
                 operation: 'chat',
-                inputTokens,
-                outputTokens,
-                totalTokens,
+                inputTokens: usage.input,
+                outputTokens: usage.output,
+                totalTokens: usage.totalTokens,
                 latencyMs,
                 status: 'ok',
             }).catch(() => { });
@@ -525,14 +499,14 @@ async function handleSendMessage(req, res, entityId) {
             id: `msg_${Date.now()}`,
             choices: [{
                     index: 0,
-                    message: { role: 'assistant', content: result.content },
+                    message: { role: 'assistant', content },
                     finish_reason: 'stop',
                 }],
             model,
             usage: {
-                prompt_tokens: inputTokens,
-                completion_tokens: outputTokens,
-                total_tokens: totalTokens,
+                prompt_tokens: usage.input,
+                completion_tokens: usage.output,
+                total_tokens: usage.totalTokens,
             },
         });
     }
@@ -567,7 +541,7 @@ function createLlmApiRouter() {
     // ── Global routes (no entity_id — bills to actor_id from JWT) ────────────
     router.post('/v1/threads', async (req, res) => {
         try {
-            const userId = req.token?.user_id;
+            const userId = req.constructive?.userId;
             if (!userId) {
                 res.status(401).json({ error: 'Authentication required' });
                 return;
@@ -583,7 +557,7 @@ function createLlmApiRouter() {
     });
     router.post('/v1/threads/:thread_id/messages', async (req, res) => {
         try {
-            const userId = req.token?.user_id;
+            const userId = req.constructive?.userId;
             if (!userId) {
                 res.status(401).json({ error: 'Authentication required' });
                 return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-server",
-  "version": "4.32.0",
+  "version": "4.34.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "Constructive GraphQL Server",
   "main": "index.js",
@@ -41,18 +41,19 @@
     "backend"
   ],
   "dependencies": {
-    "@agentic-kit/ollama": "^1.2.1",
+    "@agentic-kit/ollama": "^2.0.0",
     "@constructive-io/csrf": "^0.14.0",
-    "@constructive-io/graphql-env": "^3.11.1",
-    "@constructive-io/graphql-types": "^3.10.1",
+    "@constructive-io/express-context": "^0.2.0",
+    "@constructive-io/graphql-env": "^3.12.0",
+    "@constructive-io/graphql-types": "^3.11.0",
     "@constructive-io/s3-utils": "^2.17.1",
     "@constructive-io/upload-names": "^2.16.0",
     "@constructive-io/url-domains": "^2.16.0",
     "@graphile-contrib/pg-many-to-many": "2.0.0-rc.2",
-    "@pgpmjs/env": "^2.23.0",
+    "@pgpmjs/env": "^2.24.0",
     "@pgpmjs/logger": "^2.11.0",
-    "@pgpmjs/server-utils": "^3.11.0",
-    "@pgpmjs/types": "^2.27.0",
+    "@pgpmjs/server-utils": "^3.12.0",
+    "@pgpmjs/types": "^2.28.0",
     "@pgsql/quotes": "^17.1.0",
     "cors": "^2.8.6",
     "deepmerge": "^4.3.1",
@@ -62,19 +63,19 @@
     "grafserv": "1.0.0",
     "graphile-build": "5.0.2",
     "graphile-build-pg": "5.0.2",
-    "graphile-cache": "^3.11.2",
+    "graphile-cache": "^3.12.0",
     "graphile-config": "1.0.1",
-    "graphile-llm": "^0.8.0",
-    "graphile-settings": "^5.2.4",
+    "graphile-llm": "^0.10.0",
+    "graphile-settings": "^5.3.0",
     "graphile-utils": "5.0.1",
     "graphql": "16.13.0",
     "graphql-upload": "^13.0.0",
     "lru-cache": "^11.2.7",
     "multer": "^2.1.1",
     "pg": "^8.21.0",
-    "pg-cache": "^3.10.1",
-    "pg-env": "^1.14.0",
-    "pg-query-context": "^2.15.1",
+    "pg-cache": "^3.11.0",
+    "pg-env": "^1.15.0",
+    "pg-query-context": "^2.16.0",
     "pg-sql2": "5.0.1",
     "postgraphile": "5.0.3",
     "request-ip": "^3.3.0"
@@ -89,10 +90,10 @@
     "@types/pg": "^8.20.0",
     "@types/request-ip": "^0.0.41",
     "cookie-parser": "^1.4.7",
-    "graphile-test": "4.15.3",
+    "graphile-test": "4.16.0",
     "makage": "^0.3.0",
     "nodemon": "^3.1.14",
     "ts-node": "^10.9.2"
   },
-  "gitHead": "030e1144acbd4e288ee74eff2ac0021ca0382ef7"
+  "gitHead": "c0d04574f7719d92e67becb58d60791ae978c5f5"
 }

package/server.js

@@ -34,6 +34,7 @@ const captcha_1 = require("./middleware/captcha");
 const cookie_1 = require("./middleware/cookie");
 const upload_1 = require("./middleware/upload");
 const llm_api_1 = require("./middleware/llm-api");
+const express_context_1 = require("@constructive-io/express-context");
 const debug_sampler_1 = require("./diagnostics/debug-sampler");
 const log = new logger_1.Logger('server');
 /**
@@ -142,10 +143,12 @@ class Server {
         app.use('/graphql', multipart_bridge_1.multipartBridge);
         app.use((0, url_domains_1.middleware)());
         app.use(request_ip_1.default.mw());
+        app.use((0, express_context_1.requestIdMiddleware)());
         app.use(requestLogger);
         app.use(api);
         app.post('/upload', uploadAuthenticate, ...upload_1.uploadRoute);
         app.use(authenticate);
+        app.use((0, express_context_1.createContextMiddleware)({ pg: effectiveOpts.pg }));
         app.use((0, captcha_1.createCaptchaMiddleware)());
         // CSRF protection for cookie-authenticated requests
         // Skip CSRF for Bearer token auth (not vulnerable to CSRF) and anonymous requests