Package Exports

@vibe-agent-toolkit/runtime-langchain

Readme

@vibe-agent-toolkit/runtime-langchain

LangChain.js runtime adapter for VAT (Vibe Agent Toolkit) agents.

Converts VAT archetype agents to LangChain primitives, enabling portability across LLM providers (OpenAI, Anthropic, etc.) while maintaining type safety and agent semantics.

Installation

npm install @vibe-agent-toolkit/runtime-langchain langchain @langchain/core
# or
bun add @vibe-agent-toolkit/runtime-langchain langchain @langchain/core

You'll also need an LLM provider package:

npm install @langchain/openai    # For OpenAI
npm install @langchain/anthropic # For Anthropic Claude

Supported Archetypes

Conversational Assistant → Async Function with History

Converts multi-turn conversational VAT agents to stateful async functions that manage conversation history and session state.

Use cases: Chatbots, advisory systems, interactive assistants, context-aware conversations.

Example: Breed Advisor

import { ChatOpenAI } from '@langchain/openai';
import { breedAdvisorAgent, BreedAdvisorInputSchema, BreedAdvisorOutputSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
import { convertConversationalAssistantToFunction } from '@vibe-agent-toolkit/runtime-langchain';

// Convert VAT agent to conversational function
const chat = convertConversationalAssistantToFunction({
  agent: breedAdvisorAgent,
  inputSchema: BreedAdvisorInputSchema,
  outputSchema: BreedAdvisorOutputSchema,
  llmConfig: {
    model: new ChatOpenAI({ model: 'gpt-4o' }),
    temperature: 0.7,
  },
});

// First turn
let result = await chat({
  message: 'I need help finding a cat breed',
});
console.log(result.output.reply);

// Second turn (pass session to maintain history)
result = await chat(
  {
    message: 'I love classical music',
    sessionState: { profile: result.output.updatedProfile },
  },
  result.session
);
console.log(result.output.reply);

// Continue conversation with accumulated context
result = await chat(
  {
    message: 'I live in an apartment with kids',
    sessionState: { profile: result.output.updatedProfile },
  },
  result.session
);

// Get recommendations
if (result.output.recommendations) {
  console.log('Recommended breeds:', result.output.recommendations);
}

Pure Function Tools → `DynamicStructuredTool`

Converts synchronous, deterministic VAT agents to LangChain tools that can be called by LLMs.

Use cases: Validation, transformation, computation, structured data operations.

Example: Haiku Validator

import { ChatOpenAI } from '@langchain/openai';
import { createToolCallingAgent, AgentExecutor } from 'langchain/agents';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { haikuValidatorAgent, HaikuSchema, HaikuValidationResultSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
import { convertPureFunctionToTool } from '@vibe-agent-toolkit/runtime-langchain';

// Convert VAT agent to LangChain tool
const { tool } = convertPureFunctionToTool(
  haikuValidatorAgent,
  HaikuSchema,
  HaikuValidationResultSchema
);

// Use with LangChain agent
const llm = new ChatOpenAI({ model: 'gpt-4o-mini' });
const prompt = ChatPromptTemplate.fromMessages([
  ['system', 'You are a helpful assistant'],
  ['human', '{input}'],
  ['placeholder', '{agent_scratchpad}'],
]);

const agent = await createToolCallingAgent({
  llm,
  tools: [tool],
  prompt,
});

const executor = new AgentExecutor({ agent, tools: [tool] });
const result = await executor.invoke({
  input: 'Write a haiku about an orange cat and validate it'
});

LLM Analyzer → Async Function

Converts LLM-powered VAT agents to executable async functions that work with any LangChain chat model.

Use cases: Content generation, analysis, transformation, structured output from LLMs.

Example: Name Generator

import { ChatOpenAI } from '@langchain/openai';
import { nameGeneratorAgent, NameGeneratorInputSchema, NameSuggestionSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
import { convertLLMAnalyzerToFunction } from '@vibe-agent-toolkit/runtime-langchain';

// Convert VAT agent to executable function
const generateName = convertLLMAnalyzerToFunction(
  nameGeneratorAgent,
  NameGeneratorInputSchema,
  NameSuggestionSchema,
  {
    model: new ChatOpenAI({ model: 'gpt-4o-mini' }),
    temperature: 0.9,
  }
);

// Execute directly
const result = await generateName({
  characteristics: {
    physical: { furColor: 'Orange' },
    behavioral: { personality: ['Distinguished'] },
    description: 'A noble orange cat',
  },
});

console.log(result.name);      // "Sir Whiskersworth III"
console.log(result.reasoning); // "This name captures..."

Provider-Agnostic Architecture

The same VAT agent code works with any LangChain-supported LLM provider:

import { ChatOpenAI } from '@langchain/openai';
import { ChatAnthropic } from '@langchain/anthropic';
import { convertLLMAnalyzerToFunction } from '@vibe-agent-toolkit/runtime-langchain';

// OpenAI
const generateNameOpenAI = convertLLMAnalyzerToFunction(
  nameGeneratorAgent,
  NameGeneratorInputSchema,
  NameSuggestionSchema,
  { model: new ChatOpenAI({ model: 'gpt-4o-mini' }) }
);

// Anthropic
const generateNameAnthropic = convertLLMAnalyzerToFunction(
  nameGeneratorAgent,
  NameGeneratorInputSchema,
  NameSuggestionSchema,
  { model: new ChatAnthropic({ model: 'claude-sonnet-4-5-20250929' }) }
);

// Same agent, different providers
const [openaiResult, anthropicResult] = await Promise.all([
  generateNameOpenAI(input),
  generateNameAnthropic(input),
]);

API Reference

`convertPureFunctionToTool()`

Converts a VAT Pure Function agent to a LangChain DynamicStructuredTool.

Parameters:

agent: PureFunctionAgent<TInput, TOutput> - The VAT agent to convert
inputSchema: z.ZodType<TInput> - Zod schema for input validation
outputSchema: z.ZodType<TOutput> - Zod schema for output validation

Returns: Object with:

tool: DynamicStructuredTool - LangChain tool ready for agent use
metadata: { name, description, version, archetype } - Agent metadata
inputSchema: z.ZodType<TInput> - Original input schema
outputSchema: z.ZodType<TOutput> - Original output schema

`convertPureFunctionsToTools()`

Batch converts multiple pure function agents to LangChain tools.

Parameters:

configs: Record<string, ToolConversionConfig> - Map of tool names to conversion configs

Returns: Record<string, { tool: DynamicStructuredTool, metadata }> - Map of converted tools

`convertLLMAnalyzerToFunction()`

Converts a VAT LLM Analyzer agent to an executable async function.

Parameters:

agent: Agent<TInput, TOutput> - The VAT agent to convert
inputSchema: z.ZodType<TInput> - Zod schema for input validation
outputSchema: z.ZodType<TOutput> - Zod schema for output validation
llmConfig: LangChainLLMConfig - LangChain LLM configuration

Returns: (input: TInput) => Promise<TOutput> - Executable async function

`convertLLMAnalyzersToFunctions()`

Batch converts multiple LLM Analyzer agents with shared LLM config.

Parameters:

configs: Record<string, LLMAnalyzerConversionConfig> - Map of function names to conversion configs
llmConfig: LangChainLLMConfig - Shared LangChain LLM configuration

Returns: Record<string, (input: any) => Promise<any>> - Map of executable functions

`convertConversationalAssistantToFunction()`

Converts a VAT Conversational Assistant agent to a stateful async function with conversation history management.

Parameters:

config: ConversationalAssistantConfig<TInput, TOutput, TState> - Configuration object containing:
- agent: Agent<TInput, TOutput> - The VAT agent to convert
- inputSchema: z.ZodType<TInput> - Zod schema for input validation
- outputSchema: z.ZodType<TOutput> - Zod schema for output validation
- llmConfig: LangChainLLMConfig - LangChain LLM configuration
- initialState?: TState - Optional initial session state
- systemPrompt?: string - Optional system prompt override

Returns: (input: TInput, session?: ConversationalSession<TState>) => Promise<ConversationalResult<TOutput, TState>>

The returned function accepts:

input - User input for this turn
session - Optional session from previous turn (for conversation continuity)

And returns:

output - Agent's validated output
session - Updated session to pass to next turn (includes history and state)

`convertConversationalAssistantsToFunctions()`

Batch converts multiple Conversational Assistant agents with shared LLM config.

Parameters:

configs: Record<string, ConversationalAssistantConversionConfig> - Map of function names to conversion configs
llmConfig: LangChainLLMConfig - Shared LangChain LLM configuration

Returns: Record<string, (input: any, session?: ConversationalSession) => Promise<ConversationalResult<any>>> - Map of executable functions

Type Definitions

`LangChainLLMConfig`

interface LangChainLLMConfig {
  model: BaseChatModel;              // LangChain chat model instance
  temperature?: number;               // 0-1, default 0.7
  maxTokens?: number;                 // Maximum tokens to generate
  additionalSettings?: Record<string, unknown>; // Provider-specific settings
}

`ConversationalSession<TState>`

interface ConversationalSession<TState = Record<string, unknown>> {
  history: Message[];     // Conversation history (system/user/assistant messages)
  state: TState;          // Session-specific state (e.g., user profile)
}

`ConversationalResult<TOutput, TState>`

interface ConversationalResult<TOutput, TState = Record<string, unknown>> {
  output: TOutput;                        // Agent's validated output
  session: ConversationalSession<TState>; // Updated session for next turn
}

Examples

See @vibe-agent-toolkit/vat-example-cat-agents for complete agent examples that work with this adapter.

License

MIT