@layer-ai/core 0.1.0

package/dist/routes/logs.js

@@ -0,0 +1,120 @@
+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' });
+    }
+});
+export default router;

package/dist/services/providers/anthropic.d.ts

@@ -0,0 +1,18 @@
+import type { Message } from '@layer-ai/sdk';
+export interface AnthropicCompletionParams {
+    model: string;
+    messages: Message[];
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    systemPrompt?: string;
+}
+export interface ProviderResponse {
+    content: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    costUsd: number;
+}
+export declare function createCompletion(params: AnthropicCompletionParams): Promise<ProviderResponse>;
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/services/providers/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/services/providers/anthropic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,eAAe,CAAC;AAe7D,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAgDnG"}

package/dist/services/providers/anthropic.js

@@ -0,0 +1,55 @@
+import Anthropic from '@anthropic-ai/sdk/index';
+import { MODEL_REGISTRY } from '@layer-ai/sdk';
+// Lazy-initialize Anthropic client
+let anthropic = null;
+function getAnthropicClient() {
+    if (!anthropic) {
+        anthropic = new Anthropic({
+            apiKey: process.env.ANTHROPIC_API_KEY,
+        });
+    }
+    return anthropic;
+}
+export async function createCompletion(params) {
+    // Separate system message from conversation
+    let systemPrompt = params.systemPrompt || '';
+    const conversationMessages = params.messages.filter(msg => {
+        if (msg.role === 'system') {
+            systemPrompt = msg.content;
+            return false;
+        }
+        return true;
+    });
+    // map to anthropic format
+    const anthropicMessages = conversationMessages.map(msg => ({
+        role: msg.role,
+        content: msg.content,
+    }));
+    // Call anthropic api
+    const response = await getAnthropicClient().messages.create({
+        model: params.model,
+        max_tokens: params.maxTokens || 1024,
+        messages: anthropicMessages,
+        ...(systemPrompt && { system: systemPrompt }),
+        ...(params.temperature != null && { temperature: params.temperature }),
+        ...(params.topP != null && { top_p: params.topP }),
+    });
+    // Extract response content
+    const content = response.content[0].type === 'text'
+        ? response.content[0].text
+        : '';
+    // Get token usage
+    const promptTokens = response.usage.input_tokens;
+    const completionTokens = response.usage.output_tokens;
+    const totalTokens = promptTokens + completionTokens;
+    // Calculate cost
+    const pricing = MODEL_REGISTRY[params.model].pricing;
+    const costUsd = (promptTokens / 1000 * pricing.input) + (completionTokens / 1000 * pricing.output);
+    return {
+        content,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        costUsd,
+    };
+}

package/dist/services/providers/base-adapter.d.ts

@@ -0,0 +1,32 @@
+import { LayerRequest, LayerResponse, Role, ImageDetail, ImageSize, ImageQuality, ImageStyle, VideoSize, AudioFormat, AudioMimeType, ImageMimeType, FinishReason, ToolChoice, EncodingFormat, ADAPTER_HANDLED } from '@layer-ai/sdk';
+export { ADAPTER_HANDLED };
+export declare abstract class ProviderAdapter {
+    protected abstract provider: string;
+    protected roleMappings?: Record<Role, string>;
+    protected imageDetailMappings?: Record<ImageDetail, string>;
+    protected toolChoiceMappings?: Record<string, string | object>;
+    protected finishReasonMappings?: Record<string, FinishReason>;
+    protected imageSizeMappings?: Record<ImageSize, string>;
+    protected imageQualityMappings?: Record<ImageQuality, string>;
+    protected imageStyleMappings?: Record<ImageStyle, string>;
+    protected videoSizeMappings?: Record<VideoSize, string>;
+    protected audioFormatMappings?: Record<AudioFormat, string>;
+    protected audioMimeTypeMappings?: Record<AudioMimeType, string>;
+    protected imageMimeTypeMappings?: Record<ImageMimeType, string>;
+    protected encodingFormatMappings?: Record<EncodingFormat, string>;
+    abstract call(request: LayerRequest): Promise<LayerResponse>;
+    protected mapRole(role: Role): string;
+    protected mapImageDetail(detail: ImageDetail): string | undefined;
+    protected mapImageSize(size: ImageSize): string | undefined;
+    protected mapImageQuality(quality: ImageQuality): string | undefined;
+    protected mapImageStyle(style: ImageStyle): string | undefined;
+    protected mapVideoSize(size: VideoSize): string | undefined;
+    protected mapAudioFormat(format: AudioFormat): string | undefined;
+    protected mapAudioMimeType(mimeType: AudioMimeType): string | undefined;
+    protected mapImageMimeType(mimeType: ImageMimeType): string | undefined;
+    protected mapEncodingFormat(format: EncodingFormat): string | undefined;
+    protected mapFinishReason(providerFinishReason: string): FinishReason;
+    protected mapToolChoice(choice: ToolChoice): string | object | undefined;
+    protected calculateCost(model: string, promptTokens: number, completionTokens: number): number;
+}
+//# sourceMappingURL=base-adapter.d.ts.map

