@mongoosejs/studio 0.1.6 → 0.1.8

package/backend/actions/ChatThread/createChatMessage.js

@@ -2,6 +2,7 @@
 
 const Archetype = require('archetype');
 const authorize = require('../../authorize');
+const callLLM = require('../../integrations/callLLM');
 const getModelDescriptions = require('../../helpers/getModelDescriptions');
 const mongoose = require('mongoose');
 
@@ -13,7 +14,7 @@ const CreateChatMessageParams = new Archetype({
     $type: mongoose.Types.ObjectId
   },
   content: {
-    $type: String
+    $type: 'string'
   },
   authorization: {
     $type: 'string'
@@ -42,29 +43,43 @@ module.exports = ({ db, studioConnection, options }) => async function createCha
   const messages = await ChatMessage.find({ chatThreadId }).sort({ createdAt: 1 });
   const llmMessages = messages.map(m => ({
     role: m.role,
-    content: m.content
+    content: [{
+      type: 'text',
+      text: m.content
+    }]
   }));
-  llmMessages.push({ role: 'user', content });
+  llmMessages.push({ role: 'user', content: [{ type: 'text', text: content }] });
 
   let summarizePromise = Promise.resolve();
   if (chatThread.title == null) {
-    summarizePromise = summarizeChatThread(llmMessages, authorization, options).then(res => {
-      const title = res.response;
+    const threadText = messages
+      .filter(m => m.role === 'user' || m.role === 'assistant')
+      .map(m => `${m.role.toUpperCase()}: ${m.content}`)
+      .join('\n')
+      .slice(0, 5000);
+    summarizePromise = callLLM(
+      [{
+        role: 'user',
+        content: [{
+          type: 'text',
+          text: 'Summarize the following chat thread into a concise, helpful title (≤ 6 words).\n\n' +
+            `${threadText}\n\n` +
+            'Return only the title.'
+        }]
+      }],
+      'You are a helpful assistant that summarizes chat threads into titles.',
+      options
+    ).then(res => {
+      const title = res.text;
       chatThread.title = title;
       return chatThread.save();
     });
   }
 
-  if (options?.context) {
-    llmMessages.unshift({
-      role: 'system',
-      content: options.context
-    });
-  }
-
   const modelDescriptions = getModelDescriptions(db);
+  const system = systemPrompt + '\n\n' + modelDescriptions + (options?.context ? '\n\n' + options.context : '');
 
-  // Create the chat message and get OpenAI response in parallel
+  // Create the chat message and get LLM response in parallel
   const chatMessages = await Promise.all([
     ChatMessage.create({
       chatThreadId,
@@ -73,8 +88,8 @@ module.exports = ({ db, studioConnection, options }) => async function createCha
       script,
       executionResult: null
     }),
-    createChatMessageCore(llmMessages, modelDescriptions, options?.model, authorization, options).then(res => {
-      const content = res.response;
+    callLLM(llmMessages, system, options).then(res => {
+      const content = res.text;
       return ChatMessage.create({
         chatThreadId,
         role: 'assistant',
@@ -87,157 +102,43 @@ module.exports = ({ db, studioConnection, options }) => async function createCha
   return { chatMessages, chatThread };
 };
 
-async function summarizeChatThread(messages, authorization, options) {
-  if (options?.openAIAPIKey) {
-    const response = await callOpenAI({
-      apiKey: options.openAIAPIKey,
-      model: options.model,
-      messages: [
-        {
-          role: 'system',
-          content: 'Summarize the following conversation into a concise title of at most 7 words. Respond with the title only.'
-        },
-        ...messages
-      ]
-    });
-
-    return { response };
-  }
-
-  const headers = { 'Content-Type': 'application/json' };
-  if (authorization) {
-    headers.Authorization = authorization;
-  }
-  const response = await fetch('https://mongoose-js.netlify.app/.netlify/functions/summarizeChatThread', {
-    method: 'POST',
-    headers,
-    body: JSON.stringify({
-      messages
-    })
-  }).then(response => {
-    if (response.status < 200 || response.status >= 400) {
-      return response.json().then(data => {
-        throw new Error(`Mongoose Studio chat thread summarization error: ${data.message}`);
-      });
-    }
-    return response;
-  });
-
-  return await response.json();
-}
-
-async function createChatMessageCore(messages, modelDescriptions, model, authorization, options) {
-  if (options?.openAIAPIKey) {
-    const openAIMessages = [];
-    if (modelDescriptions) {
-      openAIMessages.push({
-        role: 'system',
-        content: `${systemPrompt}:\n\n${modelDescriptions}`
-      });
-    }
-    openAIMessages.push(...messages);
-
-    const response = await callOpenAI({
-      apiKey: options.openAIAPIKey,
-      model,
-      messages: openAIMessages
-    });
-
-    return { response };
-  }
-
-  const headers = { 'Content-Type': 'application/json' };
-  if (authorization) {
-    headers.Authorization = authorization;
-  }
-  const response = await fetch('https://mongoose-js.netlify.app/.netlify/functions/createChatMessage', {
-    method: 'POST',
-    headers,
-    body: JSON.stringify({
-      messages,
-      modelDescriptions,
-      model
-    })
-  }).then(response => {
-    if (response.status < 200 || response.status >= 400) {
-      return response.json().then(data => {
-        throw new Error(`Mongoose Studio chat completion error: ${data.message}`);
-      });
-    }
-    return response;
-  });
-
-  return await response.json();
-}
-
 const systemPrompt = `
-You are a data querying assistant who writes scripts for users accessing MongoDB data using Node.js and Mongoose.
-
-Keep scripts concise. Avoid unnecessary comments, error handling, and temporary variables.
-
-Do not write any imports or require() statements, that will cause the script to break.
+  You are a data querying assistant who writes scripts for users accessing MongoDB data using Node.js and Mongoose.
 
-If the user approves the script, the script will run in the Node.js server in a sandboxed vm.createContext() call with only 1 global variable: db, which contains the Mongoose connection. The script return value will then send the response via JSON to the client. Be aware that the result of the query will be serialized to JSON before being displayed to the user. MAKE SURE TO RETURN A VALUE FROM THE SCRIPT.
+  Keep scripts concise. Avoid unnecessary comments, error handling, and temporary variables.
 
-Optimize scripts for readability first, followed by reliability, followed by performance. Avoid using the aggregation framework unless explicitly requested by the user. Use indexed fields in queries where possible.
+  Do not write any imports or require() statements, that will cause the script to break.
 
-Assume the user has pre-defined schemas and models. Do not define any new schemas or models for the user.
+  If the user approves the script, the script will run in the Node.js server in a sandboxed vm.createContext() call with only 1 global variable: db, which contains the Mongoose connection. The script return value will then send the response via JSON to the client. Be aware that the result of the query will be serialized to JSON before being displayed to the user. MAKE SURE TO RETURN A VALUE FROM THE SCRIPT.
 
-Use async/await where possible. Assume top-level await is allowed.
+  Optimize scripts for readability first, followed by reliability, followed by performance. Avoid using the aggregation framework unless explicitly requested by the user. Use indexed fields in queries where possible.
 
-Write at most one script, unless the user explicitly asks for multiple scripts.
+  Assume the user has pre-defined schemas and models. Do not define any new schemas or models for the user.
 
-Think carefully about the user's input and identify the models referred to by the user's query.
+  Use async/await where possible. Assume top-level await is allowed.
 
-Format output as Markdown, including code fences for any scripts the user requested.
+  Write at most one script, unless the user explicitly asks for multiple scripts.
 
-Add a brief text description of what the script does.
+  Think carefully about the user's input and identify the models referred to by the user's query.
 
-If the user's query is best answered with a chart, return a Chart.js 4 configuration as \`return { $chart: chartJSConfig };\`. Disable ChartJS animation by default unless user asks for it. Set responsive: true, maintainAspectRatio: false options unless the user explicitly asks.
+  Format output as Markdown, including code fences for any scripts the user requested.
 
-If the user\'s query is best answered by a map, return an object { $featureCollection } which contains a GeoJSON FeatureCollection
+  Add a brief text description of what the script does.
 
-Example output:
+  If the user's query is best answered with a chart, return a Chart.js 4 configuration as \`return { $chart: chartJSConfig };\`. Disable ChartJS animation by default unless user asks for it. Set responsive: true, maintainAspectRatio: false options unless the user explicitly asks.
 
-The following script counts the number of users which are not deleted.
+  If the user\'s query is best answered by a map, return an object { $featureCollection } which contains a GeoJSON FeatureCollection
 
-\`\`\`javascript
-const users = await db.model('User').find({ isDeleted: false });
-return { numUsers: users.length };
-\`\`\`
+  Example output:
 
------------
+  The following script counts the number of users which are not deleted.
 
-Here is a description of the user's models. Assume these are the only models available in the system unless explicitly instructed otherwise by the user.
-`.trim();
+  \`\`\`javascript
+  const users = await db.model('User').find({ isDeleted: false });
+  return { numUsers: users.length };
+  \`\`\`
 
-async function callOpenAI({ apiKey, model, messages }) {
-  if (!apiKey) {
-    throw new Error('OpenAI API key required');
-  }
-
-  const response = await fetch('https://api.openai.com/v1/chat/completions', {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify({
-      model: model || 'gpt-4o-mini',
-      messages
-    })
-  });
-
-  const data = await response.json();
-
-  if (response.status < 200 || response.status >= 400) {
-    throw new Error(`OpenAI chat completion error ${response.status}: ${data.error?.message || data.message || 'Unknown error'}`);
-  }
-
-  const content = data?.choices?.[0]?.message?.content;
-  if (!content) {
-    throw new Error('OpenAI chat completion error: missing response content');
-  }
+  -----------
 
-  return content.trim();
-}
+  Here is a description of the user's models. Assume these are the only models available in the system unless explicitly instructed otherwise by the user.
+  `.trim();

package/backend/actions/Model/getDocuments.js

@@ -73,13 +73,26 @@ module.exports = ({ db }) => async function getDocuments(params) {
 
   const schemaPaths = {};
   for (const path of Object.keys(Model.schema.paths)) {
+    const schemaType = Model.schema.paths[path];
     schemaPaths[path] = {
-      instance: Model.schema.paths[path].instance,
+      instance: schemaType.instance,
       path,
-      ref: Model.schema.paths[path].options?.ref,
-      required: Model.schema.paths[path].options?.required,
-      enum: Model.schema.paths[path].options?.enum
+      ref: schemaType.options?.ref,
+      required: schemaType.options?.required,
+      enum: schemaType.options?.enum
     };
+    if (schemaType.schema) {
+      schemaPaths[path].schema = {};
+      for (const subpath of Object.keys(schemaType.schema.paths)) {
+        schemaPaths[path].schema[subpath] = {
+          instance: schemaType.schema.paths[subpath].instance,
+          path: subpath,
+          ref: schemaType.schema.paths[subpath].options?.ref,
+          required: schemaType.schema.paths[subpath].options?.required,
+          enum: schemaType.schema.paths[subpath].options?.enum
+        };
+      }
+    }
   }
   removeSpecifiedPaths(schemaPaths, '.$*');
 

package/backend/actions/Model/getDocumentsStream.js

@@ -63,13 +63,26 @@ module.exports = ({ db }) => async function* getDocumentsStream(params) {
 
   const schemaPaths = {};
   for (const path of Object.keys(Model.schema.paths)) {
+    const schemaType = Model.schema.paths[path];
     schemaPaths[path] = {
-      instance: Model.schema.paths[path].instance,
+      instance: schemaType.instance,
       path,
-      ref: Model.schema.paths[path].options?.ref,
-      required: Model.schema.paths[path].options?.required,
-      enum: Model.schema.paths[path].options?.enum
+      ref: schemaType.options?.ref,
+      required: schemaType.options?.required,
+      enum: schemaType.options?.enum
     };
+    if (schemaType.schema) {
+      schemaPaths[path].schema = {};
+      for (const subpath of Object.keys(schemaType.schema.paths)) {
+        schemaPaths[path].schema[subpath] = {
+          instance: schemaType.schema.paths[subpath].instance,
+          path: subpath,
+          ref: schemaType.schema.paths[subpath].options?.ref,
+          required: schemaType.schema.paths[subpath].options?.required,
+          enum: schemaType.schema.paths[subpath].options?.enum
+        };
+      }
+    }
   }
   removeSpecifiedPaths(schemaPaths, '.$*');
 

package/backend/integrations/callLLM.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { createAnthropic } = require('@ai-sdk/anthropic');
+const { createOpenAI } = require('@ai-sdk/openai');
+const { generateText } = require('ai');
+
+module.exports = async function callLLM(messages, system, options) {
+  let provider = null;
+  let model = null;
+  if (options?.openAIAPIKey && options?.anthropicAPIKey) {
+    throw new Error('Cannot set both OpenAI and Anthropic API keys');
+  }
+
+  if (options?.openAIAPIKey) {
+    provider = createOpenAI({ apiKey: options.openAIAPIKey });
+    model = options?.model ?? 'gpt-4o-mini';
+  } else if (options?.anthropicAPIKey) {
+    provider = createAnthropic({ apiKey: options.anthropicAPIKey });
+    model = options?.model ?? 'claude-haiku-4-5-20251001';
+  }
+
+  if (provider) {
+    return generateText({
+      model: provider(model),
+      system,
+      messages
+    });
+  }
+
+  const headers = { 'Content-Type': 'application/json' };
+  const response = await fetch('https://mongoose-js.netlify.app/.netlify/functions/getChatCompletion', {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      messages,
+      model: options?.model
+    })
+  }).then(response => {
+    if (!response.ok) {
+      return response.json().then(data => {
+        throw new Error(`Mongoose Studio chat completion error: ${data.message}`);
+      });
+    }
+    return response;
+  });
+
+  return await response.json().then(res => ({ text: res.response }));
+};