@alpic80/rivet-core 1.24.0-aidon.5 → 1.24.2-aidon.10

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

@@ -0,0 +1,290 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../GraphProcessor.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';
+import { getError } from '../../utils/errors.js';
+import { getMCPBaseInputs } from '../../integrations/mcp/MCPBase.js';
+import { getServerHelperMessage, getServerOptions, loadMCPConfiguration } from '../../integrations/mcp/MCPUtils.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import { interpolate } from '../../utils/interpolation.js';
+import { keys } from '../../utils/typeSafety.js';
+export class MCPToolCallNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'mcpToolCall',
+            title: 'MCP Tool Call',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                name: 'mcp-tool-call-client',
+                version: '1.0.0',
+                transportType: 'stdio',
+                serverUrl: 'http://localhost:8080/mcp',
+                headers: '',
+                serverId: '',
+                toolName: '',
+                toolArguments: dedent `
+        {
+          "key": "value"
+        }`,
+                toolCallId: '',
+                useNameInput: false,
+                useVersionInput: false,
+                useToolNameInput: true,
+                useToolArgumentsInput: true,
+                useToolCallIdInput: true,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = getMCPBaseInputs(this.data);
+        if (this.data.useToolNameInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'toolName',
+                title: 'Tool Name',
+            });
+        }
+        if (this.data.useToolArgumentsInput) {
+            inputs.push({
+                dataType: 'object',
+                id: 'toolArguments',
+                title: 'Tool Arguments',
+            });
+        }
+        if (this.data.useToolCallIdInput) {
+            inputs.push({
+                dataType: 'object',
+                id: 'toolCallId',
+                title: 'Tool ID',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        const outputDefinitions = [];
+        outputDefinitions.push({
+            id: 'response',
+            title: 'Response',
+            dataType: 'object',
+            description: 'Response from the Tool Call',
+        });
+        outputDefinitions.push({
+            id: 'toolCallId',
+            title: 'Tool ID',
+            dataType: 'string',
+            description: 'ID associated with the Tool Call',
+        });
+        return outputDefinitions;
+    }
+    async getEditors(context) {
+        const editors = [
+            {
+                type: 'string',
+                label: 'Name',
+                dataKey: 'name',
+                useInputToggleDataKey: 'useNameInput',
+                helperMessage: 'The name for the MCP Client',
+            },
+            {
+                type: 'string',
+                label: 'Version',
+                dataKey: 'version',
+                useInputToggleDataKey: 'useVersionInput',
+                helperMessage: 'A version for the MCP Client',
+            },
+            {
+                type: 'dropdown',
+                label: 'Transport Type',
+                dataKey: 'transportType',
+                options: [
+                    { label: 'HTTP', value: 'http' },
+                    { label: 'STDIO', value: 'stdio' },
+                ],
+            },
+            {
+                type: 'string',
+                label: 'Tool Name',
+                dataKey: 'toolName',
+                useInputToggleDataKey: 'useToolNameInput',
+                helperMessage: 'The name for the MCP Tool Call',
+            },
+            {
+                type: 'code',
+                label: 'Tool Arguments',
+                dataKey: 'toolArguments',
+                language: 'json',
+                useInputToggleDataKey: 'useToolArgumentsInput',
+            },
+            {
+                type: 'string',
+                label: 'Tool ID',
+                dataKey: 'toolCallId',
+                useInputToggleDataKey: 'useToolCallIdInput',
+                helperMessage: 'The ID associated with the tool call',
+            },
+        ];
+        if (this.data.transportType === 'http') {
+            editors.push({
+                type: 'string',
+                label: 'Server URL',
+                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') {
+            const serverOptions = await getServerOptions(context);
+            editors.push({
+                type: 'dropdown',
+                label: 'Server ID',
+                dataKey: 'serverId',
+                helperMessage: getServerHelperMessage(context, serverOptions.length),
+                options: serverOptions,
+            });
+        }
+        return editors;
+    }
+    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, headers];
+        if (context.executor !== 'nodejs') {
+            parts.push('(Requires Node Executor)');
+        }
+        return parts.join('\n');
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Connects to an MCP (Model Context Protocol) server and gets a tool call response.
+      `,
+            infoBoxTitle: 'MCP Tool Call Node',
+            contextMenuTitle: 'MCP Tool Call',
+            group: ['MCP'],
+        };
+    }
+    async process(inputs, context) {
+        const name = getInputOrData(this.data, inputs, 'name', 'string');
+        const version = getInputOrData(this.data, inputs, 'version', 'string');
+        const toolName = getInputOrData(this.data, inputs, 'toolName', 'string');
+        const toolCallId = getInputOrData(this.data, inputs, 'toolCallId', 'string');
+        let toolArguments;
+        if (this.data.useToolArgumentsInput) {
+            toolArguments = getInputOrData(this.data, inputs, 'toolArguments', 'object');
+            if (toolArguments == null) {
+                throw new MCPError(MCPErrorType.INVALID_SCHEMA, 'Cannot parse tool argument with input toggle on');
+            }
+        }
+        else {
+            const inputMap = keys(inputs)
+                .filter((key) => key.startsWith('input'))
+                .reduce((acc, key) => {
+                const stringValue = coerceTypeOptional(inputs[key], 'string') ?? '';
+                const interpolationKey = key.slice('input-'.length);
+                acc[interpolationKey] = stringValue;
+                return acc;
+            }, {});
+            const interpolated = interpolate(this.data.toolArguments ?? '', inputMap);
+            toolArguments = JSON.parse(interpolated);
+        }
+        const toolCall = {
+            name: toolName,
+            arguments: toolArguments,
+        };
+        const transportType = getInputOrData(this.data, inputs, 'transportType', 'string');
+        let toolResponse = undefined;
+        try {
+            if (!context.mcpProvider) {
+                throw new Error('MCP Provider not found');
+            }
+            if (transportType === 'http') {
+                const serverUrl = getInputOrData(this.data, inputs, 'serverUrl', 'string');
+                if (!serverUrl || serverUrl === '') {
+                    throw new MCPError(MCPErrorType.SERVER_NOT_FOUND, 'No server URL was provided');
+                }
+                if (!serverUrl.includes('/mcp')) {
+                    throw new MCPError(MCPErrorType.SERVER_COMMUNICATION_FAILED, 'Include /mcp in your server URL. For example: http://localhost:8080/mcp');
+                }
+                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 ?? '';
+                const mcpConfig = await loadMCPConfiguration(context);
+                if (!mcpConfig.mcpServers[serverId]) {
+                    throw new MCPError(MCPErrorType.SERVER_NOT_FOUND, `Server ${serverId} not found in MCP config`);
+                }
+                const serverConfig = {
+                    config: mcpConfig.mcpServers[serverId],
+                    serverId,
+                };
+                toolResponse = await context.mcpProvider.stdioToolCall({ name, version }, serverConfig, toolCall);
+            }
+            const output = {};
+            output['response'] = {
+                type: 'object[]',
+                value: toolResponse?.content,
+            };
+            output['toolCallId'] = {
+                type: 'string',
+                value: toolCallId,
+            };
+            return output;
+        }
+        catch (err) {
+            const { message } = getError(err);
+            if (context.executor === 'browser') {
+                throw new Error('Failed to create Client without a node executor');
+            }
+            console.log(message);
+            throw err;
+        }
+    }
+}
+export const mcpToolCallNode = nodeDefinition(MCPToolCallNodeImpl, 'MCP Tool Call');

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

@@ -5,6 +5,7 @@ import { nodeDefinition } from '../NodeDefinition.js';
 import {} from '../DataValue.js';
 import { dedent } from 'ts-dedent';
 import {} from '../EditorDefinition.js';
+import { resolveExpressionRawValue, unwrapPotentialDataValue } from '../../utils/interpolation.js';
 const DEFAULT_JSON_TEMPLATE = `{
   "key": "{{input}}"
 }`;
@@ -26,17 +27,23 @@ export class ObjectNodeImpl extends NodeImpl {
         return chartNode;
     }
     getInputDefinitions() {
-        // Extract inputs from text, everything like {{input}}
-        const inputNames = [...new Set(this.chartNode.data.jsonTemplate.match(/\{\{([^}]+)\}\}/g))];
-        return (inputNames?.map((inputName) => {
+        // Provide default empty string for jsonTemplate if undefined
+        const jsonTemplate = this.chartNode.data.jsonTemplate ?? '';
+        const matches = jsonTemplate.match(/\{\{([^}]+?)\}\}/g); // matches is string[] | null
+        const allTokens = matches ?? []; // allTokens is now explicitly string[]
+        const inputTokens = allTokens
+            // id and title should not have the {{ and }}
+            .map((token) => token.slice(2, -2).trim())
+            .filter((tokenContent) => !tokenContent.startsWith('@graphInputs.') && !tokenContent.startsWith('@context.'))
+            .filter((token) => token !== '');
+        return [...new Set(inputTokens)].map((inputName) => {
             return {
-                // id and title should not have the {{ and }}
-                id: inputName.slice(2, -2),
-                title: inputName.slice(2, -2),
+                id: inputName,
+                title: inputName,
                 dataType: 'any',
                 required: false,
             };
-        }) ?? []);
+        });
     }
     getOutputDefinitions() {
         return [
@@ -77,10 +84,22 @@ export class ObjectNodeImpl extends NodeImpl {
             group: ['Objects'],
         };
     }
-    interpolate(baseString, values) {
-        return baseString.replace(/("?)\{\{([^}]+)\}\}("?)/g, (_m, openQuote, key, _closeQuote) => {
+    interpolate(baseString, values, graphInputNodeValues, contextValues) {
+        return baseString.replace(/("?)\{\{([^}]+?)\}\}("?)/g, (_m, openQuote, key, _closeQuote) => {
             const isQuoted = Boolean(openQuote);
-            const value = values[key];
+            const trimmedKey = key.trim(); // Use trimmedKey for lookups
+            let value;
+            const graphInputPrefix = '@graphInputs.';
+            const contextPrefix = '@context.';
+            if (trimmedKey.startsWith(graphInputPrefix) && graphInputNodeValues) {
+                value = resolveExpressionRawValue(graphInputNodeValues, trimmedKey.substring(graphInputPrefix.length), 'graphInputs');
+            }
+            else if (trimmedKey.startsWith(contextPrefix) && contextValues) {
+                value = resolveExpressionRawValue(contextValues, trimmedKey.substring(contextPrefix.length), 'context');
+            }
+            else {
+                value = values[trimmedKey]; // Original logic for non-@ variables
+            }
             if (value == null) {
                 return 'null';
             }
@@ -96,23 +115,25 @@ export class ObjectNodeImpl extends NodeImpl {
             return JSON.stringify(value);
         });
     }
-    async process(inputs) {
+    async process(inputs, context) {
         const inputMap = Object.keys(inputs).reduce((acc, key) => {
-            acc[key] = inputs[key]?.value;
+            acc[key] = unwrapPotentialDataValue(inputs[key]);
             return acc;
         }, {});
-        const outputValue = JSON.parse(this.interpolate(this.chartNode.data.jsonTemplate, inputMap));
-        if (Array.isArray(outputValue)) {
-            return {
-                output: {
-                    type: 'object[]',
-                    value: outputValue,
-                },
-            };
+        const interpolatedString = this.interpolate(this.chartNode.data.jsonTemplate, inputMap, context.graphInputNodeValues, // Pass graph inputs
+        context.contextValues // Pass context values
+        );
+        let outputValue;
+        try {
+            outputValue = JSON.parse(interpolatedString);
+        }
+        catch (err) {
+            throw new Error(`Failed to parse JSON template: ${err.message}`);
         }
+        const outputType = Array.isArray(outputValue) ? 'object[]' : 'object';
         return {
             output: {
-                type: 'object',
+                type: outputType,
                 value: outputValue,
             },
         };

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

@@ -177,7 +177,7 @@ export class PromptNodeImpl extends NodeImpl {
     }
     async process(inputs, context) {
         const inputMap = mapValues(inputs, (input) => coerceType(input, 'string'));
-        const outputValue = interpolate(this.chartNode.data.promptText, inputMap);
+        const outputValue = interpolate(this.chartNode.data.promptText, inputMap, context.graphInputNodeValues, context.contextValues);
         const type = getInputOrData(this.data, inputs, 'type', 'string');
         const isCacheBreakpoint = getInputOrData(this.data, inputs, 'isCacheBreakpoint', 'boolean');
         if (['assistant', 'system', 'user', 'function'].includes(type) === false) {

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

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

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

@@ -20,6 +20,7 @@ export class TextNodeImpl extends NodeImpl {
             },
             data: {
                 text: '{{input}}',
+                normalizeLineEndings: true, // Default to true for better compatibility
             },
         };
         return chartNode;
@@ -61,6 +62,12 @@ export class TextNodeImpl extends NodeImpl {
                 language: 'prompt-interpolation-markdown',
                 theme: 'prompt-interpolation',
             },
+            {
+                type: 'toggle',
+                label: 'Normalize Line Endings',
+                dataKey: 'normalizeLineEndings',
+                helperMessage: 'Normalize line endings to use only LF (\\n) instead of CRLF (\\r\\n).',
+            },
         ];
     }
     getBody() {
@@ -72,13 +79,17 @@ export class TextNodeImpl extends NodeImpl {
             text: truncated,
         };
     }
-    async process(inputs) {
+    async process(inputs, context) {
         const inputMap = Object.keys(inputs).reduce((acc, key) => {
             const stringValue = coerceTypeOptional(inputs[key], 'string') ?? '';
             acc[key] = stringValue;
             return acc;
         }, {});
-        const outputValue = interpolate(this.chartNode.data.text, inputMap);
+        let outputValue = interpolate(this.chartNode.data.text, inputMap, context.graphInputNodeValues, // Pass graph inputs
+        context.contextValues);
+        if (this.chartNode.data.normalizeLineEndings) {
+            outputValue = outputValue.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        }
         return {
             output: {
                 type: 'string',

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/anthropic/anthropic.js

@@ -80,12 +80,28 @@ export const anthropicModels = {
         },
         displayName: 'Claude 3.7 Sonnet',
     },
+    'claude-sonnet-4-20250514': {
+        maxTokens: 200_000,
+        cost: {
+            prompt: 3e-6,
+            completion: 3.75e-6,
+        },
+        displayName: 'Claude Sonnet 4',
+    },
+    'claude-opus-4-20250514': {
+        maxTokens: 200_000,
+        cost: {
+            prompt: 15e-6,
+            completion: 18.75e-6,
+        },
+        displayName: 'Claude Opus 4',
+    },
 };
 export const anthropicModelOptions = Object.entries(anthropicModels).map(([id, { displayName }]) => ({
     value: id,
     label: displayName,
 }));
-export async function* streamChatCompletions({ apiEndpoint, apiKey, signal, ...rest }) {
+export async function* streamChatCompletions({ apiEndpoint, apiKey, signal, additionalHeaders, ...rest }) {
     const defaultSignal = new AbortController().signal;
     const response = await fetchEventSource(`${apiEndpoint}/completions`, {
         method: 'POST',
@@ -94,6 +110,7 @@ export async function* streamChatCompletions({ apiEndpoint, apiKey, signal, ...r
             'x-api-key': apiKey,
             'anthropic-version': '2023-06-01',
             'anthropic-dangerous-direct-browser-access': 'true',
+            ...additionalHeaders,
         },
         body: JSON.stringify({
             ...rest,
@@ -125,7 +142,7 @@ export async function* streamChatCompletions({ apiEndpoint, apiKey, signal, ...r
         throw new AnthropicError(`No chunks received. Response: ${JSON.stringify(responseJson)}`, response, responseJson);
     }
 }
-export async function callMessageApi({ apiEndpoint, apiKey, signal, tools, beta, ...rest }) {
+export async function callMessageApi({ apiEndpoint, apiKey, signal, tools, beta, additionalHeaders, ...rest }) {
     const defaultSignal = new AbortController().signal;
     const response = await fetch(`${apiEndpoint}/messages`, {
         method: 'POST',
@@ -135,6 +152,7 @@ export async function callMessageApi({ apiEndpoint, apiKey, signal, tools, beta,
             'anthropic-version': '2023-06-01',
             'anthropic-dangerous-direct-browser-access': 'true',
             ...(beta ? { 'anthropic-beta': beta } : {}),
+            ...additionalHeaders,
         },
         body: JSON.stringify({
             ...rest,
@@ -149,7 +167,7 @@ export async function callMessageApi({ apiEndpoint, apiKey, signal, tools, beta,
     }
     return responseJson;
 }
-export async function* streamMessageApi({ apiEndpoint, apiKey, signal, beta, ...rest }) {
+export async function* streamMessageApi({ apiEndpoint, apiKey, signal, beta, additionalHeaders, ...rest }) {
     // Use the Messages API for Claude 3 models
     const defaultSignal = new AbortController().signal;
     const response = await fetchEventSource(`${apiEndpoint}/messages`, {
@@ -160,6 +178,7 @@ export async function* streamMessageApi({ apiEndpoint, apiKey, signal, beta, ...
             'anthropic-version': '2023-06-01',
             'anthropic-dangerous-direct-browser-access': 'true',
             ...(beta ? { 'anthropic-beta': beta } : {}),
+            ...additionalHeaders,
         },
         body: JSON.stringify({
             ...rest,

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

@@ -12,7 +12,7 @@ import { getScalarTypeOf, isArrayDataValue } from '../../../model/DataValue.js';
 import { assertNever } from '../../../utils/assertNever.js';
 import { isNotNull } from '../../../utils/genericUtilFunctions.js';
 import { uint8ArrayToBase64 } from '../../../utils/base64.js';
-import { getInputOrData } from '../../../utils/inputs.js';
+import { getInputOrData, cleanHeaders } from '../../../utils/inputs.js';
 // Temporary
 const cache = new Map();
 export const ChatAnthropicNodeImpl = {
@@ -27,7 +27,7 @@ export const ChatAnthropicNodeImpl = {
                 width: 275,
             },
             data: {
-                model: 'claude-3-7-sonnet-latest',
+                model: 'claude-sonnet-4-20250514',
                 useModelInput: false,
                 temperature: 0.5,
                 useTemperatureInput: false,
@@ -120,6 +120,14 @@ export const ChatAnthropicNodeImpl = {
                 coerced: false,
             });
         }
+        if (data.useHeadersInput) {
+            inputs.push({
+                dataType: 'object',
+                id: 'headers',
+                title: 'Headers',
+                description: 'Additional headers to send to the API.',
+            });
+        }
         return inputs;
     },
     getOutputDefinitions(data) {
@@ -267,6 +275,14 @@ export const ChatAnthropicNodeImpl = {
                         useInputToggleDataKey: 'useOverrideModelInput',
                         helperMessage: 'Overrides the AI model used for the chat node to this value.',
                     },
+                    {
+                        type: 'keyValuePair',
+                        label: 'Headers',
+                        dataKey: 'headers',
+                        useInputToggleDataKey: 'useHeadersInput',
+                        keyPlaceholder: 'Header',
+                        helperMessage: 'Additional headers to send to the API.',
+                    },
                 ],
             },
         ];
@@ -343,6 +359,18 @@ export const ChatAnthropicNodeImpl = {
             addWarning(output, message);
             maxTokens = Math.floor((modelInfo.maxTokens - tokenCountEstimate) * 0.95); // reduce max tokens by 5% to be safe, calculation is a little wrong.
         }
+        const headersFromData = (data.headers ?? []).reduce((acc, header) => {
+            acc[header.key] = header.value;
+            return acc;
+        }, {});
+        const additionalHeaders = data.useHeadersInput
+            ? coerceTypeOptional(inputs['headers'], 'object') ??
+                headersFromData
+            : headersFromData;
+        const allAdditionalHeaders = cleanHeaders({
+            ...context.settings.chatNodeHeaders,
+            ...additionalHeaders,
+        });
         try {
             return await retry(async () => {
                 const completionOptions = {
@@ -365,7 +393,7 @@ export const ChatAnthropicNodeImpl = {
                         ? tools.map((tool) => ({ name: tool.name, description: tool.description, input_schema: tool.parameters }))
                         : undefined,
                 };
-                const useMessageApi = model.startsWith('claude-3');
+                const useMessageApi = model.startsWith('claude-3') || model.startsWith('claude-sonnet') || model.startsWith('claude-opus');
                 const cacheKey = JSON.stringify(useMessageApi ? messageOptions : completionOptions);
                 if (data.cache) {
                     const cached = cache.get(cacheKey);
@@ -385,6 +413,7 @@ export const ChatAnthropicNodeImpl = {
                         apiKey: apiKey ?? '',
                         signal: context.signal,
                         beta: 'prompt-caching-2024-07-31',
+                        additionalHeaders: allAdditionalHeaders,
                         ...messageOptions,
                     });
                     // Process the response chunks and update the output
@@ -516,6 +545,7 @@ export const ChatAnthropicNodeImpl = {
                         apiEndpoint,
                         apiKey: apiKey ?? '',
                         signal: context.signal,
+                        additionalHeaders: allAdditionalHeaders,
                         ...completionOptions,
                     });
                     // Process the response chunks and update the output