@layer-ai/core 2.0.19 → 2.0.21

package/dist/routes/v1/chat-completions.js

@@ -0,0 +1,269 @@
+import { Router } from 'express';
+import { nanoid } from 'nanoid';
+import { db } from '../../lib/db/postgres.js';
+import { authenticate } from '../../middleware/auth.js';
+import { spendingTracker } from '../../lib/spending-tracker.js';
+import { convertOpenAIRequestToLayer, convertLayerResponseToOpenAI, convertLayerChunkToOpenAI, } from '../../lib/openai-conversion.js';
+import { resolveFinalRequest } from '../v3/chat.js';
+import { callAdapter, callAdapterStream } from '../../lib/provider-factory.js';
+const router = Router();
+async function* executeWithRoutingStream(gateConfig, request, userId) {
+    yield* callAdapterStream(request, userId);
+}
+async function executeWithRouting(gateConfig, request, userId) {
+    const result = await callAdapter(request, userId);
+    return { result, modelUsed: request.model };
+}
+router.post('/', authenticate, async (req, res) => {
+    const startTime = Date.now();
+    if (!req.userId) {
+        const error = {
+            error: {
+                message: 'Missing user ID',
+                type: 'authentication_error',
+                code: 'unauthorized',
+            },
+        };
+        res.status(401).json(error);
+        return;
+    }
+    const userId = req.userId;
+    let gateConfig = null;
+    let layerRequest = null;
+    try {
+        const openaiReq = req.body;
+        const gateId = openaiReq.gateId || req.headers['x-layer-gate-id'];
+        if (!gateId) {
+            const error = {
+                error: {
+                    message: 'Missing required field: gateId (provide in request body or X-Layer-Gate-Id header)',
+                    type: 'invalid_request_error',
+                    param: 'gateId',
+                    code: 'missing_field',
+                },
+            };
+            res.status(400).json(error);
+            return;
+        }
+        const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(gateId);
+        if (!isUUID) {
+            const error = {
+                error: {
+                    message: 'gateId must be a valid UUID',
+                    type: 'invalid_request_error',
+                    param: 'gateId',
+                    code: 'invalid_format',
+                },
+            };
+            res.status(400).json(error);
+            return;
+        }
+        gateConfig = await db.getGateByUserAndId(userId, gateId);
+        if (!gateConfig) {
+            const error = {
+                error: {
+                    message: `Gate with ID "${gateId}" not found`,
+                    type: 'invalid_request_error',
+                    param: 'gateId',
+                    code: 'not_found',
+                },
+            };
+            res.status(404).json(error);
+            return;
+        }
+        if (!openaiReq.messages || !Array.isArray(openaiReq.messages) || openaiReq.messages.length === 0) {
+            const error = {
+                error: {
+                    message: 'Missing required field: messages (must be a non-empty array)',
+                    type: 'invalid_request_error',
+                    param: 'messages',
+                    code: 'missing_field',
+                },
+            };
+            res.status(400).json(error);
+            return;
+        }
+        if (gateConfig.taskType && gateConfig.taskType !== 'chat') {
+            console.warn(`[Type Mismatch] Gate "${gateConfig.name}" (${gateConfig.id}) configured for taskType="${gateConfig.taskType}" ` +
+                `but received request to /v1/chat/completions endpoint. Processing as chat request.`);
+        }
+        layerRequest = convertOpenAIRequestToLayer(openaiReq, gateId);
+        const finalRequest = resolveFinalRequest(gateConfig, layerRequest);
+        const isStreaming = finalRequest.data && 'stream' in finalRequest.data && finalRequest.data.stream === true;
+        if (isStreaming) {
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            res.setHeader('X-Accel-Buffering', 'no');
+            const requestId = `chatcmpl-${nanoid()}`;
+            const created = Math.floor(Date.now() / 1000);
+            let promptTokens = 0;
+            let completionTokens = 0;
+            let totalCost = 0;
+            let modelUsed = finalRequest.model;
+            try {
+                for await (const layerChunk of executeWithRoutingStream(gateConfig, finalRequest, userId)) {
+                    if (layerChunk.usage) {
+                        promptTokens = layerChunk.usage.promptTokens || 0;
+                        completionTokens = layerChunk.usage.completionTokens || 0;
+                    }
+                    if (layerChunk.cost) {
+                        totalCost = layerChunk.cost;
+                    }
+                    if (layerChunk.model) {
+                        modelUsed = layerChunk.model;
+                    }
+                    const openaiChunk = convertLayerChunkToOpenAI(layerChunk, requestId, created);
+                    res.write(`data: ${JSON.stringify(openaiChunk)}\n\n`);
+                }
+                res.write(`data: [DONE]\n\n`);
+                res.end();
+                const latencyMs = Date.now() - startTime;
+                db.logRequest({
+                    userId,
+                    gateId: gateConfig.id,
+                    gateName: gateConfig.name,
+                    modelRequested: layerRequest.model || gateConfig.model,
+                    modelUsed: modelUsed,
+                    promptTokens,
+                    completionTokens,
+                    totalTokens: promptTokens + completionTokens,
+                    costUsd: totalCost,
+                    latencyMs,
+                    success: true,
+                    errorMessage: null,
+                    userAgent: req.headers['user-agent'] || null,
+                    ipAddress: req.ip || null,
+                    requestPayload: {
+                        gateId: layerRequest.gateId,
+                        type: layerRequest.type,
+                        model: layerRequest.model,
+                        data: layerRequest.data,
+                        metadata: layerRequest.metadata,
+                    },
+                    responsePayload: {
+                        streamed: true,
+                        model: modelUsed,
+                        usage: { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens },
+                        cost: totalCost,
+                    },
+                }).catch(err => console.error('Failed to log request:', err));
+                spendingTracker.trackSpending(userId, totalCost).catch(err => {
+                    console.error('Failed to track spending:', err);
+                });
+            }
+            catch (streamError) {
+                const errorMessage = streamError instanceof Error ? streamError.message : 'Unknown streaming error';
+                const openaiError = {
+                    error: {
+                        message: errorMessage,
+                        type: 'server_error',
+                        code: 'stream_error',
+                    },
+                };
+                res.write(`data: ${JSON.stringify(openaiError)}\n\n`);
+                res.end();
+                db.logRequest({
+                    userId,
+                    gateId: gateConfig.id,
+                    gateName: gateConfig.name,
+                    modelRequested: layerRequest.model || gateConfig.model,
+                    modelUsed: null,
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalTokens: 0,
+                    costUsd: 0,
+                    latencyMs: Date.now() - startTime,
+                    success: false,
+                    errorMessage,
+                    userAgent: req.headers['user-agent'] || null,
+                    ipAddress: req.ip || null,
+                    requestPayload: {
+                        gateId: layerRequest.gateId,
+                        type: layerRequest.type,
+                        model: layerRequest.model,
+                        data: layerRequest.data,
+                        metadata: layerRequest.metadata,
+                    },
+                    responsePayload: null,
+                }).catch(err => console.error('Failed to log request:', err));
+            }
+            return;
+        }
+        const { result, modelUsed } = await executeWithRouting(gateConfig, finalRequest, userId);
+        const latencyMs = Date.now() - startTime;
+        db.logRequest({
+            userId,
+            gateId: gateConfig.id,
+            gateName: gateConfig.name,
+            modelRequested: layerRequest.model || gateConfig.model,
+            modelUsed: modelUsed,
+            promptTokens: result.usage?.promptTokens || 0,
+            completionTokens: result.usage?.completionTokens || 0,
+            totalTokens: result.usage?.totalTokens || 0,
+            costUsd: result.cost || 0,
+            latencyMs,
+            success: true,
+            errorMessage: null,
+            userAgent: req.headers['user-agent'] || null,
+            ipAddress: req.ip || null,
+            requestPayload: {
+                gateId: layerRequest.gateId,
+                type: layerRequest.type,
+                model: layerRequest.model,
+                data: layerRequest.data,
+                metadata: layerRequest.metadata,
+            },
+            responsePayload: {
+                content: result.content,
+                model: result.model,
+                usage: result.usage,
+                cost: result.cost,
+                finishReason: result.finishReason,
+            },
+        }).catch(err => console.error('Failed to log request:', err));
+        spendingTracker.trackSpending(userId, result.cost || 0).catch(err => {
+            console.error('Failed to track spending:', err);
+        });
+        const openaiResponse = convertLayerResponseToOpenAI(result);
+        res.json(openaiResponse);
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        db.logRequest({
+            userId,
+            gateId: gateConfig?.id || null,
+            gateName: gateConfig?.name || null,
+            modelRequested: (layerRequest?.model || gateConfig?.model) || 'unknown',
+            modelUsed: null,
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+            costUsd: 0,
+            latencyMs,
+            success: false,
+            errorMessage,
+            userAgent: req.headers['user-agent'] || null,
+            ipAddress: req.ip || null,
+            requestPayload: layerRequest ? {
+                gateId: layerRequest.gateId,
+                type: layerRequest.type,
+                model: layerRequest.model,
+                data: layerRequest.data,
+                metadata: layerRequest.metadata,
+            } : null,
+            responsePayload: null,
+        }).catch(err => console.error('Failed to log request:', err));
+        console.error('OpenAI chat completion error:', error);
+        const openaiError = {
+            error: {
+                message: errorMessage,
+                type: 'server_error',
+                code: 'internal_error',
+            },
+        };
+        res.status(500).json(openaiError);
+    }
+});
+export default router;

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

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

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

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

