Build a composable AI Devin

LANGBASE_API_KEY=xxxxxxxxx

import { runCodeGenerationAgent } from '@/utils/run-agents';
import { validateRequestBody } from '@/utils/validate-request-body';

export const runtime = 'edge';

/**
 * Handles the POST request for the specified route.
 *
 * @param req - The request object.
 * @returns A response object.
 */
export async function POST(req: Request) {
	try {
		const { prompt, error } = await validateRequestBody(req);

		if (error || !prompt) {
			return new Response(JSON.stringify(error), { status: 400 });
		}

		const { stream, pipe } = await runCodeGenerationAgent(prompt);

		if (stream) {
			return new Response(stream, {
				headers: {
					pipe
				}
			});
		}

		return new Response(JSON.stringify({ error: 'No stream' }), {
			status: 500
		});
	} catch (error: any) {
		console.error('Uncaught API Error:', error.message);
		return new Response(JSON.stringify(error.message), { status: 500 });
	}
}

import 'server-only';
import { Langbase, getToolsFromRunStream } from 'langbase';

const langbase = new Langbase({
	apiKey: process.env.LANGBASE_API_KEY!
});

/**
 * Runs a code generation agent with the provided prompt.
 *
 * @param prompt - The input prompt for code generation
 * @returns A promise that resolves to an object containing:
 *          - pipe: The name of the pipe used for generation
 *          - stream: The output stream containing the generated content
 *
 * @remarks
 * This function processes the prompt through a langbase pipe and handles potential tool calls.
 * If tool calls are detected, it delegates to the appropriate PipeAgent.
 * Otherwise, it returns the direct output from the code-alchemist pipe.
 */
export async function runCodeGenerationAgent(prompt: string) {
	const {stream} = await langbase.pipes.run({
		stream: true,
		name: 'code-alchemist',
		messages: [{ role: 'user', content: prompt }],
	})

	const [streamForCompletion, streamForReturn] = stream.tee();

	const toolCalls = await getToolsFromRunStream(streamForCompletion);
	const hasToolCalls = toolCalls.length > 0;

	if(hasToolCalls) {
		const toolCall = toolCalls[0];
		const toolName = toolCall.function.name;
		const response = await PipeAgents[toolName](prompt);

		return {
			pipe: response.pipe,
			stream: response.stream
		};
	} else {
		return {
			pipe: 'code-alchemist',
			stream: streamForReturn
		}
	}
}

type PipeAgentsT = Record<string, (prompt: string) => Promise<{
	stream: ReadableStream<any>,
	pipe: string
}>>;

export const PipeAgents: PipeAgentsT = {
	runPairProgrammer: runPairProgrammerAgent,
	runDatabaseArchitect: runDatabaseArchitectAgent
};

async function runPairProgrammerAgent(prompt: string) {}

async function runDatabaseArchitectAgent(prompt: string) {}

/**
 * Executes a pair programmer agent with React-specific configuration.
 *
 * @param prompt - The user input prompt to be processed by the agent
 * @returns {Promise<{stream: ReadableStream, pipe: string}>} An object containing:
 *   - stream: A ReadableStream of the agent's response
 *   - pipe: The name of the pipe being used ('react-copilot')
 *
 * @example
 * const result = await runPairProgrammerAgent("Create a React button component");
 * // Use the returned stream to process the agent's response
 */
async function runPairProgrammerAgent(prompt: string) {
	const { stream } = await langbase.pipes.run({
		stream: true,
		name: 'react-copilot',
		messages: [{ role: 'user', content: prompt }],
		variables: [
			{
				name: 'framework',
				value: 'React'
			}
		]
	});

	return {
		stream,
		pipe: 'react-copilot'
	};
}

/**
 * Executes the Database Architect Agent with the given prompt.
 *
 * @param prompt - The input prompt string to be processed by the database architect agent
 * @returns An object containing:
 *          - stream: The output stream from the agent
 *          - pipe: The name of the pipe used ('database-architect')
 * @async
 */
async function runDatabaseArchitectAgent(prompt: string) {
	const {stream} = await langbase.pipes.run({
		stream: true,
		name: 'database-architect',
		messages: [{ role: 'user', content: prompt }]
	})


	return {
		stream,
		pipe: 'database-architect'
	};
}

import { getRunner } from 'langbase';
import { FormEvent, useState } from 'react';

const useLangbase = () => {
	const [loading, setLoading] = useState(false);
	const [completion, setCompletion] = useState('');
	const [hasFinishedRun, setHasFinishedRun] = useState(false);

	/**
	 * Executes the Code Alchemist agent with the provided prompt and handles the response stream.
	 *
	 * @param {Object} params - The parameters for running the Code Alchemist agent
	 * @param {FormEvent<HTMLFormElement>} [params.e] - Optional form event to prevent default behavior
	 * @param {string} params.prompt - The prompt to send to the Code Alchemist agent
	 * @param {string} [params.originalPrompt] - Optional original prompt text
	 *
	 * @throws {Error} When the API request fails or returns an error response
	 *
	 * @returns {Promise<void>}
	 */
	async function runCodeAlchemistAgent({
		e,
		prompt,
	}: {
		prompt: string;
		e?: FormEvent<HTMLFormElement>;
	}) {
		e && e.preventDefault();

		// if the prompt is empty, return
		if (!prompt.trim()) {
			console.info('Please enter a prompt first.');
			return;
		}

		try {
			setLoading(true);
			setHasFinishedRun(false);

			// make a POST request to the API endpoint to call AI pipes
			const response = await fetch('/api/generate', {
				method: 'POST',
				headers: {
					'Content-Type': 'application/json'
				},
				body: JSON.stringify({ prompt })
			});

			// if the response is not ok, throw an error
			if (!response.ok) {
				const error = await response.json();
				console.error(error);
				return;
			}

			// get the response body as a stream
			if (response.body) {
				const runner = getRunner(response.body);
				// const stream = fromReadableStream(response.body);
				runner.on('content', (content) => {
					content && setCompletion(prev => prev + content);
				});
			}


		} catch (error) {
			console.error('Something went wrong. Please try again later.');
		} finally {
			setLoading(false);
			setHasFinishedRun(true);
		}
	}


	return {
		loading,
		completion,
		hasFinishedRun,
		runCodeAlchemistAgent
	};
};

export default useLangbase;