agentic-server 0.21.2 → 0.22.0

package/esm/server.js

@@ -0,0 +1,31 @@
+import express from 'express';
+import { createRouter } from './router';
+/** Identity headers trusted only when isPublic === false (private network). */
+const IDENTITY_HEADERS = [
+    'x-database-id',
+    'x-entity-id',
+    'x-actor-id'
+];
+/**
+ * Create a standalone Express app for the agentic server.
+ * Used by both standalone mode and integration tests.
+ */
+export const createAgenticServer = (options) => {
+    const app = express();
+    app.use(express.json());
+    // When isPublic === true, strip identity headers from all incoming requests.
+    // Public deployments cannot trust client-supplied tenant context.
+    // When isPublic === false (default), the server is on a private network
+    // and trusts identity headers directly — same pattern as the GraphQL server
+    // with API_IS_PUBLIC=false.
+    if (options.isPublic) {
+        app.use((req, _res, next) => {
+            for (const header of IDENTITY_HEADERS) {
+                req.headers[header] = undefined;
+            }
+            next();
+        });
+    }
+    app.use(createRouter(options));
+    return app;
+};

package/esm/transforms.js

@@ -0,0 +1,111 @@
+export function transformChatRequest(provider, body) {
+    let model = body.model || provider.defaultModel;
+    if (typeof model === 'string' && model.includes('/')) {
+        const prefix = model.split('/')[0];
+        if (prefix === provider.type) {
+            model = model.split('/').slice(1).join('/');
+        }
+    }
+    if (provider.type === 'ollama') {
+        return {
+            model: model || 'llama3',
+            messages: body.messages,
+            stream: false,
+            ...(body.temperature !== undefined && {
+                options: { temperature: body.temperature }
+            })
+        };
+    }
+    if (provider.type === 'anthropic') {
+        const messages = body.messages;
+        const systemMsg = messages?.find((m) => m.role === 'system');
+        const nonSystem = messages?.filter((m) => m.role !== 'system') || [];
+        return {
+            model: model || 'claude-sonnet-4-20250514',
+            messages: nonSystem,
+            max_tokens: body.max_tokens || 4096,
+            ...(systemMsg && { system: systemMsg.content }),
+            ...(body.temperature !== undefined && { temperature: body.temperature })
+        };
+    }
+    // OpenAI-compatible (default)
+    return { ...body, model: model || 'gpt-4o' };
+}
+export function transformEmbedRequest(provider, body) {
+    const model = body.model || provider.defaultModel;
+    if (provider.type === 'ollama') {
+        return {
+            model: model || 'nomic-embed-text',
+            input: body.input
+        };
+    }
+    return { ...body, model: model || 'text-embedding-3-small' };
+}
+export function transformChatResponse(data, provider) {
+    if (provider.type === 'ollama') {
+        const msg = data.message;
+        const promptTokens = data.prompt_eval_count || 0;
+        const completionTokens = data.eval_count || 0;
+        const usage = {
+            prompt_tokens: promptTokens,
+            completion_tokens: completionTokens,
+            total_tokens: promptTokens + completionTokens
+        };
+        return {
+            body: {
+                id: `chatcmpl-${Date.now()}`,
+                object: 'chat.completion',
+                choices: [{
+                        message: msg || { role: 'assistant', content: '' },
+                        finish_reason: 'stop',
+                        index: 0
+                    }],
+                usage
+            },
+            usage
+        };
+    }
+    if (provider.type === 'anthropic') {
+        const content = data.content;
+        const text = content?.find((c) => c.type === 'text')?.text || '';
+        const inputUsage = data.usage || {};
+        const usage = {
+            prompt_tokens: inputUsage.input_tokens || 0,
+            completion_tokens: inputUsage.output_tokens || 0,
+            total_tokens: (inputUsage.input_tokens || 0) + (inputUsage.output_tokens || 0)
+        };
+        return {
+            body: {
+                id: data.id || `chatcmpl-${Date.now()}`,
+                object: 'chat.completion',
+                choices: [{
+                        message: { role: 'assistant', content: text },
+                        finish_reason: 'stop',
+                        index: 0
+                    }],
+                usage
+            },
+            usage
+        };
+    }
+    // OpenAI — pass through
+    const usage = (data.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 });
+    return { body: data, usage };
+}
+export function transformEmbedResponse(data, provider) {
+    if (provider.type === 'ollama') {
+        const raw = (data.embeddings || data.embedding || []);
+        const embeddings = Array.isArray(raw[0]) ? raw : [raw];
+        const usage = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+        return {
+            body: {
+                object: 'list',
+                data: embeddings.map((emb, i) => ({ object: 'embedding', embedding: emb, index: i })),
+                usage
+            },
+            usage
+        };
+    }
+    const usage = (data.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 });
+    return { body: data, usage };
+}

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/index.d.ts

