@layer-ai/core 0.5.4 → 0.5.6

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { default as authRouter } from './routes/auth.js';
-export { default as gatesRouter } from './routes/gates.js';
-export { default as keysRouter } from './routes/keys.js';
-export { default as logsRouter } from './routes/logs.js';
+export { default as authRouter } from './routes/v1/auth.js';
+export { default as gatesRouter } from './routes/v1/gates.js';
+export { default as keysRouter } from './routes/v1/keys.js';
+export { default as logsRouter } from './routes/v1/logs.js';
 export { default as completeRouter } from './routes/v2/complete.js';
 export { authenticate } from './middleware/auth.js';
 export type {} from './middleware/auth.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAGpE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAG3C,OAAO,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,gBAAgB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,CAGrE,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,IAAI,CAG3E,CAAC;AAGF,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAGpE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAG3C,OAAO,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,gBAAgB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,CAGrE,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,IAAI,CAG3E,CAAC;AAGF,cAAc,6BAA6B,CAAC"}

package/dist/index.js

@@ -1,8 +1,8 @@
 // Routes
-export { default as authRouter } from './routes/auth.js';
-export { default as gatesRouter } from './routes/gates.js';
-export { default as keysRouter } from './routes/keys.js';
-export { default as logsRouter } from './routes/logs.js';
+export { default as authRouter } from './routes/v1/auth.js';
+export { default as gatesRouter } from './routes/v1/gates.js';
+export { default as keysRouter } from './routes/v1/keys.js';
+export { default as logsRouter } from './routes/v1/logs.js';
 export { default as completeRouter } from './routes/v2/complete.js';
 // Middleware
 export { authenticate } from './middleware/auth.js';

package/dist/routes/v1/auth.d.ts

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

package/dist/routes/v1/auth.d.ts.map

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

package/dist/routes/v1/auth.js

