@vibe-agent-toolkit/runtime-openai 0.1.2-rc.3

package/README.md

@@ -0,0 +1,268 @@
+# @vibe-agent-toolkit/runtime-openai
+
+OpenAI SDK runtime adapter for VAT (Vibe Agent Toolkit) agents.
+
+Converts VAT archetype agents to OpenAI SDK primitives (function calling, chat completions), enabling direct API access without framework overhead while maintaining type safety and agent semantics.
+
+## Installation
+
+```bash
+npm install @vibe-agent-toolkit/runtime-openai openai
+# or
+bun add @vibe-agent-toolkit/runtime-openai openai
+```
+
+## Supported Archetypes
+
+### Pure Function Tools → Function Calling
+
+Converts synchronous, deterministic VAT agents to OpenAI function calling tools.
+
+**Use cases:** Validation, transformation, computation, structured data operations.
+
+#### Example: Haiku Validator
+
+```typescript
+import OpenAI from 'openai';
+import { haikuValidatorAgent, HaikuSchema, HaikuValidationResultSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+import { convertPureFunctionToTool } from '@vibe-agent-toolkit/runtime-openai';
+
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+// Convert VAT agent to OpenAI tool
+const { tool, execute } = convertPureFunctionToTool(
+  haikuValidatorAgent,
+  HaikuSchema,
+  HaikuValidationResultSchema
+);
+
+// Use with OpenAI function calling
+const response = await openai.chat.completions.create({
+  model: 'gpt-4o-mini',
+  messages: [
+    { role: 'user', content: 'Write a haiku about an orange cat and validate it' }
+  ],
+  tools: [tool],
+});
+
+// Execute tool calls
+for (const toolCall of response.choices[0].message.tool_calls ?? []) {
+  if (toolCall.function.name === tool.function.name) {
+    const args = JSON.parse(toolCall.function.arguments);
+    const result = await execute(args);
+    console.log(result); // { valid: true, syllables: { line1: 5, line2: 7, line3: 5 } }
+  }
+}
+```
+
+### LLM Analyzer → Chat Completions
+
+Converts LLM-powered VAT agents to executable async functions using OpenAI chat completions API.
+
+**Use cases:** Content generation, analysis, transformation, structured output from LLMs.
+
+### Conversational Assistant → Multi-Turn Chat
+
+Converts conversational assistant agents to stateful chat functions with conversation history management.
+
+**Use cases:** Interactive assistants, multi-turn dialogues, context-aware conversations, customer support bots.
+
+#### Example: Name Generator
+
+```typescript
+import OpenAI from 'openai';
+import { nameGeneratorAgent, NameGeneratorInputSchema, NameSuggestionSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+import { convertLLMAnalyzerToFunction } from '@vibe-agent-toolkit/runtime-openai';
+
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+// Convert VAT agent to executable function
+const generateName = convertLLMAnalyzerToFunction(
+  nameGeneratorAgent,
+  NameGeneratorInputSchema,
+  NameSuggestionSchema,
+  {
+    client: openai,
+    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..."
+```
+
+#### Example: Breed Advisor (Multi-Turn)
+
+```typescript
+import OpenAI from 'openai';
+import { breedAdvisorAgent, BreedAdvisorInputSchema, BreedAdvisorOutputSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+import { convertConversationalAssistantToFunction, type ConversationalSessionState } from '@vibe-agent-toolkit/runtime-openai';
+
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+// Convert VAT agent to executable function
+const chat = convertConversationalAssistantToFunction(
+  breedAdvisorAgent,
+  BreedAdvisorInputSchema,
+  BreedAdvisorOutputSchema,
+  {
+    client: openai,
+    model: 'gpt-4o',
+    temperature: 0.8,
+  }
+);
+
+// Initialize session state (persists across turns)
+const session: ConversationalSessionState = { history: [] };
+let profile = { conversationPhase: 'gathering' };
+
+// Turn 1
+const result1 = await chat(
+  { message: 'I need help finding a cat breed', sessionState: { profile } },
+  session
+);
+console.log(result1.reply); // "I'd love to help! ..."
+profile = result1.updatedProfile;
+
+// Turn 2 (uses accumulated history)
+const result2 = await chat(
+  { message: 'I live in an apartment and love classical music', sessionState: { profile } },
+  session
+);
+console.log(result2.reply); // "Classical music! That's wonderful..."
+profile = result2.updatedProfile;
+
+// Turn 3 (recommendations appear when ready)
+const result3 = await chat(
+  { message: "I prefer calm cats and don't mind grooming", sessionState: { profile } },
+  session
+);
+console.log(result3.recommendations); // [{ breed: 'Persian', matchScore: 95, ... }]
+```
+
+## Why Direct OpenAI SDK?
+
+Unlike framework-based adapters (Vercel AI SDK, LangChain), this adapter provides:
+
+- **Zero framework overhead** - Direct API access, minimal abstraction
+- **Lightweight** - Only OpenAI SDK dependency
+- **Full API control** - Access to all OpenAI-specific features
+- **Simpler debugging** - Fewer layers between your code and the API
+
+Perfect for:
+- Production applications requiring minimal dependencies
+- Users already familiar with OpenAI SDK
+- Projects needing fine-grained control over API calls
+- Serverless/edge environments with size constraints
+
+## API Reference
+
+### `convertPureFunctionToTool()`
+
+Converts a VAT Pure Function agent to an OpenAI function calling tool definition.
+
+**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: OpenAI.Chat.ChatCompletionTool` - OpenAI tool definition
+- `execute: (args: TInput) => Promise<TOutput>` - Function to execute tool calls
+- `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 OpenAI tools.
+
+**Parameters:**
+- `configs: Record<string, ToolConversionConfig>` - Map of tool names to conversion configs
+
+**Returns:** `Record<string, { tool, execute, 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
+- `openaiConfig: OpenAIConfig` - OpenAI configuration
+
+**Returns:** `(input: TInput) => Promise<TOutput>` - Executable async function
+
+### `convertLLMAnalyzersToFunctions()`
+
+Batch converts multiple LLM Analyzer agents with shared OpenAI config.
+
+**Parameters:**
+- `configs: Record<string, LLMAnalyzerConversionConfig>` - Map of function names to conversion configs
+- `openaiConfig: OpenAIConfig` - Shared OpenAI configuration
+
+**Returns:** `Record<string, (input: any) => Promise<any>>` - Map of executable functions
+
+### `convertConversationalAssistantToFunction()`
+
+Converts a VAT Conversational Assistant agent to an executable async function with session state management.
+
+**Parameters:**
+- `agent: Agent<TInput, TOutput>` - The VAT conversational assistant agent to convert
+- `inputSchema: z.ZodType<TInput>` - Zod schema for input validation
+- `outputSchema: z.ZodType<TOutput>` - Zod schema for output validation
+- `openaiConfig: OpenAIConfig` - OpenAI configuration
+- `systemPrompt?: string` - Optional system prompt (overrides agent's system prompt)
+
+**Returns:** `(input: TInput, session: ConversationalSessionState) => Promise<TOutput>` - Executable async function with session state
+
+**Session State:**
+```typescript
+interface ConversationalSessionState {
+  history: Message[];              // Conversation history
+  state?: Record<string, unknown>; // Custom state data
+}
+```
+
+## Type Definitions
+
+### `OpenAIConfig`
+
+```typescript
+interface OpenAIConfig {
+  client: OpenAI;                 // OpenAI client instance
+  model: string;                  // Model to use (e.g., 'gpt-4o-mini')
+  temperature?: number;           // 0-2, default 0.7
+  maxTokens?: number;             // Maximum tokens to generate
+  additionalSettings?: Omit<...>; // Other chat completion params
+}
+```
+
+## Examples
+
+See [@vibe-agent-toolkit/vat-example-cat-agents](../vat-example-cat-agents) for complete agent examples that work with this adapter.
+
+## Comparison with Other Adapters
+
+| Feature | runtime-openai | runtime-vercel-ai-sdk | runtime-langchain |
+|---------|----------------|----------------------|-------------------|
+| **Dependencies** | 1 (openai) | 2 (ai, @ai-sdk/*) | 2 (langchain, @langchain/core) |
+| **Bundle Size** | Smallest | Medium | Largest |
+| **API Control** | Full | High | High |
+| **Learning Curve** | Low (if you know OpenAI SDK) | Medium | High |
+| **Best For** | Direct API access, minimal deps | Multi-provider, streaming | Agent frameworks, RAG |
+
+## License
+
+MIT

package/dist/adapters/common-helpers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Common helper functions for OpenAI runtime adapters
+ */
+import type { Message } from '@vibe-agent-toolkit/agent-runtime';
+import type { OpenAIConfig } from '../types.js';
+/**
+ * Helper to extract text from OpenAI API response
+ */
+export declare function extractTextFromResponse(response: {
+    choices: Array<{
+        message: {
+            content: string | null;
+        };
+    }>;
+}): string;
+/**
+ * Creates a callLLM function for LLM Analyzer agents
+ *
+ * @param openaiConfig - OpenAI configuration
+ * @returns callLLM function for single-turn prompts
+ */
+export declare function createLLMAnalyzerCallLLM(openaiConfig: OpenAIConfig): (prompt: string) => Promise<string>;
+/**
+ * Creates a callLLM function for Conversational Assistant agents
+ *
+ * @param openaiConfig - OpenAI configuration
+ * @returns callLLM function for multi-turn conversations
+ */
+export declare function createConversationalCallLLM(openaiConfig: OpenAIConfig): (messages: Message[]) => Promise<string>;
+//# sourceMappingURL=common-helpers.d.ts.map

package/dist/adapters/common-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-helpers.d.ts","sourceRoot":"","sources":["../../src/adapters/common-helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAEjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE;IAAE,OAAO,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE;YAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAA;KAAE,CAAC,CAAA;CAAE,GAAG,MAAM,CAErH;AA+BD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,YAAY,IACnD,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC,CAe/C;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,YAAY,IACtD,UAAU,OAAO,EAAE,KAAG,OAAO,CAAC,MAAM,CAAC,CAqBpD"}

package/dist/adapters/common-helpers.js

@@ -0,0 +1,63 @@
+/**
+ * Common helper functions for OpenAI runtime adapters
+ */
+/**
+ * Helper to extract text from OpenAI API response
+ */
+export function extractTextFromResponse(response) {
+    return response.choices[0]?.message.content ?? '';
+}
+/**
+ * Helper to create OpenAI API parameters with optional fields
+ */
+function createBaseParams(model, temperature, maxTokens) {
+    const params = { model };
+    // Only add optional parameters if defined
+    if (temperature !== undefined) {
+        params.temperature = temperature;
+    }
+    if (maxTokens !== undefined) {
+        params.max_tokens = maxTokens;
+    }
+    return params;
+}
+/**
+ * Creates a callLLM function for LLM Analyzer agents
+ *
+ * @param openaiConfig - OpenAI configuration
+ * @returns callLLM function for single-turn prompts
+ */
+export function createLLMAnalyzerCallLLM(openaiConfig) {
+    return async (prompt) => {
+        const params = createBaseParams(openaiConfig.model, openaiConfig.temperature, openaiConfig.maxTokens);
+        const response = await openaiConfig.client.chat.completions.create({
+            ...params,
+            messages: [{ role: 'user', content: prompt }],
+            ...openaiConfig.additionalSettings,
+        });
+        return extractTextFromResponse(response);
+    };
+}
+/**
+ * Creates a callLLM function for Conversational Assistant agents
+ *
+ * @param openaiConfig - OpenAI configuration
+ * @returns callLLM function for multi-turn conversations
+ */
+export function createConversationalCallLLM(openaiConfig) {
+    return async (messages) => {
+        const params = createBaseParams(openaiConfig.model, openaiConfig.temperature, openaiConfig.maxTokens);
+        // Convert VAT messages to OpenAI format
+        const openaiMessages = messages.map((m) => ({
+            role: m.role,
+            content: m.content,
+        }));
+        const response = await openaiConfig.client.chat.completions.create({
+            ...params,
+            messages: openaiMessages,
+            ...openaiConfig.additionalSettings,
+        });
+        return extractTextFromResponse(response);
+    };
+}
+//# sourceMappingURL=common-helpers.js.map

package/dist/adapters/common-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-helpers.js","sourceRoot":"","sources":["../../src/adapters/common-helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH;;GAEG;AACH,MAAM,UAAU,uBAAuB,CAAC,QAAqE;IAC3G,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;AACpD,CAAC;AAED;;GAEG;AACH,SAAS,gBAAgB,CACvB,KAAa,EACb,WAAoB,EACpB,SAAkB;IAMlB,MAAM,MAAM,GAIR,EAAE,KAAK,EAAE,CAAC;IAEd,0CAA0C;IAC1C,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,CAAC,WAAW,GAAG,WAAW,CAAC;IACnC,CAAC;IACD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;IAChC,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB,CAAC,YAA0B;IACjE,OAAO,KAAK,EAAE,MAAc,EAAmB,EAAE;QAC/C,MAAM,MAAM,GAAG,gBAAgB,CAC7B,YAAY,CAAC,KAAK,EAClB,YAAY,CAAC,WAAW,EACxB,YAAY,CAAC,SAAS,CACvB,CAAC;QAEF,MAAM,QAAQ,GAAG,MAAM,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;YACjE,GAAG,MAAM;YACT,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;YAC7C,GAAG,YAAY,CAAC,kBAAkB;SACnC,CAAC,CAAC;QAEH,OAAO,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IAC3C,CAAC,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,2BAA2B,CAAC,YAA0B;IACpE,OAAO,KAAK,EAAE,QAAmB,EAAmB,EAAE;QACpD,MAAM,MAAM,GAAG,gBAAgB,CAC7B,YAAY,CAAC,KAAK,EAClB,YAAY,CAAC,WAAW,EACxB,YAAY,CAAC,SAAS,CACvB,CAAC;QAEF,wCAAwC;QACxC,MAAM,cAAc,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC1C,IAAI,EAAE,CAAC,CAAC,IAAuC;YAC/C,OAAO,EAAE,CAAC,CAAC,OAAO;SACnB,CAAC,CAAC,CAAC;QAEJ,MAAM,QAAQ,GAAG,MAAM,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;YACjE,GAAG,MAAM;YACT,QAAQ,EAAE,cAAc;YACxB,GAAG,YAAY,CAAC,kBAAkB;SACnC,CAAC,CAAC;QAEH,OAAO,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IAC3C,CAAC,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,54 @@
+import type { Agent, Message } from '@vibe-agent-toolkit/agent-runtime';
+import type { z } from 'zod';
+import type { OpenAIConfig } from '../types.js';
+/**
+ * Session state type for conversational assistants
+ * Includes conversation history and custom state data
+ */
+export interface ConversationalSessionState {
+    /** Conversation history */
+    history: Message[];
+    /** Custom state data (e.g., user profile, context) */
+    state?: Record<string, unknown>;
+}
+/**
+ * Converts a VAT Conversational Assistant agent to an executable async function with OpenAI
+ *
+ * @param agent - The VAT conversational assistant agent to convert
+ * @param inputSchema - Zod schema for validating inputs
+ * @param outputSchema - Zod schema for validating outputs
+ * @param openaiConfig - OpenAI configuration
+ * @param systemPrompt - Optional system prompt to prepend to conversation
+ * @returns Async function that executes the agent with OpenAI chat completions
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { breedAdvisorAgent, BreedAdvisorInputSchema, BreedAdvisorOutputSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertConversationalAssistantToFunction } from '@vibe-agent-toolkit/runtime-openai';
+ *
+ * const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * const chat = convertConversationalAssistantToFunction(
+ *   breedAdvisorAgent,
+ *   BreedAdvisorInputSchema,
+ *   BreedAdvisorOutputSchema,
+ *   {
+ *     client: openai,
+ *     model: 'gpt-4o',
+ *     temperature: 0.8,
+ *   }
+ * );
+ *
+ * // First turn
+ * let session: ConversationalSessionState = { history: [] };
+ * const result1 = await chat({ message: 'I need help finding a cat', sessionState: { profile: {} } }, session);
+ * console.log(result1.reply);
+ *
+ * // Second turn (uses accumulated history)
+ * const result2 = await chat({ message: 'I live in an apartment', sessionState: { profile: result1.updatedProfile } }, session);
+ * console.log(result2.reply);
+ * ```
+ */
+export declare function convertConversationalAssistantToFunction<TInput, TOutput>(agent: Agent<TInput, TOutput>, inputSchema: z.ZodType<TInput>, outputSchema: z.ZodType<TOutput>, openaiConfig: OpenAIConfig, systemPrompt?: string): (input: TInput, session: ConversationalSessionState) => Promise<TOutput>;
+//# 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":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAyB,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAC/F,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIhD;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,2BAA2B;IAC3B,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,sDAAsD;IACtD,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,wCAAwC,CAAC,MAAM,EAAE,OAAO,EACtE,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,YAAY,EAAE,YAAY,EAC1B,YAAY,CAAC,EAAE,MAAM,GACpB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,0BAA0B,KAAK,OAAO,CAAC,OAAO,CAAC,CAgD1E"}