package/dist/routes/v1/spending.js

@@ -0,0 +1,94 @@
+import { Router } from 'express';
+import { db } from '../../lib/db/postgres.js';
+import { cache } from '../../lib/db/redis.js';
+import { authenticate } from '../../middleware/auth.js';
+const router = Router();
+router.use(authenticate);
+// GET /spending - Get current spending information
+router.get('/', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const spendingInfo = await db.getUserSpending(req.userId);
+        if (!spendingInfo) {
+            res.status(404).json({ error: 'not_found', message: 'User spending data not found' });
+            return;
+        }
+        const { currentSpending, limit, periodStart, status, limitEnforcementType } = spendingInfo;
+        res.json({
+            currentSpending,
+            limit,
+            periodStart,
+            status,
+            limitEnforcementType,
+            percentUsed: limit ? Math.round((currentSpending / limit) * 100) : null,
+        });
+    }
+    catch (error) {
+        console.error('Get spending error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to get spending data' });
+    }
+});
+// PUT /spending/limit - Update spending limit
+router.put('/limit', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const { limit } = req.body;
+        if (limit !== null && (typeof limit !== 'number' || limit < 0)) {
+            res.status(400).json({ error: 'bad_request', message: 'Limit must be a positive number or null' });
+            return;
+        }
+        await db.setUserSpendingLimit(req.userId, limit);
+        await cache.invalidateUserSpending(req.userId);
+        res.json({ success: true, limit });
+    }
+    catch (error) {
+        console.error('Update spending limit error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to update spending limit' });
+    }
+});
+// PUT /spending/enforcement - Update limit enforcement type
+router.put('/enforcement', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        const { enforcementType } = req.body;
+        if (!['alert_only', 'block'].includes(enforcementType)) {
+            res.status(400).json({
+                error: 'bad_request',
+                message: 'Enforcement type must be "alert_only" or "block"'
+            });
+            return;
+        }
+        await db.setUserEnforcementType(req.userId, enforcementType);
+        res.json({ success: true, enforcementType });
+    }
+    catch (error) {
+        console.error('Update enforcement type error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to update enforcement type' });
+    }
+});
+// POST /spending/reset - Manually reset spending period
+router.post('/reset', async (req, res) => {
+    if (!req.userId) {
+        res.status(401).json({ error: 'unauthorized', message: 'Missing user ID' });
+        return;
+    }
+    try {
+        await db.resetUserSpending(req.userId);
+        await cache.invalidateUserSpending(req.userId);
+        res.json({ success: true, message: 'Spending period reset successfully' });
+    }
+    catch (error) {
+        console.error('Reset spending error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to reset spending' });
+    }
+});
+export default router;

