@alpic80/rivet-core 1.19.1-aidon.1

package/dist/esm/plugins/aidon/nodes/ChatAidonNode.js

@@ -0,0 +1,215 @@
+import { ChatNodeImpl, Rivet, globalRivetNodeRegistry, } from '../../../index.js';
+import { omit } from 'lodash-es';
+import { dedent } from 'ts-dedent';
+import { coerceTypeOptional } from '../../../utils/coerceType.js';
+import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
+// Temporary
+const cache = new Map();
+const registry = globalRivetNodeRegistry;
+;
+class ChatAidonNodeImpl extends ChatNodeImpl {
+    create() {
+        const chatNode = {
+            ...this.chartNode,
+            type: 'chatAidon',
+            title: 'Chat (Aidon)',
+        };
+        return chatNode;
+    }
+    removeInvalidInputs(inputs) {
+        if (!inputs['toolSchemas']) {
+            const { ['functions']: _, ...rest } = inputs;
+            return rest;
+        }
+        return inputs;
+    }
+    convertToolSchemaToSchemaDetail(toolSchema) {
+        const { name, description, parameters } = toolSchema;
+        // Assuming the structure of parameters from the example
+        const { headers, requestInBody, routeMap, url } = parameters;
+        return {
+            title: name,
+            description,
+            url,
+            headers,
+            routeMap,
+            requestInBody
+        };
+    }
+    extractPath(schemaDetail, functionName, parsedArgs) {
+        const pathTemplate = Object.keys(schemaDetail.routeMap).find(key => schemaDetail.routeMap[key] === functionName);
+        if (!pathTemplate) {
+            throw new Error(`Path for function ${functionName} not found`);
+        }
+        const path = pathTemplate.replace(/:(\w+)/g, (_, paramName) => {
+            const value = parsedArgs.parameters[paramName];
+            if (!value) {
+                throw new Error(`Parameter ${paramName} not found for function ${functionName}`);
+            }
+            return encodeURIComponent(value);
+        });
+        if (!path) {
+            throw new Error(`Path for function ${functionName} not found`);
+        }
+        return path;
+    }
+    async callToolGet(parsedArgs, schemaDetail, path, data) {
+        const queryParams = new URLSearchParams(parsedArgs.parameters).toString();
+        const fullUrl = schemaDetail.url + path + (queryParams ? "?" + queryParams : "");
+        let headers = {};
+        // Check if custom headers are set
+        const customHeaders = schemaDetail.headers;
+        if (customHeaders && typeof customHeaders === "string") {
+            headers = JSON.parse(customHeaders);
+        }
+        const response = await fetch(fullUrl, {
+            method: "GET",
+            headers: headers
+        });
+        if (!response.ok) {
+            data = {
+                error: response.statusText
+            };
+        }
+        else {
+            data = await response.json();
+        }
+        return data;
+    }
+    async callToolPost(schemaDetail, path, parsedArgs, data) {
+        let headers = {
+            "Content-Type": "application/json"
+        };
+        // Check if custom headers are set
+        const customHeaders = schemaDetail.headers; // Moved this line up to the loop
+        // Check if custom headers are set and are of type string
+        if (customHeaders && typeof customHeaders === "string") {
+            let parsedCustomHeaders = JSON.parse(customHeaders);
+            headers = {
+                ...headers,
+                ...parsedCustomHeaders
+            };
+        }
+        const fullUrl = schemaDetail.url + path;
+        const bodyContent = parsedArgs.requestBody || parsedArgs;
+        const requestInit = {
+            method: "POST",
+            headers,
+            body: JSON.stringify(bodyContent) // Use the extracted requestBody or the entire parsedArgs
+        };
+        const response = await fetch(fullUrl, requestInit);
+        if (!response.ok) {
+            data = {
+                error: response.statusText
+            };
+        }
+        else {
+            data = await response.json();
+        }
+        return data;
+    }
+    // Override the process function
+    async process(inputs, context) {
+        //make sure not to include functions if we have no way to run them after.
+        inputs = this.removeInvalidInputs(inputs);
+        // Call the parent class's process method to do its job
+        let outputs = await super.process(inputs, context);
+        const funcCallOutput = outputs['function-call'] ?? outputs['function-calls'];
+        const funcCalls = funcCallOutput?.type === 'object[]'
+            ? funcCallOutput.value
+            : undefined; // coerceTypeOptional(functionCallOutput, 'string[]');
+        if (funcCalls !== undefined) {
+            const messages = outputs['all-messages'];
+            const toolSchemas = coerceTypeOptional(inputs['toolSchemas'], 'gpt-function[]');
+            const functionCalls = funcCalls.map((functionCall) => ({
+                name: functionCall.name,
+                arguments: functionCall.arguments,
+                id: functionCall.id,
+            }));
+            //call the tool(s) to get the results to add to the message
+            for (const functionCall of functionCalls) {
+                // Find the schema detail that contains the function name
+                const toolSchema = toolSchemas.find(detail => detail.name == functionCall.name);
+                if (!toolSchema) {
+                    throw new Error(`Function ${functionCall.name} not found in any schema`);
+                }
+                const schemaDetail = this.convertToolSchemaToSchemaDetail(toolSchema);
+                const path = this.extractPath(schemaDetail, functionCall.name, functionCall.arguments);
+                // Determine if the request should be in the body or as a query
+                let data = {};
+                if (schemaDetail.requestInBody) {
+                    // If the type is set to body
+                    data = await this.callToolPost(schemaDetail, path, functionCall.arguments, data);
+                }
+                else { // If the type is set to query
+                    data = await this.callToolGet(functionCall.arguments, schemaDetail, path, data);
+                }
+                messages['value'].push({
+                    type: "function",
+                    name: functionCall.id,
+                    message: JSON.stringify(data)
+                });
+            }
+            inputs = omit(inputs, ['functions', 'prompt']);
+            inputs['prompt'] = messages;
+            outputs = await super.process(inputs, context);
+        }
+        return outputs;
+    }
+}
+const createPluginNodeImpl = (chatNode) => {
+    const impl = new ChatAidonNodeImpl(chatNode);
+    return {
+        create() {
+            return impl.create();
+        },
+        getInputDefinitions(data) {
+            impl.chartNode.data = data; // Ensure data is set correctly in the base class
+            const inputs = impl.getInputDefinitions();
+            if (data.enableFunctionUse) {
+                inputs.push({
+                    dataType: ['gpt-function', 'gpt-function[]'],
+                    id: 'toolSchemas',
+                    title: 'Tool Schemas',
+                    description: 'The schemas required to run the tool(s) specified in the functions input keyed by function name.',
+                    coerced: true,
+                });
+            }
+            return inputs;
+        },
+        getOutputDefinitions(data) {
+            impl.chartNode.data = data; // Ensure data is set correctly in the base class
+            const outputs = impl.getOutputDefinitions();
+            return outputs.filter(output => {
+                return !(output.id === 'function-calls');
+            });
+        },
+        getEditors(data) {
+            impl.chartNode.data = data; // Ensure data is set correctly in the base class
+            return impl.getEditors();
+        },
+        getBody(data) {
+            impl.chartNode.data = data; // Ensure data is set correctly in the base class
+            return impl.getBody();
+        },
+        getUIData() {
+            return {
+                infoBoxBody: dedent `
+					Makes a call to an Aidon chat model. The settings contains many options for tweaking the model's behavior.
+				`,
+                infoBoxTitle: 'Chat (Aidon) Node',
+                contextMenuTitle: 'Chat (Aidon)',
+                group: ['AI'],
+            };
+        },
+        async process(data, inputData, context) {
+            impl.chartNode.data = data; // Ensure data is set correctly in the base class
+            return impl.process(inputData, context);
+        },
+    };
+};
+export function chatAidonNode() {
+    const chatNode = registry.create('chat');
+    const chatAidonNodeImpl = createPluginNodeImpl(chatNode);
+    return pluginNodeDefinition(chatAidonNodeImpl, 'Chat Aidon Node');
+}

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

