more attempts to cleanup typing, etc in chat box

2 files changed, 82 insertions, 96 deletions

diff --git a/src/client/views/nodes/chatbot/tools/CreateAnyDocTool.ts b/src/client/views/nodes/chatbot/tools/CreateAnyDocTool.ts
index 6f61b77d4..0049612fd 100644
--- a/src/client/views/nodes/chatbot/tools/CreateAnyDocTool.ts
+++ b/src/client/views/nodes/chatbot/tools/CreateAnyDocTool.ts
@@ -1,49 +1,61 @@
 import { v4 as uuidv4 } from 'uuid';
 import { BaseTool } from './BaseTool';
 import { Observation } from '../types/types';
-import { ParametersType, Parameter } from '../types/tool_types';
-import { DocumentOptions, Docs } from '../../../../documents/Documents';
+import { ParametersType } from '../types/tool_types';
+import { DocumentOptions } from '../../../../documents/Documents';
+import { toLower } from 'lodash';
 
-/**
- * List of supported document types that can be created via text LLM.
- */
-type supportedDocumentTypesType = 'text' | 'html' | 'equation' | 'functionPlot' | 'dataviz' | 'noteTaking' | 'rtf' | 'message';
-const supportedDocumentTypes: supportedDocumentTypesType[] = ['text', 'html', 'equation', 'functionPlot', 'dataviz', 'noteTaking', 'rtf', 'message'];
+export enum supportedDocumentTypes {
+    flashcard = 'flashcard',
+    text = 'text',
+    html = 'html',
+    equation = 'equation',
+    functionplot = 'functionplot',
+    dataviz = 'dataviz',
+    notetaking = 'notetaking',
+    rtf = 'rtf',
+    message = 'message',
+}
 
+const standardOptions = ['title', 'backgroundColor', 'layout'];
 /**
  * Description of document options and data field for each type.
  */
