agentic-server 0.21.1 → 0.22.0

package/esm/router.js

@@ -1,486 +1,263 @@
 /**
- * router — Express router for the agentic-server
+ * Express router — OpenAI-compatible LLM proxy with multi-provider routing.
  *
- * Provides REST endpoints for AI agent conversations:
- *
- *   POST /v1/threads                             → create thread
- *   POST /v1/threads/:thread_id/messages         → send message + stream response
- *   POST /v1/orgs/:entity_id/threads             → create thread (entity-scoped)
- *   POST /v1/orgs/:entity_id/threads/:thread_id/messages → send message (entity-scoped)
- *   POST /v1/embed                               → generate embedding
- *
- * All routes require `req.constructive` (from @constructive-io/express-context).
- * Billing (check_quota + record_usage) and inference logging are automatic
- * when the billing/inference_log modules are provisioned.
- *
- * LLM provider config is resolved per-database via `ctx.useLlm()` from the
- * llm_module table, falling back to env vars (EMBEDDER_*, CHAT_*) when the
- * module is not provisioned.
+ * Supports:
+ *   - Multiple providers (OpenAI, Anthropic, Ollama) configured at startup
+ *   - Model-based routing: "anthropic/claude-3.5-sonnet" → anthropic provider
+ *   - Header-based routing: X-LLM-Provider: ollama → ollama provider
+ *   - Fire-and-forget inference metering via an injected InferenceSink
+ *   - /v1/usage reporting endpoint for external usage submission
  */
-import { OllamaAdapter } from '@agentic-kit/ollama';
 import { Logger } from '@pgpmjs/logger';
-import express, { Router } from 'express';
-import { getEnvOptions as getLlmEnvOptions } from '@constructive-io/llm-env';
+import { Router } from 'express';
+import { buildProviderHeaders, resolveProvider, resolveUpstreamUrl } from './providers';
+import { transformChatRequest, transformChatResponse, transformEmbedRequest, transformEmbedResponse } from './transforms';
 const log = new Logger('agentic-server');