package/dist/adapters/conversational-assistant.js

@@ -0,0 +1,81 @@
+import { createConversationalCallLLM } from './common-helpers.js';
+/**
+ * Converts a VAT Conversational Assistant agent to an executable async function with OpenAI
+ *
+ * @param agent - The VAT conversational assistant agent to convert
+ * @param inputSchema - Zod schema for validating inputs
+ * @param outputSchema - Zod schema for validating outputs
+ * @param openaiConfig - OpenAI configuration
+ * @param systemPrompt - Optional system prompt to prepend to conversation
+ * @returns Async function that executes the agent with OpenAI chat completions
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { breedAdvisorAgent, BreedAdvisorInputSchema, BreedAdvisorOutputSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertConversationalAssistantToFunction } from '@vibe-agent-toolkit/runtime-openai';
+ *
+ * const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * const chat = convertConversationalAssistantToFunction(
+ *   breedAdvisorAgent,
+ *   BreedAdvisorInputSchema,
+ *   BreedAdvisorOutputSchema,
+ *   {
+ *     client: openai,
+ *     model: 'gpt-4o',
+ *     temperature: 0.8,
+ *   }
+ * );
+ *
+ * // First turn
+ * let session: ConversationalSessionState = { history: [] };
+ * const result1 = await chat({ message: 'I need help finding a cat', sessionState: { profile: {} } }, session);
+ * console.log(result1.reply);
+ *
+ * // Second turn (uses accumulated history)
+ * const result2 = await chat({ message: 'I live in an apartment', sessionState: { profile: result1.updatedProfile } }, session);
+ * console.log(result2.reply);
+ * ```
+ */
+export function convertConversationalAssistantToFunction(agent, inputSchema, outputSchema, openaiConfig, systemPrompt) {
+    // Extract system prompt from agent manifest if not provided
+    const metadataSystemPrompt = agent.manifest.metadata?.['systemPrompt'];
+    const effectiveSystemPrompt = systemPrompt ??
+        (typeof metadataSystemPrompt === 'string'
+            ? metadataSystemPrompt
+            : metadataSystemPrompt?.gathering);
+    // Create base callLLM function
+    const baseCallLLM = createConversationalCallLLM(openaiConfig);
+    // Wrap it to handle system prompt
+    const callLLM = async (messages) => {
+        // Prepend system prompt if provided
+        const messagesWithSystem = effectiveSystemPrompt
+            ? [{ role: 'system', content: effectiveSystemPrompt }, ...messages]
+            : messages;
+        return baseCallLLM(messagesWithSystem);
+    };
+    // Return wrapped function
+    return async (input, session) => {
+        // Validate input
+        const validatedInput = inputSchema.parse(input);
+        // Initialize or use existing session history
+        if (!session.history) {
+            session.history = [];
+        }
+        // Create conversation context
+        const context = {
+            mockable: false,
+            history: session.history,
+            addToHistory: (role, content) => {
+                session.history.push({ role, content });
+            },
+            callLLM,
+        };
+        // Execute the agent
+        const output = await agent.execute(validatedInput, context);
+        // Validate output
+        return outputSchema.parse(output);
+    };
+}
+//# 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":"AAKA,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAalE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,UAAU,wCAAwC,CACtD,KAA6B,EAC7B,WAA8B,EAC9B,YAAgC,EAChC,YAA0B,EAC1B,YAAqB;IAErB,4DAA4D;IAC5D,MAAM,oBAAoB,GAAG,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,cAAc,CAAC,CAAC;IACvE,MAAM,qBAAqB,GACzB,YAAY;QACZ,CAAC,OAAO,oBAAoB,KAAK,QAAQ;YACvC,CAAC,CAAC,oBAAoB;YACtB,CAAC,CAAE,oBAA+C,EAAE,SAAS,CAAC,CAAC;IAEnE,+BAA+B;IAC/B,MAAM,WAAW,GAAG,2BAA2B,CAAC,YAAY,CAAC,CAAC;IAE9D,kCAAkC;IAClC,MAAM,OAAO,GAAG,KAAK,EAAE,QAAmB,EAAmB,EAAE;QAC7D,oCAAoC;QACpC,MAAM,kBAAkB,GAAG,qBAAqB;YAC9C,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAiB,EAAE,OAAO,EAAE,qBAAqB,EAAE,EAAE,GAAG,QAAQ,CAAC;YAC5E,CAAC,CAAC,QAAQ,CAAC;QAEb,OAAO,WAAW,CAAC,kBAAkB,CAAC,CAAC;IACzC,CAAC,CAAC;IAEF,0BAA0B;IAC1B,OAAO,KAAK,EAAE,KAAa,EAAE,OAAmC,EAAoB,EAAE;QACpF,iBAAiB;QACjB,MAAM,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAEhD,6CAA6C;QAC7C,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACrB,OAAO,CAAC,OAAO,GAAG,EAAE,CAAC;QACvB,CAAC;QAED,8BAA8B;QAC9B,MAAM,OAAO,GAA0B;YACrC,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,YAAY,EAAE,CAAC,IAAqC,EAAE,OAAe,EAAE,EAAE;gBACvE,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;YAC1C,CAAC;YACD,OAAO;SACR,CAAC;QAEF,oBAAoB;QACpB,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"}

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

