nebula-notebook 0.1.1 → 0.2.1

package/node-server/dist/llm/llm-service.js

@@ -1,454 +0,0 @@
-"use strict";
-/**
- * Multi-Provider LLM Service
- *
- * Supports Google Gemini, OpenAI, and Anthropic.
- * Node.js port of the Python LLMService.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.llmService = exports.LLMService = void 0;
-const genai_1 = require("@google/genai");
-const openai_1 = __importDefault(require("openai"));
-const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
-const types_1 = require("./types");
-class LLMService {
-    googleClient = null;
-    openaiClient = null;
-    anthropicClient = null;
-    /**
-     * Get or create Google GenAI client
-     */
-    getGoogleClient(apiKey) {
-        if (apiKey) {
-            // Create new client with provided key (don't cache)
-            return new genai_1.GoogleGenAI({ apiKey });
-        }
-        if (!this.googleClient) {
-            const envKey = process.env.GEMINI_API_KEY;
-            if (!envKey) {
-                throw new Error('GEMINI_API_KEY not found. Configure it in settings or server environment.');
-            }
-            this.googleClient = new genai_1.GoogleGenAI({ apiKey: envKey });
-        }
-        return this.googleClient;
-    }
-    /**
-     * Get or create OpenAI client
-     */
-    getOpenaiClient(apiKey) {
-        if (apiKey) {
-            return new openai_1.default({ apiKey });
-        }
-        if (!this.openaiClient) {
-            const envKey = process.env.OPENAI_API_KEY;
-            if (!envKey) {
-                throw new Error('OPENAI_API_KEY not found. Configure it in settings or server environment.');
-            }
-            this.openaiClient = new openai_1.default({ apiKey: envKey });
-        }
-        return this.openaiClient;
-    }
-    /**
-     * Get or create Anthropic client
-     */
-    getAnthropicClient(apiKey) {
-        if (apiKey) {
-            return new sdk_1.default({ apiKey });
-        }
-        if (!this.anthropicClient) {
-            const envKey = process.env.ANTHROPIC_API_KEY;
-            if (!envKey) {
-                throw new Error('ANTHROPIC_API_KEY not found. Configure it in settings or server environment.');
-            }
-            this.anthropicClient = new sdk_1.default({ apiKey: envKey });
-        }
-        return this.anthropicClient;
-    }
-    /**
-     * Get available providers based on configured API keys
-     */
-    getAvailableProviders() {
-        const available = {};
-        if (process.env.GEMINI_API_KEY) {
-            available.google = types_1.AVAILABLE_MODELS.google;
-        }
-        if (process.env.OPENAI_API_KEY) {
-            available.openai = types_1.AVAILABLE_MODELS.openai;
-        }
-        if (process.env.ANTHROPIC_API_KEY) {
-            available.anthropic = types_1.AVAILABLE_MODELS.anthropic;
-        }
-        return available;
-    }
-    /**
-     * Normalize config with defaults
-     */
-    normalizeConfig(config) {
-        return {
-            provider: config.provider,
-            model: config.model,
-            temperature: config.temperature ?? types_1.DEFAULT_TEMPERATURE,
-            maxTokens: config.maxTokens ?? types_1.DEFAULT_MAX_TOKENS,
-            apiKey: config.apiKey,
-        };
-    }
-    /**
-     * Repair common JSON formatting issues
-     */
-    repairJson(s) {
-        let result = s;
-        // Replace : 'value' with : "value"
-        result = result.replace(/:\s*'([^']*)'/g, ': "$1"');
-        // Remove trailing commas before } or ]
-        result = result.replace(/,(\s*[}\]])/g, '$1');
-        return result;
-    }
-    /**
-     * Parse JSON with automatic repair on failure
-     */
-    parseJsonWithRepair(s) {
-        try {
-            return JSON.parse(s);
-        }
-        catch {
-            try {
-                const repaired = this.repairJson(s);
-                return JSON.parse(repaired);
-            }
-            catch {
-                throw new Error('Failed to parse JSON');
-            }
-        }
-    }
-    /**
-     * Extract JSON from a response that may contain markdown code blocks
-     */
-    extractJsonFromResponse(response) {
-        // Try to find JSON in code block first
-        const codeBlockMatch = response.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-        if (codeBlockMatch) {
-            return this.parseJsonWithRepair(codeBlockMatch[1]);
-        }
-        // Try to find raw JSON object
-        const jsonMatch = response.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-            return this.parseJsonWithRepair(jsonMatch[0]);
-        }
-        throw new Error('No JSON found in response');
-    }
-    /**
-     * Generate response from Google Gemini
-     */
-    async generateGoogle(prompt, systemPrompt, config, images) {
-        const client = this.getGoogleClient(config.apiKey);
-        // Build content parts
-        const contents = [prompt];
-        if (images) {
-            for (const img of images) {
-                contents.push({
-                    inlineData: {
-                        mimeType: img.mimeType || 'image/png',
-                        data: img.data,
-                    },
-                });
-            }
-        }
-        const response = await client.models.generateContent({
-            model: config.model,
-            contents,
-            config: {
-                systemInstruction: systemPrompt,
-                temperature: config.temperature,
-                maxOutputTokens: config.maxTokens,
-            },
-        });
-        return response.text || '';
-    }
-    /**
-     * Generate response from OpenAI
-     */
-    async generateOpenai(prompt, systemPrompt, config, images) {
-        const client = this.getOpenaiClient(config.apiKey);
-        const messages = [
-            { role: 'system', content: systemPrompt },
-        ];
-        // Build user message content
-        if (images && images.length > 0) {
-            const content = [
-                { type: 'text', text: prompt },
-            ];
-            for (const img of images) {
-                content.push({
-                    type: 'image_url',
-                    image_url: {
-                        url: `data:${img.mimeType || 'image/png'};base64,${img.data}`,
-                    },
-                });
-            }
-            messages.push({ role: 'user', content });
-        }
-        else {
-            messages.push({ role: 'user', content: prompt });
-        }
-        const response = await client.chat.completions.create({
-            model: config.model,
-            messages,
-            temperature: config.temperature,
-            max_completion_tokens: config.maxTokens,
-        });
-        return response.choices[0]?.message?.content || '';
-    }
-    /**
-     * Generate response from Anthropic Claude
-     */
-    async generateAnthropic(prompt, systemPrompt, config, images) {
-        const client = this.getAnthropicClient(config.apiKey);
-        // Build user message content
-        let content;
-        if (images && images.length > 0) {
-            const parts = [];
-            for (const img of images) {
-                parts.push({
-                    type: 'image',
-                    source: {
-                        type: 'base64',
-                        media_type: img.mimeType || 'image/png',
-                        data: img.data,
-                    },
-                });
-            }
-            parts.push({ type: 'text', text: prompt });
-            content = parts;
-        }
-        else {
-            content = prompt;
-        }
-        const response = await client.messages.create({
-            model: config.model,
-            max_tokens: config.maxTokens,
-            system: systemPrompt,
-            messages: [{ role: 'user', content }],
-            temperature: config.temperature,
-        });
-        const textBlock = response.content.find(c => c.type === 'text');
-        return textBlock && 'text' in textBlock ? textBlock.text : '';
-    }
-    /**
-     * Generate a response from the LLM
-     */
-    async generate(options) {
-        const { prompt, systemPrompt, config, images } = options;
-        const normalizedConfig = this.normalizeConfig(config);
-        switch (config.provider) {
-            case 'google':
-                return this.generateGoogle(prompt, systemPrompt, normalizedConfig, images);
-            case 'openai':
-                return this.generateOpenai(prompt, systemPrompt, normalizedConfig, images);
-            case 'anthropic':
-                return this.generateAnthropic(prompt, systemPrompt, normalizedConfig, images);
-            default:
-                throw new Error(`Unknown provider: ${config.provider}`);
-        }
-    }
-    /**
-     * Generate structured JSON response
-     */
-    async generateStructured(options) {
-        const { prompt, systemPrompt, config } = options;
-        const normalizedConfig = this.normalizeConfig(config);
-        switch (config.provider) {
-            case 'google':
-                return this.generateStructuredGoogle(prompt, systemPrompt, normalizedConfig);
-            case 'openai':
-                return this.generateStructuredOpenai(prompt, systemPrompt, normalizedConfig);
-            case 'anthropic':
-                return this.generateStructuredAnthropic(prompt, systemPrompt, normalizedConfig);
-            default:
-                throw new Error(`Unknown provider: ${config.provider}`);
-        }
-    }
-    async generateStructuredGoogle(prompt, systemPrompt, config) {
-        const client = this.getGoogleClient(config.apiKey);
-        const response = await client.models.generateContent({
-            model: config.model,
-            contents: [prompt],
-            config: {
-                systemInstruction: systemPrompt,
-                temperature: config.temperature,
-                maxOutputTokens: config.maxTokens,
-                responseMimeType: 'application/json',
-            },
-        });
-        return this.extractJsonFromResponse(response.text || '');
-    }
-    async generateStructuredOpenai(prompt, systemPrompt, config) {
-        const client = this.getOpenaiClient(config.apiKey);
-        const response = await client.chat.completions.create({
-            model: config.model,
-            messages: [
-                { role: 'system', content: systemPrompt },
-                { role: 'user', content: prompt },
-            ],
-            temperature: config.temperature,
-            max_completion_tokens: config.maxTokens,
-            response_format: { type: 'json_object' },
-        });
-        const content = response.choices[0]?.message?.content || '{}';
-        return JSON.parse(content);
-    }
-    async generateStructuredAnthropic(prompt, systemPrompt, config) {
-        const client = this.getAnthropicClient(config.apiKey);
-        // Anthropic doesn't have native JSON mode, so we enforce via prompt
-        const enhancedSystem = systemPrompt +
-            '\n\nIMPORTANT: Respond with ONLY a valid JSON object. No markdown, no explanation outside the JSON.';
-        const response = await client.messages.create({
-            model: config.model,
-            max_tokens: config.maxTokens,
-            system: enhancedSystem,
-            messages: [{ role: 'user', content: prompt }],
-            temperature: config.temperature,
-        });
-        const textBlock = response.content.find(c => c.type === 'text');
-        const text = textBlock && 'text' in textBlock ? textBlock.text : '';
-        return this.extractJsonFromResponse(text);
-    }
-    /**
-     * Chat with conversation history
-     */
-    async chat(options) {
-        const { message, history, systemPrompt, config, images } = options;
-        const normalizedConfig = this.normalizeConfig(config);
-        switch (config.provider) {
-            case 'google':
-                return this.chatGoogle(message, history, systemPrompt, normalizedConfig, images);
-            case 'openai':
-                return this.chatOpenai(message, history, systemPrompt, normalizedConfig, images);
-            case 'anthropic':
-                return this.chatAnthropic(message, history, systemPrompt, normalizedConfig, images);
-            default:
-                throw new Error(`Unknown provider: ${config.provider}`);
-        }
-    }
-    async chatGoogle(message, history, systemPrompt, config, images) {
-        const client = this.getGoogleClient(config.apiKey);
-        // Convert history to Gemini format
-        const contents = [];
-        for (const msg of history) {
-            contents.push({
-                role: msg.role === 'user' ? 'user' : 'model',
-                parts: [{ text: msg.content }],
-            });
-        }
-        // Add current message with images
-        const currentParts = [
-            { text: message },
-        ];
-        if (images) {
-            for (const img of images) {
-                currentParts.push({
-                    inlineData: {
-                        mimeType: img.mimeType || 'image/png',
-                        data: img.data,
-                    },
-                });
-            }
-        }
-        contents.push({
-            role: 'user',
-            parts: currentParts,
-        });
-        const response = await client.models.generateContent({
-            model: config.model,
-            contents,
-            config: {
-                systemInstruction: systemPrompt,
-                temperature: config.temperature,
-                maxOutputTokens: config.maxTokens,
-            },
-        });
-        return response.text || '';
-    }
-    async chatOpenai(message, history, systemPrompt, config, images) {
-        const client = this.getOpenaiClient(config.apiKey);
-        const messages = [
-            { role: 'system', content: systemPrompt },
-        ];
-        // Add history
-        for (const msg of history) {
-            messages.push({
-                role: msg.role,
-                content: msg.content,
-            });
-        }
-        // Add current message with images
-        if (images && images.length > 0) {
-            const content = [
-                { type: 'text', text: message },
-            ];
-            for (const img of images) {
-                content.push({
-                    type: 'image_url',
-                    image_url: {
-                        url: `data:${img.mimeType || 'image/png'};base64,${img.data}`,
-                    },
-                });
-            }
-            messages.push({ role: 'user', content });
-        }
-        else {
-            messages.push({ role: 'user', content: message });
-        }
-        const response = await client.chat.completions.create({
-            model: config.model,
-            messages,
-            temperature: config.temperature,
-            max_completion_tokens: config.maxTokens,
-        });
-        return response.choices[0]?.message?.content || '';
-    }
-    async chatAnthropic(message, history, systemPrompt, config, images) {
-        const client = this.getAnthropicClient(config.apiKey);
-        const messages = [];
-        // Add history
-        for (const msg of history) {
-            messages.push({
-                role: msg.role,
-                content: msg.content,
-            });
-        }
-        // Add current message with images
-        if (images && images.length > 0) {
-            const parts = [];
-            for (const img of images) {
-                parts.push({
-                    type: 'image',
-                    source: {
-                        type: 'base64',
-                        media_type: img.mimeType || 'image/png',
-                        data: img.data,
-                    },
-                });
-            }
-            parts.push({ type: 'text', text: message });
-            messages.push({ role: 'user', content: parts });
-        }
-        else {
-            messages.push({ role: 'user', content: message });
-        }
-        const response = await client.messages.create({
-            model: config.model,
-            max_tokens: config.maxTokens,
-            system: systemPrompt,
-            messages,
-            temperature: config.temperature,
-        });
-        const textBlock = response.content.find(c => c.type === 'text');
-        return textBlock && 'text' in textBlock ? textBlock.text : '';
-    }
-}
-exports.LLMService = LLMService;
-// Global instance
-exports.llmService = new LLMService();

