@alpic80/rivet-core 1.19.1-aidon.1

package/dist/esm/plugins/assemblyAi/LemurActionItemsNode.js

@@ -0,0 +1,75 @@
+import { nanoid } from 'nanoid/non-secure';
+import { dedent } from 'ts-dedent';
+import {} from '../../index.js';
+import { pluginNodeDefinition } from '../../model/NodeDefinition.js';
+import { getClient, getLemurParams, lemurEditorDefinitions, lemurInputDefinitions, } from './lemurHelpers.js';
+export const LemurActionItemsNodeImpl = {
+    create() {
+        const chartNode = {
+            type: 'assemblyAiLemurActionItems',
+            title: 'LeMUR Action Items',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                final_model: 'default',
+            },
+        };
+        return chartNode;
+    },
+    getInputDefinitions() {
+        return [
+            ...lemurInputDefinitions,
+            {
+                id: 'context',
+                dataType: 'string',
+                title: 'Context',
+            },
+        ];
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'string',
+                id: 'response',
+                title: 'Response',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Context',
+                dataKey: 'context',
+            },
+            ...lemurEditorDefinitions,
+        ];
+    },
+    getBody() {
+        return '';
+    },
+    getUIData() {
+        return {
+            infoBoxBody: dedent `Use AssemblyAI LeMUR Action Items to extract action items`,
+            infoBoxTitle: 'Use AssemblyAI LeMUR Action Items',
+            contextMenuTitle: 'LeMUR Action Items',
+            group: ['AI', 'AssemblyAI'],
+        };
+    },
+    async process(data, inputs, context) {
+        const client = getClient(context);
+        const params = getLemurParams(inputs, data);
+        const { response } = await client.lemur.actionItems(params);
+        return {
+            ['response']: {
+                type: 'string',
+                value: response,
+            },
+        };
+    },
+};
+export const lemurActionItemsNode = pluginNodeDefinition(LemurActionItemsNodeImpl, 'LeMUR Action Items');

package/dist/esm/plugins/assemblyAi/LemurQaNode.js