-const documentTypesInfo = {
-    text: {
-        options: ['title', 'backgroundColor', 'fontColor', 'text_align', 'layout'],
+const documentTypesInfo: { [key in supportedDocumentTypes]: { options: string[]; dataDescription: string } } = {
+    [supportedDocumentTypes.flashcard]: {
+        options: [...standardOptions, 'fontColor', 'text_align'],
+        dataDescription: 'an array of two strings.  the first string contains a question, and the second string contains an answer',
+    },
+    [supportedDocumentTypes.text]: {
+        options: [...standardOptions, 'fontColor', 'text_align'],
         dataDescription: 'The text content of the document.',
     },
-    html: {
-        options: ['title', 'backgroundColor', 'layout'],
+    [supportedDocumentTypes.html]: {
+        options: [],
         dataDescription: 'The HTML-formatted text content of the document.',
     },
-    equation: {
-        options: ['title', 'backgroundColor', 'fontColor', 'layout'],
+    [supportedDocumentTypes.equation]: {
+        options: [...standardOptions, 'fontColor'],
         dataDescription: 'The equation content as a string.',
     },
-    functionPlot: {
-        options: ['title', 'backgroundColor', 'layout', 'function_definition'],
+    [supportedDocumentTypes.functionplot]: {
+        options: [...standardOptions, 'function_definition'],
         dataDescription: 'The function definition(s) for plotting. Provide as a string or array of function definitions.',
     },
-    dataviz: {
-        options: ['title', 'backgroundColor', 'layout', 'chartType'],
+    [supportedDocumentTypes.dataviz]: {
+        options: [...standardOptions, 'chartType'],
         dataDescription: 'A string of comma-separated values representing the CSV data.',
     },
-    noteTaking: {
-        options: ['title', 'backgroundColor', 'layout'],
+    [supportedDocumentTypes.notetaking]: {
+        options: standardOptions,
         dataDescription: 'The initial content or structure for note-taking.',
     },
-    rtf: {
-        options: ['title', 'backgroundColor', 'layout'],
+    [supportedDocumentTypes.rtf]: {
+        options: standardOptions,
         dataDescription: 'The rich text content in RTF format.',
     },
-    message: {
-        options: ['title', 'backgroundColor', 'layout'],
+    [supportedDocumentTypes.message]: {
+        options: standardOptions,
         dataDescription: 'The message content of the document.',
     },
 };
@@ -52,7 +64,7 @@ const createAnyDocumentToolParams = [
     {
         name: 'document_type',
         type: 'string',
-        description: `The type of the document to create. Supported types are: ${supportedDocumentTypes.join(', ')}`,
+        description: `The type of the document to create. Supported types are: ${Object.values(supportedDocumentTypes).join(', ')}`,
         required: true,
     },
     {
@@ -64,90 +76,63 @@ const createAnyDocumentToolParams = [
     {
         name: 'options',
         type: 'string',
-        description: `A JSON string representing the document options. Available options depend on the document type. For example:
-${supportedDocumentTypes
-    .map(
-        docType => `
-- For '${docType}' documents, options include: ${documentTypesInfo[docType].options.join(', ')}`
-    )
-    .join('\n')}`,
         required: false,
+        description: `A JSON string representing the document options. Available options depend on the document type. For example:
+            ${Object.entries(documentTypesInfo).map( ([doc_type, info]) => `
+- For '${doc_type}' documents, options include: ${info.options.join(', ')}`) 
+                    .join('\n')}`, // prettier-ignore
     },
 ] as const;
 
 type CreateAnyDocumentToolParamsType = typeof createAnyDocumentToolParams;
 
 export class CreateAnyDocumentTool extends BaseTool<CreateAnyDocumentToolParamsType> {
-    private _addLinkedDoc: (doc_type: string, data: string | undefined, options: DocumentOptions, id: string) => void;
+    private _addLinkedDoc: (doc_type: supportedDocumentTypes, data: unknown, options: DocumentOptions, id: string) => void;
 
-    constructor(addLinkedDoc: (doc_type: string, data: string | undefined, options: DocumentOptions, id: string) => void) {
+    constructor(addLinkedDoc: (doc_type: supportedDocumentTypes, data: unknown, options: DocumentOptions, id: string) => void) {
+        // prettier-ignore
         super(
             'createAnyDocument',
-            `Creates any type of document with the provided options and data. Supported document types are: ${supportedDocumentTypes.join(', ')}. dataviz is a csv table tool, so for CSVs, use dataviz. Here are the options for each type:
+            `Creates any type of document with the provided options and data. Supported document types are: ${Object.values(supportedDocumentTypes).join(', ')}. dataviz is a csv table tool, so for CSVs, use dataviz. Here are the options for each type:
             <supported_document_types>
-        ${supportedDocumentTypes
-            .map(
-                docType => `
-        <document_type name="${docType}">
-          <data_description>${documentTypesInfo[docType].dataDescription}</data_description>
-          <options>
-            ${documentTypesInfo[docType].options.map(option => `<option>${option}</option>`).join('\n')}
-          </options>
-        </document_type>
-        `
-            )
-            .join('\n')}
-      </supported_document_types>`,
+                ${Object.entries(documentTypesInfo).map(([doc_type, info]) => `
+                <document_type name="${doc_type}">
+                    <data_description>${info.dataDescription}</data_description>
+                    <options>
+                        ${info.options.map(option => `<option>${option}</option>`).join('\n')}
+                    </options>
+                </document_type>
+                `).join('\n')}
+            </supported_document_types>`,
             createAnyDocumentToolParams,
             'Provide the document type, data, and options for the document. Options should be a valid JSON string containing the document options specific to the document type.',
-            `Creates any type of document with the provided options and data. Supported document types are: ${supportedDocumentTypes.join(', ')}.`
+            `Creates any type of document with the provided options and data. Supported document types are: ${Object.values(supportedDocumentTypes).join(', ')}.`
         );
         this._addLinkedDoc = addLinkedDoc;
     }
 
     async execute(args: ParametersType<CreateAnyDocumentToolParamsType>): Promise<Observation[]> {
         try {
-            const documentType: supportedDocumentTypesType = args.document_type.toLowerCase() as supportedDocumentTypesType;
-            let options: DocumentOptions = {};
+            const documentType = toLower(args.document_type) as unknown as supportedDocumentTypes;
+            const info = documentTypesInfo[documentType];
 
-            if (!supportedDocumentTypes.includes(documentType)) {
-                throw new Error(`Unsupported document type: ${documentType}. Supported types are: ${supportedDocumentTypes.join(', ')}.`);
+            if (info === undefined) {
+                throw new Error(`Unsupported document type: ${documentType}. Supported types are: ${Object.values(supportedDocumentTypes).join(', ')}.`);
             }
 
             if (!args.data) {
-                throw new Error(`Data is required for ${documentType} documents. ${documentTypesInfo[documentType].dataDescription}`);
-            }
-
-            if (args.options) {
-                try {
-                    options = JSON.parse(args.options as string) as DocumentOptions;
-                } catch (e) {
-                    throw new Error('Options must be a valid JSON string.');
-                }
+                throw new Error(`Data is required for ${documentType} documents. ${info.dataDescription}`);
             }
 
-            const data = args.data as string;
             const id = uuidv4();
+            const options: DocumentOptions = !args.options ? {} : JSON.parse(args.options);
 
-            // Set default options if not provided
-            options.title = options.title || `New ${documentType.charAt(0).toUpperCase() + documentType.slice(1)} Document`;
-
-            // Call the function to add the linked document
-            this._addLinkedDoc(documentType, data, options, id);
+            // Call the function to add the linked document (add default title that can be overriden if set in options)
+            this._addLinkedDoc(documentType, args.data, { title: `New ${documentType.charAt(0).toUpperCase() + documentType.slice(1)} Document`, ...options }, id);
 
-            return [
-                {
-                    type: 'text',
-                    text: `Created ${documentType} document with ID ${id}.`,
-                },
-            ];
+            return [{ type: 'text', text: `Created ${documentType} document with ID ${id}.` }];
         } catch (error) {
-            return [
-                {
-                    type: 'text',
-                    text: 'Error creating document: ' + (error as Error).message,
-                },
-            ];
+            return [{ type: 'text', text: 'Error creating document: ' + (error as Error).message }];
         }
     }
 }
diff --git a/src/client/views/nodes/chatbot/tools/CreateDocumentTool.ts b/src/client/views/nodes/chatbot/tools/CreateDocumentTool.ts
index 63a6004a7..f0f2fe703 100644
--- a/src/client/views/nodes/chatbot/tools/CreateDocumentTool.ts
+++ b/src/client/views/nodes/chatbot/tools/CreateDocumentTool.ts
@@ -3,6 +3,7 @@ import { BaseTool } from './BaseTool';
 import { Observation } from '../types/types';
 import { ParametersType } from '../types/tool_types';
 import { DocumentOptions } from '../../../../documents/Documents';
+import { supportedDocumentTypes } from './CreateAnyDocTool';
 
 /**
  * Tthe CreateDocTool class is responsible for creating
@@ -343,9 +344,9 @@ type CreateListDocToolParamsType = typeof createListDocToolParams;
 
 // Tool class for creating documents
 export class CreateDocTool extends BaseTool<CreateListDocToolParamsType> {
-    private _addLinkedDoc: (doc_type: string, data: string, options: DocumentOptions, id: string) => void;
+    private _addLinkedDoc: (doc_type: supportedDocumentTypes, data: unknown, options: DocumentOptions, id: string) => void;
 
-    constructor(addLinkedDoc: (doc_type: string, data: string, options: DocumentOptions, id: string) => void) {
+    constructor(addLinkedDoc: (doc_type: supportedDocumentTypes, data: unknown, options: DocumentOptions, id: string) => void) {
         super(
             'createDoc',
             'Creates one or more documents that best fit the user’s request. If the user requests a "dashboard," first call the search tool and then generate a variety of document types individually, with absolutely a minimum of 20 documents with two stacks of flashcards that are small and it should have a couple nested freeform collections of things, each with different content and color schemes. For example, create multiple individual documents like "text," "deck," "web", "equation," and "comparison." Use decks instead of flashcards for dashboards. Decks should have at least three flashcards. Really think about what documents are useful to the user. If they ask for a dashboard about the skeletal system, include flashcards, as they would be helpful.  Arrange the documents in a grid layout, ensuring that the x and y coordinates are calculated so no documents overlap but they should be directly next to each other with 20 padding in between. Take into account the width and height of each document, spacing them appropriately to prevent collisions. Use a systematic approach, such as placing each document in a grid cell based on its order, where cell dimensions match the document dimensions plus a fixed margin for spacing. Do not nest all documents within a single collection unless explicitly requested by the user. Instead, create a set of independent documents with diverse document types. Each type should appear separately unless specified otherwise.',
@@ -363,27 +364,27 @@ export class CreateDocTool extends BaseTool<CreateListDocToolParamsType> {
     async execute(args: ParametersType<CreateListDocToolParamsType>): Promise<Observation[]> {
         try {
             console.log('EXE' + args.docs);
-            const parsedDoc = JSON.parse(args.docs);
+            const parsedDoc = JSON.parse(args.docs) as ({ doc_type: supportedDocumentTypes; data: unknown } & DocumentOptions)[];
             console.log('parsed' + parsedDoc);
-            parsedDoc.forEach(doc => {
+            parsedDoc.forEach(doc =>
                 this._addLinkedDoc(
-                    doc['doc_type'],
-                    doc['data'],
+                    doc.doc_type,
+                    doc.data,
                     {
-                        title: doc['title'],
-                        backgroundColor: doc['backgroundColor'],
-                        text_fontColor: doc['font_color'],
-                        _width: doc['width'],
-                        _height: doc['height'],
-                        type_collection: doc['type_collection'],
+                        title: doc.title,
+                        backgroundColor: doc.backgroundColor,
+                        text_fontColor: doc.text_fontColor,
+                        _width: doc._width,
+                        _height: doc._height,
+                        type_collection: doc.type_collection,
                         _layout_fitWidth: false,
                         _layout_autoHeight: true,
-                        x: doc['x'],
-                        y: doc['y'],
+                        x: doc.x,
+                        y: doc.y,
                     },
                     uuidv4()
-                );
-            });
+                )
+            );
             return [{ type: 'text', text: 'Created document.' }];
         } catch (error) {
             return [{ type: 'text', text: 'Error creating text document, ' + error }];