@@ -0,0 +1,82 @@
+import { Router } from 'express';
+import bcrypt from 'bcryptjs';
+import crypto from 'crypto';
+import { db } from '../../lib/db/postgres.js';
+const router = Router();
+// POST /auth/signup
+router.post('/signup', async (req, res) => {
+    try {
+        const { email, password } = req.body;
+        if (!email || !password) {
+            res.status(400).json({ error: 'bad_request', message: 'Email and password required' });
+            return;
+        }
+        const existing = await db.getUserByEmail(email);
+        if (existing) {
+            res.status(409).json({ error: 'conflict', message: 'Email already registered' });
+            return;
+        }
+        const passwordHash = await bcrypt.hash(password, 10);
+        const user = await db.createUser(email, passwordHash);
+        res.status(201).json({ id: user.id, email: user.email });
+    }
+    catch (error) {
+        console.error('Signup error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to create account ' });
+    }
+});
+// POST /auth/login
+router.post('/login', async (req, res) => {
+    try {
+        const { email, password } = req.body;
+        if (!email || !password) {
+            res.status(400).json({ error: 'bad_request', message: 'Email and password required' });
+            return;
+        }
+        const user = await db.getUserByEmail(email);
+        if (!user) {
+            res.status(401).json({ error: 'unauthorized', message: 'Invalid credentials' });
+            return;
+        }
+        const valid = await bcrypt.compare(password, user.passwordHash);
+        if (!valid) {
+            res.status(401).json({ error: 'unauthorized', message: 'Invalid credentials' });
+            return;
+        }
+        res.json({ id: user.id, email: user.email });
+    }
+    catch (error) {
+        console.error('Login error', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to login' });
+    }
+});
+// POST /auth/token
+router.post('/token', async (req, res) => {
+    try {
+        const { email, password } = req.body;
+        if (!email || !password) {
+            res.status(400).json({ error: 'bad_request', message: 'Email and password required' });
+            return;
+        }
+        const user = await db.getUserByEmail(email);
+        if (!user) {
+            res.status(401).json({ error: 'unauthorized', message: 'Invalid credentials' });
+            return;
+        }
+        const valid = await bcrypt.compare(password, user.passwordHash);
+        if (!valid) {
+            res.status(401).json({ error: 'unauthorized', message: 'Invalid credentials' });
+            return;
+        }
+        const rawKey = `layer_${crypto.randomBytes(32).toString('hex')}`;
+        const keyHash = crypto.createHash('sha256').update(rawKey).digest('hex');
+        const keyPrefix = rawKey.substring(0, 12); // "layer_xxxxxx"
+        await db.createApiKey(user.id, keyHash, keyPrefix, 'CLI');
+        res.status(201).json({ apiKey: rawKey });
+    }
+    catch (error) {
+        console.error('api key creation error', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to create api key' });
+    }
+});
+export default router;

package/dist/routes/v1/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/v1/gates.d.ts.map

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

package/dist/routes/v1/gates.js

@@ -0,0 +1,275 @@
+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, taskType, model, systemPrompt, allowOverrides, temperature, maxTokens, topP, tags, routingStrategy, fallbackModels, costWeight, latencyWeight, qualityWeight, reanalysisPeriod, taskAnalysis } = 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,
+            taskType,
+            model,
+            systemPrompt,
+            allowOverrides,
+            temperature,
+            maxTokens,
+            topP,
+            tags,
+            routingStrategy,
+            fallbackModels,
+            costWeight,
+            latencyWeight,
+            qualityWeight,
+            reanalysisPeriod,
+            taskAnalysis,
+        });
+        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, taskType, model, systemPrompt, allowOverrides, temperature, maxTokens, topP, tags, routingStrategy, fallbackModels, costWeight, latencyWeight, qualityWeight, reanalysisPeriod, taskAnalysis } = 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,
+            taskType,
+            model,
+            systemPrompt,
+            allowOverrides,
+            temperature,
+            maxTokens,
+            topP,
+            tags,
+            routingStrategy,
+            fallbackModels,
+            costWeight,
+            latencyWeight,
+            qualityWeight,
+            reanalysisPeriod,
+            taskAnalysis,
+        });
+        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, taskType, model, systemPrompt, allowOverrides, temperature, maxTokens, topP, tags, routingStrategy, fallbackModels, costWeight, latencyWeight, qualityWeight, reanalysisPeriod, taskAnalysis } = 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,
+            taskType,
+            model,
+            systemPrompt,
+            allowOverrides,
+            temperature,
+            maxTokens,
+            topP,
+            tags,
+            routingStrategy,
+            fallbackModels,
+            costWeight,
+            latencyWeight,
+            qualityWeight,
+            reanalysisPeriod,
+            taskAnalysis,
+        });
+        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' });
+    }
+});
+// POST /suggestions - Get AI-powered model suggestions for a gate
+router.post('/suggestions', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const { description, costWeight, latencyWeight, qualityWeight } = req.body;
+        if (!description) {
+            res.status(400).json({ error: 'bad_request', message: 'Gate must have a description for AI recommendations' });
+            return;
+        }
+        const userPreferences = {
+            costWeight: parseFloat(costWeight ?? '0.33'),
+            latencyWeight: parseFloat(latencyWeight ?? '0.33'),
+            qualityWeight: parseFloat(qualityWeight ?? '0.34'),
+        };
+        const { analyzeTask } = await import('../../services/task-analysis.js');
+        const suggestions = await analyzeTask(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/v1/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/v1/keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/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/v1/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/v1/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/v1/logs.d.ts.map

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

package/dist/routes/v1/logs.js

@@ -0,0 +1,151 @@
+import { Router } from 'express';
+import { db } from '../../lib/db/postgres.js';
+import { authenticate } from '../../middleware/auth.js';
+const router = Router();
+// All routes require SDK authentication
+router.use(authenticate);
+// GET /v1/logs - List request logs
+router.get('/', async (req, res) => {
+    try {
+        const userId = req.userId;
+        const limit = parseInt(req.query.limit) || 50;
+        const offset = parseInt(req.query.offset) || 0;
+        const gate = req.query.gate;
+        let query = `
+      SELECT
+        id,
+        user_id,
+        gate_id,
+        gate_name,
+        model_requested,
+        model_used,
+        prompt_tokens,
+        completion_tokens,
+        cost_usd,
+        latency_ms,
+        success,
+        error_message,
+        created_at as logged_at
+      FROM requests
+      WHERE user_id = $1
+    `;
+        const params = [userId];
+        if (gate) {
+            query += ` AND gate_name = $2`;
+            params.push(gate);
+        }
+        query += ` ORDER BY created_at DESC LIMIT $${params.length + 1} OFFSET $${params.length + 2}`;
+        params.push(limit, offset);
+        const result = await db.query(query, params);
+        const logs = result.rows.map((row) => ({
+            id: row.id,
+            userId: row.user_id,
+            gateId: row.gate_id,
+            gateName: row.gate_name,
+            modelRequested: row.model_requested,
+            modelUsed: row.model_used,
+            promptTokens: row.prompt_tokens,
+            completionTokens: row.completion_tokens,
+            costUsd: parseFloat(row.cost_usd),
+            latencyMs: row.latency_ms,
+            success: row.success,
+            errorMessage: row.error_message,
+            loggedAt: row.logged_at,
+        }));
+        res.json(logs);
+    }
+    catch (error) {
+        console.error('Logs list error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to fetch logs' });
+    }
+});
+// GET /v1/logs/overview - Get logs for api calls
+router.get('/overview', async (req, res) => {
+    try {
+        const userId = req.userId;
+        const [statsResult, gatesResult, recentRequestsResult] = await Promise.all([
+            // Get aggregate stats
+            db.query(`SELECT
+          COUNT(*) as total_requests,
+          COALESCE(SUM(cost_usd), 0) as total_cost,
+          COALESCE(AVG(latency_ms), 0) as avg_latency
+         FROM requests
+         WHERE user_id = $1`, [userId]),
+            // Get gates count
+            db.query(`SELECT COUNT(*) as active_gates FROM gates WHERE user_id = $1`, [userId]),
+            // Get recent requests
+            db.query(`SELECT
+          id,
+          gate_name,
+          model_used,
+          prompt_tokens,
+          completion_tokens,
+          total_tokens,
+          cost_usd,
+          latency_ms,
+          success,
+          created_at
+         FROM requests
+         WHERE user_id = $1
+         ORDER BY created_at DESC
+         LIMIT 20`, [userId]),
+        ]);
+        const stats = statsResult.rows[0];
+        const gatesCount = gatesResult.rows[0];
+        const recentRequests = recentRequestsResult.rows;
+        res.json({
+            totalRequests: parseInt(stats.total_requests),
+            totalCost: parseFloat(stats.total_cost),
+            avgLatency: Math.round(parseFloat(stats.avg_latency)),
+            activeGates: parseInt(gatesCount.active_gates),
+            recentRequests: recentRequests.map((req) => ({
+                id: req.id,
+                gateName: req.gate_name,
+                model: req.model_used,
+                promptTokens: req.prompt_tokens,
+                completionTokens: req.completion_tokens,
+                totalTokens: req.total_tokens,
+                cost: parseFloat(req.cost_usd),
+                latency: req.latency_ms,
+                success: req.success,
+                createdAt: req.created_at,
+            })),
+        });
+    }
+    catch (error) {
+        console.error('Analytics overview error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to fetch analytics' });
+    }
+});
+// GET /v1/logs/gate/:gateId - Get metrics for a specific gate
+router.get('/gate/:gateId', async (req, res) => {
+    try {
+        const userId = req.userId;
+        const { gateId } = req.params;
+        // Verify gate ownership
+        const gateCheck = await db.query('SELECT id FROM gates WHERE id = $1 AND user_id = $2', [gateId, userId]);
+        if (gateCheck.rows.length === 0) {
+            return res.status(404).json({ error: 'not_found', message: 'Gate not found' });
+        }
+        // Get gate metrics
+        const metricsResult = await db.query(`SELECT
+        COUNT(*) as requests,
+        COALESCE(SUM(cost_usd), 0) as cost,
+        COALESCE(AVG(latency_ms), 0) as latency,
+        MAX(created_at) as last_request
+       FROM requests
+       WHERE gate_id = $1`, [gateId]);
+        const metrics = metricsResult.rows[0];
+        res.json({
+            requests: parseInt(metrics.requests) || 0,
+            cost: parseFloat(metrics.cost) || 0,
+            latency: Math.round(parseFloat(metrics.latency)) || 0,
+            lastRequest: metrics.last_request,
+        });
+    }
+    catch (error) {
+        console.error('Gate metrics error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to fetch gate metrics' });
+    }
+});
+export default router;

package/dist/services/providers/base-adapter.js

@@ -85,6 +85,6 @@ export class BaseProviderAdapter {
         if (!modelInfo || !('pricing' in modelInfo) || !modelInfo.pricing?.input || !modelInfo.pricing?.output) {
             return 0;
         }
-        return (promptTokens / 1000 * modelInfo.pricing.input) + (completionTokens / 1000 * modelInfo.pricing.output);
+        return (promptTokens / 1000000 * modelInfo.pricing.input) + (completionTokens / 1000000 * modelInfo.pricing.output);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layer-ai/core",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Core API routes and services for Layer AI",
   "type": "module",
   "main": "./dist/index.js",