package/dist/services/providers/base-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-adapter.d.ts","sourceRoot":"","sources":["../../../src/services/providers/base-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,IAAI,EACJ,WAAW,EACX,SAAS,EACT,YAAY,EACZ,UAAU,EACV,SAAS,EACT,WAAW,EACX,aAAa,EACb,aAAa,EACb,YAAY,EACZ,UAAU,EACV,cAAc,EACd,eAAe,EAGhB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,CAAC;AAE3B,8BAAsB,eAAe;IACnC,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAEpC,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC9C,SAAS,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IAC5D,SAAS,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IAC/D,SAAS,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC9D,SAAS,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACxD,SAAS,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC9D,SAAS,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAC1D,SAAS,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACxD,SAAS,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IAC5D,SAAS,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IAChE,SAAS,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IAChE,SAAS,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;IAElE,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IAE5D,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAcrC,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS;IAQjE,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS;IAQ3D,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS;IAQpE,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS;IAQ9D,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS;IAQ3D,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS;IAQjE,SAAS,CAAC,gBAAgB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS;IAQvE,SAAS,CAAC,gBAAgB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS;IAQvE,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS;IAQvE,SAAS,CAAC,eAAe,CAAC,oBAAoB,EAAE,MAAM,GAAG,YAAY;IAQrE,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;IAYxE,SAAS,CAAC,aAAa,CACrB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,GACvB,MAAM;CAMV"}

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

@@ -0,0 +1,89 @@
+import { ADAPTER_HANDLED, MODEL_REGISTRY, } from '@layer-ai/sdk';
+export { ADAPTER_HANDLED };
+export class ProviderAdapter {
+    mapRole(role) {
+        if (!this.roleMappings) {
+            return role;
+        }
+        const mapped = this.roleMappings[role];
+        if (mapped === ADAPTER_HANDLED) {
+            return ADAPTER_HANDLED;
+        }
+        return mapped || role;
+    }
+    mapImageDetail(detail) {
+        if (!this.imageDetailMappings) {
+            return undefined;
+        }
+        return this.imageDetailMappings[detail];
+    }
+    mapImageSize(size) {
+        if (!this.imageSizeMappings) {
+            return size;
+        }
+        return this.imageSizeMappings[size];
+    }
+    mapImageQuality(quality) {
+        if (!this.imageQualityMappings) {
+            return undefined;
+        }
+        return this.imageQualityMappings[quality];
+    }
+    mapImageStyle(style) {
+        if (!this.imageStyleMappings) {
+            return undefined;
+        }
+        return this.imageStyleMappings[style];
+    }
+    mapVideoSize(size) {
+        if (!this.videoSizeMappings) {
+            return size;
+        }
+        return this.videoSizeMappings[size];
+    }
+    mapAudioFormat(format) {
+        if (!this.audioFormatMappings) {
+            return undefined;
+        }
+        return this.audioFormatMappings[format];
+    }
+    mapAudioMimeType(mimeType) {
+        if (!this.audioMimeTypeMappings) {
+            return mimeType;
+        }
+        return this.audioMimeTypeMappings[mimeType];
+    }
+    mapImageMimeType(mimeType) {
+        if (!this.imageMimeTypeMappings) {
+            return mimeType;
+        }
+        return this.imageMimeTypeMappings[mimeType];
+    }
+    mapEncodingFormat(format) {
+        if (!this.encodingFormatMappings) {
+            return format;
+        }
+        return this.encodingFormatMappings[format];
+    }
+    mapFinishReason(providerFinishReason) {
+        if (!this.finishReasonMappings) {
+            return 'completed';
+        }
+        return this.finishReasonMappings[providerFinishReason] || 'completed';
+    }
+    mapToolChoice(choice) {
+        if (typeof choice === 'object') {
+            return choice;
+        }
+        if (!this.toolChoiceMappings) {
+            return choice;
+        }
+        return this.toolChoiceMappings[choice];
+    }
+    calculateCost(model, promptTokens, completionTokens) {
+        const modelInfo = MODEL_REGISTRY[model];
+        return modelInfo?.pricing
+            ? (promptTokens / 1000 * modelInfo.pricing.input) + (completionTokens / 1000 * modelInfo.pricing.output)
+            : 0;
+    }
+}

