@vibe-agent-toolkit/runtime-langchain 0.1.2-rc.4

package/README.md

@@ -0,0 +1,307 @@
+# @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
+
+```bash
+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:
+```bash
+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
+
+```typescript
+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
+
+```typescript
+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
+
+```typescript
+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:
+
+```typescript
+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`
+
+```typescript
+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>`
+
+```typescript
+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>`
+
+```typescript
+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](../vat-example-cat-agents) for complete agent examples that work with this adapter.
+
+## License
+
+MIT

package/dist/adapters/conversational-assistant.d.ts

@@ -0,0 +1,121 @@
+import type { Agent, Message } from '@vibe-agent-toolkit/agent-runtime';
+import type { z } from 'zod';
+import type { LangChainLLMConfig } from '../types.js';
+/**
+ * Session state for conversational assistants
+ */
+export interface ConversationalSession<TState = Record<string, unknown>> {
+    /** Conversation history */
+    history: Message[];
+    /** Session-specific state (e.g., user profile, preferences) */
+    state: TState;
+}
+/**
+ * Configuration for conversational assistant conversion
+ */
+export interface ConversationalAssistantConfig<TInput, TOutput, TState = Record<string, unknown>> {
+    /** The VAT conversational assistant agent */
+    agent: Agent<TInput, TOutput>;
+    /** Zod schema for validating inputs */
+    inputSchema: z.ZodType<TInput>;
+    /** Zod schema for validating outputs */
+    outputSchema: z.ZodType<TOutput>;
+    /** LangChain LLM configuration */
+    llmConfig: LangChainLLMConfig;
+    /** Initial session state (optional) */
+    initialState?: TState;
+    /** System prompt (overrides agent's system prompt if provided) */
+    systemPrompt?: string;
+}
+/**
+ * Result from a conversational turn
+ */
+export interface ConversationalResult<TOutput, TState = Record<string, unknown>> {
+    /** The agent's output */
+    output: TOutput;
+    /** Updated session to pass to next turn */
+    session: ConversationalSession<TState>;
+}
+/**
+ * Converts a VAT Conversational Assistant agent to an executable function with LangChain
+ *
+ * The returned function manages conversation history and session state across turns,
+ * providing a stateful conversational interface backed by LangChain models.
+ *
+ * @param config - Configuration including agent, schemas, and LLM settings
+ * @returns Async function that executes the agent with conversation context
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { breedAdvisorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertConversationalAssistantToFunction } from '@vibe-agent-toolkit/runtime-langchain';
+ *
+ * const chat = convertConversationalAssistantToFunction({
+ *   agent: breedAdvisorAgent,
+ *   inputSchema: BreedAdvisorInputSchema,
+ *   outputSchema: BreedAdvisorOutputSchema,
+ *   llmConfig: {
+ *     model: new ChatOpenAI({ modelName: '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)
+ * result = await chat(
+ *   { message: 'I love classical music', sessionState: result.session.state },
+ *   result.session
+ * );
+ * console.log(result.output.reply);
+ * ```
+ */
+export declare function convertConversationalAssistantToFunction<TInput, TOutput, TState = Record<string, unknown>>(config: ConversationalAssistantConfig<TInput, TOutput, TState>): (input: TInput, session?: ConversationalSession<TState>) => Promise<ConversationalResult<TOutput, TState>>;
+/**
+ * Batch configuration for conversational assistant conversions
+ */
+export interface ConversationalAssistantConversionConfigs {
+    [key: string]: {
+        agent: Agent<unknown, unknown>;
+        inputSchema: z.ZodType<unknown>;
+        outputSchema: z.ZodType<unknown>;
+    };
+}
+/**
+ * Batch converts multiple VAT Conversational Assistant agents to executable functions
+ *
+ * @param configs - Map of function names to conversion configurations
+ * @param llmConfig - Shared LangChain LLM configuration for all agents
+ * @returns Map of function names to executable async functions
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const assistants = convertConversationalAssistantsToFunctions(
+ *   {
+ *     breedAdvisor: {
+ *       agent: breedAdvisorAgent,
+ *       inputSchema: BreedAdvisorInputSchema,
+ *       outputSchema: BreedAdvisorOutputSchema,
+ *     },
+ *     petCareAdvisor: {
+ *       agent: petCareAdvisorAgent,
+ *       inputSchema: PetCareInputSchema,
+ *       outputSchema: PetCareOutputSchema,
+ *     },
+ *   },
+ *   {
+ *     model: new ChatOpenAI({ modelName: 'gpt-4o' }),
+ *     temperature: 0.7,
+ *   }
+ * );
+ *
+ * const result = await assistants.breedAdvisor({ message: 'Hello' });
+ * ```
+ */
+export declare function convertConversationalAssistantsToFunctions(configs: ConversationalAssistantConversionConfigs, llmConfig: LangChainLLMConfig): Record<string, (input: unknown, session?: ConversationalSession) => Promise<ConversationalResult<unknown>>>;
+//# sourceMappingURL=conversational-assistant.d.ts.map