package/node-server/dist/llm/types.d.ts

@@ -1,40 +0,0 @@
-/**
- * LLM Service Types
- */
-export type LLMProvider = 'google' | 'openai' | 'anthropic';
-export interface LLMConfig {
-    provider: LLMProvider;
-    model: string;
-    temperature?: number;
-    maxTokens?: number;
-    apiKey?: string;
-}
-export interface ImageInput {
-    mimeType: string;
-    data: string;
-}
-export interface ChatMessage {
-    role: 'user' | 'assistant';
-    content: string;
-}
-export interface GenerateOptions {
-    prompt: string;
-    systemPrompt: string;
-    config: LLMConfig;
-    images?: ImageInput[];
-}
-export interface ChatOptions {
-    message: string;
-    history: ChatMessage[];
-    systemPrompt: string;
-    config: LLMConfig;
-    images?: ImageInput[];
-}
-export interface GenerateStructuredOptions {
-    prompt: string;
-    systemPrompt: string;
-    config: LLMConfig;
-}
-export declare const AVAILABLE_MODELS: Record<LLMProvider, string[]>;
-export declare const DEFAULT_MAX_TOKENS = 4096;
-export declare const DEFAULT_TEMPERATURE = 0.2;

package/node-server/dist/llm/types.js

@@ -1,15 +0,0 @@
-"use strict";
-/**
- * LLM Service Types
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_TEMPERATURE = exports.DEFAULT_MAX_TOKENS = exports.AVAILABLE_MODELS = void 0;
-// Available models per provider (Dec 2025)
-exports.AVAILABLE_MODELS = {
-    google: ['gemini-3.0-flash', 'gemini-3.0-pro', 'gemini-2.5-flash'],
-    openai: ['gpt-5.2', 'gpt-5-mini', 'gpt-4o'],
-    anthropic: ['claude-opus-4-5-20251101', 'claude-sonnet-4-5-20250929', 'claude-haiku-4-5-20251101'],
-};
-// Default configuration
-exports.DEFAULT_MAX_TOKENS = 4096;
-exports.DEFAULT_TEMPERATURE = 0.2;

package/node-server/dist/routes/llm.d.ts

@@ -1,8 +0,0 @@
-/**
- * LLM API Routes
- */
-import { FastifyInstance } from 'fastify';
-import { LLMService } from '../llm/llm-service';
-declare const llmService: LLMService;
-export default function llmRoutes(fastify: FastifyInstance): Promise<void>;
-export { llmService };