@@ -0,0 +1,81 @@
+import { type Agent } from '@vibe-agent-toolkit/agent-runtime';
+import type { z } from 'zod';
+import type { LLMAnalyzerConversionConfigs, OpenAIConfig } from '../types.js';
+/**
+ * Converts a VAT LLM Analyzer agent to an executable async function with OpenAI
+ *
+ * @param agent - The VAT LLM analyzer agent to convert
+ * @param inputSchema - Zod schema for validating inputs
+ * @param outputSchema - Zod schema for validating outputs
+ * @param openaiConfig - OpenAI configuration
+ * @returns Async function that executes the agent with OpenAI chat completions
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { nameGeneratorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertLLMAnalyzerToFunction } from '@vibe-agent-toolkit/runtime-openai';
+ *
+ * const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * const generateName = convertLLMAnalyzerToFunction(
+ *   nameGeneratorAgent,
+ *   NameGeneratorInputSchema,
+ *   NameSuggestionSchema,
+ *   {
+ *     client: openai,
+ *     model: '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>, openaiConfig: OpenAIConfig): (input: TInput) => Promise<TOutput>;
+/**
+ * Batch converts multiple VAT LLM Analyzer agents to executable functions
+ *
+ * @param configs - Map of function names to conversion configurations
+ * @param openaiConfig - Shared OpenAI configuration for all agents
+ * @returns Map of function names to executable async functions
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ *
+ * const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * const functions = convertLLMAnalyzersToFunctions(
+ *   {
+ *     generateName: {
+ *       agent: nameGeneratorAgent,
+ *       inputSchema: NameGeneratorInputSchema,
+ *       outputSchema: NameSuggestionSchema,
+ *     },
+ *     generateHaiku: {
+ *       agent: haikuGeneratorAgent,
+ *       inputSchema: HaikuGeneratorInputSchema,
+ *       outputSchema: HaikuSchema,
+ *     },
+ *   },
+ *   {
+ *     client: openai,
+ *     model: 'gpt-4o-mini',
+ *     temperature: 0.8,
+ *   }
+ * );
+ *
+ * const name = await functions.generateName(catInput);
+ * const haiku = await functions.generateHaiku(catInput);
+ * ```
+ */
+export declare function convertLLMAnalyzersToFunctions(configs: LLMAnalyzerConversionConfigs, openaiConfig: OpenAIConfig): 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,4BAA4B,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;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,YAAY,EAAE,YAAY,GACzB,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAsBrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,4BAA4B,EACrC,YAAY,EAAE,YAAY,GACzB,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAStD"}

