@alpic80/rivet-core 1.24.2-aidon.1 → 1.24.2-aidon.11

package/dist/esm/api/streaming.js

@@ -9,12 +9,14 @@ function nodeMatches(spec, event) {
 export async function* getProcessorEvents(processor, spec) {
     const previousIndexes = new Map();
     const usages = [];
+    let hasDelta = false;
     for await (const event of processor.events()) {
         if (event.type === 'partialOutput') {
             if (spec.partialOutputs === true ||
                 nodeMatches(spec.partialOutputs, event)) {
                 const currentOutput = coerceType(event.outputs['response'], 'string');
                 const delta = currentOutput.slice(previousIndexes.get(event.node.id) ?? 0);
+                hasDelta = true;
                 yield {
                     type: 'partialOutput',
                     nodeId: event.node.id,
@@ -76,8 +78,8 @@ export async function* getProcessorEvents(processor, spec) {
                     usages.push(usage);
                 }
             }
-            if (spec.nodeFinish === true ||
-                nodeMatches(spec.nodeFinish, event)) {
+            if ((spec.nodeFinish === true || nodeMatches(spec.nodeFinish, event)) &&
+                !(spec.removeFinalOutput && hasDelta)) {
                 yield {
                     type: 'nodeFinish',
                     outputs: event.outputs,
@@ -121,10 +123,14 @@ spec) {
     return new ReadableStream({
         async start(controller) {
             const userEventHandler = async (eventName, data) => {
-                sendEvent(controller, 'event', {
-                    name: eventName,
-                    message: coerceType(data, 'string')
-                });
+                const graphEvent = {
+                    type: 'event',
+                    graphEvent: {
+                        name: eventName,
+                        message: coerceType(data, 'string')
+                    }
+                };
+                sendEvent(controller, 'event', graphEvent);
             };
             const streamEvents = createOnStreamUserEvents(spec.userStreamEvents, userEventHandler);
             if (streamEvents) {
@@ -159,6 +165,19 @@ export function getSingleNodeStream(processor, arg) {
     return new ReadableStream({
         async start(controller) {
             try {
+                const userEventHandler = async (eventName, data) => {
+                    const payload = {
+                        name: eventName,
+                        message: coerceType(data, 'string')
+                    };
+                    controller.enqueue(`event: ${JSON.stringify(payload)}\n\n`);
+                };
+                const streamEvents = createOnStreamUserEvents(spec.userStreamEvents, userEventHandler);
+                if (streamEvents) {
+                    for (const [name, fn] of Object.entries(streamEvents)) {
+                        processor.onUserEvent(name, fn);
+                    }
+                }
                 for await (const event of getProcessorEvents(processor, spec)) {
                     if (event.type === 'partialOutput') { //nodeIdOrTitle filter managed by spec
                         controller.enqueue(`data: ${JSON.stringify(event.delta)}\n\n`);

package/dist/esm/integrations/mcp/MCPBase.js

@@ -23,6 +23,13 @@ export const getMCPBaseInputs = (data) => {
             description: 'The endpoint URL for the MCP server',
         });
     }
+    if (data.transportType === 'http' && data.useHeadersInput) {
+        inputs.push({
+            dataType: 'object',
+            id: 'headers',
+            title: 'Headers',
+        });
+    }
     return inputs;
 };
 export const getMCPBaseEditors = async (context, data) => {
@@ -71,6 +78,12 @@ export const getMCPBaseEditors = async (context, data) => {
             dataKey: 'serverUrl',
             useInputToggleDataKey: 'useServerUrlInput',
             helperMessage: 'The endpoint URL for the MCP server to connect',
+        }, {
+            type: 'code',
+            label: 'Headers',
+            dataKey: 'headers',
+            useInputToggleDataKey: 'useHeadersInput',
+            language: 'json',
         });
     }
     else if (data.transportType === 'stdio') {

package/dist/esm/model/GraphProcessor.js

@@ -13,7 +13,6 @@ import { coerceTypeOptional } from '../utils/coerceType.js';
 import { globalRivetNodeRegistry } from './Nodes.js';
 import { getPluginConfig } from '../utils/index.js';
 import { GptTokenizerTokenizer } from '../integrations/GptTokenizerTokenizer.js';
-// eslint-disable-next-line import/no-cycle -- There has to be a cycle because CodeRunner needs to import the entirety of Rivet
 import { IsomorphicCodeRunner } from '../integrations/CodeRunner.js';
 // CJS compatibility, gets default.default for whatever reason
 let PQueue = PQueueImport;
@@ -514,6 +513,7 @@ export class GraphProcessor {
             if (this.#running) {
                 throw new Error('Cannot process graph while already processing');
             }
+            this.#emitTraceEvent(`Process graph called. Context:${JSON.stringify(context)}, Inputs: ${JSON.stringify(inputs)}, Context Values: ${JSON.stringify(contextValues)}`);
             this.#initProcessState();
             this.#context = context;
             this.#graphInputs = inputs;
@@ -524,8 +524,11 @@ export class GraphProcessor {
                     this.#emitter.emit('error', { error });
                 });
             }
+            this.#emitTraceEvent(`Process graph calling loadProjectReferences`);
             await this.#loadProjectReferences();
+            this.#emitTraceEvent(`Process graph called loadProjectReferences`);
             this.#preprocessGraph();
+            this.#emitTraceEvent(`Process graph called preprocessGraph`);
             if (!this.#isSubProcessor) {
                 await this.#emitter.emit('start', {
                     contextValues: this.#contextValues,

package/dist/esm/model/nodes/HttpCallNode.js

@@ -141,7 +141,7 @@ export class HttpCallNodeImpl extends NodeImpl {
         return dedent `
       ${this.data.useMethodInput ? '(Method Using Input)' : this.data.method} ${this.data.useUrlInput ? '(URL Using Input)' : this.data.url} ${this.data.useHeadersInput
             ? '\nHeaders: (Using Input)'
-            : this.data.headers.trim()
+            : this.data.headers?.trim()
                 ? `\nHeaders: ${this.data.headers}`
                 : ''}${this.data.useBodyInput ? '\nBody: (Using Input)' : this.data.body.trim() ? `\nBody: ${this.data.body}` : ''}${this.data.errorOnNon200 ? '\nError on non-200' : ''}
     `;
@@ -179,7 +179,7 @@ export class HttpCallNodeImpl extends NodeImpl {
                 headers = coerceType(headersInput, 'object');
             }
         }
-        else if (this.data.headers.trim()) {
+        else if (this.data.headers?.trim()) {
             headers = JSON.parse(this.data.headers);
         }
         let body;

package/dist/esm/model/nodes/MCPDiscoveryNode.js

@@ -2,7 +2,7 @@ import { nanoid } from 'nanoid';
 import { NodeImpl } from '../NodeImpl.js';
 import {} from '../../index.js';
 import { MCPError, MCPErrorType } from '../../integrations/mcp/MCPProvider.js';
-import { dedent, getInputOrData } from '../../utils/index.js';
+import { coerceType, dedent, getInputOrData } from '../../utils/index.js';
 import { nodeDefinition } from '../NodeDefinition.js';
 import { getServerHelperMessage, getServerOptions, loadMCPConfiguration } from '../../integrations/mcp/MCPUtils.js';
 import { getMCPBaseInputs } from '../../integrations/mcp/MCPBase.js';
@@ -22,6 +22,7 @@ class MCPDiscoveryNodeImpl extends NodeImpl {
                 version: '1.0.0',
                 transportType: 'stdio',
                 serverUrl: 'http://localhost:8080/mcp',
+                headers: '',
                 serverId: '',
                 useNameInput: false,
                 useVersionInput: false,
@@ -100,6 +101,12 @@ class MCPDiscoveryNodeImpl extends NodeImpl {
                 dataKey: 'serverUrl',
                 useInputToggleDataKey: 'useServerUrlInput',
                 helperMessage: 'The base URL endpoint for the MCP server with `/mcp`',
+            }, {
+                type: 'code',
+                label: 'Headers',
+                dataKey: 'headers',
+                useInputToggleDataKey: 'useHeadersInput',
+                language: 'json',
             });
         }
         else if (this.data.transportType === 'stdio') {
@@ -116,15 +123,21 @@ class MCPDiscoveryNodeImpl extends NodeImpl {
     }
     getBody(context) {
         let base;
+        let headers = '';
         if (this.data.transportType === 'http') {
             base = this.data.useServerUrlInput ? '(Using Server URL Input)' : this.data.serverUrl;
+            headers = this.data.useHeadersInput
+                ? '\nHeaders: (Using Input)'
+                : this.data.headers?.trim()
+                    ? `\nHeaders: ${this.data.headers}`
+                    : '';
         }
         else {
             base = `Server ID: ${this.data.serverId || '(None)'}`;
         }
         const namePart = `Name: ${this.data.name}`;
         const versionPart = `Version: ${this.data.version}`;
-        const parts = [namePart, versionPart, base];
+        const parts = [namePart, versionPart, base, headers];
         if (context.executor !== 'nodejs') {
             parts.push('(Requires Node Executor)');
         }
@@ -158,8 +171,24 @@ class MCPDiscoveryNodeImpl extends NodeImpl {
                 if (!serverUrl.includes('/mcp')) {
                     throw new MCPError(MCPErrorType.SERVER_COMMUNICATION_FAILED, 'Include /mcp in your server URL. For example: http://localhost:8080/mcp');
                 }
-                tools = await context.mcpProvider.getHTTPTools({ name, version }, serverUrl);
-                prompts = await context.mcpProvider.getHTTPrompts({ name, version }, serverUrl);
+                let headers;
+                if (this.data.useHeadersInput) {
+                    const headersInput = inputs['headers'];
+                    if (headersInput?.type === 'string') {
+                        headers = JSON.parse(headersInput.value);
+                    }
+                    else if (headersInput?.type === 'object') {
+                        headers = headersInput.value;
+                    }
+                    else {
+                        headers = coerceType(headersInput, 'object');
+                    }
+                }
+                else if (this.data.headers?.trim()) {
+                    headers = JSON.parse(this.data.headers);
+                }
+                tools = await context.mcpProvider.getHTTPTools({ name, version }, serverUrl, headers);
+                prompts = await context.mcpProvider.getHTTPrompts({ name, version }, serverUrl, headers);
             }
             else if (transportType === 'stdio') {
                 const serverId = this.data.serverId ?? '';

package/dist/esm/model/nodes/MCPGetPromptNode.js

@@ -3,7 +3,7 @@ import { nanoid } from 'nanoid/non-secure';
 import { NodeImpl } from '../NodeImpl.js';
 import { nodeDefinition } from '../NodeDefinition.js';
 import {} from '../GraphProcessor.js';
-import {} from '../../index.js';
+import { coerceType } from '../../index.js';
 import { MCPError, MCPErrorType } from '../../integrations/mcp/MCPProvider.js';
 import { coerceTypeOptional } from '../../utils/coerceType.js';
 import { dedent, getInputOrData } from '../../utils/index.js';
@@ -28,6 +28,7 @@ export class MCPGetPromptNodeImpl extends NodeImpl {
                 version: '1.0.0',
                 transportType: 'stdio',
                 serverUrl: 'http://localhost:8080/mcp',
+                headers: '',
                 serverId: '',
                 promptName: '',
                 promptArguments: dedent `
@@ -117,7 +118,13 @@ export class MCPGetPromptNodeImpl extends NodeImpl {
                 label: 'Server URL',
                 dataKey: 'serverUrl',
                 useInputToggleDataKey: 'useServerUrlInput',
-                helperMessage: 'The endpoint URL for the MCP server to connect',
+                helperMessage: 'The base URL endpoint for the MCP server with `/mcp`',
+            }, {
+                type: 'code',
+                label: 'Headers',
+                dataKey: 'headers',
+                useInputToggleDataKey: 'useHeadersInput',
+                language: 'json',
             });
         }
         else if (this.data.transportType === 'stdio') {
@@ -134,15 +141,21 @@ export class MCPGetPromptNodeImpl extends NodeImpl {
     }
     getBody(context) {
         let base;
+        let headers = '';
         if (this.data.transportType === 'http') {
             base = this.data.useServerUrlInput ? '(Using Server URL Input)' : this.data.serverUrl;
+            headers = this.data.useHeadersInput
+                ? '\nHeaders: (Using Input)'
+                : this.data.headers?.trim()
+                    ? `\nHeaders: ${this.data.headers}`
+                    : '';
         }
         else {
             base = `Server ID: ${this.data.serverId || '(None)'}`;
         }
         const namePart = `Name: ${this.data.name}`;
         const versionPart = `Version: ${this.data.version}`;
-        const parts = [namePart, versionPart, base];
+        const parts = [namePart, versionPart, base, headers];
         if (context.executor !== 'nodejs') {
             parts.push('(Requires Node Executor)');
         }
@@ -199,7 +212,23 @@ export class MCPGetPromptNodeImpl extends NodeImpl {
                 if (!serverUrl.includes('/mcp')) {
                     throw new MCPError(MCPErrorType.SERVER_COMMUNICATION_FAILED, 'Include /mcp in your server URL. For example: http://localhost:8080/mcp');
                 }
-                getPromptResponse = await context.mcpProvider.getHTTPrompt({ name, version }, serverUrl, getPromptRequest);
+                let headers;
+                if (this.data.useHeadersInput) {
+                    const headersInput = inputs['headers'];
+                    if (headersInput?.type === 'string') {
+                        headers = JSON.parse(headersInput.value);
+                    }
+                    else if (headersInput?.type === 'object') {
+                        headers = headersInput.value;
+                    }
+                    else {
+                        headers = coerceType(headersInput, 'object');
+                    }
+                }
+                else if (this.data.headers?.trim()) {
+                    headers = JSON.parse(this.data.headers);
+                }
+                getPromptResponse = await context.mcpProvider.getHTTPrompt({ name, version }, serverUrl, headers, getPromptRequest);
             }
             else if (transportType === 'stdio') {
                 const serverId = this.data.serverId ?? '';

package/dist/esm/model/nodes/MCPToolCallNode.js

@@ -3,7 +3,7 @@ import { nanoid } from 'nanoid/non-secure';
 import { NodeImpl } from '../NodeImpl.js';
 import { nodeDefinition } from '../NodeDefinition.js';
 import {} from '../GraphProcessor.js';
-import {} from '../../index.js';
+import { coerceType } from '../../index.js';
 import { MCPError, MCPErrorType } from '../../integrations/mcp/MCPProvider.js';
 import { coerceTypeOptional } from '../../utils/coerceType.js';
 import { getInputOrData } from '../../utils/index.js';
@@ -30,6 +30,7 @@ export class MCPToolCallNodeImpl extends NodeImpl {
                 version: '1.0.0',
                 transportType: 'stdio',
                 serverUrl: 'http://localhost:8080/mcp',
+                headers: '',
                 serverId: '',
                 toolName: '',
                 toolArguments: dedent `
@@ -131,7 +132,7 @@ export class MCPToolCallNodeImpl extends NodeImpl {
                 label: 'Tool ID',
                 dataKey: 'toolCallId',
                 useInputToggleDataKey: 'useToolCallIdInput',
-                helperMessage: 'The name for the MCP Tool Call',
+                helperMessage: 'The ID associated with the tool call',
             },
         ];
         if (this.data.transportType === 'http') {
@@ -140,7 +141,13 @@ export class MCPToolCallNodeImpl extends NodeImpl {
                 label: 'Server URL',
                 dataKey: 'serverUrl',
                 useInputToggleDataKey: 'useServerUrlInput',
-                helperMessage: 'The endpoint URL for the MCP server to connect',
+                helperMessage: 'The base URL endpoint for the MCP server with `/mcp`',
+            }, {
+                type: 'code',
+                label: 'Headers',
+                dataKey: 'headers',
+                useInputToggleDataKey: 'useHeadersInput',
+                language: 'json',
             });
         }
         else if (this.data.transportType === 'stdio') {
@@ -157,15 +164,21 @@ export class MCPToolCallNodeImpl extends NodeImpl {
     }
     getBody(context) {
         let base;
+        let headers = '';
         if (this.data.transportType === 'http') {
             base = this.data.useServerUrlInput ? '(Using Server URL Input)' : this.data.serverUrl;
+            headers = this.data.useHeadersInput
+                ? '\nHeaders: (Using Input)'
+                : this.data.headers?.trim()
+                    ? `\nHeaders: ${this.data.headers}`
+                    : '';
         }
         else {
             base = `Server ID: ${this.data.serverId || '(None)'}`;
         }
         const namePart = `Name: ${this.data.name}`;
         const versionPart = `Version: ${this.data.version}`;
-        const parts = [namePart, versionPart, base];
+        const parts = [namePart, versionPart, base, headers];
         if (context.executor !== 'nodejs') {
             parts.push('(Requires Node Executor)');
         }
@@ -223,7 +236,23 @@ export class MCPToolCallNodeImpl extends NodeImpl {
                 if (!serverUrl.includes('/mcp')) {
                     throw new MCPError(MCPErrorType.SERVER_COMMUNICATION_FAILED, 'Include /mcp in your server URL. For example: http://localhost:8080/mcp');
                 }
-                toolResponse = await context.mcpProvider.httpToolCall({ name, version }, serverUrl, toolCall);
+                let headers;
+                if (this.data.useHeadersInput) {
+                    const headersInput = inputs['headers'];
+                    if (headersInput?.type === 'string') {
+                        headers = JSON.parse(headersInput.value);
+                    }
+                    else if (headersInput?.type === 'object') {
+                        headers = headersInput.value;
+                    }
+                    else {
+                        headers = coerceType(headersInput, 'object');
+                    }
+                }
+                else if (this.data.headers?.trim()) {
+                    headers = JSON.parse(this.data.headers);
+                }
+                toolResponse = await context.mcpProvider.httpToolCall({ name, version }, serverUrl, headers, toolCall);
             }
             else if (transportType === 'stdio') {
                 const serverId = this.data.serverId ?? '';

package/dist/esm/model/nodes/SubGraphNode.js

@@ -159,6 +159,7 @@ export class SubGraphNodeImpl extends NodeImpl {
             return outputs;
         }
         catch (err) {
+            context.trace(`Error Processing subgraph: ${getError(err).message}`);
             if (!this.data.useErrorOutput) {
                 throw err;
             }

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

@@ -53,7 +53,7 @@ class ChatAidonNodeImpl extends ChatNodeImpl {
         }
         return path;
     }
-    async callToolGet(parsedArgs, schemaDetail, path, data) {
+    async callToolGet(schemaDetail, path, parsedArgs, data) {
         const queryParams = new URLSearchParams(parsedArgs.parameters).toString();
         const fullUrl = schemaDetail.url + path + (queryParams ? "?" + queryParams : "");
         let headers = {};
@@ -112,8 +112,11 @@ class ChatAidonNodeImpl extends ChatNodeImpl {
     async process(inputs, context) {
         //make sure not to include functions if we have no way to run them after.
         inputs = this.removeInvalidInputs(inputs);
+        // const configData = this.data
+        // configData.frequencyPenalty = 2;
         // Call the parent class's process method to do its job
         let outputs = await super.process(inputs, context);
+        //Now check if the LLM wants us to do some tool calling
         const funcCallOutput = outputs['function-call'] ?? outputs['function-calls'];
         const funcCalls = funcCallOutput?.type === 'object[]'
             ? funcCallOutput.value
@@ -135,14 +138,13 @@ class ChatAidonNodeImpl extends ChatNodeImpl {
                 }
                 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
+                // Determine if the request should be in the body or as a query
+                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);
+                    data = await this.callToolGet(schemaDetail, path, functionCall.arguments, data);
                 }
                 messages['value'].push({
                     type: "function",

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

@@ -3,6 +3,21 @@ import { chatAidonNode } from './nodes/ChatAidonNode.js';
 export const aidonPlugin = {
     id: 'aidon',
     name: 'Aidon',
+    configSpec: {
+        aidonURL: {
+            type: 'string',
+            label: 'Aidon URL',
+            description: 'The URL for the Aidon application.',
+            helperText: 'Defaults to https://app.aidon.ai. URL for the Aidon application.',
+            default: 'https://app.aidon.ai',
+        },
+        aidonKey: {
+            type: 'secret',
+            label: 'Aidon API Key',
+            description: 'The API Key for the Aidon application.',
+            helperText: 'API Key for the Aidon application.',
+        },
+    },
     register: (register) => {
         register(chatAidonNode());
     },

package/dist/esm/plugins/huggingface/nodes/ChatHuggingFace.js

@@ -1,6 +1,6 @@
 import { nanoid } from 'nanoid/non-secure';
 import {} from '../../../index.js';
-import { HfInference, HfInferenceEndpoint } from '@huggingface/inference';
+import { InferenceClient } from '@huggingface/inference';
 import { getInputOrData } from '../../../utils/inputs.js';
 import { coerceType } from '../../../utils/coerceType.js';
 import { dedent } from '../../../utils/misc.js';
@@ -206,7 +206,9 @@ export const ChatHuggingFaceNodeImpl = {
         const repetitionPenalty = getInputOrData(data, inputData, 'repetitionPenalty', 'number');
         const topP = getInputOrData(data, inputData, 'topP', 'number');
         const topK = getInputOrData(data, inputData, 'topK', 'number');
-        const hf = endpoint ? new HfInferenceEndpoint(endpoint, accessToken) : new HfInference(accessToken);
+        const hf = endpoint
+            ? new InferenceClient(accessToken, { endpointUrl: endpoint })
+            : new InferenceClient(accessToken);
         const generationStream = hf.textGenerationStream({
             inputs: prompt,
             model,

package/dist/esm/plugins/huggingface/nodes/TextToImageHuggingFace.js

@@ -1,6 +1,6 @@
 import { nanoid } from 'nanoid/non-secure';
 import {} from '../../../index.js';
-import { HfInference, HfInferenceEndpoint } from '@huggingface/inference';
+import { InferenceClient } from '@huggingface/inference';
 import { dedent } from 'ts-dedent';
 import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
 import { getInputOrData } from '../../../utils/inputs.js';
@@ -163,7 +163,9 @@ export const TextToImageHuggingFaceNodeImpl = {
         const negativePrompt = getInputOrData(data, inputData, 'negativePrompt') || undefined;
         const guidanceScale = getInputOrData(data, inputData, 'guidanceScale', 'number');
         const numInferenceSteps = getInputOrData(data, inputData, 'numInferenceSteps', 'number');
-        const hf = endpoint ? new HfInferenceEndpoint(endpoint, accessToken) : new HfInference(accessToken);
+        const hf = endpoint
+            ? new InferenceClient(accessToken, { endpointUrl: endpoint })
+            : new InferenceClient(accessToken);
         const image = await hf.textToImage({
             inputs: prompt,
             model,
@@ -174,7 +176,7 @@ export const TextToImageHuggingFaceNodeImpl = {
                 guidance_scale: guidanceScale,
                 num_inference_steps: numInferenceSteps,
             },
-        });
+        }, { outputType: "blob" });
         return {
             ['output']: {
                 type: 'image',

package/dist/types/api/streaming.d.ts

@@ -1,4 +1,4 @@
-import { type NodeId, type Inputs, type Outputs, type GraphOutputs, type GraphProcessor, type DataValue, type RunGraphOptions } from '../index.js';
+import { type NodeId, type Inputs, type Outputs, type GraphOutputs, type GraphProcessor, type DataValue, type RunGraphOptions, type GraphEvents } from '../index.js';
 export type RivetEventStreamFilterSpec = {
     /** Stream partial output deltas for the specified node IDs or node titles. */
     partialOutputs?: string[] | true;
@@ -41,8 +41,7 @@ export type RivetEventStreamEvent = {
         graphOutput: GraphOutputs;
     };
     event: {
-        name: string;
-        message: string;
+        graphEvent: GraphEvents;
     };
     error: {
         error: string;

package/dist/types/integrations/mcp/MCPBase.d.ts

@@ -8,6 +8,8 @@ export interface MCPBaseNodeData {
     transportType: MCP.TransportType;
     serverUrl?: string;
     serverId?: string;
+    headers: string;
+    useHeadersInput?: boolean;
     useNameInput?: boolean;
     useVersionInput?: boolean;
     useServerUrlInput?: boolean;

package/dist/types/integrations/mcp/MCPProvider.d.ts

@@ -121,7 +121,7 @@ export interface MCPProvider {
     getHTTPTools(clientConfig: {
         name: string;
         version: string;
-    }, serverUrl: string): Promise<MCP.Tool[]>;
+    }, serverUrl: string, headers: Record<string, string> | undefined): Promise<MCP.Tool[]>;
     getStdioTools(clientConfig: {
         name: string;
         version: string;
@@ -129,7 +129,7 @@ export interface MCPProvider {
     getHTTPrompts(clientConfig: {
         name: string;
         version: string;
-    }, serverUrl: string): Promise<MCP.Prompt[]>;
+    }, serverUrl: string, headers: Record<string, string> | undefined): Promise<MCP.Prompt[]>;
     getStdioPrompts(clientConfig: {
         name: string;
         version: string;
@@ -137,7 +137,7 @@ export interface MCPProvider {
     httpToolCall(clientConfig: {
         name: string;
         version: string;
-    }, serverUrl: string, toolCall: MCP.ToolCallRequest): Promise<MCP.ToolCallResponse>;
+    }, serverUrl: string, headers: Record<string, string> | undefined, toolCall: MCP.ToolCallRequest): Promise<MCP.ToolCallResponse>;
     stdioToolCall(clientConfig: {
         name: string;
         version: string;
@@ -145,7 +145,7 @@ export interface MCPProvider {
     getHTTPrompt(clientConfig: {
         name: string;
         version: string;
-    }, serverUrl: string, getPromptRequest: MCP.GetPromptRequest): Promise<MCP.GetPromptResponse>;
+    }, serverUrl: string, headers: Record<string, string> | undefined, getPromptRequest: MCP.GetPromptRequest): Promise<MCP.GetPromptResponse>;
     getStdioPrompt(clientConfig: {
         name: string;
         version: string;

package/dist/types/model/GraphProcessor.d.ts

@@ -126,6 +126,10 @@ export type ProcessEvent = {
 }[keyof ProcessEvents];
 export type GraphOutputs = Record<string, DataValue>;
 export type GraphInputs = Record<string, DataValue>;
+export type GraphEvents = {
+    name: string;
+    message: string;
+};
 export type NodeResults = Map<NodeId, Outputs>;
 export type Inputs = Record<PortId, DataValue | undefined>;
 export type Outputs = Record<PortId, DataValue | undefined>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@alpic80/rivet-core",
   "license": "MIT",
   "repository": "https://github.com/castortech/rivet",
-  "version": "1.24.2-aidon.1",
+  "version": "1.24.2-aidon.11",
   "packageManager": "yarn@3.5.0",
   "main": "dist/cjs/bundle.cjs",
   "module": "dist/esm/index.js",
@@ -47,8 +47,8 @@
     "@gentrace/core": "^2.2.5",
     "@google-cloud/vertexai": "^0.1.3",
     "@google/genai": "^0.12.0",
-    "@huggingface/inference": "^2.6.4",
-    "@ironclad/rivet-core": "npm:@alpic80/rivet-core@1.24.2-aidon.1",
+    "@huggingface/inference": "^4.13.0",
+    "@ironclad/rivet-core": "npm:@alpic80/rivet-core@1.24.2-aidon.11",
     "assemblyai": "^4.6.0",
     "autoevals": "^0.0.26",
     "cron-parser": "^4.9.0",
@@ -56,12 +56,12 @@
     "emittery": "^1.0.1",
     "emittery-0-13": "npm:emittery@^0.13.1",
     "gpt-tokenizer": "^2.1.2",
-    "jsonpath-plus": "^10.2.0",
+    "jsonpath-plus": "^10.3.0",
     "lodash-es": "^4.17.21",
     "mdast-util-gfm-table": "^2.0.0",
     "mdast-util-to-markdown": "^2.1.2",
     "minimatch": "^9.0.3",
-    "nanoid": "^3.3.6",
+    "nanoid": "^3.3.8",
     "openai": "^4.28.4",
     "p-queue": "^7.4.1",
     "p-queue-6": "npm:p-queue@^6.0.0",
@@ -83,7 +83,7 @@
     "@types/yaml": "^1.9.7",
     "@typescript-eslint/eslint-plugin": "^8.24.0",
     "@typescript-eslint/parser": "^8.24.0",
-    "esbuild": "^0.19.5",
+    "esbuild": "^0.25.12",
     "eslint": "^9.20.1",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.31.0",