jeanmemory-node/dist/index.js

Node.js SDK for Jean Memory - Build personalized AI chatbots for backend applications

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.JeanAgent = void 0;
exports.createJeanHandler = createJeanHandler;
/**
 * Jean Memory Node.js SDK - Ultimate Minimal Implementation
 * For Next.js API routes and backend integration
 */
const ai_1 = require("ai");
const openai_1 = require("@ai-sdk/openai");
const JEAN_API_BASE = 'https://jean-memory-api-virginia.onrender.com';
class JeanAgent {
    constructor(config) {
        this.config = {
            model: 'gpt-4o-mini',
            systemPrompt: 'You are a helpful assistant.',
            ...config
        };
    }
    /**
     * Process a message with Jean Memory context enhancement
     */
    async process(message, userToken) {
        try {
            // Extract user from token
            const user = await this.getUserFromToken(userToken);
            // Enhance message with Jean Memory context
            const contextResponse = await fetch(`${JEAN_API_BASE}/sdk/chat/enhance`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    api_key: this.config.apiKey,
                    client_name: 'Node.js App',
                    user_id: user.user_id,
                    messages: [{ role: 'user', content: message }],
                    system_prompt: this.config.systemPrompt
                })
            });
            const { enhanced_messages, user_context } = await contextResponse.json();
            // Use enhanced messages with AI SDK
            const result = (0, ai_1.streamText)({
                model: (0, openai_1.openai)(this.config.model),
                messages: enhanced_messages,
                system: user_context ?
                    `${this.config.systemPrompt}\n\nUser Context: ${user_context}` :
                    this.config.systemPrompt
            });
            return result.toDataStreamResponse();
        }
        catch (error) {
            throw new Error(`Jean Memory processing failed: ${error}`);
        }
    }
    /**
     * Create Next.js API route handler
     */
    createHandler() {
        return async (req, res) => {
            if (req.method !== 'POST') {
                return res.status(405).json({ error: 'Method not allowed' });
            }
            try {
                const { message } = req.body;
                const userToken = req.headers.authorization;
                if (!userToken) {
                    return res.status(401).json({ error: 'Authorization required' });
                }
                const response = await this.process(message, userToken);
                return response;
            }
            catch (error) {
                console.error('Jean Memory API error:', error);
                return res.status(500).json({ error: 'Internal server error' });
            }
        };
    }
    async getUserFromToken(token) {
        // Extract user info from the Jean Memory token
        // This would validate the token and return user details
        const cleanToken = token.replace('Bearer ', '');
        // For now, we'll extract from JWT payload (simplified)
        const payload = JSON.parse(atob(cleanToken.split('.')[1]));
        return {
            user_id: payload.sub,
            email: payload.email
        };
    }
}
exports.JeanAgent = JeanAgent;
// Convenience function for quick setup
function createJeanHandler(config) {
    const agent = new JeanAgent(config);
    return agent.createHandler();
}
//# sourceMappingURL=index.js.map