📦 NEW: tools support in pipe.run() endpoint (#140)

* 📦 NEW: tools support in pipe.run() endpoint

* 👌 IMPROVE: Code

Author: msaaddev

examples/nextjs/app/api/langbase/pipes/run-tool-stream/route.ts

@@ -9,9 +9,10 @@ export async function POST(req: NextRequest) {
 	const pipe = new Pipe(pipeWithToolsStream());
 
 	// 2. Run the pipe with user messages and other run options.
-	let {stream, threadId} = (await pipe.run(
-		runOptions,
-	)) as unknown as RunResponseStream;
+	let {stream, threadId} = (await pipe.run({
+		...runOptions,
+		stream: true,
+	})) as unknown as RunResponseStream;
 
 	// 3. Stream the response.
 	return new Response(stream, {

packages/baseai/src/dev/llms/call-anthropic.ts

@@ -6,21 +6,24 @@ import { handleLlmError } from './utils';
 import type { ModelParams } from 'types/providers';
 import type { Message, Pipe } from 'types/pipe';
 import { addToolsToParams } from '../utils/add-tools-to-params';
+import type { PipeTool } from 'types/tools';
 
 export async function callAnthropic({
 	pipe,
 	messages,
 	llmApiKey,
-	stream
+	stream,
+	paramsTools
 }: {
 	pipe: Pipe;
 	llmApiKey: string;
 	stream: boolean;
 	messages: Message[];
+	paramsTools: PipeTool[] | undefined;
 }) {
 	try {
 		const modelParams = buildModelParams(pipe, stream, messages);
-		addToolsToParams(modelParams, pipe);
+		addToolsToParams(modelParams, pipe, paramsTools);
 
 		// Transform params according to provider's format
 		const transformedRequestParams = transformToProviderRequest({

packages/baseai/src/dev/llms/call-google.ts

@@ -6,21 +6,24 @@ import { applyJsonModeIfEnabledForGoogle, handleLlmError } from './utils';
 import type { ModelParams } from 'types/providers';
 import type { Message, Pipe } from 'types/pipe';
 import { addToolsToParams } from '../utils/add-tools-to-params';
+import type { PipeTool } from 'types/tools';
 
 export async function callGoogle({
 	pipe,
 	messages,
 	llmApiKey,
-	stream
+	stream,
+	paramsTools
 }: {
 	pipe: Pipe;
 	stream: boolean;
 	llmApiKey: string;
 	messages: Message[];
+	paramsTools: PipeTool[] | undefined;
 }) {
 	try {
 		const modelParams = buildModelParams(pipe, stream, messages);
-		addToolsToParams(modelParams, pipe);
+		addToolsToParams(modelParams, pipe, paramsTools);
 
 		// Transform params according to provider's format
 		const transformedRequestParams = transformToProviderRequest({

packages/baseai/src/dev/llms/call-llm.ts

@@ -27,19 +27,22 @@ import { callPerplexity } from './call-perplexity';
 import { callTogether } from './call-together';
 import { callXAI } from './call-xai';
 import { getProvider } from '../utils/get-provider';
+import type { PipeTool } from 'types/tools';
 
 export async function callLLM({
 	pipe,
 	stream,
 	messages,
 	llmApiKey,
-	variables
+	variables,
+	paramsTools
 }: {
 	pipe: Pipe;
 	stream: boolean;
 	llmApiKey: string;
 	messages: Message[];
 	variables?: VariablesI;
+	paramsTools: PipeTool[] | undefined;
 }) {
 	try {
 		// Get the model provider from the pipe.
@@ -70,27 +73,30 @@ export async function callLLM({
 				pipe,
 				stream,
 				messages,
-				llmApiKey
+				llmApiKey,
+				paramsTools
 			});
 		}
 
 		if (modelProvider === ANTHROPIC) {
 			dlog('ANTHROPIC', '✅');
 			return await callAnthropic({
 				pipe,
+				stream,
 				messages,
 				llmApiKey,
-				stream
+				paramsTools
 			});
 		}
 
 		if (modelProvider === TOGETHER_AI) {
 			dlog('TOGETHER_AI', '✅');
 			return await callTogether({
 				pipe,
+				stream,
 				messages,
 				llmApiKey,
-				stream
+				paramsTools,
 			});
 		}
 
@@ -110,7 +116,8 @@ export async function callLLM({
 				pipe,
 				messages,
 				llmApiKey,
-				stream
+				stream,
+				paramsTools
 			});
 		}
 
@@ -120,7 +127,8 @@ export async function callLLM({
 				pipe,
 				messages,
 				llmApiKey,
-				stream
+				stream,
+				paramsTools
 			});
 		}
 

packages/baseai/src/dev/llms/call-openai.ts

@@ -7,25 +7,28 @@ import { applyJsonModeIfEnabled, handleLlmError } from './utils';
 import type { Message, Pipe } from 'types/pipe';
 import type { ModelParams } from 'types/providers';
 import { addToolsToParams } from '../utils/add-tools-to-params';
+import type { PipeTool } from 'types/tools';
 
 export async function callOpenAI({
 	pipe,
 	stream,
 	llmApiKey,
-	messages
+	messages,
+	paramsTools
 }: {
 	pipe: Pipe;
 	stream: boolean;
 	llmApiKey: string;
 	messages: Message[];
+	paramsTools: PipeTool[] | undefined;
 }) {
 	try {
 		validateInput(pipe, messages);
 		const openai = new OpenAI({ apiKey: llmApiKey });
 		await moderateContent(openai, messages, pipe.moderate);
 
 		const modelParams = buildModelParams(pipe, stream, messages);
-		addToolsToParams(modelParams, pipe);
+		addToolsToParams(modelParams, pipe, paramsTools);
 		applyJsonModeIfEnabled(modelParams, pipe);
 
 		dlog('modelParams', modelParams);

packages/baseai/src/dev/llms/call-together.ts

@@ -5,17 +5,20 @@ import { applyJsonModeIfEnabled, handleLlmError } from './utils';
 import type { Message, Pipe } from 'types/pipe';
 import type { ModelParams } from 'types/providers';
 import { addToolsToParams } from '../utils/add-tools-to-params';
+import type { PipeTool } from 'types/tools';
 
 export async function callTogether({
 	pipe,
 	messages,
 	llmApiKey,
-	stream
+	stream,
+	paramsTools
 }: {
 	pipe: Pipe;
 	llmApiKey: string;
 	stream: boolean;
 	messages: Message[];
+	paramsTools: PipeTool[] | undefined;
 }) {
 	try {
 		const modelParams = buildModelParams(pipe, stream, messages);
@@ -29,7 +32,7 @@ export async function callTogether({
 		// Together behaves weirdly with stop value. Omitting it.
 		delete modelParams['stop'];
 		applyJsonModeIfEnabled(modelParams, pipe);
-		addToolsToParams(modelParams, pipe);
+		addToolsToParams(modelParams, pipe, paramsTools);
 		dlog('modelParams', modelParams);
 
 		return await together.chat.completions.create(modelParams as any);

packages/baseai/src/dev/llms/call-xai.ts

@@ -5,17 +5,20 @@ import { handleLlmError } from './utils';
 import type { Message, Pipe } from 'types/pipe';
 import type { ModelParams } from 'types/providers';
 import { addToolsToParams } from '../utils/add-tools-to-params';
+import type { PipeTool } from 'types/tools';
 
 export async function callXAI({
 	pipe,
 	stream,
 	llmApiKey,
-	messages
+	messages,
+	paramsTools
 }: {
 	pipe: Pipe;
 	stream: boolean;
 	llmApiKey: string;
 	messages: Message[];
+	paramsTools: PipeTool[] | undefined;
 }) {
 	try {
 		const modelParams = buildModelParams(pipe, stream, messages);
@@ -27,7 +30,7 @@ export async function callXAI({
 		});
 
 		// Add tools (functions) to modelParams
-		addToolsToParams(modelParams, pipe);
+		addToolsToParams(modelParams, pipe, paramsTools);
 		dlog('modelParams', modelParams);
 
 		return await groq.chat.completions.create(modelParams as any);

packages/baseai/src/dev/routes/v1/pipes/run.ts

@@ -44,6 +44,7 @@ const RequestBodySchema = z.object({
 	stream: z.boolean(),
 	messages: z.array(schemaMessage),
 	llmApiKey: z.string(),
+	tools: z.array(pipeToolSchema).optional(),
 	variables: VariablesSchema.optional()
 });
 
@@ -138,7 +139,8 @@ const handleRun = async (c: any) => {
 			messages,
 			llmApiKey,
 			stream,
-			variables
+			variables,
+			paramsTools: validatedBody.tools
 		});
 
 		return processLlmResponse(c, validatedBody, rawLlmResponse);

packages/baseai/src/dev/utils/add-tools-to-params.ts

@@ -1,10 +1,19 @@
-import type { Pipe } from 'types/pipe';
+import type { Pipe, ToolCall } from 'types/pipe';
 import { getProvider } from './get-provider';
 import { getSupportedToolSettings, hasToolSupport } from './has-tool-support';
-import type { ModelParams, Tool } from 'types/providers';
+import type { ModelParams } from 'types/providers';
+import type { PipeTool } from 'types/tools';
 
-export function addToolsToParams(modelParams: ModelParams, pipe: Pipe) {
-	if (!pipe.tools.length) return;
+export function addToolsToParams(
+	modelParams: ModelParams,
+	pipe: Pipe,
+	paramsTools: PipeTool[] | undefined
+) {
+	const pipeTools = pipe.tools as unknown as string[];
+	const hasParamsTools = paramsTools && paramsTools.length > 0;
+
+	// 1. If no tools are provided, return the modelParams as is
+	if (!hasParamsTools && !pipeTools.length) return modelParams;
 
 	const [providerString, modelName] = pipe.model.split(':');
 	const provider = getProvider(providerString);
@@ -15,21 +24,30 @@ export function addToolsToParams(modelParams: ModelParams, pipe: Pipe) {
 		provider
 	});
 
-	if (hasToolCallSupport) {
-		const { hasParallelToolCallSupport, hasToolChoiceSupport } =
-			getSupportedToolSettings({
-				modelName,
-				provider
-			});
+	// 2. If the model does not support tool calls, return the modelParams as is
+	if (!hasToolCallSupport) return modelParams;
+
+	// If tools are provided in request param, prioritize and use them
+	if (hasParamsTools) {
+		modelParams.tools = paramsTools as ToolCall[];
+	}
+
+	// If tools are not provided in request param, use the tools from the pipe config
+	if (!hasParamsTools && pipeTools.length) {
+		modelParams.tools = pipe.tools as ToolCall[];
+	}
 
-		if (hasParallelToolCallSupport) {
-			modelParams.parallel_tool_calls = pipe.parallel_tool_calls;
-		}
+	const { hasParallelToolCallSupport, hasToolChoiceSupport } =
+		getSupportedToolSettings({
+			modelName,
+			provider
+		});
 
-		if (hasToolChoiceSupport) {
-			modelParams.tool_choice = pipe.tool_choice;
-		}
+	if (hasParallelToolCallSupport) {
+		modelParams.parallel_tool_calls = pipe.parallel_tool_calls;
+	}
 
-		modelParams.tools = pipe.tools as Tool[];
+	if (hasToolChoiceSupport) {
+		modelParams.tool_choice = pipe.tool_choice;
 	}
 }

packages/baseai/types/tools.ts

@@ -10,14 +10,6 @@ export interface Tool {
 	};
 }
 
-export interface PipeTool {
-	type: 'function';
-	function: {
-		name: string;
-		description?: string;
-		parameters?: Record<string, any>;
-	};
-}
 export const pipeToolSchema = z.object({
 	type: z.literal('function'),
 	function: z.object({
@@ -26,3 +18,5 @@ export const pipeToolSchema = z.object({
 		parameters: z.record(z.any()).optional()
 	})
 });
+
+export type PipeTool = z.infer<typeof pipeToolSchema>;