package/dist/services/providers/google.d.ts

@@ -0,0 +1,18 @@
+import type { Message } from '@layer-ai/sdk';
+export interface GoogleCompletionParams {
+    model: string;
+    messages: Message[];
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    systemPrompt?: string;
+}
+export interface ProviderResponse {
+    content: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    costUsd: number;
+}
+export declare function createCompletion(params: GoogleCompletionParams): Promise<ProviderResponse>;
+//# sourceMappingURL=google.d.ts.map

package/dist/services/providers/google.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/services/providers/google.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,eAAe,CAAC;AAY7D,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAGD,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAiChG"}

package/dist/services/providers/google.js

@@ -0,0 +1,39 @@
+import { GoogleGenAI } from "@google/genai";
+import { MODEL_REGISTRY } from "@layer-ai/sdk";
+let client = null;
+function getGoogleClient() {
+    if (!client) {
+        client = new GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY || '' });
+    }
+    return client;
+}
+export async function createCompletion(params) {
+    const contents = params.messages.map(msg => ({
+        role: msg.role === 'assistant' ? 'model' : 'user',
+        parts: [{ text: msg.content }],
+    }));
+    const response = await getGoogleClient().models.generateContent({
+        model: params.model,
+        contents,
+        config: {
+            systemInstruction: params.systemPrompt,
+            temperature: params.temperature,
+            maxOutputTokens: params.maxTokens,
+            topP: params.topP,
+        },
+    });
+    const content = response.text || '';
+    const usageMetadata = response.usageMetadata;
+    const promptTokens = usageMetadata?.promptTokenCount || 0;
+    const completionTokens = usageMetadata?.candidatesTokenCount || 0;
+    const totalTokens = usageMetadata?.totalTokenCount || (promptTokens + completionTokens);
+    const pricing = MODEL_REGISTRY[params.model].pricing;
+    const costUsd = (promptTokens / 1000 * pricing.input) + (completionTokens / 1000 * pricing.output);
+    return {
+        content,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        costUsd,
+    };
+}

package/dist/services/providers/openai-adapter.d.ts

@@ -0,0 +1,19 @@
+import { ProviderAdapter } from './base-adapter.js';
+import { LayerRequest, LayerResponse, Role, ImageDetail, ImageSize, ImageQuality, ImageStyle, VideoSize, AudioFormat, FinishReason } from '@layer-ai/sdk';
+export declare class OpenAIAdapter extends ProviderAdapter {
+    protected provider: string;
+    protected roleMappings: Record<Role, string>;
+    protected imageDetailMappings: Record<ImageDetail, string>;
+    protected finishReasonMappings: Record<string, FinishReason>;
+    protected imageSizeMappings: Record<ImageSize, string>;
+    protected imageQualityMappings: Record<ImageQuality, string>;
+    protected imageStyleMappings: Record<ImageStyle, string>;
+    protected videoSizeMappings: Record<VideoSize, string>;
+    protected audioFormatMappings: Record<AudioFormat, string>;
+    call(request: LayerRequest): Promise<LayerResponse>;
+    private handleChat;
+    private handleImageGeneration;
+    private handleEmbeddings;
+    private handleTextToSpeech;
+}
+//# sourceMappingURL=openai-adapter.d.ts.map

package/dist/services/providers/openai-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-adapter.d.ts","sourceRoot":"","sources":["../../../src/services/providers/openai-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EACL,YAAY,EACZ,aAAa,EACb,IAAI,EACJ,WAAW,EACX,SAAS,EACT,YAAY,EACZ,UAAU,EACV,SAAS,EACT,WAAW,EACX,YAAY,EACb,MAAM,eAAe,CAAC;AAavB,qBAAa,aAAc,SAAQ,eAAe;IAChD,SAAS,CAAC,QAAQ,SAAY;IAE9B,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAQ1C;IAEF,SAAS,CAAC,mBAAmB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAIxD;IAEF,SAAS,CAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAK1D;IAEF,SAAS,CAAC,iBAAiB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAQpD;IAEF,SAAS,CAAC,oBAAoB,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAG1D;IAEF,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAGtD;IAEF,SAAS,CAAC,iBAAiB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAKpD;IAEF,SAAS,CAAC,mBAAmB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAOxD;IAEI,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;YAiB3C,UAAU;YAgGV,qBAAqB;YAyBrB,gBAAgB;YA6BhB,kBAAkB;CA0BjC"}

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

