agentic-server 0.21.2 → 0.22.1

package/server.d.ts

@@ -0,0 +1,10 @@
+import express from 'express';
+import type { AgenticServerOptions } from './types';
+export interface AgenticServerStartOptions extends AgenticServerOptions {
+    port?: number;
+}
+/**
+ * Create a standalone Express app for the agentic server.
+ * Used by both standalone mode and integration tests.
+ */
+export declare const createAgenticServer: (options: AgenticServerStartOptions) => express.Express;

package/server.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgenticServer = void 0;
+const express_1 = __importDefault(require("express"));
+const router_1 = require("./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.
+ */
+const createAgenticServer = (options) => {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.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((0, router_1.createRouter)(options));
+    return app;
+};
+exports.createAgenticServer = createAgenticServer;

package/transforms.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedProvider, UsageResult } from './types';
+export declare function transformChatRequest(provider: ResolvedProvider, body: Record<string, unknown>): Record<string, unknown>;
+export declare function transformEmbedRequest(provider: ResolvedProvider, body: Record<string, unknown>): Record<string, unknown>;
+export declare function transformChatResponse(data: Record<string, unknown>, provider: ResolvedProvider): {
+    body: Record<string, unknown>;
+    usage: UsageResult;
+};
+export declare function transformEmbedResponse(data: Record<string, unknown>, provider: ResolvedProvider): {
+    body: Record<string, unknown>;
+    usage: UsageResult;
+};

package/transforms.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformChatRequest = transformChatRequest;
+exports.transformEmbedRequest = transformEmbedRequest;
+exports.transformChatResponse = transformChatResponse;
+exports.transformEmbedResponse = transformEmbedResponse;
+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' };
+}
+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' };
+}
+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 };
+}
+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/types.d.ts

@@ -0,0 +1,64 @@
+export interface ProviderConfig {
+    type: string;
+    baseUrl: string;
+    apiKey?: string;
+    defaultModel?: string;
+}
+export interface AgenticServerOptions {
+    providers?: ProviderConfig[];
+    /** Legacy single-provider base URL */
+    providerBaseUrl?: string;
+    /** Legacy API key */
+    providerApiKey?: string;
+    /** Legacy default model */
+    defaultModel?: string;
+    /** Legacy provider type: 'openai' | 'ollama' | 'anthropic' */
+    providerType?: string;
+    /** Fire-and-forget sink for inference metering. Inject this to record usage
+     *  against whatever telemetry/billing backend the consumer owns. When
+     *  omitted, no metering occurs. The gateway itself is backend-agnostic and
+     *  never imports a concrete metering implementation. */
+    inferenceSink?: InferenceSink;
+    /** Whether this server instance is publicly accessible.
+     *  When false (default), the server is deployed behind a private network
+     *  (Docker network, K8s service mesh) and trusts identity headers directly:
+     *    X-Database-Id, X-Entity-Id, X-Actor-Id
+     *  When true, identity headers are stripped from incoming requests
+     *  (external clients cannot set tenant context). */
+    isPublic?: boolean;
+}
+export interface ResolvedProvider {
+    type: string;
+    baseUrl: string;
+    apiKey?: string;
+    defaultModel?: string;
+}
+export interface UsageResult {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+/**
+ * Fire-and-forget sink for inference metering. Implementations record the entry
+ * to whatever telemetry/billing backend they own (e.g. compute_log) and MUST
+ * NOT throw — metering must never affect inference latency or response delivery.
+ */
+export interface InferenceSink {
+    logInference(entry: InferenceEntry): void;
+}
+export interface InferenceEntry {
+    databaseId: string;
+    entityId?: string;
+    actorId?: string;
+    model: string;
+    provider: string;
+    service: 'chat' | 'embed';
+    operation: string;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    latencyMs: number;
+    status: 'ok' | 'error';
+    errorType?: string;
+    rawUsage?: unknown;
+}

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });