LangChainJS

import { createRefileTool } from "./refileTool.js";
import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage } from "@langchain/core/messages";

// Initialize the OpenAI chat model
const model = new ChatOpenAI({
	temperature: 0,
	modelName: "gpt-4o", // You can change to a different model as needed
	openAIApiKey: "<token>",
});

// Create the refile tool
const refileTool = createRefileTool("<token>");

// Bind the tool to the model
const llmWithTool = model.bindTools([refileTool]);

// Create a messages array to track conversation
const messages = [
	new HumanMessage(
		"Create a research report on the rainforests of the Amazon as a PDF. Include sections on biodiversity, conservation efforts, and threats. Reply with the URL."
	),
];

// Get the initial response from the model
const aiMessage = await llmWithTool.invoke(messages);
console.log("Initial AI response:", aiMessage);

// Add the AI's response to the messages
messages.push(aiMessage);

// Check if there are tool calls to execute
if (aiMessage.tool_calls && aiMessage.tool_calls.length > 0) {
	// Process each tool call
	for (const toolCall of aiMessage.tool_calls) {
		console.log(`Executing tool call: ${toolCall.name}`);

		// Execute the tool with the tool call
		const toolMessage = await refileTool.invoke(toolCall);

		// Add the tool result to the messages
		messages.push(toolMessage);
	}

	// Get the final response with the tool results
	const finalResponse = await llmWithTool.invoke(messages);
	console.log("Final response:", finalResponse);
} else {
	// No tool calls were made
	console.log("No tool calls were made.");
}

import { DynamicStructuredTool } from "@langchain/core/tools";
import { z } from "zod";

/**
 * Creates a LangChain tool for generating PDFs from markdown text using the Refile API
 *
 * @param {string} refileApiKey - Your Refile API key
 * @param {string} [theme="modern"] - PDF theme (e.g., "modern", "minimal", "academic")
 * @param {string} [pageNumeration="center"] - Page number position ("center", "right", "none")
 * @param {string} [pageSize="A4"] - Page size (e.g., "A4", "Letter", "Legal")
 * @param {string} [refileApiBaseUrl="https://www.refile.co/api/v1"] - Refile API base URL
 * @returns {DynamicStructuredTool} - LangChain compatible tool for PDF generation
 */
export function createRefileTool(
	refileApiKey,
	theme = "modern",
	pageNumeration = "center",
	pageSize = "A4",
	refileApiBaseUrl = "https://www.refile.co/api/v1"
) {
	return new DynamicStructuredTool({
		name: "generatePdf",
		description: "Generate a PDF document from markdown text",
		schema: z.object({
			markdown: z
				.string()
				.describe("The markdown content to convert into a PDF"),
		}),
		func: async ({ markdown }) => {
			// Prepare request options
			const options = {
				method: "POST",
				headers: {
					"Content-Type": "application/json",
					Authorization: `Bearer ${refileApiKey}`,
				},
				body: JSON.stringify({
					markdown: markdown,
					theme: theme,
					pageNumeration: pageNumeration,
					pageSize: pageSize,
					output: "url",
				}),
			};

			try {
				// Make the API call
				const response = await fetch(
					`${refileApiBaseUrl}/pdf/markdown`,
					options
				);

				if (!response.ok) {
					const errorData = await response.json().catch(() => null);
					throw new Error(
						`Failed to generate PDF: ${response.status} ${response.statusText}${
							errorData ? ` - ${JSON.stringify(errorData)}` : ""
						}`
					);
				}

				// Parse and return the response
				const data = await response.json();
				return JSON.stringify({
					url: data.url,
					success: true,
					message: "PDF generated successfully",
				});
			} catch (error) {
				console.error("Error generating PDF:", error);
				return JSON.stringify({
					success: false,
					error: error.message,
					message: "Failed to generate PDF",
				});
			}
		},
	});
}