@@ -0,0 +1,155 @@
+import { nanoid } from 'nanoid/non-secure';
+import { dedent } from 'ts-dedent';
+import {} from '../../index.js';
+import { getClient, getLemurParams, lemurEditorDefinitions, lemurInputDefinitions, } from './lemurHelpers.js';
+import { coerceType } from '../../utils/coerceType.js';
+import { pluginNodeDefinition } from '../../model/NodeDefinition.js';
+import { AssemblyAI } from 'assemblyai';
+export const LemurQaNodeImpl = {
+    create() {
+        const chartNode = {
+            type: 'assemblyAiLemurQa',
+            title: 'LeMUR Question & Answers',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                final_model: 'default',
+            },
+        };
+        return chartNode;
+    },
+    getInputDefinitions() {
+        return [
+            ...lemurInputDefinitions,
+            {
+                id: 'questions',
+                dataType: ['string', 'string[]', 'object', 'object[]', 'any', 'any[]'],
+                title: 'Questions',
+            },
+            {
+                id: 'context',
+                dataType: 'string',
+                title: 'Context',
+            },
+        ];
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'object[]',
+                id: 'response',
+                title: 'Response',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Context',
+                dataKey: 'context',
+            },
+            ...lemurEditorDefinitions,
+            {
+                type: 'string',
+                label: 'Questions Answer Format',
+                dataKey: 'questions_answer_format',
+            },
+            {
+                type: 'string',
+                label: 'Questions Context',
+                dataKey: 'questions_context',
+            },
+            {
+                type: 'string',
+                label: 'Questions Answer Options',
+                dataKey: 'questions_answer_options',
+            },
+        ];
+    },
+    getBody() {
+        return '';
+    },
+    getUIData() {
+        return {
+            infoBoxBody: dedent `Use AssemblyAI LeMUR to ask questions about transcripts`,
+            infoBoxTitle: 'Use AssemblyAI LeMUR Question & Answer',
+            contextMenuTitle: 'LeMUR Q&A',
+            group: ['AI', 'AssemblyAI'],
+        };
+    },
+    async process(data, inputs, context) {
+        const client = getClient(context);
+        const questions = getQuestions(inputs).map((question) => applyQuestionEditors(data, question));
+        const params = {
+            questions,
+            ...getLemurParams(inputs, data),
+        };
+        const { response } = await client.lemur.questionAnswer(params);
+        return {
+            ['response']: {
+                type: 'object[]',
+                value: response,
+            },
+        };
+    },
+};
+function getQuestions(inputs) {
+    const input = inputs['questions'];
+    if (!input)
+        throw new Error('Questions are required.');
+    if (input.type === 'string') {
+        return [
+            {
+                question: coerceType(input, 'string'),
+            },
+        ];
+    }
+    else if (input.type === 'string[]') {
+        return coerceType(input, 'string[]').map((question) => ({ question }));
+    }
+    else if (input.type === 'object') {
+        return [coerceType(input, 'object')];
+    }
+    else if (input.type === 'object[]') {
+        return coerceType(input, 'object[]');
+    }
+    else if (input.type === 'any' && typeof input.value === 'string') {
+        return [
+            {
+                question: coerceType(input, 'string'),
+            },
+        ];
+    }
+    else if ((input.type === 'any' && Array.isArray(input.value)) || input.type === 'any[]') {
+        return input.value.map((question) => {
+            if (typeof question === 'string') {
+                return { question };
+            }
+            else if (typeof question === 'object') {
+                return question;
+            }
+            else {
+                throw new Error('Question must be a string or object.');
+            }
+        });
+    }
+    throw new Error('Questions must be a string, string[], a question object, or an array of question objects.');
+}
+function applyQuestionEditors(data, question) {
+    if (!('answer_format' in question) && data.questions_answer_format) {
+        question.answer_format = data.questions_answer_format;
+    }
+    if (!('answer_options' in question) && data.questions_answer_options) {
+        question.answer_options = data.questions_answer_options.split(';');
+    }
+    if (!('context' in question) && data.questions_context) {
+        question.context = data.questions_context;
+    }
+    return question;
+}
+export const lemurQaNode = pluginNodeDefinition(LemurQaNodeImpl, 'LeMUR Q&A');

package/dist/esm/plugins/assemblyAi/LemurSummaryNode.js

@@ -0,0 +1,79 @@
+import { nanoid } from 'nanoid/non-secure';
+import { dedent } from 'ts-dedent';
+import { AssemblyAI } from 'assemblyai';
+import {} from '../../index.js';
+import { getClient, getLemurParams, lemurEditorDefinitions, lemurInputDefinitions, } from './lemurHelpers.js';
+import { pluginNodeDefinition } from '../../model/NodeDefinition.js';
+export const LemurSummaryNodeImpl = {
+    create() {
+        const chartNode = {
+            type: 'assemblyAiLemurSummary',
+            title: 'LeMUR Summary',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                final_model: 'default',
+            },
+        };
+        return chartNode;
+    },
+    getInputDefinitions() {
+        return [
+            ...lemurInputDefinitions,
+            {
+                id: 'context',
+                dataType: 'string',
+                title: 'Context',
+            },
+        ];
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'string',
+                id: 'response',
+                title: 'Response',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Context',
+                dataKey: 'context',
+            },
+            ...lemurEditorDefinitions,
+        ];
+    },
+    getBody() {
+        return '';
+    },
+    getUIData() {
+        return {
+            infoBoxBody: dedent `Use AssemblyAI LeMUR Summary to summarize transcripts`,
+            infoBoxTitle: 'Use AssemblyAI LeMUR Summary',
+            contextMenuTitle: 'LeMUR Summary',
+            group: ['AI', 'AssemblyAI'],
+        };
+    },
+    async process(data, inputs, context) {
+        const client = getClient(context);
+        const params = getLemurParams(inputs, data);
+        if (data.answer_format) {
+            params.answer_format = data.answer_format;
+        }
+        const { response } = await client.lemur.summary(params);
+        return {
+            ['response']: {
+                type: 'string',
+                value: response,
+            },
+        };
+    },
+};
+export const lemurSummaryNode = pluginNodeDefinition(LemurSummaryNodeImpl, 'LeMUR Summary');