@@ -0,0 +1,240 @@
+import OpenAI from 'openai';
+import { ProviderAdapter } from './base-adapter.js';
+let openai = null;
+function getOpenAIClient() {
+    if (!openai) {
+        openai = new OpenAI({
+            apiKey: process.env.OPENAI_API_KEY,
+        });
+    }
+    return openai;
+}
+export class OpenAIAdapter extends ProviderAdapter {
+    constructor() {
+        super(...arguments);
+        this.provider = 'openai';
+        this.roleMappings = {
+            system: 'system',
+            user: 'user',
+            assistant: 'assistant',
+            tool: 'tool',
+            function: 'function',
+            model: 'assistant',
+            developer: 'system',
+        };
+        this.imageDetailMappings = {
+            auto: 'auto',
+            low: 'low',
+            high: 'high',
+        };
+        this.finishReasonMappings = {
+            stop: 'completed',
+            length: 'length_limit',
+            tool_calls: 'tool_call',
+            content_filter: 'filtered',
+        };
+        this.imageSizeMappings = {
+            '256x256': '256x256',
+            '512x512': '512x512',
+            '1024x1024': '1024x1024',
+            '1792x1024': '1792x1024',
+            '1024x1792': '1024x1792',
+            '1536x1024': '1536x1024',
+            '1024x1536': '1024x1536',
+        };
+        this.imageQualityMappings = {
+            standard: 'standard',
+            hd: 'hd',
+        };
+        this.imageStyleMappings = {
+            vivid: 'vivid',
+            natural: 'natural',
+        };
+        this.videoSizeMappings = {
+            '720x1280': '720x1280',
+            '1280x720': '1280x720',
+            '1024x1792': '1024x1792',
+            '1792x1024': '1792x1024',
+        };
+        this.audioFormatMappings = {
+            mp3: 'mp3',
+            opus: 'opus',
+            aac: 'aac',
+            flac: 'flac',
+            wav: 'wav',
+            pcm: 'pcm',
+        };
+    }
+    async call(request) {
+        switch (request.type) {
+            case 'chat':
+                return this.handleChat(request);
+            case 'image':
+                return this.handleImageGeneration(request);
+            case 'embeddings':
+                return this.handleEmbeddings(request);
+            case 'tts':
+                return this.handleTextToSpeech(request);
+            case 'video':
+                throw new Error('Video generation not yet supported by OpenAI');
+            default:
+                throw new Error(`Unknown modality: ${request.type}`);
+        }
+    }
+    async handleChat(request) {
+        const startTime = Date.now();
+        const client = getOpenAIClient();
+        const { data: chat, model } = request;
+        const messages = [];
+        if (chat.systemPrompt) {
+            messages.push({ role: 'system', content: chat.systemPrompt });
+        }
+        for (const msg of chat.messages) {
+            const role = this.mapRole(msg.role);
+            if (msg.images && msg.images.length > 0) {
+                const content = [];
+                if (msg.content) {
+                    content.push({ type: 'text', text: msg.content });
+                }
+                for (const image of msg.images) {
+                    const imageUrl = image.url || `data:${image.mimeType || 'image/jpeg'};base64,${image.base64}`;
+                    content.push({
+                        type: 'image_url',
+                        image_url: {
+                            url: imageUrl,
+                            ...(image.detail && { detail: this.mapImageDetail(image.detail) }),
+                        },
+                    });
+                }
+                messages.push({ role: role, content });
+            }
+            else if (msg.toolCalls) {
+                messages.push({
+                    role: 'assistant',
+                    content: msg.content || null,
+                    tool_calls: msg.toolCalls,
+                });
+            }
+            else if (msg.toolCallId) {
+                messages.push({
+                    role: 'tool',
+                    content: msg.content || '',
+                    tool_call_id: msg.toolCallId,
+                });
+            }
+            else {
+                messages.push({
+                    role,
+                    content: msg.content || '',
+                    ...(role === 'function' && msg.name && { name: msg.name }),
+                });
+            }
+        }
+        const openaiRequest = {
+            model: model,
+            messages,
+            stream: false,
+            ...(chat.temperature !== undefined && { temperature: chat.temperature }),
+            ...(chat.maxTokens !== undefined && { max_completion_tokens: chat.maxTokens }),
+            ...(chat.topP !== undefined && { top_p: chat.topP }),
+            ...(chat.stopSequences !== undefined && { stop: chat.stopSequences }),
+            ...(chat.frequencyPenalty !== undefined && { frequency_penalty: chat.frequencyPenalty }),
+            ...(chat.presencePenalty !== undefined && { presence_penalty: chat.presencePenalty }),
+            ...(chat.seed !== undefined && { seed: chat.seed }),
+            ...(chat.tools && {
+                tools: chat.tools,
+                ...(chat.toolChoice && { tool_choice: chat.toolChoice }),
+            }),
+        };
+        const response = await client.chat.completions.create(openaiRequest);
+        const choice = response.choices[0];
+        const promptTokens = response.usage?.prompt_tokens || 0;
+        const completionTokens = response.usage?.completion_tokens || 0;
+        const totalTokens = response.usage?.total_tokens || 0;
+        const cost = this.calculateCost(model, promptTokens, completionTokens);
+        return {
+            content: choice.message.content || undefined,
+            toolCalls: choice.message.tool_calls,
+            model: response.model,
+            finishReason: this.mapFinishReason(choice.finish_reason),
+            rawFinishReason: choice.finish_reason,
+            usage: {
+                promptTokens,
+                completionTokens,
+                totalTokens,
+            },
+            cost,
+            latencyMs: Date.now() - startTime,
+            raw: response,
+        };
+    }
+    async handleImageGeneration(request) {
+        const startTime = Date.now();
+        const client = getOpenAIClient();
+        const { data: image, model } = request;
+        const response = await client.images.generate({
+            model: model,
+            prompt: image.prompt,
+            ...(image.size && { size: this.mapImageSize(image.size) }),
+            ...(image.quality && { quality: this.mapImageQuality(image.quality) }),
+            ...(image.count && { n: image.count }),
+            ...(image.style && { style: this.mapImageStyle(image.style) }),
+        });
+        return {
+            images: (response.data || []).map(img => ({
+                url: img.url,
+                revisedPrompt: img.revised_prompt,
+            })),
+            model: model,
+            latencyMs: Date.now() - startTime,
+            raw: response,
+        };
+    }
+    async handleEmbeddings(request) {
+        const startTime = Date.now();
+        const client = getOpenAIClient();
+        const { data: embedding, model } = request;
+        const response = await client.embeddings.create({
+            model: model,
+            input: embedding.input,
+            ...(embedding.dimensions && { dimensions: embedding.dimensions }),
+            ...(embedding.encodingFormat && { encoding_format: embedding.encodingFormat }),
+        });
+        const promptTokens = response.usage?.prompt_tokens || 0;
+        const cost = this.calculateCost(model, promptTokens, 0);
+        return {
+            embeddings: response.data.map(d => d.embedding),
+            model: response.model,
+            usage: {
+                promptTokens,
+                completionTokens: 0,
+                totalTokens: promptTokens,
+            },
+            cost,
+            latencyMs: Date.now() - startTime,
+            raw: response,
+        };
+    }
+    async handleTextToSpeech(request) {
+        const startTime = Date.now();
+        const client = getOpenAIClient();
+        const { data: tts, model } = request;
+        const response = await client.audio.speech.create({
+            model: model,
+            input: tts.input,
+            voice: (tts.voice || 'alloy'),
+            ...(tts.speed !== undefined && { speed: tts.speed }),
+            ...(tts.responseFormat && { response_format: this.mapAudioFormat(tts.responseFormat) }),
+        });
+        const buffer = Buffer.from(await response.arrayBuffer());
+        const base64 = buffer.toString('base64');
+        return {
+            audio: {
+                base64,
+                format: tts.responseFormat || 'mp3',
+            },
+            model: model,
+            latencyMs: Date.now() - startTime,
+        };
+    }
+}

package/dist/services/providers/openai.d.ts

@@ -0,0 +1,17 @@
+import type { Message } from '@layer-ai/sdk';
+export interface OpenAICompletionParams {
+    model: string;
+    messages: Message[];
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+}
+export interface ProviderResponse {
+    content: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    costUsd: number;
+}
+export declare function createCompletion(params: OpenAICompletionParams): Promise<ProviderResponse>;
+//# sourceMappingURL=openai.d.ts.map

package/dist/services/providers/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/services/providers/openai.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,eAAe,CAAC;AAe7D,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAmChG"}