myavana-bot-test-core 2.3.3 → 2.4.0

package/src/agentTools.js

@@ -226,7 +226,206 @@ function createUserTools(userId) {
         }
     );
 
-    return [saveHairGoal, getUserHairProfile];
+    /**
+     * Hair Journey Integration Tools
+     */
+    const { HairJourneyService } = require('./hairJourney/hairJourneyService');
+    const hairJourneyService = new HairJourneyService();
+
+    const getHairGoals = ai.dynamicTool(
+        {
+            name: 'getHairGoals',
+            description:
+                'Retrieve the user\'s active hair goals, target metrics (e.g. length in inches), target dates, and percentage progress from the Hair Journey system. ' +
+                'Call this when the user asks about their goals, asks how close they are to a milestone, or when reviewing progress.',
+            inputSchema: z.object({}),
+            outputSchema: z.record(z.unknown()),
+        },
+        async () => {
+            try {
+                const { result, blocks } = await hairJourneyService.getGoalsWithBlocks(userId);
+                return {
+                    goals: result.goals || [],
+                    overview: result.overview || {},
+                    blocks
+                };
+            } catch (err) {
+                console.error('getHairGoals tool error:', err.message);
+                return { error: 'Goals temporarily unavailable.' };
+            }
+        }
+    );
+
+    const getTodayJourney = ai.dynamicTool(
+        {
+            name: 'getTodayJourney',
+            description:
+                'Retrieve today\'s hair care checklist, routine steps for the day, and current care streak. ' +
+                'Call this when the user asks what they should do today, asks about their wash day steps, or asks for today\'s checklist.',
+            inputSchema: z.object({}),
+            outputSchema: z.record(z.unknown()),
+        },
+        async () => {
+            try {
+                const { result, blocks } = await hairJourneyService.getTodayWithBlocks(userId);
+                return {
+                    date: result.date,
+                    checklist: result.checklist || [],
+                    streakDays: result.streakDays,
+                    blocks
+                };
+            } catch (err) {
+                console.error('getTodayJourney tool error:', err.message);
+                return { error: 'Today hub temporarily unavailable.' };
+            }
+        }
+    );
+
+    const getHairRoutines = ai.dynamicTool(
+        {
+            name: 'getHairRoutines',
+            description:
+                'Retrieve the user\'s defined hair care routines (e.g. wash day, nightly maintenance, L.O.C. method steps) and product cabinet. ' +
+                'Call this when the user asks about their routine schedule or regimen.',
+            inputSchema: z.object({}),
+            outputSchema: z.record(z.unknown()),
+        },
+        async () => {
+            try {
+                const { result, blocks } = await hairJourneyService.getRoutinesWithBlocks(userId);
+                return {
+                    routines: result.routines || [],
+                    cabinet: result.cabinet || [],
+                    blocks
+                };
+            } catch (err) {
+                console.error('getHairRoutines tool error:', err.message);
+                return { error: 'Routines temporarily unavailable.' };
+            }
+        }
+    );
+
+    const completeRoutineStep = ai.dynamicTool(
+        {
+            name: 'completeRoutineStep',
+            description:
+                'Mark a specific routine step as completed for today (e.g. deep condition with heat, hydration mist). ' +
+                'Call this when the user says they completed, did, or finished a routine step.',
+            inputSchema: z.object({
+                stepId: z.string().describe('ID or name of the routine step completed'),
+            }),
+            outputSchema: z.record(z.unknown()),
+        },
+        async ({ stepId }) => {
+            try {
+                const res = await hairJourneyService.completeStep(userId, stepId);
+                return { success: true, stepId, message: 'Step marked completed.' };
+            } catch (err) {
+                console.error('completeRoutineStep tool error:', err.message);
+                return { success: false, error: err.message };
+            }
+        }
+    );
+
+    const updateHairGoal = ai.dynamicTool(
+        {
+            name: 'updateHairGoal',
+            description:
+                'Update a hair goal\'s target metric (e.g. "5 Inches") or target date (e.g. "November 2026"). ' +
+                'Call this when the user explicitly requests to change or adjust a goal.',
+            inputSchema: z.object({
+                goalId: z.string().describe('The ID of the goal to update'),
+                targetMetric: z.string().optional().describe('New target metric, e.g. "5 Inches"'),
+                targetDate: z.string().optional().describe('New target date, e.g. "November 2026"'),
+            }),
+            outputSchema: z.record(z.unknown()),
+        },
+        async ({ goalId, targetMetric, targetDate }) => {
+            try {
+                const res = await hairJourneyService.updateGoal(userId, goalId, { targetMetric, targetDate });
+                return { success: true, goalId, targetMetric, targetDate, message: 'Goal updated successfully.' };
+            } catch (err) {
+                console.error('updateHairGoal tool error:', err.message);
+                return { success: false, error: err.message };
+            }
+        }
+    );
+
+    const createJournalEntry = ai.dynamicTool(
+        {
+            name: 'createJournalEntry',
+            description:
+                'Log a hair journey journal entry or progress check-in (e.g. wash day results, moisture level, notes, photo milestone). ' +
+                'Call this when the user wants to log, write, or record something in their journal or hair diary, or after snapping a progress photo.',
+            inputSchema: z.object({
+                title: z.string().describe('Short title for the journal entry, e.g. "Sunday Wash Day" or "Twist Out Check-in"'),
+                notes: z.string().describe('Observations or notes about the hair, products used, scalp feel, or results'),
+                entryType: z.enum(['wash_day', 'quick_checkin', 'length_check', 'milestone']).optional().describe('Type of entry (default quick_checkin)'),
+                moistureLevel: z.number().int().min(1).max(5).optional().describe('Rating from 1 (very dry) to 5 (optimally hydrated)'),
+                scalpState: z.string().optional().describe('Scalp condition, e.g. "Calm, clean" or "Slight flaking"'),
+            }),
+            outputSchema: z.record(z.unknown()),
+        },
+        async ({ title, notes, entryType = 'quick_checkin', moistureLevel = 4, scalpState = 'Healthy' }) => {
+            try {
+                const { result, blocks } = await hairJourneyService.createJournalEntryWithBlock(userId, {
+                    title,
+                    notes,
+                    entryType,
+                    moistureLevel,
+                    scalpState,
+                    date: new Date().toISOString().split('T')[0]
+                });
+                return {
+                    success: true,
+                    entry: result,
+                    blocks,
+                    message: 'Journal entry recorded successfully.'
+                };
+            } catch (err) {
+                console.error('createJournalEntry tool error:', err.message);
+                return { success: false, error: err.message };
+            }
+        }
+    );
+
+    const getJournalEntries = ai.dynamicTool(
+        {
+            name: 'getJournalEntries',
+            description:
+                'Retrieve recent journal entries and logged progress notes from the user\'s hair journey. ' +
+                'Call this when the user asks what they logged recently, asks about past wash days, or reviews their hair history.',
+            inputSchema: z.object({
+                perPage: z.number().int().min(1).max(10).optional().describe('Number of entries to retrieve (default 3)'),
+            }),
+            outputSchema: z.record(z.unknown()),
+        },
+        async ({ perPage = 3 } = {}) => {
+            try {
+                const { result, blocks } = await hairJourneyService.getJournalEntriesWithBlocks(userId, { perPage });
+                return {
+                    items: result.items || [],
+                    total: result.total || 0,
+                    blocks
+                };
+            } catch (err) {
+                console.error('getJournalEntries tool error:', err.message);
+                return { error: 'Journal entries temporarily unavailable.' };
+            }
+        }
+    );
+
+    return [
+        saveHairGoal,
+        getUserHairProfile,
+        getHairGoals,
+        getTodayJourney,
+        getHairRoutines,
+        completeRoutineStep,
+        updateHairGoal,
+        createJournalEntry,
+        getJournalEntries,
+    ];
 }
 
 // ---------------------------------------------------------------------------