package/dist/esm/plugins/assemblyAi/LemurTaskNode.js

@@ -0,0 +1,82 @@
+import { nanoid } from 'nanoid/non-secure';
+import { dedent } from 'ts-dedent';
+import {} from 'assemblyai';
+import {} from '../../index.js';
+import { getClient, getLemurParams, lemurEditorDefinitions, lemurInputDefinitions, } from './lemurHelpers.js';
+import { pluginNodeDefinition } from '../../model/NodeDefinition.js';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
+export const LemurTaskNodeImpl = {
+    create() {
+        const chartNode = {
+            type: 'assemblyAiLemurTask',
+            title: 'LeMUR Task',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                final_model: 'default',
+            },
+        };
+        return chartNode;
+    },
+    getInputDefinitions() {
+        return [
+            ...lemurInputDefinitions,
+            {
+                id: 'prompt',
+                dataType: 'string',
+                title: 'Prompt',
+            },
+        ];
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'string',
+                id: 'response',
+                title: 'Response',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Prompt',
+                dataKey: 'prompt',
+            },
+            ...lemurEditorDefinitions,
+        ];
+    },
+    getBody() {
+        return '';
+    },
+    getUIData() {
+        return {
+            infoBoxBody: dedent `Use AssemblyAI LeMUR Custom Task to ask anything.`,
+            infoBoxTitle: 'Use AssemblyAI LeMUR Custom Task',
+            contextMenuTitle: 'LeMUR Custom Task',
+            group: ['AI', 'AssemblyAI'],
+        };
+    },
+    async process(data, inputs, context) {
+        const client = getClient(context);
+        const params = {
+            prompt: coerceTypeOptional(inputs['prompt'], 'string') || data.prompt || '',
+            ...getLemurParams(inputs, data),
+        };
+        if (!params.prompt)
+            throw new Error('Prompt must be provided.');
+        const { response } = await client.lemur.task(params);
+        return {
+            ['response']: {
+                type: 'string',
+                value: response,
+            },
+        };
+    },
+};
+export const lemurTaskNode = pluginNodeDefinition(LemurTaskNodeImpl, 'LeMUR Task');

package/dist/esm/plugins/assemblyAi/TranscribeAudioNode.js

@@ -0,0 +1,125 @@
+import { nanoid } from 'nanoid/non-secure';
+import { dedent } from 'ts-dedent';
+import {} from '../../index.js';
+import { getClient } from './lemurHelpers.js';
+import { pluginNodeDefinition } from '../../model/NodeDefinition.js';
+import { coerceType } from '../../utils/coerceType.js';
+export const TranscribeAudioNodeImpl = {
+    create() {
+        const chartNode = {
+            type: 'assemblyAiTranscribeAudio',
+            title: 'Transcribe Audio',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {},
+        };
+        return chartNode;
+    },
+    getInputDefinitions() {
+        return [
+            {
+                id: 'audio',
+                dataType: ['audio', 'string'],
+                title: 'Audio',
+            },
+        ];
+    },
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'string',
+                id: 'text',
+                title: 'Transcript text',
+            },
+            {
+                dataType: 'string',
+                id: 'id',
+                title: 'Transcript ID',
+            },
+            {
+                dataType: 'object',
+                id: 'transcript',
+                title: 'Transcript object',
+            },
+        ];
+    },
+    getEditors() {
+        return [
+            {
+                type: 'code',
+                label: 'Transcript Parameters (JSON)',
+                language: 'json',
+                dataKey: 'transcriptParameters',
+                helperMessage: `Configure additional parameters using a JSON object. This will override any other fields you have set.
+        For a detailed list of parameters, see [the AssemblyAI API documentation](https://www.assemblyai.com/docs/api-reference/transcripts/submit?utm_source=rivet).`,
+            },
+        ];
+    },
+    getBody() {
+        return '';
+    },
+    getUIData() {
+        return {
+            infoBoxBody: dedent `Use AssemblyAI to transcribe audio`,
+            infoBoxTitle: 'Transcribe Audio Node',
+            contextMenuTitle: 'Transcribe Audio',
+            group: ['AI', 'AssemblyAI'],
+        };
+    },
+    async process(data, inputs, context) {
+        const input = inputs['audio'];
+        if (!input)
+            throw new Error('Audio input is required.');
+        const client = getClient(context);
+        let audioUrl;
+        if (input.type === 'audio') {
+            const audio = coerceType(inputs['audio'], 'audio');
+            audioUrl = await client.files.upload(audio.data);
+        }
+        else if (input.type === 'string' || input.type === 'any') {
+            audioUrl = coerceType(inputs['audio'], 'string');
+        }
+        else {
+            throw new Error('Audio input must be audio or string containing the audio URL.');
+        }
+        let transcriptParams = { audio: audioUrl };
+        transcriptParams = { ...transcriptParams, ...getAdditionalParameters(data) };
+        const transcript = await client.transcripts.transcribe(transcriptParams);
+        return {
+            ['text']: {
+                type: 'string',
+                value: transcript.text,
+            },
+            ['id']: {
+                type: 'string',
+                value: transcript.id,
+            },
+            ['transcript']: {
+                type: 'object',
+                value: transcript,
+            },
+        };
+    },
+};
+export const transcribeAudioNode = pluginNodeDefinition(TranscribeAudioNodeImpl, 'Transcribe Audio');
+function getAdditionalParameters(data) {
+    const transcriptParams = data.transcriptParameters?.trim();
+    if (!transcriptParams) {
+        return {};
+    }
+    let transcriptParamsObj;
+    try {
+        transcriptParamsObj = JSON.parse(transcriptParams);
+    }
+    catch (e) {
+        throw new Error('The transcript parameters field has to be a valid JSON object, or empty.'); // This message is surfaced to the user
+    }
+    if (Array.isArray(transcriptParamsObj)) {
+        throw new Error('The transcript parameters field should be a JSON object, but is a JSON array'); // This message is surfaced to the user
+    }
+    return transcriptParamsObj;
+}

package/dist/esm/plugins/assemblyAi/index.js

@@ -0,0 +1,2 @@
+import { assemblyAiPlugin } from './plugin.js';
+export default assemblyAiPlugin;

package/dist/esm/plugins/assemblyAi/lemurHelpers.js

@@ -0,0 +1,114 @@
+import { AssemblyAI } from 'assemblyai';
+import {} from '../../index.js';
+import { coerceType, coerceTypeOptional } from '../../utils/coerceType.js';
+function getTranscriptIds(inputs) {
+    const input = inputs['transcript_ids'];
+    if (!input)
+        return undefined;
+    if (input.type === 'string' || (input.type === 'any' && typeof input.value === 'string')) {
+        return [coerceType(input, 'string')];
+    }
+    else if (input.type === 'string[]' ||
+        input.type === 'any[]' ||
+        (input.type === 'any' && Array.isArray(input.value))) {
+        return coerceType(input, 'string[]');
+    }
+    throw new Error('Transcript IDs must be a string or string[] of transcript IDs.');
+}
+const userAgent = {
+    integration: {
+        name: 'Rivet',
+        version: '1.0.1',
+    },
+};
+export function getClient(context) {
+    const apiKey = context.getPluginConfig('assemblyAiApiKey');
+    if (!apiKey) {
+        throw new Error('AssemblyAI API key not set.');
+    }
+    return new AssemblyAI({ apiKey, userAgent });
+}
+export function getLemurParams(inputs, editorData) {
+    const params = {
+        transcript_ids: getTranscriptIds(inputs),
+        input_text: coerceTypeOptional(inputs['input_text'], 'string'),
+        context: coerceTypeOptional(inputs['context'], 'string') || editorData.context || undefined,
+        final_model: editorData.final_model && editorData.final_model !== 'default' ? editorData.final_model : undefined,
+        max_output_size: editorData.max_output_size,
+        temperature: editorData.temperature,
+    };
+    return params;
+}
+export const lemurInputDefinitions = [
+    {
+        id: 'transcript_ids',
+        dataType: ['string', 'string[]', 'any', 'any[]'],
+        title: 'Transcript IDs',
+    },
+    {
+        id: 'input_text',
+        dataType: ['string'],
+        title: 'Input Text',
+    },
+];
+export const lemurEditorDefinitions = [
+    {
+        type: 'dropdown',
+        label: 'Final Model',
+        dataKey: 'final_model',
+        options: [
+            {
+                value: 'anthropic/claude-3-5-sonnet',
+                label: 'Claude 3.5 Sonnet (on Anthropic)',
+            },
+            {
+                value: 'anthropic/claude-3-opus',
+                label: 'Claude 3 Opus (on Anthropic)',
+            },
+            {
+                value: 'anthropic/claude-3-haiku',
+                label: 'Claude 3 Haiku (on Anthropic)',
+            },
+            {
+                value: 'anthropic/claude-3-sonnet',
+                label: 'Claude 3 Sonnet (on Anthropic)',
+            },
+            {
+                value: 'anthropic/claude-2-1',
+                label: 'Claude 2.1 (on Anthropic)',
+            },
+            {
+                value: 'anthropic/claude-2',
+                label: 'Claude 2.1 (on Anthropic)',
+            },
+            {
+                value: 'default',
+                label: 'Default',
+            },
+            {
+                value: 'anthropic/claude-instant-1-2',
+                label: 'Claude Instant 1.2 (on Anthropic)',
+            },
+            {
+                value: 'basic',
+                label: 'Basic',
+            },
+            {
+                value: 'assemblyai/mistral-7b',
+                label: 'Mistral 7B (hosted by AssemblyAI)',
+            },
+        ],
+    },
+    {
+        type: 'number',
+        label: 'Maximum Output Size',
+        dataKey: 'max_output_size',
+    },
+    {
+        type: 'number',
+        label: 'Temperature',
+        dataKey: 'temperature',
+        min: 0,
+        max: 1,
+    },
+];

package/dist/esm/plugins/assemblyAi/plugin.js

@@ -0,0 +1,32 @@
+import {} from '../../index.js';
+import { lemurQaNode } from './LemurQaNode.js';
+import { transcribeAudioNode } from './TranscribeAudioNode.js';
+import { lemurSummaryNode } from './LemurSummaryNode.js';
+import { lemurTaskNode } from './LemurTaskNode.js';
+import { lemurActionItemsNode } from './LemurActionItemsNode.js';
+export const assemblyAiPlugin = {
+    id: 'assemblyAi',
+    name: 'AssemblyAI',
+    register: (register) => {
+        register(transcribeAudioNode);
+        register(lemurSummaryNode);
+        register(lemurQaNode);
+        register(lemurTaskNode);
+        register(lemurActionItemsNode);
+    },
+    configSpec: {
+        assemblyAiApiKey: {
+            type: 'secret',
+            label: 'AssemblyAI API Key',
+            description: 'The API key for the AssemblyAI service.',
+            pullEnvironmentVariable: 'ASSEMBLYAI_API_KEY',
+            helperText: 'You may also set the ASSEMBLYAI_API_KEY environment variable.',
+        },
+    },
+    contextMenuGroups: [
+        {
+            id: 'add-node-group:assemblyai',
+            label: 'AssemblyAI',
+        },
+    ],
+};