-function resolveChatAdapter(llm) {
-    const provider = llm?.chatProvider ?? getLlmEnvOptions().chat.provider;
-    const model = llm?.chatModel ?? getLlmEnvOptions().chat.model;
-    const baseUrl = llm?.chatBaseUrl ?? getLlmEnvOptions().chat.baseUrl;
-    if (provider === 'ollama') {
-        return { adapter: new OllamaAdapter(baseUrl), model, baseUrl, provider };
-    }
-    return null;
-}
-function resolveEmbeddingAdapter(llm) {
-    const provider = llm?.embeddingProvider ?? getLlmEnvOptions().embedding.provider;
-    const model = llm?.embeddingModel ?? getLlmEnvOptions().embedding.model;
-    const baseUrl = llm?.embeddingBaseUrl ?? getLlmEnvOptions().embedding.baseUrl;
-    if (provider === 'ollama') {
-        return { adapter: new OllamaAdapter(baseUrl), model, provider };
-    }
-    return null;
-}
-// ─── Route Handlers ─────────────────────────────────────────────────────────
-async function handleCreateThread(req, res, entityId) {
-    const ctx = req.constructive;
-    if (!ctx?.userId) {
-        res.status(401).json({ error: 'Authentication required' });
-        return;
-    }
-    const agentChat = await ctx.useModule('agentChat');
-    if (!agentChat?.threadTableName) {
-        res.status(404).json({ error: 'Agent module not provisioned for this database' });
-        return;
-    }
-    const body = req.body || {};
-    const { schemaName, threadTableName } = agentChat;
-    const result = await ctx.withPgClient(async (client) => {
-        const { rows } = await client.query(`INSERT INTO "${schemaName}"."${threadTableName}"
-       (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,
-            ctx.userId,
-            body.mode ?? 'ask',
-            body.model ?? null,
-            body.system_prompt ?? null,
-            body.title ?? null
-        ]);
-        return rows[0];
-    });
-    res.status(201).json({
-        id: result.id,
-        mode: result.mode,
-        model: result.model,
-        system_prompt: result.system_prompt,
-        status: result.status,
-        created_at: result.created_at
-    });
-}
-async function handleSendMessage(req, res, entityId) {
-    const ctx = req.constructive;
-    if (!ctx?.userId) {
-        res.status(401).json({ error: 'Authentication required' });
-        return;
-    }
-    const agentChat = await ctx.useModule('agentChat');
-    if (!agentChat?.threadTableName || !agentChat?.messageTableName) {
-        res.status(404).json({ error: 'Agent module not provisioned for this database' });
-        return;
-    }
-    const body = req.body || {};
-    if (!body.messages?.length) {
-        res.status(400).json({ error: 'messages[] is required and must not be empty' });
-        return;
-    }
-    const { schemaName, threadTableName, messageTableName } = agentChat;
-    const threadId = req.params.thread_id;
-    const userId = ctx.userId;
-    // Verify thread exists (RLS enforced)
-    const threadRow = await ctx.withPgClient(async (client) => {
-        const { rows } = await client.query(`SELECT id, mode, model, system_prompt, status
-       FROM "${schemaName}"."${threadTableName}"
-       WHERE id = $1`, [threadId]);
-        return rows[0];
-    });
-    if (!threadRow) {
-        res.status(404).json({ error: 'Thread not found' });
-        return;
-    }
-    // Resolve shared billing client and LLM config (lazy, cached per request)
-    const [billing, llm] = await Promise.all([ctx.useBilling(), ctx.useLlm()]);
-    const chatAdapter = resolveChatAdapter(llm);
-    if (!chatAdapter) {
-        res.status(503).json({ error: 'No LLM provider configured' });
-        return;
-    }
-    const model = body.model ?? threadRow.model ?? chatAdapter.model;
-    const meterSlug = model;
-    // Quota check
-    if (billing) {
-        const allowed = await billing.checkQuota(meterSlug);
-        if (!allowed) {
-            res.status(429).json({
-                error: 'Token quota exceeded',
-                meter: meterSlug,
-                entity_id: entityId
-            });
+export const createRouter = (options) => {
+    const router = Router();
+    // Metering is backend-agnostic: the caller injects an InferenceSink. When
+    // none is provided, no usage is recorded.
+    const sink = options.inferenceSink;
+    // POST /v1/chat/completions — multi-provider LLM proxy
+    router.post('/v1/chat/completions', async (req, res) => {
+        const databaseId = req.get('X-Database-Id');
+        if (!databaseId) {
+            res.status(400).json({ error: { message: 'X-Database-Id is required' } });
             return;
         }
-    }
-    // Persist user messages
-    await ctx.withPgClient(async (client) => {
-        for (const msg of body.messages) {
-            if (msg.role === 'user') {
-                await client.query(`INSERT INTO "${schemaName}"."${messageTableName}"
-           (thread_id, owner_id, entity_id, author_role, parts)
-           VALUES ($1, $2, (SELECT entity_id FROM "${schemaName}"."${threadTableName}" WHERE id = $1), $3, $4)`, [threadId, userId, 'user', JSON.stringify([{ type: 'text', text: msg.content }])]);
-            }
-        }
-    });
-    // Load full thread history
-    const history = await ctx.withPgClient(async (client) => {
-        const { rows } = await client.query(`SELECT author_role, parts, created_at
-       FROM "${schemaName}"."${messageTableName}"
-       WHERE thread_id = $1
-       ORDER BY created_at ASC`, [threadId]);
-        return rows;
-    });
-    const llmMessages = [];
-    if (threadRow.system_prompt) {
-        llmMessages.push({ role: 'system', content: threadRow.system_prompt });
-    }
-    for (const row of history) {
-        const parts = Array.isArray(row.parts) ? row.parts : [];
-        const textContent = parts
-            .filter((p) => p.type === 'text')
-            .map((p) => p.text)
-            .join('');
-        if (textContent) {
-            llmMessages.push({
-                role: row.author_role === 'user' ? 'user' : 'assistant',
-                content: textContent
-            });
-        }
-    }
-    const startTime = Date.now();
-    const shouldStream = body.stream !== false;
-    if (shouldStream) {
-        await handleStreamingResponse(req, res, {
-            ctx, chatAdapter, model, llmMessages, body,
-            entityId, userId, threadId,
-            schemaName, threadTableName, messageTableName,
-            billing, startTime, meterSlug
-        });
-    }
-    else {
-        await handleBatchResponse(req, res, {
-            ctx, chatAdapter, model, llmMessages, body,
-            entityId, userId, threadId,
-            schemaName, threadTableName, messageTableName,
-            billing, startTime, meterSlug
-        });
-    }
-}
-async function handleStreamingResponse(_req, res, mc) {
-    const { ctx, chatAdapter, model, llmMessages, body, entityId, userId, threadId, schemaName, threadTableName, messageTableName, billing, startTime, meterSlug } = mc;
-    res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        Connection: 'keep-alive',
-        'X-Accel-Buffering': 'no'
-    });
-    const messageId = `msg_${Date.now()}`;
-    try {
-        const systemMsg = llmMessages.find(m => m.role === 'system');
-        const nonSystem = llmMessages.filter(m => m.role !== 'system');
-        const modelDesc = chatAdapter.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 = chatAdapter.adapter.stream(modelDesc, context, {
-            temperature: body.temperature
+        const entityId = req.get('X-Entity-Id');
+        const actorId = req.get('X-Actor-Id');
+        const requestProvider = req.get('X-LLM-Provider');
+        const startTime = process.hrtime.bigint();
+        const provider = resolveProvider(options, req.body?.model, requestProvider);
+        log.info('chat/completions', {
+            databaseId,
+            entityId,
+            provider: provider.type,
+            model: req.body?.model
         });
-        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`);
+        try {
+            const upstreamUrl = resolveUpstreamUrl(provider, '/v1/chat/completions');
+            const body = transformChatRequest(provider, req.body || {});
+            const headers = buildProviderHeaders(provider);
+            const upstream = await fetch(upstreamUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body)
+            });
+            const latencyMs = Number(process.hrtime.bigint() - startTime) / 1e6;
+            if (!upstream.ok) {
+                const text = await upstream.text().catch(() => '');
+                log.error('upstream error', { status: upstream.status, provider: provider.type, body: text });
+                if (sink) {
+                    sink.logInference({
+                        databaseId, entityId, actorId,
+                        model: String(req.body?.model || body.model || ''),
+                        provider: provider.type,
+                        service: 'chat',
+                        operation: 'chat/completions',
+                        inputTokens: 0, outputTokens: 0, totalTokens: 0,
+                        latencyMs,
+                        status: 'error',
+                        errorType: `upstream_${upstream.status}`
+                    });
+                }
+                res.status(upstream.status).json({
+                    error: { message: `LLM provider error: ${upstream.status}`, upstream: text }
+                });
+                return;
             }
-        }
-        const result = await stream.result();
-        const content = streamedContent;
-        const latencyMs = Date.now() - startTime;
-        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
-        };
-        res.write('data: [DONE]\n\n');
-        res.end();
-        // Persist assistant message (fire-and-forget)
-        if (content) {
-            ctx.withPgClient(async (client) => {
-                await client.query(`INSERT INTO "${schemaName}"."${messageTableName}"
-           (thread_id, owner_id, entity_id, author_role, parts, model)
-           VALUES ($1, $2, (SELECT entity_id FROM "${schemaName}"."${threadTableName}" WHERE id = $1), $3, $4, $5)`, [threadId, userId, 'assistant', JSON.stringify([{ type: 'text', text: content }]), model]);
-            }).catch((err) => log.error('Failed to persist assistant message:', err));
-        }
-        // Record billing usage + inference log (fire-and-forget)
-        if (billing && usage.totalTokens > 0) {
-            billing.recordUsage(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
-            }).catch(() => { });
-            billing.logInference({
-                entityId, actorId: userId, model, provider: chatAdapter.provider,
-                service: 'llm', operation: 'chat',
-                inputTokens: usage.input, outputTokens: usage.output,
-                totalTokens: usage.totalTokens, latencyMs, status: 'ok'
-            }).catch(() => { });
-        }
-    }
-    catch (streamErr) {
-        log.error('Streaming error:', streamErr);
-        const errorEvent = { error: { message: streamErr.message, type: 'stream_error' } };
-        res.write(`data: ${JSON.stringify(errorEvent)}\n\n`);
-        res.write('data: [DONE]\n\n');
-        res.end();
-    }
-}
-async function handleBatchResponse(_req, res, mc) {
-    const { ctx, chatAdapter, model, llmMessages, body, entityId, userId, threadId, schemaName, threadTableName, messageTableName, billing, startTime, meterSlug } = mc;
-    const systemMsg = llmMessages.find(m => m.role === 'system');
-    const nonSystem = llmMessages.filter(m => m.role !== 'system');
-    const modelDesc = chatAdapter.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 = chatAdapter.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 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
-    await ctx.withPgClient(async (client) => {
-        await client.query(`INSERT INTO "${schemaName}"."${messageTableName}"
-       (thread_id, owner_id, entity_id, author_role, parts, model)
-       VALUES ($1, $2, (SELECT entity_id FROM "${schemaName}"."${threadTableName}" WHERE id = $1), $3, $4, $5)`, [threadId, userId, 'assistant', JSON.stringify([{ type: 'text', text: content }]), model]);
-    });
-    // Record billing + inference log (fire-and-forget)
-    if (billing && usage.totalTokens > 0) {
-        billing.recordUsage(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
-        }).catch(() => { });
-        billing.logInference({
-            entityId, actorId: userId, model, provider: chatAdapter.provider,
-            service: 'llm', operation: 'chat',
-            inputTokens: usage.input, outputTokens: usage.output,
-            totalTokens: usage.totalTokens, latencyMs, status: 'ok'
-        }).catch(() => { });
-    }
-    res.json({
-        id: `msg_${Date.now()}`,
-        choices: [{
-                index: 0,
-                message: { role: 'assistant', content },
-                finish_reason: 'stop'
-            }],
-        model,
-        usage: {
-            prompt_tokens: usage.input,
-            completion_tokens: usage.output,
-            total_tokens: usage.totalTokens
-        }
-    });
-}
-// ─── Embedding Handler ──────────────────────────────────────────────────────
-async function handleEmbed(req, res) {
-    const ctx = req.constructive;
-    if (!ctx?.userId) {
-        res.status(401).json({ error: 'Authentication required' });
-        return;
-    }
-    const body = req.body || {};
-    if (!body.input) {
-        res.status(400).json({ error: 'input is required' });
-        return;
-    }
-    const llm = await ctx.useLlm();
-    const embedAdapter = resolveEmbeddingAdapter(llm);
-    if (!embedAdapter) {
-        res.status(503).json({ error: 'No embedding provider configured' });
-        return;
-    }
-    const model = body.model ?? embedAdapter.model;
-    const inputs = Array.isArray(body.input) ? body.input : [body.input];
-    // Resolve shared billing client
-    const billing = await ctx.useBilling();
-    // Quota check
-    if (billing) {
-        const allowed = await billing.checkQuota(model);
-        if (!allowed) {
-            res.status(429).json({ error: 'Embedding quota exceeded', meter: model });
-            return;
-        }
-    }
-    const startTime = Date.now();
-    try {
-        const results = await Promise.all(inputs.map((text) => embedAdapter.adapter.embed(text, model)));
-        const latencyMs = Date.now() - startTime;
-        const totalTokens = results.reduce((sum, r) => sum + r.promptTokens, 0);
-        // Record usage + inference log (fire-and-forget)
-        if (billing && totalTokens > 0) {
-            billing.recordUsage(model, totalTokens, {
-                input_tokens: totalTokens,
-                model,
-                latency_ms: latencyMs,
-                batch_size: inputs.length
-            }).catch(() => { });
-            billing.logInference({
-                entityId: ctx.userId,
-                actorId: ctx.userId,
-                model,
-                provider: embedAdapter.provider,
-                service: 'embedding',
-                operation: 'embed',
-                inputTokens: totalTokens,
-                outputTokens: 0,
-                totalTokens,
-                latencyMs,
-                status: 'ok'
-            }).catch(() => { });
-        }
-        res.json({
-            object: 'list',
-            data: results.map((r, i) => ({
-                object: 'embedding',
-                index: i,
-                embedding: r.embedding
-            })),
-            model,
-            usage: {
-                prompt_tokens: totalTokens,
-                total_tokens: totalTokens
+            const data = await upstream.json();
+            const { body: responseBody, usage } = transformChatResponse(data, provider);
+            log.info('inference complete', {
+                databaseId,
+                provider: provider.type,
+                model: req.body?.model,
+                promptTokens: usage.prompt_tokens,
+                completionTokens: usage.completion_tokens
+            });
+            if (sink) {
+                sink.logInference({
+                    databaseId, entityId, actorId,
+                    model: String(req.body?.model || body.model || ''),
+                    provider: provider.type,
+                    service: 'chat',
+                    operation: 'chat/completions',
+                    inputTokens: usage.prompt_tokens || 0,
+                    outputTokens: usage.completion_tokens || 0,
+                    totalTokens: usage.total_tokens || 0,
+                    latencyMs,
+                    status: 'ok',
+                    rawUsage: usage
+                });
             }
-        });
-    }
-    catch (err) {
-        log.error('Embedding error:', err);
-        res.status(500).json({ error: err.message ?? 'Embedding failed' });
-    }
-}
-// ─── Router Factory ─────────────────────────────────────────────────────────
-export function createAgenticRouter() {
-    const router = Router();
-    router.use(express.json());
-    // Entity-scoped routes
-    router.post('/v1/orgs/:entity_id/threads', async (req, res) => {
-        try {
-            await handleCreateThread(req, res, req.params.entity_id);
+            res.json(responseBody);
         }
         catch (err) {
-            log.error('Error creating thread:', err);
-            if (!res.headersSent)
-                res.status(500).json({ error: 'Internal server error' });
+            const latencyMs = Number(process.hrtime.bigint() - startTime) / 1e6;
+            log.error('chat/completions error', err);
+            if (sink) {
+                sink.logInference({
+                    databaseId, entityId, actorId,
+                    model: String(req.body?.model || ''),
+                    provider: provider.type,
+                    service: 'chat',
+                    operation: 'chat/completions',
+                    inputTokens: 0, outputTokens: 0, totalTokens: 0,
+                    latencyMs,
+                    status: 'error',
+                    errorType: err.message
+                });
+            }
+            res.status(502).json({
+                error: { message: 'Failed to reach LLM provider', details: err.message }
+            });
         }
     });
-    router.post('/v1/orgs/:entity_id/threads/:thread_id/messages', async (req, res) => {
-        try {
-            await handleSendMessage(req, res, req.params.entity_id);
-        }
-        catch (err) {
-            log.error('Error in messages endpoint:', err);
-            if (!res.headersSent)
-                res.status(500).json({ error: 'Internal server error' });
+    // POST /v1/embeddings — multi-provider embedding proxy
+    router.post('/v1/embeddings', async (req, res) => {
+        const databaseId = req.get('X-Database-Id');
+        if (!databaseId) {
+            res.status(400).json({ error: { message: 'X-Database-Id is required' } });
+            return;
         }
-    });
-    // Global routes (entity_id = user_id from JWT)
-    router.post('/v1/threads', async (req, res) => {
+        const entityId = req.get('X-Entity-Id');
+        const actorId = req.get('X-Actor-Id');
+        const requestProvider = req.get('X-LLM-Provider');
+        const startTime = process.hrtime.bigint();
+        const provider = resolveProvider(options, req.body?.model, requestProvider);
+        log.info('embeddings', { databaseId, entityId, provider: provider.type, model: req.body?.model });
         try {
-            const userId = req.constructive?.userId;
-            if (!userId) {
-                res.status(401).json({ error: 'Authentication required' });
+            const upstreamUrl = resolveUpstreamUrl(provider, '/v1/embeddings');
+            const body = transformEmbedRequest(provider, req.body || {});
+            const headers = buildProviderHeaders(provider);
+            const upstream = await fetch(upstreamUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body)
+            });
+            const latencyMs = Number(process.hrtime.bigint() - startTime) / 1e6;
+            if (!upstream.ok) {
+                const text = await upstream.text().catch(() => '');
+                log.error('upstream embed error', { status: upstream.status, provider: provider.type });
+                if (sink) {
+                    sink.logInference({
+                        databaseId, entityId, actorId,
+                        model: String(req.body?.model || body.model || ''),
+                        provider: provider.type,
+                        service: 'embed',
+                        operation: 'embeddings',
+                        inputTokens: 0, outputTokens: 0, totalTokens: 0,
+                        latencyMs,
+                        status: 'error',
+                        errorType: `upstream_${upstream.status}`
+                    });
+                }
+                res.status(upstream.status).json({
+                    error: { message: `LLM provider error: ${upstream.status}`, upstream: text }
+                });
                 return;
             }
-            await handleCreateThread(req, res, userId);
-        }
-        catch (err) {
-            log.error('Error creating thread:', err);
-            if (!res.headersSent)
-                res.status(500).json({ error: 'Internal server error' });
-        }
-    });
-    router.post('/v1/threads/:thread_id/messages', async (req, res) => {
-        try {
-            const userId = req.constructive?.userId;
-            if (!userId) {
-                res.status(401).json({ error: 'Authentication required' });
-                return;
+            const data = await upstream.json();
+            const { body: responseBody, usage } = transformEmbedResponse(data, provider);
+            log.info('embed complete', { databaseId, entityId, provider: provider.type });
+            if (sink) {
+                sink.logInference({
+                    databaseId, entityId, actorId,
+                    model: String(req.body?.model || body.model || ''),
+                    provider: provider.type,
+                    service: 'embed',
+                    operation: 'embeddings',
+                    inputTokens: usage.prompt_tokens || 0,
+                    outputTokens: 0,
+                    totalTokens: usage.total_tokens || 0,
+                    latencyMs,
+                    status: 'ok',
+                    rawUsage: usage
+                });
             }
-            await handleSendMessage(req, res, userId);
+            res.json(responseBody);
         }
         catch (err) {
-            log.error('Error in messages endpoint:', err);
-            if (!res.headersSent)
-                res.status(500).json({ error: 'Internal server error' });
+            const latencyMs = Number(process.hrtime.bigint() - startTime) / 1e6;
+            log.error('embeddings error', err);
+            if (sink) {
+                sink.logInference({
+                    databaseId, entityId, actorId,
+                    model: String(req.body?.model || ''),
+                    provider: provider.type,
+                    service: 'embed',
+                    operation: 'embeddings',
+                    inputTokens: 0, outputTokens: 0, totalTokens: 0,
+                    latencyMs,
+                    status: 'error',
+                    errorType: err.message
+                });
+            }
+            res.status(502).json({
+                error: { message: 'Failed to reach LLM provider', details: err.message }
+            });
         }
     });
-    // Embedding endpoint
-    router.post('/v1/embed', async (req, res) => {
-        try {
-            await handleEmbed(req, res);
+    // POST /v1/usage — external usage reporting endpoint
+    router.post('/v1/usage', (req, res) => {
+        const databaseId = req.get('X-Database-Id');
+        if (!databaseId) {
+            res.status(400).json({ error: { message: 'X-Database-Id is required' } });
+            return;
         }
-        catch (err) {
-            log.error('Error in embed endpoint:', err);
-            if (!res.headersSent)
-                res.status(500).json({ error: 'Internal server error' });
+        const entityId = req.get('X-Entity-Id');
+        const actorId = req.get('X-Actor-Id');
+        const { model, provider: reportedProvider, service, operation, input_tokens, output_tokens, total_tokens, latency_ms, status, error_type, raw_usage } = req.body || {};
+        if (!model) {
+            res.status(400).json({ error: { message: 'model is required' } });
+            return;
+        }
+        if (sink) {
+            sink.logInference({
+                databaseId,
+                entityId,
+                actorId,
+                model: String(model),
+                provider: String(reportedProvider || 'unknown'),
+                service: (service === 'embed' ? 'embed' : 'chat'),
+                operation: operation || 'external',
+                inputTokens: Number(input_tokens) || 0,
+                outputTokens: Number(output_tokens) || 0,
+                totalTokens: Number(total_tokens) || 0,
+                latencyMs: Number(latency_ms) || 0,
+                status: status === 'error' ? 'error' : 'ok',
+                errorType: error_type || undefined,
+                rawUsage: raw_usage || undefined
+            });
         }
+        res.status(202).json({ accepted: true });
+    });
+    // GET /v1/providers — list configured providers
+    router.get('/v1/providers', (_req, res) => {
+        const providers = options.providers || [{
+                type: options.providerType || 'ollama',
+                baseUrl: options.providerBaseUrl || 'http://localhost:11434'
+            }];
+        res.json({
+            providers: providers.map((p) => ({
+                type: p.type,
+                defaultModel: p.defaultModel
+            }))
+        });
+    });
+    // GET /healthz — health check
+    router.get('/healthz', (_req, res) => {
+        const providers = options.providers || [{
+                type: options.providerType || 'ollama',
+                baseUrl: options.providerBaseUrl || 'http://localhost:11434'
+            }];
+        res.json({
+            status: 'ok',
+            provider: providers[0]?.type || 'ollama',
+            providerUrl: providers[0]?.baseUrl || options.providerBaseUrl,
+            providers: providers.map((p) => p.type)
+        });
     });
     return router;
-}
+};