package/node-server/dist/routes/llm.js

@@ -1,105 +0,0 @@
-"use strict";
-/**
- * LLM API Routes
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.llmService = void 0;
-exports.default = llmRoutes;
-const llm_service_1 = require("../llm/llm-service");
-const llmService = new llm_service_1.LLMService();
-exports.llmService = llmService;
-async function llmRoutes(fastify) {
-    /**
-     * List available LLM providers and models
-     */
-    fastify.get('/llm/providers', async (_request, reply) => {
-        const providers = llmService.getAvailableProviders();
-        return reply.send({ providers });
-    });
-    /**
-     * Generate text/code from LLM
-     */
-    fastify.post('/llm/generate', async (request, reply) => {
-        try {
-            const { prompt, system_prompt, provider = 'google', model = 'gemini-2.5-flash', temperature = 0.2, images, } = request.body;
-            // Check for API key from header
-            const apiKey = request.headers['x-api-key'];
-            const apiProvider = request.headers['x-api-provider'];
-            const response = await llmService.generate({
-                prompt,
-                systemPrompt: system_prompt,
-                config: {
-                    provider: provider,
-                    model,
-                    temperature,
-                    apiKey: apiProvider === provider ? apiKey : undefined,
-                },
-                images: images,
-            });
-            return reply.send({ response });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Unknown error';
-            return reply.code(500).send({ detail: message });
-        }
-    });
-    /**
-     * Generate structured JSON response from LLM
-     */
-    fastify.post('/llm/generate-structured', async (request, reply) => {
-        try {
-            const { prompt, system_prompt, provider = 'google', model = 'gemini-2.5-flash', temperature = 0.2, } = request.body;
-            // Check for API key from header
-            const apiKey = request.headers['x-api-key'];
-            const apiProvider = request.headers['x-api-provider'];
-            const response = await llmService.generateStructured({
-                prompt,
-                systemPrompt: system_prompt,
-                config: {
-                    provider: provider,
-                    model,
-                    temperature,
-                    apiKey: apiProvider === provider ? apiKey : undefined,
-                },
-            });
-            return reply.send({ response });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Unknown error';
-            return reply.code(500).send({ detail: message });
-        }
-    });
-    /**
-     * Chat with LLM including history
-     */
-    fastify.post('/llm/chat', async (request, reply) => {
-        try {
-            const { message, history = [], system_prompt, provider = 'google', model = 'gemini-2.5-flash', temperature = 0.2, images, } = request.body;
-            // Check for API key from header
-            const apiKey = request.headers['x-api-key'];
-            const apiProvider = request.headers['x-api-provider'];
-            // Convert history format
-            const chatHistory = history.map((h) => ({
-                role: h.role,
-                content: h.content,
-            }));
-            const response = await llmService.chat({
-                message,
-                history: chatHistory,
-                systemPrompt: system_prompt,
-                config: {
-                    provider: provider,
-                    model,
-                    temperature,
-                    apiKey: apiProvider === provider ? apiKey : undefined,
-                },
-                images: images,
-            });
-            return reply.send({ response });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Unknown error';
-            return reply.code(500).send({ detail: message });
-        }
-    });
-}