@layer-ai/core 0.1.0

package/dist/routes/complete.js

@@ -0,0 +1,223 @@
+import { Router } from 'express';
+import { db } from '../lib/db/postgres.js';
+import { cache } from '../lib/db/redis.js';
+import { authenticate } from '../middleware/auth.js';
+import { OpenAIAdapter } from '../services/providers/openai-adapter.js';
+import * as anthropic from '../services/providers/anthropic.js';
+import * as google from '../services/providers/google.js';
+import { MODEL_REGISTRY, OverrideField } from '@layer-ai/sdk';
+const router = Router();
+// MARK:- Helper Functions
+function isOverrideAllowed(allowOverrides, field) {
+    if (allowOverrides === undefined || allowOverrides === null || allowOverrides === true)
+        return true;
+    if (allowOverrides === false)
+        return false;
+    return allowOverrides[field] ?? false;
+}
+async function getGateConfig(userId, gateName) {
+    let gateConfig = await cache.getGate(userId, gateName);
+    if (!gateConfig) {
+        gateConfig = await db.getGateByUserAndName(userId, gateName);
+        if (gateConfig) {
+            await cache.setGate(userId, gateName, gateConfig);
+        }
+    }
+    return gateConfig;
+}
+function resolveFinalParams(gateConfig, requestParams) {
+    const { model, temperature, maxTokens, topP, messages } = requestParams;
+    let finalModel = gateConfig.model;
+    if (model && isOverrideAllowed(gateConfig.allowOverrides, OverrideField.Model) && MODEL_REGISTRY[model]) {
+        finalModel = model;
+    }
+    let finalTemperature = gateConfig.temperature;
+    if (isOverrideAllowed(gateConfig.allowOverrides, OverrideField.Temperature)) {
+        finalTemperature = temperature ?? gateConfig.temperature;
+    }
+    let finalMaxTokens = gateConfig.maxTokens;
+    if (isOverrideAllowed(gateConfig.allowOverrides, OverrideField.MaxTokens)) {
+        finalMaxTokens = maxTokens ?? gateConfig.maxTokens;
+    }
+    let finalTopP = gateConfig.topP;
+    if (isOverrideAllowed(gateConfig.allowOverrides, OverrideField.TopP)) {
+        finalTopP = topP ?? gateConfig.topP;
+    }
+    return {
+        model: finalModel,
+        messages,
+        temperature: finalTemperature,
+        maxTokens: finalMaxTokens,
+        topP: finalTopP,
+        systemPrompt: gateConfig.systemPrompt,
+    };
+}
+/**
+ * MIGRATION IN PROGRESS: Moving to normalized adapter pattern.
+ * OpenAI now uses the new adapter. Other providers will follow.
+ * This temporary conversion layer will be removed after all providers are migrated.
+ */
+async function callProvider(params) {
+    const provider = MODEL_REGISTRY[params.model].provider;
+    switch (provider) {
+        case 'openai': {
+            const adapter = new OpenAIAdapter();
+            const layerResponse = await adapter.call({
+                gate: 'internal',
+                model: params.model,
+                type: 'chat',
+                data: {
+                    messages: params.messages,
+                    systemPrompt: params.systemPrompt,
+                    temperature: params.temperature,
+                    maxTokens: params.maxTokens,
+                    topP: params.topP,
+                },
+            });
+            return {
+                content: layerResponse.content || '',
+                promptTokens: layerResponse.usage?.promptTokens || 0,
+                completionTokens: layerResponse.usage?.completionTokens || 0,
+                totalTokens: layerResponse.usage?.totalTokens || 0,
+                costUsd: layerResponse.cost || 0,
+            };
+        }
+        case 'anthropic':
+            return await anthropic.createCompletion(params);
+        case 'google':
+            return await google.createCompletion(params);
+        default:
+            throw new Error(`Unknown provider: ${provider}`);
+    }
+}
+function getModelsToTry(gateConfig, primaryModel) {
+    const modelsToTry = [primaryModel];
+    if (gateConfig.routingStrategy === 'fallback' && gateConfig.fallbackModels?.length) {
+        modelsToTry.push(...gateConfig.fallbackModels);
+    }
+    return modelsToTry;
+}
+async function executeWithFallback(params, modelsToTry) {
+    let result = null;
+    let lastError = null;
+    let modelUsed = params.model;
+    for (const modelToTry of modelsToTry) {
+        try {
+            const modelParams = { ...params, model: modelToTry };
+            result = await callProvider(modelParams);
+            modelUsed = modelToTry;
+            break;
+        }
+        catch (error) {
+            lastError = error;
+            console.log(`Model ${modelToTry} failed, trying next fallback...`, error instanceof Error ? error.message : error);
+            continue;
+        }
+    }
+    if (!result) {
+        throw lastError || new Error('All models failed');
+    }
+    return { result, modelUsed };
+}
+async function executeWithRoundRobin(gateConfig, params) {
+    if (!gateConfig.fallbackModels?.length) {
+        const result = await callProvider(params);
+        return { result, modelUsed: params.model };
+    }
+    const allModels = [gateConfig.model, ...gateConfig.fallbackModels];
+    const modelIndex = Math.floor(Math.random() * allModels.length);
+    const selectedModel = allModels[modelIndex];
+    const modelParams = { ...params, model: selectedModel };
+    const result = await callProvider(modelParams);
+    return { result, modelUsed: selectedModel };
+}
+async function executeWithRouting(gateConfig, params) {
+    const modelsToTry = getModelsToTry(gateConfig, params.model);
+    switch (gateConfig.routingStrategy) {
+        case 'fallback':
+            return await executeWithFallback(params, modelsToTry);
+        case 'round-robin':
+            return await executeWithRoundRobin(gateConfig, params);
+        case 'single':
+        default:
+            const result = await callProvider(params);
+            return { result, modelUsed: params.model };
+    }
+}
+// MARK:- Route Handler
+router.post('/', authenticate, async (req, res) => {
+    const startTime = Date.now();
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    const userId = req.userId;
+    try {
+        const { gate: gateName, messages, model, temperature, maxTokens, topP } = req.body;
+        if (!gateName) {
+            res.status(400).json({ error: 'bad_request', message: 'Missing required field: gate' });
+            return;
+        }
+        if (!messages || !Array.isArray(messages) || messages.length === 0) {
+            res.status(400).json({ error: 'bad_request', message: 'Missing required field: messages' });
+            return;
+        }
+        const gateConfig = await getGateConfig(userId, gateName);
+        if (!gateConfig) {
+            res.status(404).json({ error: 'not_found', message: `Gate "${gateName}" not found` });
+            return;
+        }
+        const finalParams = resolveFinalParams(gateConfig, { model, temperature, maxTokens, topP, messages });
+        const { result, modelUsed } = await executeWithRouting(gateConfig, finalParams);
+        const latencyMs = Date.now() - startTime;
+        db.logRequest({
+            userId,
+            gateId: gateConfig.id,
+            gateName,
+            modelRequested: model || gateConfig.model,
+            modelUsed: modelUsed,
+            promptTokens: result.promptTokens,
+            completionTokens: result.completionTokens,
+            totalTokens: result.totalTokens,
+            costUsd: result.costUsd,
+            latencyMs,
+            success: true,
+            errorMessage: null,
+            userAgent: req.headers['user-agent'] || null,
+            ipAddress: req.ip || null,
+        }).catch(err => console.error('Failed to log request:', err));
+        const response = {
+            content: result?.content,
+            model: modelUsed,
+            usage: {
+                promptTokens: result.promptTokens,
+                completionTokens: result.completionTokens,
+                totalTokens: result.totalTokens,
+            },
+        };
+        res.json(response);
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        db.logRequest({
+            userId,
+            gateId: null,
+            gateName: req.body?.gate || null,
+            modelRequested: null,
+            modelUsed: null,
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+            costUsd: 0,
+            latencyMs,
+            success: false,
+            errorMessage,
+            userAgent: req.headers['user-agent'] || null,
+            ipAddress: req.ip || null,
+        }).catch(err => console.error('Failed to log request:', err));
+        console.error('Completion error:', error);
+        res.status(500).json({ error: 'internal_error', message: errorMessage });
+    }
+});
+export default router;