@@ -1,28 +1,28 @@
 /**
- * agentic-server — Standalone Express LLM service
+ * agentic-server — Standalone OpenAI-compatible LLM gateway
  *
- * Express-only equivalent of graphile-llm: agent threads, chat streaming,
- * billing metering, and inference logging. Uses @constructive-io/express-context
- * for tenant-scoped database access.
- *
- * LLM provider config is resolved per-database via `ctx.useLlm()` (from the
- * llm_module table), falling back to env vars from @constructive-io/llm-env when the module
- * is not provisioned. Discovery and billing are handled by the shared loaders
- * in express-context — no custom caching here.
+ * A stateless multi-provider proxy that:
+ *   1. Accepts OpenAI-compatible requests (`/v1/chat/completions`, `/v1/embeddings`)
+ *   2. Enforces tenant isolation via X-Database-Id / X-Entity-Id / X-Actor-Id headers
+ *   3. Routes to configured LLM provider(s) (OpenAI, Anthropic, Ollama)
+ *   4. Records inference usage through an injected {@link InferenceSink}
+ *      (fire-and-forget) — the gateway is backend-agnostic and never imports a
+ *      concrete metering implementation.
  *
  * @example
  * ```typescript
- * import express from 'express';
- * import { createContextMiddleware } from '@constructive-io/express-context';
- * import { createAgenticRouter } from 'agentic-server';
+ * import { createAgenticServer } from 'agentic-server';
  *
- * const app = express();
- * app.use(createContextMiddleware());
- * app.use(createAgenticRouter());
+ * const app = createAgenticServer({
+ *   providerType: 'ollama',
+ *   providerBaseUrl: 'http://localhost:11434',
+ *   inferenceSink: { logInference: (entry) => myBackend.record(entry) },
+ * });
  * app.listen(3001);
  * ```
  */
-export { createAgenticRouter } from './router';
-export type { BillingClient, InferenceLogEntry, LlmConfig, } from '@constructive-io/express-context';
-export type { LlmEnvOptions, LlmProviderConfig, ResolvedLlmEnvOptions } from '@constructive-io/llm-env';
-export { getEnvVars as getLlmEnvVars, getEnvOptions as getLlmEnvOptions, llmDefaults } from '@constructive-io/llm-env';
+export { buildProviderHeaders, resolveProvider, resolveUpstreamUrl } from './providers';
+export { createRouter } from './router';
+export type { AgenticServerStartOptions } from './server';
+export { createAgenticServer } from './server';
+export type { AgenticServerOptions, InferenceEntry, InferenceSink, ProviderConfig, ResolvedProvider, UsageResult } from './types';

package/index.js