package/dist/adapters/llm-analyzer.js

@@ -0,0 +1,100 @@
+import { batchConvert } from '@vibe-agent-toolkit/agent-runtime';
+import { createLLMAnalyzerCallLLM } from './common-helpers.js';
+/**
+ * Converts a VAT LLM Analyzer agent to an executable async function with OpenAI
+ *
+ * @param agent - The VAT LLM analyzer agent to convert
+ * @param inputSchema - Zod schema for validating inputs
+ * @param outputSchema - Zod schema for validating outputs
+ * @param openaiConfig - OpenAI configuration
+ * @returns Async function that executes the agent with OpenAI chat completions
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { nameGeneratorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertLLMAnalyzerToFunction } from '@vibe-agent-toolkit/runtime-openai';
+ *
+ * const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * const generateName = convertLLMAnalyzerToFunction(
+ *   nameGeneratorAgent,
+ *   NameGeneratorInputSchema,
+ *   NameSuggestionSchema,
+ *   {
+ *     client: openai,
+ *     model: '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, openaiConfig) {
+    // Create callLLM function that uses OpenAI chat completions
+    const callLLM = createLLMAnalyzerCallLLM(openaiConfig);
+    // Return wrapped function
+    return async (input) => {
+        // Validate input
+        const validatedInput = inputSchema.parse(input);
+        // Execute the agent with mock mode disabled (real LLM call)
+        const context = {
+            mockable: false,
+            model: openaiConfig.model,
+            temperature: openaiConfig.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 openaiConfig - Shared OpenAI configuration for all agents
+ * @returns Map of function names to executable async functions
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ *
+ * const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * const functions = convertLLMAnalyzersToFunctions(
+ *   {
+ *     generateName: {
+ *       agent: nameGeneratorAgent,
+ *       inputSchema: NameGeneratorInputSchema,
+ *       outputSchema: NameSuggestionSchema,
+ *     },
+ *     generateHaiku: {
+ *       agent: haikuGeneratorAgent,
+ *       inputSchema: HaikuGeneratorInputSchema,
+ *       outputSchema: HaikuSchema,
+ *     },
+ *   },
+ *   {
+ *     client: openai,
+ *     model: 'gpt-4o-mini',
+ *     temperature: 0.8,
+ *   }
+ * );
+ *
+ * const name = await functions.generateName(catInput);
+ * const haiku = await functions.generateHaiku(catInput);
+ * ```
+ */
+export function convertLLMAnalyzersToFunctions(configs, openaiConfig) {
+    return batchConvert(configs, (config) => convertLLMAnalyzerToFunction(config.agent, config.inputSchema, config.outputSchema, openaiConfig));
+}
+//# 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,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,UAAU,4BAA4B,CAC1C,KAA6B,EAC7B,WAA8B,EAC9B,YAAgC,EAChC,YAA0B;IAE1B,4DAA4D;IAC5D,MAAM,OAAO,GAAG,wBAAwB,CAAC,YAAY,CAAC,CAAC;IAEvD,0BAA0B;IAC1B,OAAO,KAAK,EAAE,KAAa,EAAoB,EAAE;QAC/C,iBAAiB;QACjB,MAAM,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAEhD,4DAA4D;QAC5D,MAAM,OAAO,GAAG;YACd,QAAQ,EAAE,KAAK;YACf,KAAK,EAAE,YAAY,CAAC,KAAK;YACzB,WAAW,EAAE,YAAY,CAAC,WAAW,IAAI,GAAG;YAC5C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,UAAU,8BAA8B,CAC5C,OAAqC,EACrC,YAA0B;IAE1B,OAAO,YAAY,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,CACtC,4BAA4B,CAC1B,MAAM,CAAC,KAAgC,EACvC,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,YAAY,EACnB,YAAY,CACb,CACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,91 @@
+import { type PureFunctionAgent, type ToolConversionConfigs } from '@vibe-agent-toolkit/agent-runtime';
+import type OpenAI from 'openai';
+import type { z } from 'zod';
+/**
+ * Converts a VAT Pure Function agent to OpenAI function calling tool definition
+ *
+ * @param agent - The VAT pure function agent to convert
+ * @param inputSchema - Zod schema for validating inputs
+ * @param outputSchema - Zod schema for validating outputs
+ * @returns OpenAI tool definition with metadata and executor
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { haikuValidatorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertPureFunctionToTool } from '@vibe-agent-toolkit/runtime-openai';
+ *
+ * const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * const { tool, execute } = convertPureFunctionToTool(
+ *   haikuValidatorAgent,
+ *   HaikuSchema,
+ *   HaikuValidationResultSchema
+ * );
+ *
+ * // Use with OpenAI chat completions
+ * const response = await openai.chat.completions.create({
+ *   model: 'gpt-4o-mini',
+ *   messages: [{ role: 'user', content: 'Validate this haiku...' }],
+ *   tools: [tool],
+ * });
+ *
+ * // Execute tool calls
+ * for (const toolCall of response.choices[0].message.tool_calls ?? []) {
+ *   const result = await execute(JSON.parse(toolCall.function.arguments));
+ * }
+ * ```
+ */
+export declare function convertPureFunctionToTool<TInput, TOutput>(agent: PureFunctionAgent<TInput, TOutput>, inputSchema: z.ZodType<TInput>, outputSchema: z.ZodType<TOutput>): {
+    tool: OpenAI.Chat.ChatCompletionTool;
+    execute: (args: TInput) => Promise<TOutput>;
+    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 OpenAI tools
+ *
+ * @param configs - Map of tool names to conversion configurations
+ * @returns Map of tool names to OpenAI tool definitions and executors
+ *
+ * @example
+ * ```typescript
+ * const tools = convertPureFunctionsToTools({
+ *   validateHaiku: {
+ *     agent: haikuValidatorAgent,
+ *     inputSchema: HaikuSchema,
+ *     outputSchema: HaikuValidationResultSchema,
+ *   },
+ *   validateName: {
+ *     agent: nameValidatorAgent,
+ *     inputSchema: NameSchema,
+ *     outputSchema: NameValidationResultSchema,
+ *   },
+ * });
+ *
+ * // Use all tools with OpenAI
+ * const toolArray = Object.values(tools).map(t => t.tool);
+ * const response = await openai.chat.completions.create({
+ *   model: 'gpt-4o-mini',
+ *   messages: [{ role: 'user', content: 'Help me...' }],
+ *   tools: toolArray,
+ * });
+ * ```
+ */
+export declare function convertPureFunctionsToTools(configs: ToolConversionConfigs): Record<string, {
+    tool: OpenAI.Chat.ChatCompletionTool;
+    execute: (args: unknown) => Promise<unknown>;
+    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,EAEL,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC3B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAG7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;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,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC;IACrC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5C,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,CA4CA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,qBAAqB,GAC7B,MAAM,CACP,MAAM,EACN;IACE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC;IACrC,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7C,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,113 @@
+import { batchConvert, } from '@vibe-agent-toolkit/agent-runtime';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+/**
+ * Converts a VAT Pure Function agent to OpenAI function calling tool definition
+ *
+ * @param agent - The VAT pure function agent to convert
+ * @param inputSchema - Zod schema for validating inputs
+ * @param outputSchema - Zod schema for validating outputs
+ * @returns OpenAI tool definition with metadata and executor
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { haikuValidatorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertPureFunctionToTool } from '@vibe-agent-toolkit/runtime-openai';
+ *
+ * const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * const { tool, execute } = convertPureFunctionToTool(
+ *   haikuValidatorAgent,
+ *   HaikuSchema,
+ *   HaikuValidationResultSchema
+ * );
+ *
+ * // Use with OpenAI chat completions
+ * const response = await openai.chat.completions.create({
+ *   model: 'gpt-4o-mini',
+ *   messages: [{ role: 'user', content: 'Validate this haiku...' }],
+ *   tools: [tool],
+ * });
+ *
+ * // Execute tool calls
+ * for (const toolCall of response.choices[0].message.tool_calls ?? []) {
+ *   const result = await execute(JSON.parse(toolCall.function.arguments));
+ * }
+ * ```
+ */
+export function convertPureFunctionToTool(agent, inputSchema, outputSchema) {
+    const { manifest } = agent;
+    // Convert Zod schema to JSON Schema for OpenAI
+    const jsonSchema = zodToJsonSchema(inputSchema, {
+        name: manifest.name,
+        $refStrategy: 'none', // Inline all schemas
+    });
+    // Create OpenAI tool definition
+    const tool = {
+        type: 'function',
+        function: {
+            name: manifest.name,
+            description: manifest.description,
+            parameters: jsonSchema,
+        },
+    };
+    // Create executor function
+    const execute = async (args) => {
+        // Validate input
+        const validatedInput = inputSchema.parse(args);
+        // Execute agent - returns output directly (unwrapped)
+        // The agent's execute wrapper validates input/output schemas and throws on error
+        const output = agent.execute(validatedInput);
+        // Validate the output with schema (redundant but explicit)
+        return outputSchema.parse(output);
+    };
+    return {
+        tool,
+        execute,
+        metadata: {
+            name: manifest.name,
+            description: manifest.description,
+            version: manifest.version,
+            archetype: manifest.archetype,
+        },
+        inputSchema,
+        outputSchema,
+    };
+}
+/**
+ * Batch converts multiple VAT Pure Function agents to OpenAI tools
+ *
+ * @param configs - Map of tool names to conversion configurations
+ * @returns Map of tool names to OpenAI tool definitions and executors
+ *
+ * @example
+ * ```typescript
+ * const tools = convertPureFunctionsToTools({
+ *   validateHaiku: {
+ *     agent: haikuValidatorAgent,
+ *     inputSchema: HaikuSchema,
+ *     outputSchema: HaikuValidationResultSchema,
+ *   },
+ *   validateName: {
+ *     agent: nameValidatorAgent,
+ *     inputSchema: NameSchema,
+ *     outputSchema: NameValidationResultSchema,
+ *   },
+ * });
+ *
+ * // Use all tools with OpenAI
+ * const toolArray = Object.values(tools).map(t => t.tool);
+ * const response = await openai.chat.completions.create({
+ *   model: 'gpt-4o-mini',
+ *   messages: [{ role: 'user', content: 'Help me...' }],
+ *   tools: toolArray,
+ * });
+ * ```
+ */
+export function convertPureFunctionsToTools(configs) {
+    return batchConvert(configs, (config) => {
+        const { tool, execute, metadata } = convertPureFunctionToTool(config.agent, config.inputSchema, config.outputSchema);
+        return { tool, execute, 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,EACL,YAAY,GAGb,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,yBAAyB,CACvC,KAAyC,EACzC,WAA8B,EAC9B,YAAgC;IAahC,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;IAE3B,+CAA+C;IAC/C,MAAM,UAAU,GAAG,eAAe,CAAC,WAAW,EAAE;QAC9C,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,YAAY,EAAE,MAAM,EAAE,qBAAqB;KAC5C,CAAC,CAAC;IAEH,gCAAgC;IAChC,MAAM,IAAI,GAAmC;QAC3C,IAAI,EAAE,UAAU;QAChB,QAAQ,EAAE;YACR,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,WAAW,EAAE,QAAQ,CAAC,WAAW;YACjC,UAAU,EAAE,UAAqC;SAClD;KACF,CAAC;IAEF,2BAA2B;IAC3B,MAAM,OAAO,GAAG,KAAK,EAAE,IAAY,EAAoB,EAAE;QACvD,iBAAiB;QACjB,MAAM,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAE/C,sDAAsD;QACtD,iFAAiF;QACjF,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QAE7C,2DAA2D;QAC3D,OAAO,YAAY,CAAC,KAAK,CAAC,MAAM,CAAY,CAAC;IAC/C,CAAC,CAAC;IAEF,OAAO;QACL,IAAI;QACJ,OAAO;QACP,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,2BAA2B,CACzC,OAA8B;IAS9B,OAAO,YAAY,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE;QACtC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,yBAAyB,CAC3D,MAAM,CAAC,KAA4C,EACnD,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,YAAY,CACpB,CAAC;QACF,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;IACrC,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,29 @@
+import type OpenAI from 'openai';
+/**
+ * OpenAI configuration for VAT agents
+ */
+export interface OpenAIConfig {
+    /**
+     * OpenAI client instance
+     */
+    client: OpenAI;
+    /**
+     * Model to use (e.g., 'gpt-4o-mini', 'gpt-4o')
+     */
+    model: string;
+    /**
+     * Temperature for text generation (0-2)
+     * Higher values make output more random, lower values more deterministic
+     */
+    temperature?: number;
+    /**
+     * Maximum tokens to generate
+     */
+    maxTokens?: number;
+    /**
+     * Additional model-specific settings
+     */
+    additionalSettings?: Omit<OpenAI.Chat.ChatCompletionCreateParamsNonStreaming, 'model' | 'messages' | 'temperature' | 'max_tokens'>;
+}
+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,MAAM,MAAM,QAAQ,CAAC;AAEjC;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,kBAAkB,CAAC,EAAE,IAAI,CACvB,MAAM,CAAC,IAAI,CAAC,sCAAsC,EAClD,OAAO,GAAG,UAAU,GAAG,aAAa,GAAG,YAAY,CACpD,CAAC;CACH;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,50 @@
+{
+  "name": "@vibe-agent-toolkit/runtime-openai",
+  "version": "0.1.2-rc.3",
+  "description": "OpenAI SDK 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": {
+    "@vibe-agent-toolkit/agent-runtime": "0.1.2-rc.3",
+    "openai": "^4.77.3",
+    "zod": "^3.24.1",
+    "zod-to-json-schema": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "@vibe-agent-toolkit/dev-tools": "0.1.2-rc.3",
+    "@vibe-agent-toolkit/vat-example-cat-agents": "0.1.2-rc.3",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  },
+  "keywords": [
+    "ai-agent",
+    "openai",
+    "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-openai"
+  }
+}