@@ -0,0 +1,9 @@
+import {} from '../../index.js';
+import { chatAidonNode } from './nodes/ChatAidonNode.js';
+export const aidonPlugin = {
+    id: 'aidon',
+    name: 'Aidon',
+    register: (register) => {
+        register(chatAidonNode());
+    },
+};

package/dist/esm/plugins/anthropic/anthropic.js

@@ -0,0 +1,187 @@
+import fetchEventSource from './fetchEventSource.js';
+export const anthropicModels = {
+    'claude-instant-1': {
+        maxTokens: 100_000,
+        cost: {
+            prompt: 0.00163,
+            completion: 0.00551,
+        },
+        displayName: 'Claude Instant',
+    },
+    'claude-instant-1.2': {
+        maxTokens: 100_000,
+        cost: {
+            prompt: 0.8e-6,
+            completion: 2.4e-6,
+        },
+        displayName: 'Claude Instant 1.2',
+    },
+    'claude-2': {
+        maxTokens: 100_000,
+        cost: {
+            prompt: 8e-6,
+            completion: 24e-6,
+        },
+        displayName: 'Claude 2',
+    },
+    'claude-2.1': {
+        maxTokens: 200_000,
+        cost: {
+            prompt: 8e-6,
+            completion: 24e-6,
+        },
+        displayName: 'Claude 2.1',
+    },
+    'claude-3-haiku-20240307': {
+        maxTokens: 200_000,
+        cost: {
+            prompt: 0.25e-6,
+            completion: 1.25e-6,
+        },
+        displayName: 'Claude 3 Haiku',
+    },
+    'claude-3-sonnet-20240229': {
+        maxTokens: 200_000,
+        cost: {
+            prompt: 3e-6,
+            completion: 15e-6,
+        },
+        displayName: 'Claude 3 Sonnet',
+    },
+    'claude-3-opus-20240229': {
+        maxTokens: 200_000,
+        cost: {
+            prompt: 15e-6,
+            completion: 75e-6,
+        },
+        displayName: 'Claude 3 Opus',
+    },
+    'claude-3-5-sonnet-20240620': {
+        maxTokens: 200_000,
+        cost: {
+            prompt: 3e-6,
+            completion: 15e-6,
+        },
+        displayName: 'Claude 3.5 Sonnet',
+    },
+};
+export const anthropicModelOptions = Object.entries(anthropicModels).map(([id, { displayName }]) => ({
+    value: id,
+    label: displayName,
+}));
+export async function* streamChatCompletions({ apiKey, signal, ...rest }) {
+    const defaultSignal = new AbortController().signal;
+    const response = await fetchEventSource('https://api.anthropic.com/v1/complete', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+            ...rest,
+            stream: true,
+        }),
+        signal: signal ?? defaultSignal,
+    });
+    let hadChunks = false;
+    let nextDataType;
+    for await (const chunk of response.events()) {
+        hadChunks = true;
+        if (chunk === '[DONE]') {
+            return;
+        }
+        else if (/\[\w+\]/.test(chunk)) {
+            nextDataType = chunk.slice(1, -1);
+            continue;
+        }
+        let data;
+        try {
+            data = JSON.parse(chunk);
+        }
+        catch (err) {
+            console.error('JSON parse failed on chunk: ', chunk);
+            throw err;
+        }
+        yield data;
+    }
+    if (!hadChunks) {
+        const responseJson = await response.json();
+        throw new AnthropicError(`No chunks received. Response: ${JSON.stringify(responseJson)}`, response, responseJson);
+    }
+}
+export async function callMessageApi({ apiKey, signal, tools, ...rest }) {
+    const defaultSignal = new AbortController().signal;
+    const response = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+            'anthropic-beta': tools ? 'tools-2024-04-04' : 'messages-2023-12-15',
+        },
+        body: JSON.stringify({
+            ...rest,
+            tools,
+            stream: false,
+        }),
+        signal: signal ?? defaultSignal,
+    });
+    const responseJson = await response.json();
+    if (response.status !== 200) {
+        throw new AnthropicError(responseJson?.error?.message ?? 'Request failed', response, responseJson);
+    }
+    return responseJson;
+}
+export async function* streamMessageApi({ apiKey, signal, ...rest }) {
+    // Use the Messages API for Claude 3 models
+    const defaultSignal = new AbortController().signal;
+    const response = await fetchEventSource('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+            'anthropic-beta': 'messages-2023-12-15',
+        },
+        body: JSON.stringify({
+            ...rest,
+            stream: true,
+        }),
+        signal: signal ?? defaultSignal,
+    });
+    let hadChunks = false;
+    let nextDataType;
+    for await (const chunk of response.events()) {
+        hadChunks = true;
+        if (chunk === '[message_stop]') {
+            return;
+        }
+        else if (/\[\w+\]/.test(chunk)) {
+            nextDataType = chunk.slice(1, -1);
+            continue;
+        }
+        let data;
+        try {
+            data = JSON.parse(chunk);
+        }
+        catch (err) {
+            console.error('JSON parse failed on chunk: ', chunk);
+            throw err;
+        }
+        yield data;
+    }
+    if (!hadChunks) {
+        const responseJson = await response.json();
+        throw new AnthropicError(`No chunks received. Response: ${JSON.stringify(responseJson)}`, response, responseJson);
+    }
+}
+export class AnthropicError extends Error {
+    response;
+    responseJson;
+    constructor(message, response, responseJson) {
+        super(message);
+        this.response = response;
+        this.responseJson = responseJson;
+    }
+}