@@ -1,33 +1,34 @@
 "use strict";
 /**
- * agentic-server — Standalone Express LLM service
+ * agentic-server — Standalone OpenAI-compatible LLM gateway
  *
- * Express-only equivalent of graphile-llm: agent threads, chat streaming,
- * billing metering, and inference logging. Uses @constructive-io/express-context
- * for tenant-scoped database access.
- *
- * LLM provider config is resolved per-database via `ctx.useLlm()` (from the
- * llm_module table), falling back to env vars from @constructive-io/llm-env when the module
- * is not provisioned. Discovery and billing are handled by the shared loaders
- * in express-context — no custom caching here.
+ * A stateless multi-provider proxy that:
+ *   1. Accepts OpenAI-compatible requests (`/v1/chat/completions`, `/v1/embeddings`)
+ *   2. Enforces tenant isolation via X-Database-Id / X-Entity-Id / X-Actor-Id headers
+ *   3. Routes to configured LLM provider(s) (OpenAI, Anthropic, Ollama)
+ *   4. Records inference usage through an injected {@link InferenceSink}
+ *      (fire-and-forget) — the gateway is backend-agnostic and never imports a
+ *      concrete metering implementation.
  *
  * @example
  * ```typescript
- * import express from 'express';
- * import { createContextMiddleware } from '@constructive-io/express-context';
- * import { createAgenticRouter } from 'agentic-server';
+ * import { createAgenticServer } from 'agentic-server';
  *
- * const app = express();
- * app.use(createContextMiddleware());
- * app.use(createAgenticRouter());
+ * const app = createAgenticServer({
+ *   providerType: 'ollama',
+ *   providerBaseUrl: 'http://localhost:11434',
+ *   inferenceSink: { logInference: (entry) => myBackend.record(entry) },
+ * });
  * app.listen(3001);
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.llmDefaults = exports.getLlmEnvOptions = exports.getLlmEnvVars = exports.createAgenticRouter = void 0;
+exports.createAgenticServer = exports.createRouter = exports.resolveUpstreamUrl = exports.resolveProvider = exports.buildProviderHeaders = void 0;
+var providers_1 = require("./providers");
+Object.defineProperty(exports, "buildProviderHeaders", { enumerable: true, get: function () { return providers_1.buildProviderHeaders; } });
+Object.defineProperty(exports, "resolveProvider", { enumerable: true, get: function () { return providers_1.resolveProvider; } });
+Object.defineProperty(exports, "resolveUpstreamUrl", { enumerable: true, get: function () { return providers_1.resolveUpstreamUrl; } });
 var router_1 = require("./router");
-Object.defineProperty(exports, "createAgenticRouter", { enumerable: true, get: function () { return router_1.createAgenticRouter; } });
-var llm_env_1 = require("@constructive-io/llm-env");
-Object.defineProperty(exports, "getLlmEnvVars", { enumerable: true, get: function () { return llm_env_1.getEnvVars; } });
-Object.defineProperty(exports, "getLlmEnvOptions", { enumerable: true, get: function () { return llm_env_1.getEnvOptions; } });
-Object.defineProperty(exports, "llmDefaults", { enumerable: true, get: function () { return llm_env_1.llmDefaults; } });
+Object.defineProperty(exports, "createRouter", { enumerable: true, get: function () { return router_1.createRouter; } });
+var server_1 = require("./server");
+Object.defineProperty(exports, "createAgenticServer", { enumerable: true, get: function () { return server_1.createAgenticServer; } });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agentic-server",
-  "version": "0.21.2",
-  "description": "Standalone Express LLM service — agent threads, chat streaming, billing metering, and inference logging via express-context",
+  "version": "0.22.0",
+  "description": "Standalone OpenAI-compatible LLM gateway — multi-provider proxy with pluggable inference metering",
   "main": "index.js",
   "module": "esm/index.js",
   "types": "index.d.ts",
@@ -29,34 +29,27 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@agentic-kit/ollama": "2.12.2",
-    "@constructive-io/express-context": "^0.23.2",
-    "@constructive-io/llm-env": "^0.12.2",
-    "@pgpmjs/logger": "^2.23.2",
-    "pg": "^8.21.0",
-    "pg-cache": "^3.24.2"
+    "@pgpmjs/logger": "^2.23.2"
   },
   "devDependencies": {
     "@types/express": "^5.0.6",
     "@types/node": "^22.19.11",
-    "@types/pg": "^8.20.0",
-    "@types/supertest": "^7.2.0",
     "express": "^5.2.1",
-    "makage": "^0.3.0",
-    "supertest": "^7.2.2"
+    "makage": "^0.3.0"
   },
   "peerDependencies": {
     "express": "^5.0.0"
   },
   "keywords": [
-    "agentic-kit",
     "express",
     "llm",
+    "gateway",
+    "openai",
     "ollama",
-    "streaming",
-    "billing",
+    "anthropic",
+    "proxy",
     "metering",
     "constructive"
   ],
-  "gitHead": "90f447482b056a4949134565db2665f21d11aca3"
+  "gitHead": "6d3e25dc5c9f93421dba49ddedf93239f87213a8"
 }

package/providers.d.ts

@@ -0,0 +1,8 @@
+import type { AgenticServerOptions, ResolvedProvider } from './types';
+/**
+ * Resolve which provider to use for a given request.
+ * Priority: model-based routing → explicit provider header → default.
+ */
+export declare function resolveProvider(options: AgenticServerOptions, requestModel?: string, requestProvider?: string): ResolvedProvider;
+export declare function resolveUpstreamUrl(provider: ResolvedProvider, path: string): string;
+export declare function buildProviderHeaders(provider: ResolvedProvider): Record<string, string>;