package/dist/routes/gates.d.ts

@@ -0,0 +1,4 @@
+import type { Router as RouterType } from 'express';
+declare const router: RouterType;
+export default router;
+//# sourceMappingURL=gates.d.ts.map

package/dist/routes/gates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gates.d.ts","sourceRoot":"","sources":["../../src/routes/gates.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAOpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AA+SpC,eAAe,MAAM,CAAC"}

package/dist/routes/gates.js

@@ -0,0 +1,262 @@
+import { Router } from 'express';
+import { db } from '../lib/db/postgres.js';
+import { cache } from '../lib/db/redis.js';
+import { authenticate } from '../middleware/auth.js';
+import { MODEL_REGISTRY } from '@layer-ai/sdk';
+const router = Router();
+// All routes require authentication (SDK auth with Bearer token)
+router.use(authenticate);
+// POST / - Create a new gate
+router.post('/', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const { name, description, model, systemPrompt, allowOverrides, temperature, maxTokens, topP, tags, routingStrategy, fallbackModels } = req.body;
+        if (!name || !model) {
+            res.status(400).json({ error: 'bad_request', message: 'Missing required fields: name and model' });
+            return;
+        }
+        if (!MODEL_REGISTRY[model]) {
+            res.status(400).json({ error: 'bad_request', message: `Unsupported model: ${model}` });
+            return;
+        }
+        const existing = await db.getGateByUserAndName(req.userId, name);
+        if (existing) {
+            res.status(409).json({ error: 'conflict', message: `Gate "${name}" already exists` });
+            return;
+        }
+        const gate = await db.createGate(req.userId, {
+            name,
+            description,
+            model,
+            systemPrompt,
+            allowOverrides,
+            temperature,
+            maxTokens,
+            topP,
+            tags,
+            routingStrategy,
+            fallbackModels,
+        });
+        res.status(201).json(gate);
+    }
+    catch (error) {
+        console.error('Create gate error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to create gate' });
+    }
+});
+// GET / - List all the gates for user
+router.get('/', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const gates = await db.getGatesForUser(req.userId);
+        res.json(gates);
+    }
+    catch (error) {
+        console.error('List gates error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to list gates' });
+    }
+});
+// GET /name/:name - Get a single gate by name
+router.get('/name/:name', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const gate = await db.getGateByUserAndName(req.userId, req.params.name);
+        if (!gate) {
+            res.status(404).json({ error: 'not_found', message: 'Gate not found' });
+            return;
+        }
+        res.json(gate);
+    }
+    catch (error) {
+        console.error('Get gate by name error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to get gate' });
+    }
+});
+// GET /:id - Get a single gate by ID
+router.get('/:id', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const gate = await db.getGateById(req.params.id);
+        if (!gate) {
+            res.status(404).json({ error: 'not_found', message: 'Gate not found' });
+            return;
+        }
+        if (gate.userId !== req.userId) {
+            res.status(404).json({ error: 'not_found', message: 'Gate not found' });
+            return;
+        }
+        res.json(gate);
+    }
+    catch (error) {
+        console.error('Get gate error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to get gate' });
+    }
+});
+// PATCH /name/:name - Update a gate by name
+router.patch('/name/:name', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const { description, model, systemPrompt, allowOverrides, temperature, maxTokens, topP, tags, routingStrategy, fallbackModels } = req.body;
+        const existing = await db.getGateByUserAndName(req.userId, req.params.name);
+        if (!existing) {
+            res.status(404).json({ error: 'not_found', message: 'Gate not found' });
+            return;
+        }
+        if (model && !MODEL_REGISTRY[model]) {
+            res.status(400).json({ error: 'bad_request', message: `Unsupported model: ${model}` });
+            return;
+        }
+        const updated = await db.updateGate(existing.id, {
+            description,
+            model,
+            systemPrompt,
+            allowOverrides,
+            temperature,
+            maxTokens,
+            topP,
+            tags,
+            routingStrategy,
+            fallbackModels,
+        });
+        await cache.invalidateGate(req.userId, existing.name);
+        res.json(updated);
+    }
+    catch (error) {
+        console.error('Update gate by name error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to update gate' });
+    }
+});
+// PATCH /:id - Update a gate by ID
+router.patch('/:id', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const { description, model, systemPrompt, allowOverrides, temperature, maxTokens, topP, tags, routingStrategy, fallbackModels } = req.body;
+        const existing = await db.getGateById(req.params.id);
+        if (!existing) {
+            res.status(404).json({ error: 'not_found', message: 'Gate not found' });
+            return;
+        }
+        if (existing.userId !== req.userId) {
+            res.status(404).json({ error: 'not_found', message: 'Gate not found' });
+            return;
+        }
+        if (model && !MODEL_REGISTRY[model]) {
+            res.status(400).json({ error: 'bad_request', message: `Unsupported model: ${model}` });
+            return;
+        }
+        const updated = await db.updateGate(req.params.id, {
+            description,
+            model,
+            systemPrompt,
+            allowOverrides,
+            temperature,
+            maxTokens,
+            topP,
+            tags,
+            routingStrategy,
+            fallbackModels,
+        });
+        await cache.invalidateGate(req.userId, existing.name);
+        res.json(updated);
+    }
+    catch (error) {
+        console.error('Update gate error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to update gate' });
+    }
+});
+// DELETE /name/:name - Delete a gate by name
+router.delete('/name/:name', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const existing = await db.getGateByUserAndName(req.userId, req.params.name);
+        if (!existing) {
+            res.status(404).json({ error: 'not_found', message: 'Gate not found' });
+            return;
+        }
+        await db.deleteGate(existing.id);
+        await cache.invalidateGate(req.userId, existing.name);
+        res.status(204).send();
+    }
+    catch (error) {
+        console.error('Delete gate by name error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to delete gate' });
+    }
+});
+// DELETE /:id - Delete a gate by ID
+router.delete('/:id', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const existing = await db.getGateById(req.params.id);
+        if (!existing) {
+            res.status(404).json({ error: 'not_found', message: 'Gate not found' });
+            return;
+        }
+        if (existing.userId !== req.userId) {
+            res.status(404).json({ error: 'not_found', message: 'Gate not found' });
+            return;
+        }
+        await db.deleteGate(req.params.id);
+        await cache.invalidateGate(req.userId, existing.name);
+        res.status(204).send();
+    }
+    catch (error) {
+        console.error('Delete gate error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to delete gate' });
+    }
+});
+// GET /:name/suggestions - Get AI-powered model suggestions for a gate
+router.get('/:name/suggestions', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const { name } = req.params;
+        const gate = await db.getGateByUserAndName(req.userId, name);
+        if (!gate) {
+            res.status(404).json({ error: 'not_found', message: 'Gate not found' });
+            return;
+        }
+        if (!gate.description) {
+            res.status(400).json({ error: 'bad_request', message: 'Gate must have a description for AI recommendations' });
+            return;
+        }
+        const userPreferences = {
+            costWeight: gate.costWeight,
+            latencyWeight: gate.latencyWeight,
+            qualityWeight: gate.qualityWeight
+        };
+        const { analyzeTask } = await import('../services/task-analysis.js');
+        const suggestions = await analyzeTask(gate.description, userPreferences);
+        res.json(suggestions);
+    }
+    catch (error) {
+        console.error('Get suggestions error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to fetch suggestions' });
+    }
+});
+export default router;