package/dist/adapters/conversational-assistant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversational-assistant.d.ts","sourceRoot":"","sources":["../../src/adapters/conversational-assistant.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAyB,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAC/F,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACrE,2BAA2B;IAC3B,OAAO,EAAE,OAAO,EAAE,CAAC;IAEnB,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC9F,6CAA6C;IAC7C,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE9B,uCAAuC;IACvC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE/B,wCAAwC;IACxC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAEjC,kCAAkC;IAClC,SAAS,EAAE,kBAAkB,CAAC;IAE9B,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC7E,yBAAyB;IACzB,MAAM,EAAE,OAAO,CAAC;IAEhB,2CAA2C;IAC3C,OAAO,EAAE,qBAAqB,CAAC,MAAM,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,wCAAwC,CACtD,MAAM,EACN,OAAO,EACP,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAEhC,MAAM,EAAE,6BAA6B,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,GAC7D,CACD,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,qBAAqB,CAAC,MAAM,CAAC,KACpC,OAAO,CAAC,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAiFlD;AAED;;GAEG;AACH,MAAM,WAAW,wCAAwC;IACvD,CAAC,GAAG,EAAE,MAAM,GAAG;QACb,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC/B,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAChC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;KAClC,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,0CAA0C,CACxD,OAAO,EAAE,wCAAwC,EACjD,SAAS,EAAE,kBAAkB,GAC5B,MAAM,CACP,MAAM,EACN,CACE,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,qBAAqB,KAC5B,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAC5C,CAmBA"}

package/dist/adapters/conversational-assistant.js