package/dist/routes/v2/complete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complete.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/complete.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AASpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AAkVpC,eAAe,MAAM,CAAC"}
+{"version":3,"file":"complete.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/complete.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAUpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AAsVpC,eAAe,MAAM,CAAC"}

package/dist/routes/v2/complete.js

@@ -3,6 +3,7 @@ import { db } from '../../lib/db/postgres.js';
 import { authenticate } from '../../middleware/auth.js';
 import { callAdapter, normalizeModelId } from '../../lib/provider-factory.js';
 import { OverrideField } from '@layer-ai/sdk';
+import { spendingTracker } from '../../lib/spending-tracker.js';
 const router = Router();
 // MARK:- Helper Functions
 function isOverrideAllowed(allowOverrides, field) {
@@ -255,6 +256,9 @@ router.post('/', authenticate, async (req, res) => {
             userAgent: req.headers['user-agent'] || null,
             ipAddress: req.ip || null,
         }).catch(err => console.error('Failed to log request:', err));
+        spendingTracker.trackSpending(userId, result.cost || 0).catch(err => {
+            console.error('Failed to track spending:', err);
+        });
         // Return LayerResponse with additional metadata
         const response = {
             ...result,

package/dist/routes/v3/chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../src/routes/v3/chat.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAIpD,OAAO,KAAK,EAAE,YAAY,EAAiB,IAAI,EAA+C,MAAM,eAAe,CAAC;AAGpH,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AAiBpC,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,IAAI,EAChB,OAAO,EAAE,YAAY,GACpB,YAAY,CAiFd;AAgWD,eAAe,MAAM,CAAC"}
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../src/routes/v3/chat.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAIpD,OAAO,KAAK,EAAE,YAAY,EAAiB,IAAI,EAA+C,MAAM,eAAe,CAAC;AAIpH,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AAiBpC,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,IAAI,EAChB,OAAO,EAAE,YAAY,GACpB,YAAY,CAiFd;AAwWD,eAAe,MAAM,CAAC"}

package/dist/routes/v3/chat.js

@@ -3,6 +3,7 @@ import { db } from '../../lib/db/postgres.js';
 import { authenticate } from '../../middleware/auth.js';
 import { callAdapter, callAdapterStream, normalizeModelId, getProviderForModel, PROVIDER } from '../../lib/provider-factory.js';
 import { OverrideField } from '@layer-ai/sdk';
+import { spendingTracker } from '../../lib/spending-tracker.js';
 const router = Router();
 // MARK:- Helper Functions
 function isOverrideAllowed(allowOverrides, field) {
@@ -282,6 +283,9 @@ router.post('/', authenticate, async (req, res) => {
                         cost: totalCost,
                     },
                 }).catch(err => console.error('Failed to log request:', err));
+                spendingTracker.trackSpending(userId, totalCost).catch(err => {
+                    console.error('Failed to track spending:', err);
+                });
             }
             catch (streamError) {
                 const errorMessage = streamError instanceof Error ? streamError.message : 'Unknown streaming error';
@@ -346,6 +350,9 @@ router.post('/', authenticate, async (req, res) => {
                 finishReason: result.finishReason,
             },
         }).catch(err => console.error('Failed to log request:', err));
+        spendingTracker.trackSpending(userId, result.cost || 0).catch(err => {
+            console.error('Failed to track spending:', err);
+        });
         const response = {
             ...result,
             model: modelUsed,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layer-ai/core",
-  "version": "2.0.19",
+  "version": "2.0.21",
   "description": "Core API routes and services for Layer AI",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,7 +36,7 @@
     "nanoid": "^5.0.4",
     "openai": "^4.24.0",
     "pg": "^8.11.3",
-    "@layer-ai/sdk": "^2.5.6"
+    "@layer-ai/sdk": "^2.5.8"
   },
   "devDependencies": {
     "@types/bcryptjs": "^2.4.6",