package/dist/routes/keys.d.ts

@@ -0,0 +1,4 @@
+import type { Router as RouterType } from 'express';
+declare const router: RouterType;
+export default router;
+//# sourceMappingURL=keys.d.ts.map

package/dist/routes/keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../src/routes/keys.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAKpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AA4EpC,eAAe,MAAM,CAAC"}

package/dist/routes/keys.js

@@ -0,0 +1,70 @@
+import { Router } from 'express';
+import crypto from 'crypto';
+import { db } from '../lib/db/postgres.js';
+import { authenticate } from '../middleware/auth.js';
+const router = Router();
+// All routes require sdk authentication
+router.use(authenticate);
+// Generate a random API key
+function generateApiKey() {
+    const randomBytes = crypto.randomBytes(32).toString('hex');
+    return `layer_${randomBytes}`;
+}
+// Hash an API key for storage
+function hashApiKey(key) {
+    return crypto.createHash('sha256').update(key).digest('hex');
+}
+// GET /api/keys - List user's API keys
+router.get('/', async (req, res) => {
+    try {
+        const keys = await db.getApiKeysForUser(req.userId);
+        res.json(keys);
+    }
+    catch (error) {
+        console.error('Get keys error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to get API keys' });
+    }
+});
+// POST /api/keys - Generate new API key
+router.post('/', async (req, res) => {
+    try {
+        const { name } = req.body;
+        if (!name) {
+            res.status(400).json({ error: 'bad_request', message: 'Key name required' });
+            return;
+        }
+        const key = generateApiKey();
+        const keyHash = hashApiKey(key);
+        const keyPrefix = key.substring(0, 12);
+        const apiKey = await db.createApiKey(req.userId, keyHash, keyPrefix, name);
+        // Return full key only once
+        res.status(201).json({
+            id: apiKey.id,
+            name: apiKey.name,
+            key: key,
+            keyPrefix: apiKey.keyPrefix,
+            createdAt: apiKey.createdAt,
+        });
+    }
+    catch (error) {
+        console.error('Create key error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to create API key' });
+    }
+});
+// DELETE /api/keys/:id - Delete an API key
+router.delete('/:id', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const deleted = await db.deleteApiKey(id, req.userId);
+        if (!deleted) {
+            res.status(404).json({ error: 'not_found', message: 'API key not found' });
+            return;
+        }
+        res.status(204).send();
+    }
+    catch (error) {
+        console.error('Delete key error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to delete API key' });
+    }
+});
+export default router;

package/dist/routes/logs.d.ts

@@ -0,0 +1,4 @@
+import type { Router as RouterType } from 'express';
+declare const router: RouterType;
+export default router;
+//# sourceMappingURL=logs.d.ts.map

package/dist/routes/logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../../src/routes/logs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAIpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AA2IpC,eAAe,MAAM,CAAC"}