package/src/ai/aiCore.js

@@ -0,0 +1,458 @@
+// packages/core/src/ai/aiCore.js
+// Clean, owned Google Gen AI SDK integration for Mya.
+// Replaces Genkit, solves the 'role: function' bug, and eliminates workspace hoisting issues.
+
+const path = require('path');
+require('dotenv').config();
+require('dotenv').config({ path: path.resolve(__dirname, '../../.env') });
+require('dotenv').config({ path: path.resolve(__dirname, '../../../myavana/.env') });
+
+const { GoogleGenAI } = require('@google/genai');
+const config = require('../config');
+
+function zodToGeminiSchema(schema) {
+    if (!schema) return { type: 'OBJECT', properties: {} };
+    if (schema.type && (schema.properties || schema.items)) return schema;
+
+    let def = schema._def;
+    if (!def) return { type: 'STRING' };
+
+    if (def.typeName === 'ZodOptional' || def.typeName === 'ZodNullable') {
+        def = def.innerType._def;
+    }
+
+    const description = schema.description || def.description;
+
+    switch (def.typeName) {
+        case 'ZodString':
+            return { type: 'STRING', description };
+        case 'ZodNumber':
+            return { type: 'NUMBER', description };
+        case 'ZodBoolean':
+            return { type: 'BOOLEAN', description };
+        case 'ZodEnum':
+            return { type: 'STRING', enum: def.values, description };
+        case 'ZodArray':
+            return { type: 'ARRAY', items: zodToGeminiSchema(def.type), description };
+        case 'ZodObject': {
+            const properties = {};
+            const required = [];
+            const shape = typeof def.shape === 'function' ? def.shape() : def.shape;
+            if (shape) {
+                for (const [key, value] of Object.entries(shape)) {
+                    properties[key] = zodToGeminiSchema(value);
+                    if (value._def?.typeName !== 'ZodOptional') {
+                        required.push(key);
+                    }
+                }
+            }
+            return {
+                type: 'OBJECT',
+                properties,
+                required: required.length > 0 ? required : undefined,
+                description,
+            };
+        }
+        case 'ZodRecord':
+            return { type: 'OBJECT', description };
+        default:
+            return { type: 'STRING', description };
+    }
+}
+
+function normalizeModelName(model) {
+    if (!model) return 'gemini-3.7-flash';
+    if (typeof model === 'string') {
+        return model.replace(/^models\//, '');
+    }
+    if (typeof model === 'object' && model.name) {
+        return model.name.replace(/^models\//, '');
+    }
+    return 'gemini-3.7-flash';
+}
+
+class AiCore {
+    constructor(opts = {}) {
+        this.opts = opts;
+        this._client = null;
+    }
+
+    get client() {
+        if (!this._client) {
+            const apiKey = this.opts.apiKey || config.genkitApiKey || process.env.GEMINI_API_KEY || process.env.GENKIT_API_KEY;
+            if (!apiKey) {
+                console.warn('⚠️ Warning: No Gemini API key provided to AiCore.');
+            }
+            this._client = new GoogleGenAI({ apiKey });
+        }
+        return this._client;
+    }
+
+    defineTool(toolConfig, fn) {
+        return {
+            name: toolConfig.name,
+            description: toolConfig.description,
+            parameters: zodToGeminiSchema(toolConfig.inputSchema),
+            execute: fn,
+        };
+    }
+
+    dynamicTool(toolConfig, fn) {
+        return this.defineTool(toolConfig, fn);
+    }
+
+    async embed(opts) {
+        const text = typeof opts === 'string' ? opts : opts.content || opts.text;
+        const model = opts.embedder || 'gemini-embedding-001';
+        const outputDimensionality = opts.outputDimensionality || 768;
+        const res = await this.client.models.embedContent({
+            model: normalizeModelName(model),
+            contents: text,
+            config: { outputDimensionality },
+        });
+        const values = res.embeddings?.[0]?.values || res.embedding?.values || [];
+        return [{ embedding: values }];
+    }
+
+    async generate(opts) {
+        const model = normalizeModelName(opts.model || 'gemini-3.7-flash');
+        const contents = opts.prompt || opts.contents;
+        const temperature = opts.config?.temperature;
+
+        const reqConfig = {};
+        if (temperature !== undefined) reqConfig.temperature = temperature;
+
+        if (opts.output?.format === 'json' || opts.output?.schema) {
+            reqConfig.responseMimeType = 'application/json';
+            if (opts.output.schema) {
+                reqConfig.responseSchema = zodToGeminiSchema(opts.output.schema);
+            }
+        }
+
+        const res = await this.client.models.generateContent({
+            model,
+            contents,
+            config: reqConfig,
+        });
+
+        let output = res.text;
+        if (opts.output?.format === 'json' || reqConfig.responseMimeType === 'application/json') {
+            try {
+                output = JSON.parse(res.text);
+            } catch {
+                // keep as string if parse fails
+            }
+        }
+        return { text: res.text, output };
+    }
+
+    /**
+     * Transcribes spoken audio into text using gemini-3.5-transcribe with domain biasing
+     * and automatic fallback to gemini-2.5-flash.
+     *
+     * @param {object} opts
+     * @param {Buffer|string} opts.audioData - Raw Buffer or base64 encoded audio string
+     * @param {string} [opts.mimeType='audio/webm']
+     * @param {string[]} [opts.customVocabulary] - Custom domain biasing terms
+     * @param {string} [opts.model='gemini-3.5-transcribe']
+     * @returns {Promise<{text: string, modelUsed: string}>}
+     */
+    async transcribeAudio({ audioData, mimeType = 'audio/webm', customVocabulary = [], model = 'gemini-3.5-transcribe' }) {
+        const base64Data = Buffer.isBuffer(audioData) ? audioData.toString('base64') : audioData;
+        const defaultVocab = [
+            'MYAVANA', 'Mya', 'HairID', 'HHCP', 'porosity', 'elasticity', 'density',
+            'Type 4A', 'Type 4B', 'Type 4C', 'Type 3A', 'Type 3B', 'Type 3C',
+            'coils', 'curls', 'pre-poo', 'clarifying cleanse', 'steam hydration',
+            'L.O.C. method', 'knotless', 'boho braids', 'length retention', 'scalp care', 'Candace'
+        ];
+        const vocabulary = Array.from(new Set([...defaultVocab, ...customVocabulary]));
+
+        const primaryModel = normalizeModelName(model);
+        try {
+            console.log(`🎙️ Transcribing audio with ${primaryModel}... (${base64Data.length} b64 chars, ${mimeType})`);
+            const contents = [
+                {
+                    inlineData: {
+                        mimeType,
+                        data: base64Data,
+                    },
+                },
+            ];
+
+            if (vocabulary.length > 0) {
+                contents.push({
+                    text: `Speech recognition biasing vocabulary: ${vocabulary.join(', ')}. Return only the exact transcription without meta-commentary.`
+                });
+            }
+
+            const res = await this.client.models.generateContent({
+                model: primaryModel,
+                contents,
+            });
+
+            const text = (res.text || '').trim();
+            if (!text) {
+                throw new Error(`Empty transcription returned by ${primaryModel}`);
+            }
+            console.log(`✅ Transcription success (${primaryModel}): "${text}"`);
+            return { text, modelUsed: primaryModel };
+        } catch (err) {
+            console.warn(`⚠️ Primary transcription failed with ${primaryModel}: ${err.message}. Falling back to gemini-2.5-flash...`);
+            const fallbackModel = 'gemini-2.5-flash';
+            const fallbackRes = await this.client.models.generateContent({
+                model: fallbackModel,
+                contents: [
+                    {
+                        inlineData: {
+                            mimeType,
+                            data: base64Data,
+                        },
+                    },
+                    {
+                        text: 'Transcribe this spoken audio accurately. Return only the transcribed text.'
+                    }
+                ],
+            });
+            const text = (fallbackRes.text || '').trim();
+            console.log(`✅ Fallback transcription success (${fallbackModel}): "${text}"`);
+            return { text, modelUsed: fallbackModel };
+        }
+    }
+
+    /**
+     * Connect to Gemini Live API for bidirectional real-time audio/multimodal sessions
+     *
+     * @param {object} opts
+     * @param {string} [opts.model='gemini-3.5-live-translate-preview']
+     * @param {object} opts.callbacks - { onopen, onmessage, onerror, onclose }
+     * @param {string} [opts.systemInstruction]
+     * @param {Array} [opts.tools]
+     */
+    async createLiveSession(opts = {}) {
+        const model = normalizeModelName(opts.model || 'gemini-3.5-live-translate-preview');
+        return await this.client.live.connect({
+            model,
+            callbacks: opts.callbacks,
+            config: {
+                systemInstruction: opts.systemInstruction,
+                generationConfig: {
+                    responseModalities: ['AUDIO', 'TEXT'],
+                    speechConfig: {
+                        voiceConfig: {
+                            prebuiltVoiceConfig: {
+                                voiceName: opts.voiceName || 'Aoede'
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+    chat(opts = {}) {
+        const model = normalizeModelName(opts.model || 'gemini-3.7-flash');
+        const tools = Array.isArray(opts.tools) ? opts.tools : [];
+        const temperature = opts.config?.temperature ?? 1.0;
+
+        const toolMap = new Map();
+        const functionDeclarations = [];
+
+        for (const t of tools) {
+            if (t && t.name && typeof t.execute === 'function') {
+                toolMap.set(t.name, t);
+                functionDeclarations.push({
+                    name: t.name,
+                    description: t.description || '',
+                    parameters: t.parameters || { type: 'OBJECT', properties: {} },
+                });
+            }
+        }
+
+        const chatConfig = {
+            temperature,
+        };
+
+        if (opts.cache) {
+            chatConfig.cachedContent = opts.cache;
+        } else if (opts.system) {
+            chatConfig.systemInstruction = opts.system;
+        }
+
+        if (functionDeclarations.length > 0) {
+            chatConfig.tools = [{ functionDeclarations }];
+        }
+
+        const genaiChat = this.client.chats.create({
+            model,
+            config: chatConfig,
+            history: opts.history,
+        });
+
+        return {
+            genaiChat,
+            send: async (message) => {
+                let res = await genaiChat.sendMessage({ message });
+                const toolCalls = [];
+                let loopCount = 0;
+                const maxLoops = 5;
+
+                while (res.functionCalls && res.functionCalls.length > 0 && loopCount < maxLoops) {
+                    loopCount++;
+                    const functionResponses = [];
+
+                    for (const call of res.functionCalls) {
+                        const tool = toolMap.get(call.name);
+                        toolCalls.push({ name: call.name, args: call.args });
+                        let toolResult = null;
+
+                        if (tool) {
+                            try {
+                                toolResult = await tool.execute(call.args);
+                            } catch (err) {
+                                console.error(`❌ Tool ${call.name} execution error:`, err.message);
+                                toolResult = { error: err.message };
+                            }
+                        } else {
+                            console.warn(`⚠️ Tool ${call.name} requested by model but not found.`);
+                            toolResult = { error: `Tool ${call.name} not implemented.` };
+                        }
+
+                        functionResponses.push({
+                            functionResponse: {
+                                name: call.name,
+                                response: typeof toolResult === 'object' && toolResult !== null ? toolResult : { result: toolResult },
+                            },
+                        });
+                    }
+
+                    res = await genaiChat.sendMessage({ message: functionResponses });
+                }
+
+                const text = res.text || '';
+                let output = text;
+
+                // Try parsing JSON if output looks like JSON (e.g. Kommunicate payload or JSON blocks)
+                const trimmed = text.trim();
+                if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+                    try {
+                        output = JSON.parse(trimmed);
+                    } catch {
+                        output = text;
+                    }
+                }
+
+                return { output, text, toolCalls };
+            },
+
+            sendStream: (message) => {
+                let textAccumulator = '';
+                const toolCalls = [];
+                const toolBlocks = [];
+                let resolveResponse;
+                const responsePromise = new Promise((resolve) => {
+                    resolveResponse = resolve;
+                });
+
+                const streamGenerator = async function* () {
+                    try {
+                        let currentMessage = message;
+                        let loopCount = 0;
+                        const maxLoops = 5;
+
+                        while (loopCount < maxLoops) {
+                            loopCount++;
+                            const pendingFunctionCalls = [];
+                            const responseStream = await genaiChat.sendMessageStream({ message: currentMessage });
+
+                            for await (const chunk of responseStream) {
+                                if (chunk.functionCalls && chunk.functionCalls.length > 0) {
+                                    pendingFunctionCalls.push(...chunk.functionCalls);
+                                }
+                                if (chunk.text) {
+                                    textAccumulator += chunk.text;
+                                    yield { text: chunk.text };
+                                }
+                            }
+
+                            if (pendingFunctionCalls.length === 0) {
+                                break;
+                            }
+
+                            const functionResponses = [];
+                            for (const call of pendingFunctionCalls) {
+                                const tool = toolMap.get(call.name);
+                                toolCalls.push({ name: call.name, args: call.args });
+                                let toolResult = null;
+
+                                if (tool) {
+                                    try {
+                                        toolResult = await tool.execute(call.args);
+                                    } catch (err) {
+                                        console.error(`❌ Tool ${call.name} execution error:`, err.message);
+                                        toolResult = { error: err.message };
+                                    }
+                                } else {
+                                    console.warn(`⚠️ Tool ${call.name} requested by model but not found.`);
+                                    toolResult = { error: `Tool ${call.name} not implemented.` };
+                                }
+
+                                if (toolResult && toolResult.blocks && Array.isArray(toolResult.blocks)) {
+                                    toolBlocks.push(...toolResult.blocks);
+                                }
+
+                                functionResponses.push({
+                                    functionResponse: {
+                                        name: call.name,
+                                        response: typeof toolResult === 'object' && toolResult !== null ? toolResult : { result: toolResult },
+                                    },
+                                });
+                            }
+
+                            currentMessage = functionResponses;
+                        }
+                    } finally {
+                        resolveResponse({ text: textAccumulator, output: textAccumulator, toolCalls, toolBlocks });
+                    }
+                };
+
+                const stream = streamGenerator();
+
+                return {
+                    stream,
+                    response: responsePromise,
+                };
+            },
+        };
+    }
+
+    async loadSession(userId, { store } = {}) {
+        let sessionData = null;
+        if (store && typeof store.get === 'function') {
+            sessionData = await store.get(userId);
+        }
+
+        return {
+            userId,
+            chat: (opts = {}) => {
+                return this.chat({
+                    ...opts,
+                    history: sessionData?.history,
+                });
+            },
+            save: async (data) => {
+                if (store && typeof store.save === 'function') {
+                    await store.save(userId, data);
+                }
+            },
+        };
+    }
+}
+
+const aiCore = new AiCore();
+
+module.exports = {
+    AiCore,
+    aiCore,
+    zodToGeminiSchema,
+    normalizeModelName,
+};

package/src/ai/index.js

@@ -0,0 +1,8 @@
+// packages/core/src/ai/index.js
+const { AiCore, aiCore, zodToGeminiSchema, normalizeModelName } = require('./aiCore');
+
+module.exports = aiCore;
+module.exports.aiCore = aiCore;
+module.exports.AiCore = AiCore;
+module.exports.zodToGeminiSchema = zodToGeminiSchema;
+module.exports.normalizeModelName = normalizeModelName;

package/src/ai.js

@@ -1,14 +1,4 @@
 // ai.js
-const { genkit } = require('genkit/beta');
-const { googleAI } = require('@genkit-ai/google-genai');
-
-const config = require('./config');
-
-const ai = genkit({
-    plugins: [googleAI({
-        apiKey: config.genkitApiKey,
-    })],
-    model: googleAI.model('gemini-3.7-flash'),
-});
-
+// Backwards-compatible entrypoint exporting owned AiCore singleton.
+const ai = require('./ai/index');
 module.exports = ai;