package/providers.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProvider = resolveProvider;
+exports.resolveUpstreamUrl = resolveUpstreamUrl;
+exports.buildProviderHeaders = buildProviderHeaders;
+/**
+ * Resolve which provider to use for a given request.
+ * Priority: model-based routing → explicit provider header → default.
+ */
+function resolveProvider(options, requestModel, requestProvider) {
+    const providers = options.providers || [];
+    if (providers.length > 0) {
+        if (requestProvider) {
+            const match = providers.find((p) => p.type === requestProvider);
+            if (match)
+                return match;
+        }
+        // Route by model prefix: "anthropic/claude-3" → anthropic provider
+        if (requestModel && requestModel.includes('/')) {
+            const prefix = requestModel.split('/')[0];
+            const match = providers.find((p) => p.type === prefix);
+            if (match) {
+                return { ...match, defaultModel: requestModel.split('/').slice(1).join('/') };
+            }
+        }
+        // Route by known model patterns
+        if (requestModel) {
+            if (requestModel.startsWith('claude')) {
+                const match = providers.find((p) => p.type === 'anthropic');
+                if (match)
+                    return match;
+            }
+            if (requestModel.startsWith('gpt') || requestModel.startsWith('o1') || requestModel.startsWith('o3')) {
+                const match = providers.find((p) => p.type === 'openai');
+                if (match)
+                    return match;
+            }
+            if (requestModel.startsWith('llama') ||
+                requestModel.startsWith('mistral') ||
+                requestModel.startsWith('gemma') ||
+                requestModel.startsWith('nomic')) {
+                const match = providers.find((p) => p.type === 'ollama');
+                if (match)
+                    return match;
+            }
+        }
+        return providers[0];
+    }
+    // Legacy single-provider mode (default: ollama for local dev)
+    return {
+        type: options.providerType || 'ollama',
+        baseUrl: options.providerBaseUrl || 'http://localhost:11434',
+        apiKey: options.providerApiKey,
+        defaultModel: options.defaultModel
+    };
+}
+function resolveUpstreamUrl(provider, path) {
+    if (provider.type === 'ollama') {
+        if (path === '/v1/chat/completions')
+            return `${provider.baseUrl}/api/chat`;
+        if (path === '/v1/embeddings')
+            return `${provider.baseUrl}/api/embed`;
+    }
+    if (provider.type === 'anthropic') {
+        if (path === '/v1/chat/completions')
+            return `${provider.baseUrl}/v1/messages`;
+    }
+    return `${provider.baseUrl}${path}`;
+}
+function buildProviderHeaders(provider) {
+    const headers = { 'Content-Type': 'application/json' };
+    if (provider.apiKey) {
+        if (provider.type === 'anthropic') {
+            headers['x-api-key'] = provider.apiKey;
+            headers['anthropic-version'] = '2023-06-01';
+        }
+        else {
+            headers['Authorization'] = `Bearer ${provider.apiKey}`;
+        }
+    }
+    return headers;
+}

package/router.d.ts

@@ -1,21 +1,13 @@
 /**
- * router — Express router for the agentic-server
- *
- * 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.
+ * Express router — OpenAI-compatible LLM proxy with multi-provider routing.
+ *
+ * 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 { Router } from 'express';
-export declare function createAgenticRouter(): Router;
+import type { AgenticServerOptions } from './types';
+export declare const createRouter: (options: AgenticServerOptions) => Router;