@@ -0,0 +1,151 @@
+import { HumanMessage, SystemMessage, AIMessage } from '@langchain/core/messages';
+/**
+ * Converts a VAT Conversational Assistant agent to an executable function with LangChain
+ *
+ * The returned function manages conversation history and session state across turns,
+ * providing a stateful conversational interface backed by LangChain models.
+ *
+ * @param config - Configuration including agent, schemas, and LLM settings
+ * @returns Async function that executes the agent with conversation context
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { breedAdvisorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertConversationalAssistantToFunction } from '@vibe-agent-toolkit/runtime-langchain';
+ *
+ * const chat = convertConversationalAssistantToFunction({
+ *   agent: breedAdvisorAgent,
+ *   inputSchema: BreedAdvisorInputSchema,
+ *   outputSchema: BreedAdvisorOutputSchema,
+ *   llmConfig: {
+ *     model: new ChatOpenAI({ modelName: '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)
+ * result = await chat(
+ *   { message: 'I love classical music', sessionState: result.session.state },
+ *   result.session
+ * );
+ * console.log(result.output.reply);
+ * ```
+ */
+export function convertConversationalAssistantToFunction(config) {
+    const { agent, inputSchema, outputSchema, llmConfig, systemPrompt } = config;
+    return async (input, session) => {
+        // Validate input
+        const validatedInput = inputSchema.parse(input);
+        // Initialize or continue session
+        const currentSession = session ?? {
+            history: [],
+            state: (config.initialState ?? {}),
+        };
+        // Add system prompt to history if this is the first turn
+        if (currentSession.history.length === 0) {
+            const metadataPrompt = agent.manifest['metadata']?.['systemPrompt'];
+            const prompt = systemPrompt ??
+                (typeof metadataPrompt === 'string'
+                    ? metadataPrompt
+                    : metadataPrompt?.gathering);
+            if (typeof prompt === 'string') {
+                currentSession.history.push({
+                    role: 'system',
+                    content: prompt,
+                });
+            }
+        }
+        // Create conversational context
+        const context = {
+            mockable: false,
+            history: [...currentSession.history],
+            addToHistory: (role, content) => {
+                context.history.push({ role, content });
+            },
+            callLLM: async (messages) => {
+                // Convert VAT messages to LangChain messages
+                const langchainMessages = messages.map((msg) => {
+                    switch (msg.role) {
+                        case 'system':
+                            return new SystemMessage(msg.content);
+                        case 'user':
+                            return new HumanMessage(msg.content);
+                        case 'assistant':
+                            return new AIMessage(msg.content);
+                        default:
+                            throw new Error(`Unknown message role: ${msg.role}`);
+                    }
+                });
+                // Call LangChain model
+                // Note: LangChain models configure temperature/maxTokens at initialization,
+                // not per-invocation. Model configuration should be passed when creating the model.
+                const response = await llmConfig.model.invoke(langchainMessages);
+                return response.content.toString();
+            },
+        };
+        // Execute the agent
+        const output = await agent.execute(validatedInput, context);
+        // Validate output
+        const validatedOutput = outputSchema.parse(output);
+        // Update session with new history
+        const updatedSession = {
+            history: context.history,
+            state: currentSession.state,
+        };
+        return {
+            output: validatedOutput,
+            session: updatedSession,
+        };
+    };
+}
+/**
+ * Batch converts multiple VAT Conversational Assistant agents to executable functions
+ *
+ * @param configs - Map of function names to conversion configurations
+ * @param llmConfig - Shared LangChain LLM configuration for all agents
+ * @returns Map of function names to executable async functions
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const assistants = convertConversationalAssistantsToFunctions(
+ *   {
+ *     breedAdvisor: {
+ *       agent: breedAdvisorAgent,
+ *       inputSchema: BreedAdvisorInputSchema,
+ *       outputSchema: BreedAdvisorOutputSchema,
+ *     },
+ *     petCareAdvisor: {
+ *       agent: petCareAdvisorAgent,
+ *       inputSchema: PetCareInputSchema,
+ *       outputSchema: PetCareOutputSchema,
+ *     },
+ *   },
+ *   {
+ *     model: new ChatOpenAI({ modelName: 'gpt-4o' }),
+ *     temperature: 0.7,
+ *   }
+ * );
+ *
+ * const result = await assistants.breedAdvisor({ message: 'Hello' });
+ * ```
+ */
+export function convertConversationalAssistantsToFunctions(configs, llmConfig) {
+    const result = {};
+    for (const [name, config] of Object.entries(configs)) {
+        result[name] = convertConversationalAssistantToFunction({
+            agent: config.agent,
+            inputSchema: config.inputSchema,
+            outputSchema: config.outputSchema,
+            llmConfig,
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=conversational-assistant.js.map

package/dist/adapters/conversational-assistant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversational-assistant.js","sourceRoot":"","sources":["../../src/adapters/conversational-assistant.ts"],"names":[],"mappings":"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"}

package/dist/adapters/llm-analyzer.d.ts

@@ -0,0 +1,75 @@
+import { type Agent } from '@vibe-agent-toolkit/agent-runtime';
+import type { z } from 'zod';
+import type { LangChainLLMConfig, LLMAnalyzerConversionConfigs } from '../types.js';
+/**
+ * Converts a VAT LLM Analyzer agent to an executable async function with LangChain
+ *
+ * @param agent - The VAT LLM analyzer agent to convert
+ * @param inputSchema - Zod schema for validating inputs
+ * @param outputSchema - Zod schema for validating outputs
+ * @param llmConfig - LangChain LLM configuration
+ * @returns Async function that executes the agent with LangChain model
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { nameGeneratorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertLLMAnalyzerToFunction } from '@vibe-agent-toolkit/runtime-langchain';
+ *
+ * const generateName = convertLLMAnalyzerToFunction(
+ *   nameGeneratorAgent,
+ *   NameGeneratorInputSchema,
+ *   NameSuggestionSchema,
+ *   {
+ *     model: new ChatOpenAI({ modelName: 'gpt-4o-mini' }),
+ *     temperature: 0.9,
+ *   }
+ * );
+ *
+ * const result = await generateName({
+ *   characteristics: {
+ *     physical: { furColor: 'Orange' },
+ *     behavioral: { personality: ['Distinguished'] },
+ *     description: 'A noble cat',
+ *   },
+ * });
+ * console.log(result.name); // "Sir Whiskersworth III"
+ * ```
+ */
+export declare function convertLLMAnalyzerToFunction<TInput, TOutput>(agent: Agent<TInput, TOutput>, inputSchema: z.ZodType<TInput>, outputSchema: z.ZodType<TOutput>, llmConfig: LangChainLLMConfig): (input: TInput) => Promise<TOutput>;
+/**
+ * Batch converts multiple VAT LLM Analyzer agents to executable functions
+ *
+ * @param configs - Map of function names to conversion configurations
+ * @param llmConfig - Shared LangChain LLM configuration for all agents
+ * @returns Map of function names to executable async functions
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const functions = convertLLMAnalyzersToFunctions(
+ *   {
+ *     generateName: {
+ *       agent: nameGeneratorAgent,
+ *       inputSchema: NameGeneratorInputSchema,
+ *       outputSchema: NameSuggestionSchema,
+ *     },
+ *     generateHaiku: {
+ *       agent: haikuGeneratorAgent,
+ *       inputSchema: HaikuGeneratorInputSchema,
+ *       outputSchema: HaikuSchema,
+ *     },
+ *   },
+ *   {
+ *     model: new ChatOpenAI({ modelName: 'gpt-4o-mini' }),
+ *     temperature: 0.8,
+ *   }
+ * );
+ *
+ * const name = await functions.generateName(catInput);
+ * const haiku = await functions.generateHaiku(catInput);
+ * ```
+ */
+export declare function convertLLMAnalyzersToFunctions(configs: LLMAnalyzerConversionConfigs, llmConfig: LangChainLLMConfig): Record<string, (input: unknown) => Promise<unknown>>;
+//# sourceMappingURL=llm-analyzer.d.ts.map

package/dist/adapters/llm-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-analyzer.d.ts","sourceRoot":"","sources":["../../src/adapters/llm-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,kBAAkB,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,OAAO,EAC1D,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAC9B,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAChC,SAAS,EAAE,kBAAkB,GAC5B,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAmCrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,4BAA4B,EACrC,SAAS,EAAE,kBAAkB,GAC5B,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAStD"}

package/dist/adapters/llm-analyzer.js

@@ -0,0 +1,107 @@
+import { batchConvert } from '@vibe-agent-toolkit/agent-runtime';
+/**
+ * Converts a VAT LLM Analyzer agent to an executable async function with LangChain
+ *
+ * @param agent - The VAT LLM analyzer agent to convert
+ * @param inputSchema - Zod schema for validating inputs
+ * @param outputSchema - Zod schema for validating outputs
+ * @param llmConfig - LangChain LLM configuration
+ * @returns Async function that executes the agent with LangChain model
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { nameGeneratorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertLLMAnalyzerToFunction } from '@vibe-agent-toolkit/runtime-langchain';
+ *
+ * const generateName = convertLLMAnalyzerToFunction(
+ *   nameGeneratorAgent,
+ *   NameGeneratorInputSchema,
+ *   NameSuggestionSchema,
+ *   {
+ *     model: new ChatOpenAI({ modelName: 'gpt-4o-mini' }),
+ *     temperature: 0.9,
+ *   }
+ * );
+ *
+ * const result = await generateName({
+ *   characteristics: {
+ *     physical: { furColor: 'Orange' },
+ *     behavioral: { personality: ['Distinguished'] },
+ *     description: 'A noble cat',
+ *   },
+ * });
+ * console.log(result.name); // "Sir Whiskersworth III"
+ * ```
+ */
+export function convertLLMAnalyzerToFunction(agent, inputSchema, outputSchema, llmConfig) {
+    // Create callLLM function that uses LangChain model
+    const callLLM = async (prompt) => {
+        const response = await llmConfig.model.invoke(prompt);
+        return response.content.toString();
+    };
+    // Return wrapped function
+    return async (input) => {
+        // Validate input
+        const validatedInput = inputSchema.parse(input);
+        // Extract model name from LangChain model
+        let modelName;
+        if ('modelName' in llmConfig.model && typeof llmConfig.model.modelName === 'string') {
+            modelName = llmConfig.model.modelName;
+        }
+        else if ('model' in llmConfig.model && typeof llmConfig.model.model === 'string') {
+            modelName = llmConfig.model.model;
+        }
+        else {
+            modelName = 'unknown';
+        }
+        // Execute the agent with mock mode disabled (real LLM call)
+        const context = {
+            mockable: false,
+            model: modelName,
+            temperature: llmConfig.temperature ?? 0.7,
+            callLLM,
+        };
+        const output = await agent.execute(validatedInput, context);
+        // Validate output
+        return outputSchema.parse(output);
+    };
+}
+/**
+ * Batch converts multiple VAT LLM Analyzer agents to executable functions
+ *
+ * @param configs - Map of function names to conversion configurations
+ * @param llmConfig - Shared LangChain LLM configuration for all agents
+ * @returns Map of function names to executable async functions
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const functions = convertLLMAnalyzersToFunctions(
+ *   {
+ *     generateName: {
+ *       agent: nameGeneratorAgent,
+ *       inputSchema: NameGeneratorInputSchema,
+ *       outputSchema: NameSuggestionSchema,
+ *     },
+ *     generateHaiku: {
+ *       agent: haikuGeneratorAgent,
+ *       inputSchema: HaikuGeneratorInputSchema,
+ *       outputSchema: HaikuSchema,
+ *     },
+ *   },
+ *   {
+ *     model: new ChatOpenAI({ modelName: 'gpt-4o-mini' }),
+ *     temperature: 0.8,
+ *   }
+ * );
+ *
+ * const name = await functions.generateName(catInput);
+ * const haiku = await functions.generateHaiku(catInput);
+ * ```
+ */
+export function convertLLMAnalyzersToFunctions(configs, llmConfig) {
+    return batchConvert(configs, (config) => convertLLMAnalyzerToFunction(config.agent, config.inputSchema, config.outputSchema, llmConfig));
+}
+//# sourceMappingURL=llm-analyzer.js.map

package/dist/adapters/llm-analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-analyzer.js","sourceRoot":"","sources":["../../src/adapters/llm-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAc,MAAM,mCAAmC,CAAC;AAK7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,4BAA4B,CAC1C,KAA6B,EAC7B,WAA8B,EAC9B,YAAgC,EAChC,SAA6B;IAE7B,oDAAoD;IACpD,MAAM,OAAO,GAAG,KAAK,EAAE,MAAc,EAAmB,EAAE;QACxD,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACtD,OAAO,QAAQ,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;IACrC,CAAC,CAAC;IAEF,0BAA0B;IAC1B,OAAO,KAAK,EAAE,KAAa,EAAoB,EAAE;QAC/C,iBAAiB;QACjB,MAAM,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAEhD,0CAA0C;QAC1C,IAAI,SAAiB,CAAC;QACtB,IAAI,WAAW,IAAI,SAAS,CAAC,KAAK,IAAI,OAAO,SAAS,CAAC,KAAK,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;YACpF,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;QACxC,CAAC;aAAM,IAAI,OAAO,IAAI,SAAS,CAAC,KAAK,IAAI,OAAO,SAAS,CAAC,KAAK,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;YACnF,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC;QACpC,CAAC;aAAM,CAAC;YACN,SAAS,GAAG,SAAS,CAAC;QACxB,CAAC;QAED,4DAA4D;QAC5D,MAAM,OAAO,GAAG;YACd,QAAQ,EAAE,KAAK;YACf,KAAK,EAAE,SAAS;YAChB,WAAW,EAAE,SAAS,CAAC,WAAW,IAAI,GAAG;YACzC,OAAO;SACR,CAAC;QAEF,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;QAE5D,kBAAkB;QAClB,OAAO,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,8BAA8B,CAC5C,OAAqC,EACrC,SAA6B;IAE7B,OAAO,YAAY,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,CACtC,4BAA4B,CAC1B,MAAM,CAAC,KAAgC,EACvC,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,YAAY,EACnB,SAAS,CACV,CACF,CAAC;AACJ,CAAC"}

package/dist/adapters/pure-function.d.ts

@@ -0,0 +1,76 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { type PureFunctionAgent, type ToolConversionConfigs } from '@vibe-agent-toolkit/agent-runtime';
+import type { z } from 'zod';
+/**
+ * Converts a VAT Pure Function agent to a LangChain DynamicStructuredTool
+ *
+ * @param agent - The VAT pure function agent to convert
+ * @param inputSchema - Zod schema for validating inputs
+ * @param outputSchema - Zod schema for validating outputs
+ * @returns LangChain tool with metadata
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { haikuValidatorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertPureFunctionToTool } from '@vibe-agent-toolkit/runtime-langchain';
+ *
+ * const tool = convertPureFunctionToTool(
+ *   haikuValidatorAgent,
+ *   HaikuSchema,
+ *   HaikuValidationResultSchema
+ * );
+ *
+ * // Use with LangChain agent
+ * const llm = new ChatOpenAI({ model: 'gpt-4' });
+ * const agent = createToolCallingAgent({ llm, tools: [tool.tool] });
+ * ```
+ */
+export declare function convertPureFunctionToTool<TInput, TOutput>(agent: PureFunctionAgent<TInput, TOutput>, inputSchema: z.ZodType<TInput>, outputSchema: z.ZodType<TOutput>): {
+    tool: DynamicStructuredTool;
+    metadata: {
+        name: string;
+        description: string;
+        version: string;
+        archetype: string;
+    };
+    inputSchema: z.ZodType<TInput>;
+    outputSchema: z.ZodType<TOutput>;
+};
+/**
+ * Batch converts multiple VAT Pure Function agents to LangChain tools
+ *
+ * @param configs - Map of tool names to conversion configurations
+ * @returns Map of tool names to LangChain DynamicStructuredTools
+ *
+ * @example
+ * ```typescript
+ * const tools = convertPureFunctionsToTools({
+ *   validateHaiku: {
+ *     agent: haikuValidatorAgent,
+ *     inputSchema: HaikuSchema,
+ *     outputSchema: HaikuValidationResultSchema,
+ *   },
+ *   validateName: {
+ *     agent: nameValidatorAgent,
+ *     inputSchema: NameSchema,
+ *     outputSchema: NameValidationResultSchema,
+ *   },
+ * });
+ *
+ * // Use all tools with LangChain agent
+ * const llm = new ChatOpenAI({ model: 'gpt-4' });
+ * const toolArray = Object.values(tools).map(t => t.tool);
+ * const agent = createToolCallingAgent({ llm, tools: toolArray });
+ * ```
+ */
+export declare function convertPureFunctionsToTools(configs: ToolConversionConfigs): Record<string, {
+    tool: DynamicStructuredTool;
+    metadata: {
+        name: string;
+        description: string;
+        version: string;
+        archetype: string;
+    };
+}>;
+//# sourceMappingURL=pure-function.d.ts.map

package/dist/adapters/pure-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure-function.d.ts","sourceRoot":"","sources":["../../src/adapters/pure-function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC3B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,EACvD,KAAK,EAAE,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,EACzC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAC9B,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,GAC/B;IACD,IAAI,EAAE,qBAAqB,CAAC;IAC5B,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/B,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;CAClC,CAgCA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,qBAAqB,GAC7B,MAAM,CACP,MAAM,EACN;IACE,IAAI,EAAE,qBAAqB,CAAC;IAC5B,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CACrF,CACF,CASA"}

package/dist/adapters/pure-function.js

@@ -0,0 +1,90 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { batchConvert, } from '@vibe-agent-toolkit/agent-runtime';
+/**
+ * Converts a VAT Pure Function agent to a LangChain DynamicStructuredTool
+ *
+ * @param agent - The VAT pure function agent to convert
+ * @param inputSchema - Zod schema for validating inputs
+ * @param outputSchema - Zod schema for validating outputs
+ * @returns LangChain tool with metadata
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { haikuValidatorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertPureFunctionToTool } from '@vibe-agent-toolkit/runtime-langchain';
+ *
+ * const tool = convertPureFunctionToTool(
+ *   haikuValidatorAgent,
+ *   HaikuSchema,
+ *   HaikuValidationResultSchema
+ * );
+ *
+ * // Use with LangChain agent
+ * const llm = new ChatOpenAI({ model: 'gpt-4' });
+ * const agent = createToolCallingAgent({ llm, tools: [tool.tool] });
+ * ```
+ */
+export function convertPureFunctionToTool(agent, inputSchema, outputSchema) {
+    const { manifest } = agent;
+    // Create LangChain DynamicStructuredTool
+    const tool = new DynamicStructuredTool({
+        name: manifest.name,
+        description: manifest.description,
+        schema: inputSchema,
+        func: async (input) => {
+            // Execute the agent - returns output directly (unwrapped)
+            // The agent's execute wrapper validates input/output schemas and throws on error
+            const output = agent.execute(input);
+            // Validate the output with schema (redundant but explicit)
+            const validated = outputSchema.parse(output);
+            // LangChain tools must return string or object that can be JSON stringified
+            return JSON.stringify(validated);
+        },
+    });
+    return {
+        tool,
+        metadata: {
+            name: manifest.name,
+            description: manifest.description,
+            version: manifest.version,
+            archetype: manifest.archetype,
+        },
+        inputSchema,
+        outputSchema,
+    };
+}
+/**
+ * Batch converts multiple VAT Pure Function agents to LangChain tools
+ *
+ * @param configs - Map of tool names to conversion configurations
+ * @returns Map of tool names to LangChain DynamicStructuredTools
+ *
+ * @example
+ * ```typescript
+ * const tools = convertPureFunctionsToTools({
+ *   validateHaiku: {
+ *     agent: haikuValidatorAgent,
+ *     inputSchema: HaikuSchema,
+ *     outputSchema: HaikuValidationResultSchema,
+ *   },
+ *   validateName: {
+ *     agent: nameValidatorAgent,
+ *     inputSchema: NameSchema,
+ *     outputSchema: NameValidationResultSchema,
+ *   },
+ * });
+ *
+ * // Use all tools with LangChain agent
+ * const llm = new ChatOpenAI({ model: 'gpt-4' });
+ * const toolArray = Object.values(tools).map(t => t.tool);
+ * const agent = createToolCallingAgent({ llm, tools: toolArray });
+ * ```
+ */
+export function convertPureFunctionsToTools(configs) {
+    return batchConvert(configs, (config) => {
+        const { tool, metadata } = convertPureFunctionToTool(config.agent, config.inputSchema, config.outputSchema);
+        return { tool, metadata };
+    });
+}
+//# sourceMappingURL=pure-function.js.map

package/dist/adapters/pure-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure-function.js","sourceRoot":"","sources":["../../src/adapters/pure-function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EACL,YAAY,GAGb,MAAM,mCAAmC,CAAC;AAG3C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,yBAAyB,CACvC,KAAyC,EACzC,WAA8B,EAC9B,YAAgC;IAYhC,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;IAE3B,yCAAyC;IACzC,MAAM,IAAI,GAAG,IAAI,qBAAqB,CAAC;QACrC,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,MAAM,EAAE,WAAW;QACnB,IAAI,EAAE,KAAK,EAAE,KAAa,EAAE,EAAE;YAC5B,0DAA0D;YAC1D,iFAAiF;YACjF,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAEpC,2DAA2D;YAC3D,MAAM,SAAS,GAAG,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAE7C,4EAA4E;YAC5E,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QACnC,CAAC;KACF,CAAC,CAAC;IAEH,OAAO;QACL,IAAI;QACJ,QAAQ,EAAE;YACR,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,WAAW,EAAE,QAAQ,CAAC,WAAW;YACjC,OAAO,EAAE,QAAQ,CAAC,OAAO;YACzB,SAAS,EAAE,QAAQ,CAAC,SAAS;SAC9B;QACD,WAAW;QACX,YAAY;KACb,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,2BAA2B,CACzC,OAA8B;IAQ9B,OAAO,YAAY,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE;QACtC,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,yBAAyB,CAClD,MAAM,CAAC,KAA4C,EACnD,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,YAAY,CACpB,CAAC;QACF,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IAC5B,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './adapters/pure-function.js';
+export * from './adapters/llm-analyzer.js';
+export * from './adapters/conversational-assistant.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wCAAwC,CAAC;AAGvD,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+// Adapters
+export * from './adapters/pure-function.js';
+export * from './adapters/llm-analyzer.js';
+export * from './adapters/conversational-assistant.js';
+// Types
+export * from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,WAAW;AACX,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wCAAwC,CAAC;AAEvD,QAAQ;AACR,cAAc,YAAY,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+/**
+ * LangChain LLM configuration for VAT agents
+ */
+export interface LangChainLLMConfig {
+    /**
+     * LangChain chat model instance (e.g., ChatOpenAI, ChatAnthropic)
+     */
+    model: BaseChatModel;
+    /**
+     * Temperature for text generation (0-1)
+     * Higher values make output more random, lower values more deterministic
+     */
+    temperature?: number;
+    /**
+     * Maximum tokens to generate
+     */
+    maxTokens?: number;
+    /**
+     * Additional model-specific settings
+     */
+    additionalSettings?: Record<string, unknown>;
+}
+export type { LLMAnalyzerConversionConfig, LLMAnalyzerConversionConfigs, ToolConversionConfig, ToolConversionConfigs, } from '@vibe-agent-toolkit/agent-runtime';
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,KAAK,EAAE,aAAa,CAAC;IAErB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9C;AAGD,YAAY,EACV,2BAA2B,EAC3B,4BAA4B,EAC5B,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,mCAAmC,CAAC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@vibe-agent-toolkit/runtime-langchain",
+  "version": "0.1.2-rc.4",
+  "description": "LangChain.js runtime adapter for VAT agents",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "demo": "tsx examples/demo.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:llm-regression": "RUN_LLM_TESTS=true bun test test/llm-regression.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@langchain/core": "^0.3.29",
+    "@vibe-agent-toolkit/agent-runtime": "0.1.2-rc.4",
+    "langchain": "^0.3.11",
+    "zod": "^3.24.1",
+    "zod-to-json-schema": "^3.24.1"
+  },
+  "devDependencies": {
+    "@langchain/anthropic": "^0.3.11",
+    "@langchain/openai": "^0.3.16",
+    "@types/node": "^22.10.5",
+    "@vibe-agent-toolkit/dev-tools": "0.1.2-rc.4",
+    "@vibe-agent-toolkit/vat-example-cat-agents": "0.1.2-rc.4",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  },
+  "keywords": [
+    "ai-agent",
+    "langchain",
+    "vibe-agent-toolkit",
+    "runtime-adapter"
+  ],
+  "author": "Jeff Dutton",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jdutton/vibe-agent-toolkit.git",
+    "directory": "packages/runtime-langchain"
+  }
+}