package/dist/esm/plugins/anthropic/fetchEventSource.js

@@ -0,0 +1,106 @@
+// https://github.com/openai/openai-node/issues/18#issuecomment-1518715285
+export class EventSourceResponse extends Response {
+    name;
+    streams;
+    constructor(body, init) {
+        if (body == null) {
+            super(null, init);
+            this.name = 'EventSourceResponse';
+            this.streams = null;
+            return;
+        }
+        const [bodyForString, bodyForEvents] = body.tee();
+        const streams = createEventStream(bodyForEvents);
+        // By passing our transformed stream into the Response constructor, we prevent anyone
+        // from accidentally accessing the raw response.body stream.
+        super(bodyForString, init);
+        this.name = 'EventSourceResponse';
+        this.streams = streams;
+    }
+    async *events() {
+        if (this.streams == null) {
+            return;
+        }
+        const reader = this.streams.eventStream.getReader();
+        try {
+            while (true) {
+                const { done, value } = await this.raceWithTimeout(reader.read());
+                if (done) {
+                    break;
+                }
+                yield value;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async raceWithTimeout(promise, timeout = 5000) {
+        // eslint-disable-next-line no-async-promise-executor -- Error handled correctly
+        return new Promise(async (resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error('Timeout: API response took too long.'));
+            }, timeout);
+            try {
+                const result = await promise;
+                clearTimeout(timer);
+                resolve(result);
+            }
+            catch (error) {
+                clearTimeout(timer);
+                reject(error);
+            }
+        });
+    }
+}
+export default async function fetchEventSource(url, init) {
+    const headers = {
+        ...init?.headers,
+        accept: 'text/event-stream',
+    };
+    const response = await fetch(url, {
+        ...init,
+        headers,
+    });
+    return new EventSourceResponse(response.body, response);
+}
+class LineSplitter {
+    separator;
+    buffer = '';
+    constructor(separator = /\n+/) {
+        this.separator = separator;
+    }
+    transform(chunk, controller) {
+        this.buffer += chunk;
+        const lines = this.buffer.split(this.separator);
+        this.buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            controller.enqueue(line);
+        }
+    }
+    flush(controller) {
+        if (this.buffer.length > 0) {
+            controller.enqueue(this.buffer);
+            this.buffer = '';
+        }
+    }
+}
+function createEventStream(body) {
+    if (body == null) {
+        return null;
+    }
+    const textStream = body.pipeThrough(new TextDecoderStream());
+    const eventStream = textStream.pipeThrough(new TransformStream(new LineSplitter())).pipeThrough(new TransformStream({
+        transform(line, controller) {
+            if (line.startsWith('data: ')) {
+                const data = line.slice(6).trim();
+                controller.enqueue(data);
+            }
+            else if (line.startsWith('event: ')) {
+                const event = line.slice(7).trim();
+                controller.enqueue(`[${event}]`);
+            }
+        },
+    }));
+    return { eventStream, textStream };
+}

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

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