1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
import { toLower } from 'lodash';
import { v4 as uuidv4 } from 'uuid';
import { DocumentOptions } from '../../../../documents/Documents';
import { ParametersType } from '../types/tool_types';
import { Observation } from '../types/types';
import { BaseTool } from './BaseTool';
import { supportedDocumentTypes } from './CreateDocumentTool';
const standardOptions = ['title', 'backgroundColor'];
/**
* Description of document options and data field for each type.
*/
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.',
},
[supportedDocumentTypes.html]: {
options: [],
dataDescription: 'The HTML-formatted text content of the document.',
},
[supportedDocumentTypes.equation]: {
options: [...standardOptions, 'fontColor'],
dataDescription: 'The equation content as a string.',
},
[supportedDocumentTypes.functionplot]: {
options: [...standardOptions, 'function_definition'],
dataDescription: 'The function definition(s) for plotting. Provide as a string or array of function definitions.',
},
[supportedDocumentTypes.dataviz]: {
options: [...standardOptions, 'chartType'],
dataDescription: 'A string of comma-separated values representing the CSV data.',
},
[supportedDocumentTypes.notetaking]: {
options: standardOptions,
dataDescription: 'The initial content or structure for note-taking.',
},
[supportedDocumentTypes.rtf]: {
options: standardOptions,
dataDescription: 'The rich text content in RTF format.',
},
[supportedDocumentTypes.message]: {
options: standardOptions,
dataDescription: 'The message content of the document.',
},
};
const createAnyDocumentToolParams = [
{
name: 'document_type',
type: 'string',
description: `The type of the document to create. Supported types are: ${Object.values(supportedDocumentTypes).join(', ')}`,
required: true,
},
{
name: 'data',
type: 'string',
description: 'The content or data of the document. The exact format depends on the document type.',
required: true,
},
{
name: 'options',
type: 'string',
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: supportedDocumentTypes, data: unknown, 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: ${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>
${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: ${Object.values(supportedDocumentTypes).join(', ')}.`
);
this._addLinkedDoc = addLinkedDoc;
}
async execute(args: ParametersType<CreateAnyDocumentToolParamsType>): Promise<Observation[]> {
try {
const documentType = toLower(args.document_type) as unknown as supportedDocumentTypes;
const info = documentTypesInfo[documentType];
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. ${info.dataDescription}`);
}
const id = uuidv4();
const options: DocumentOptions = !args.options ? {} : JSON.parse(args.options);
// 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}.` }];
} catch (error) {
return [{ type: 'text', text: 'Error creating document: ' + (error as Error).message }];
}
}
}
|
