@vibe-agent-toolkit/runtime-vercel-ai-sdk 0.1.2-rc.4

package/README.md

@@ -0,0 +1,468 @@
+# @vibe-agent-toolkit/runtime-vercel-ai-sdk
+
+Vercel AI SDK runtime adapter for VAT (Vibe Agent Toolkit) agents.
+
+Converts VAT archetype agents to Vercel AI SDK primitives, enabling portability across LLM providers (OpenAI, Anthropic, etc.) while maintaining type safety and agent semantics.
+
+## Installation
+
+```bash
+npm install @vibe-agent-toolkit/runtime-vercel-ai-sdk ai
+# or
+bun add @vibe-agent-toolkit/runtime-vercel-ai-sdk ai
+```
+
+You'll also need an LLM provider package:
+```bash
+npm install @ai-sdk/openai    # For OpenAI
+npm install @ai-sdk/anthropic # For Anthropic Claude
+```
+
+## Supported Archetypes
+
+### Pure Function Tools → `tool()`
+
+Converts synchronous, deterministic VAT agents to Vercel AI SDK tools that can be called by LLMs.
+
+**Use cases:** Validation, transformation, computation, structured data operations.
+
+**Archetypes:** Pure Function Tool (Archetype 1)
+
+#### Example: Haiku Validator
+
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { generateText } from 'ai';
+import { haikuValidatorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+import { HaikuSchema, HaikuValidationResultSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+import { convertPureFunctionToTool } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+
+// Convert VAT agent to Vercel AI tool
+const haikuTool = convertPureFunctionToTool(
+  haikuValidatorAgent,
+  HaikuSchema,
+  HaikuValidationResultSchema
+);
+
+// Use with generateText()
+const result = await generateText({
+  model: openai('gpt-4'),
+  tools: {
+    validateHaiku: haikuTool.tool
+  },
+  prompt: `
+    Write a haiku about an orange cat and validate it using the validateHaiku tool.
+  `
+});
+
+console.log(result.text);
+console.log(result.toolCalls); // Shows validation results
+```
+
+#### Batch Conversion
+
+```typescript
+import { convertPureFunctionsToTools } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+import { haikuValidatorAgent, nameValidatorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+import { HaikuSchema, HaikuValidationResultSchema, NameValidationInputSchema, NameValidationResultSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+
+const tools = convertPureFunctionsToTools({
+  validateHaiku: {
+    agent: haikuValidatorAgent,
+    inputSchema: HaikuSchema,
+    outputSchema: HaikuValidationResultSchema,
+  },
+  validateName: {
+    agent: nameValidatorAgent,
+    inputSchema: NameValidationInputSchema,
+    outputSchema: NameValidationResultSchema,
+  },
+});
+
+const result = await generateText({
+  model: openai('gpt-4'),
+  tools,
+  prompt: 'Generate and validate cat names and haikus...'
+});
+```
+
+### Conversational Assistants → `streamText()` with History
+
+Converts multi-turn conversational agents to executable functions that maintain conversation history.
+
+**Use cases:** Interactive dialogs, multi-turn decision-making, stateful conversations, progressive information gathering.
+
+**Archetypes:** Conversational Assistant (Archetype 3)
+
+#### Example: Breed Advisor
+
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { breedAdvisorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+import { BreedAdvisorInputSchema, BreedAdvisorOutputSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+import { convertConversationalAssistantToFunction, type ConversationSession } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+
+// Convert VAT agent to executable function
+const breedAdvisor = convertConversationalAssistantToFunction(
+  breedAdvisorAgent,
+  BreedAdvisorInputSchema,
+  BreedAdvisorOutputSchema,
+  {
+    model: openai('gpt-4'),
+    temperature: 0.8,
+  }
+);
+
+// Initialize conversation session
+const session: ConversationSession = { history: [] };
+
+// Turn 1: Initial inquiry
+const turn1 = await breedAdvisor(
+  { message: "I'm looking for a cat", sessionState: {} },
+  session
+);
+console.log(turn1.reply); // "Great! What's your living situation?"
+
+// Turn 2: Continue conversation (history is maintained)
+const turn2 = await breedAdvisor(
+  { message: "Small apartment, love jazz music", sessionState: turn1.sessionState },
+  session
+);
+console.log(turn2.recommendations); // Breed recommendations based on profile
+```
+
+#### Batch Conversion with Independent Sessions
+
+```typescript
+import { convertConversationalAssistantsToFunctions } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+import { breedAdvisorAgent, petCareAdvisorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+
+const assistants = convertConversationalAssistantsToFunctions(
+  {
+    breedAdvisor: {
+      agent: breedAdvisorAgent,
+      inputSchema: BreedAdvisorInputSchema,
+      outputSchema: BreedAdvisorOutputSchema,
+    },
+    petCareAdvisor: {
+      agent: petCareAdvisorAgent,
+      inputSchema: PetCareInputSchema,
+      outputSchema: PetCareOutputSchema,
+    },
+  },
+  {
+    model: openai('gpt-4'),
+    temperature: 0.8,
+  }
+);
+
+// Each assistant maintains its own independent session
+const breedSession: ConversationSession = { history: [] };
+const careSession: ConversationSession = { history: [] };
+
+const breedResponse = await assistants.breedAdvisor({ message: "I want a cat" }, breedSession);
+const careResponse = await assistants.petCareAdvisor({ message: "Feeding schedule?" }, careSession);
+```
+
+### LLM Analyzers → `generateText()`
+
+Converts single-shot LLM analysis agents to executable functions powered by Vercel AI SDK.
+
+**Use cases:** Classification, extraction, generation, summarization, sentiment analysis.
+
+**Archetypes:** One-Shot LLM Analyzer (Archetype 2)
+
+#### Example: Cat Name Generator
+
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { nameGeneratorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+import { NameGeneratorInputSchema, NameSuggestionSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+import { convertLLMAnalyzerToFunction } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+
+// Convert VAT agent to executable function
+const generateName = convertLLMAnalyzerToFunction(
+  nameGeneratorAgent,
+  NameGeneratorInputSchema,
+  NameSuggestionSchema,
+  {
+    model: openai('gpt-4'),
+    temperature: 0.9, // High creativity for name generation
+  }
+);
+
+// Use the function directly
+const result = await generateName({
+  characteristics: {
+    physical: {
+      furColor: 'Orange',
+      size: 'medium',
+    },
+    behavioral: {
+      personality: ['Mischievous', 'Energetic'],
+      quirks: ['Knocks things off tables'],
+    },
+    description: 'A mischievous orange cat who loves causing trouble',
+  },
+});
+
+console.log(result.name);        // "Sir Knocksalot"
+console.log(result.reasoning);   // "Given the cat's tendency to knock..."
+console.log(result.alternatives); // ["Lord Tumbleton", "Duke Paws"]
+```
+
+#### Batch Conversion with Shared Config
+
+```typescript
+import { convertLLMAnalyzersToFunctions } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+import { nameGeneratorAgent, haikuGeneratorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+
+const analyzers = convertLLMAnalyzersToFunctions(
+  {
+    generateName: {
+      agent: nameGeneratorAgent,
+      inputSchema: NameGeneratorInputSchema,
+      outputSchema: NameSuggestionSchema,
+    },
+    generateHaiku: {
+      agent: haikuGeneratorAgent,
+      inputSchema: HaikuGeneratorInputSchema,
+      outputSchema: HaikuSchema,
+    },
+  },
+  {
+    model: openai('gpt-4'),
+    temperature: 0.8, // Shared config for all analyzers
+  }
+);
+
+// Use the functions
+const name = await analyzers.generateName({ characteristics });
+const haiku = await analyzers.generateHaiku({ characteristics });
+```
+
+## Provider Support
+
+Works with any Vercel AI SDK provider:
+
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { anthropic } from '@ai-sdk/anthropic';
+import { google } from '@ai-sdk/google';
+
+// OpenAI
+const llmConfig = { model: openai('gpt-4'), temperature: 0.7 };
+
+// Anthropic Claude
+const llmConfig = { model: anthropic('claude-3-5-sonnet-20241022'), temperature: 0.8 };
+
+// Google Gemini
+const llmConfig = { model: google('gemini-2.0-flash-001'), temperature: 0.9 };
+```
+
+## Mock Mode vs. Real LLM
+
+VAT agents support mock mode for testing. When using this adapter, agents always run in real LLM mode:
+
+```typescript
+// In VAT agent definition (supports both modes)
+export const nameGeneratorAgent = defineLLMAnalyzer(
+  { name: 'name-generator', ... },
+  async (input, ctx) => {
+    if (ctx.mockable) {
+      // Fast mock for testing
+      return mockGenerateName(input);
+    }
+    // Real LLM call
+    const response = await ctx.callLLM(prompt);
+    return JSON.parse(response);
+  }
+);
+
+// With Vercel AI SDK adapter (always real LLM)
+const generateName = convertLLMAnalyzerToFunction(
+  nameGeneratorAgent,
+  NameGeneratorInputSchema,
+  NameSuggestionSchema,
+  { model: openai('gpt-4') }
+);
+// ctx.mockable = false, uses ctx.callLLM() powered by Vercel AI SDK
+```
+
+## API Reference
+
+### `convertConversationalAssistantToFunction<TInput, TOutput>`
+
+Converts a Conversational Assistant agent to an executable async function with conversation history.
+
+**Parameters:**
+- `agent: Agent<TInput, TOutput>` - The VAT conversational assistant agent
+- `inputSchema: z.ZodType<TInput>` - Input Zod schema
+- `outputSchema: z.ZodType<TOutput>` - Output Zod schema
+- `llmConfig: VercelAILLMConfig` - LLM configuration (model, temperature, etc.)
+
+**Returns:** `(input: TInput, session: ConversationSession) => Promise<TOutput>` - Executable async function that requires a session parameter
+
+**Session Management:**
+```typescript
+interface ConversationSession {
+  history: Message[];      // Maintained across turns
+  state?: Record<string, unknown>;  // Agent-specific state
+}
+```
+
+### `convertConversationalAssistantsToFunctions`
+
+Batch converts multiple Conversational Assistant agents with shared LLM config.
+
+**Parameters:**
+- `configs: Record<string, ConversationalAssistantConversionConfig>` - Map of assistant names to conversion configs
+- `llmConfig: VercelAILLMConfig` - Shared LLM configuration
+
+**Returns:** `Record<string, (input: any, session: ConversationSession) => Promise<any>>` - Map of assistant names to executable functions
+
+### `convertPureFunctionToTool<TInput, TOutput>`
+
+Converts a PureFunctionAgent to a Vercel AI SDK tool.
+
+**Parameters:**
+- `agent: PureFunctionAgent<TInput, TOutput>` - The VAT agent
+- `inputSchema: z.ZodType<TInput>` - Input Zod schema
+- `outputSchema: z.ZodType<TOutput>` - Output Zod schema
+
+**Returns:** `ConversionResult<TInput, TOutput>`
+- `tool: VercelAITool` - The tool ready for use with generateText()
+- `inputSchema: z.ZodType<TInput>` - Original input schema
+- `outputSchema: z.ZodType<TOutput>` - Original output schema
+- `metadata` - Agent name, description, version, archetype
+
+### `convertPureFunctionsToTools`
+
+Batch converts multiple PureFunctionAgents to tools.
+
+**Parameters:**
+- `configs: Record<string, ToolConversionConfig>` - Map of tool names to conversion configs
+
+**Returns:** `Record<string, VercelAITool>` - Map of tool names to Vercel AI tools
+
+### `convertLLMAnalyzerToFunction<TInput, TOutput>`
+
+Converts an LLM Analyzer agent to an executable async function.
+
+**Parameters:**
+- `agent: Agent<TInput, TOutput>` - The VAT LLM analyzer agent
+- `inputSchema: z.ZodType<TInput>` - Input Zod schema
+- `outputSchema: z.ZodType<TOutput>` - Output Zod schema
+- `llmConfig: VercelAILLMConfig` - LLM configuration (model, temperature, etc.)
+
+**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: VercelAILLMConfig` - Shared LLM configuration
+
+**Returns:** `Record<string, (input: any) => Promise<any>>` - Map of function names to executable functions
+
+## Type Definitions
+
+### `VercelAILLMConfig`
+
+```typescript
+interface VercelAILLMConfig {
+  model: LanguageModelV1;           // From Vercel AI SDK
+  temperature?: number;              // 0-1, default 0.7
+  maxTokens?: number;                // Maximum tokens to generate
+  additionalSettings?: Record<string, unknown>; // Provider-specific settings
+}
+```
+
+### `ToolConversionConfig<TInput, TOutput>`
+
+```typescript
+interface ToolConversionConfig<TInput, TOutput> {
+  agent: PureFunctionAgent<TInput, TOutput>;
+  inputSchema: z.ZodType<TInput>;
+  outputSchema: z.ZodType<TOutput>;
+}
+```
+
+### `ConversationalAssistantConversionConfig<TInput, TOutput>`
+
+```typescript
+interface ConversationalAssistantConversionConfig<TInput, TOutput> {
+  agent: Agent<TInput, TOutput>;
+  inputSchema: z.ZodType<TInput>;
+  outputSchema: z.ZodType<TOutput>;
+}
+```
+
+### `LLMAnalyzerConversionConfig<TInput, TOutput>`
+
+```typescript
+interface LLMAnalyzerConversionConfig<TInput, TOutput> {
+  agent: Agent<TInput, TOutput>;
+  inputSchema: z.ZodType<TInput>;
+  outputSchema: z.ZodType<TOutput>;
+}
+```
+
+## Examples
+
+See [@vibe-agent-toolkit/vat-example-cat-agents](../vat-example-cat-agents) for complete agent examples that work with this adapter.
+
+## Testing
+
+### Unit Tests
+
+Standard unit tests verify adapter structure and type safety without making real LLM calls:
+
+```bash
+bun run test        # Run all unit tests (free, fast)
+bun run test:watch  # Watch mode for development
+```
+
+### LLM Regression Tests
+
+LLM regression tests make **real API calls** to OpenAI and Anthropic to verify end-to-end integration. These tests are:
+- **Expensive**: Cost money (API calls to GPT-4o-mini and Claude 4.5 Sonnet)
+- **Slow**: Take 15-60 seconds depending on API latency
+- **Skipped by default**: Only run when explicitly requested
+
+**Run regression tests:**
+
+```bash
+# From this package directory
+bun run test:llm-regression
+
+# Or manually with environment variable
+RUN_LLM_TESTS=true bun test test/llm-regression.test.ts
+```
+
+**What they test:**
+- ✅ Pure function tools work with real LLMs
+- ✅ LLM analyzer functions work with OpenAI
+- ✅ LLM analyzer functions work with Anthropic Claude
+- ✅ Same adapter code works across providers (provider-agnostic architecture)
+
+**Requirements:**
+- `OPENAI_API_KEY` environment variable for OpenAI tests
+- `ANTHROPIC_API_KEY` environment variable for Anthropic tests
+- Tests gracefully skip if API keys are not set
+
+**When to run:**
+- Before releases to verify provider integrations still work
+- After upgrading `ai` or provider packages (e.g., `@ai-sdk/openai`)
+- When adding support for new LLM providers
+- Periodically (weekly/monthly) to catch API breaking changes
+
+**Cost estimate:**
+- Full test suite: ~4 LLM calls (2 OpenAI, 2 Anthropic)
+- Approximate cost: $0.01-0.05 per run (varies by model pricing)
+
+## License
+
+MIT

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

@@ -0,0 +1,109 @@
+import type { Agent, Message } from '@vibe-agent-toolkit/agent-runtime';
+import type { z } from 'zod';
+import type { VercelAILLMConfig } from '../types.js';
+/**
+ * Session state for conversational assistants
+ * Maintains conversation history and agent-specific state
+ */
+export interface ConversationSession {
+    /** Conversation history */
+    history: Message[];
+    /** Agent-specific session state */
+    state?: Record<string, unknown>;
+}
+/**
+ * Converts a VAT Conversational Assistant agent to a function compatible with Vercel AI SDK.
+ *
+ * Conversational assistants maintain context across multiple turns using conversation history.
+ * They're perfect for interactive dialogs, multi-turn decision-making, and stateful interactions.
+ *
+ * Example:
+ * ```typescript
+ * import { openai } from '@ai-sdk/openai';
+ * import { breedAdvisorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { BreedAdvisorInputSchema, BreedAdvisorOutputSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertConversationalAssistantToFunction } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+ *
+ * const breedAdvisor = convertConversationalAssistantToFunction(
+ *   breedAdvisorAgent,
+ *   BreedAdvisorInputSchema,
+ *   BreedAdvisorOutputSchema,
+ *   { model: openai('gpt-4'), temperature: 0.8 }
+ * );
+ *
+ * // Start conversation
+ * const session: ConversationSession = { history: [] };
+ * const turn1 = await breedAdvisor(
+ *   { message: "I'm looking for a cat", sessionState: {} },
+ *   session
+ * );
+ * console.log(turn1.reply); // "Great! Tell me about your living space..."
+ *
+ * // Continue conversation
+ * const turn2 = await breedAdvisor(
+ *   { message: "I live in an apartment", sessionState: turn1.sessionState },
+ *   session
+ * );
+ * console.log(turn2.recommendations); // Breed recommendations
+ * ```
+ *
+ * @param agent - The VAT conversational assistant agent to convert
+ * @param inputSchema - The Zod input schema
+ * @param outputSchema - The Zod output schema
+ * @param llmConfig - Configuration for the LLM (model, temperature, etc.)
+ * @returns An async function that executes the agent with conversation context
+ */
+export declare function convertConversationalAssistantToFunction<TInput, TOutput>(agent: Agent<TInput, TOutput>, inputSchema: z.ZodType<TInput>, outputSchema: z.ZodType<TOutput>, llmConfig: VercelAILLMConfig): (input: TInput, session: ConversationSession) => Promise<TOutput>;
+/**
+ * Batch converts multiple conversational assistant agents to executable functions.
+ *
+ * Useful when you need multiple conversational agents with shared LLM configuration.
+ * Each agent maintains its own independent conversation session.
+ *
+ * Example:
+ * ```typescript
+ * import { openai } from '@ai-sdk/openai';
+ * import { breedAdvisorAgent, petCareAdvisorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertConversationalAssistantsToFunctions } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+ *
+ * const assistants = convertConversationalAssistantsToFunctions(
+ *   {
+ *     breedAdvisor: {
+ *       agent: breedAdvisorAgent,
+ *       inputSchema: BreedAdvisorInputSchema,
+ *       outputSchema: BreedAdvisorOutputSchema,
+ *     },
+ *     petCareAdvisor: {
+ *       agent: petCareAdvisorAgent,
+ *       inputSchema: PetCareInputSchema,
+ *       outputSchema: PetCareOutputSchema,
+ *     },
+ *   },
+ *   { model: openai('gpt-4'), temperature: 0.8 }
+ * );
+ *
+ * // Each assistant has its own session
+ * const breedSession: ConversationSession = { history: [] };
+ * const careSession: ConversationSession = { history: [] };
+ *
+ * const breedResponse = await assistants.breedAdvisor(
+ *   { message: "I want a cat" },
+ *   breedSession
+ * );
+ * const careResponse = await assistants.petCareAdvisor(
+ *   { message: "How often should I feed my cat?" },
+ *   careSession
+ * );
+ * ```
+ *
+ * @param configs - Map of assistant names to conversion configurations
+ * @param llmConfig - Shared LLM configuration for all assistants
+ * @returns Map of assistant names to executable async functions
+ */
+export interface ConversationalAssistantConversionConfig<TInput, TOutput> {
+    agent: Agent<TInput, TOutput>;
+    inputSchema: z.ZodType<TInput>;
+    outputSchema: z.ZodType<TOutput>;
+}
+export declare function convertConversationalAssistantsToFunctions<T extends Record<string, ConversationalAssistantConversionConfig<unknown, unknown>>>(configs: T, llmConfig: VercelAILLMConfig): Record<keyof T, (input: unknown, session: ConversationSession) => Promise<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":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAExE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,2BAA2B;IAC3B,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,mCAAmC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;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,SAAS,EAAE,iBAAiB,GAC3B,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAkDnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,WAAW,uCAAuC,CAAC,MAAM,EAAE,OAAO;IACtE,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/B,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;CAClC;AAED,wBAAgB,0CAA0C,CACxD,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,uCAAuC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,EAEnF,OAAO,EAAE,CAAC,EACV,SAAS,EAAE,iBAAiB,GAC3B,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAmBrF"}

package/dist/adapters/conversational-assistant.js

@@ -0,0 +1,93 @@
+import { streamText } from 'ai';
+/**
+ * Converts a VAT Conversational Assistant agent to a function compatible with Vercel AI SDK.
+ *
+ * Conversational assistants maintain context across multiple turns using conversation history.
+ * They're perfect for interactive dialogs, multi-turn decision-making, and stateful interactions.
+ *
+ * Example:
+ * ```typescript
+ * import { openai } from '@ai-sdk/openai';
+ * import { breedAdvisorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { BreedAdvisorInputSchema, BreedAdvisorOutputSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertConversationalAssistantToFunction } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+ *
+ * const breedAdvisor = convertConversationalAssistantToFunction(
+ *   breedAdvisorAgent,
+ *   BreedAdvisorInputSchema,
+ *   BreedAdvisorOutputSchema,
+ *   { model: openai('gpt-4'), temperature: 0.8 }
+ * );
+ *
+ * // Start conversation
+ * const session: ConversationSession = { history: [] };
+ * const turn1 = await breedAdvisor(
+ *   { message: "I'm looking for a cat", sessionState: {} },
+ *   session
+ * );
+ * console.log(turn1.reply); // "Great! Tell me about your living space..."
+ *
+ * // Continue conversation
+ * const turn2 = await breedAdvisor(
+ *   { message: "I live in an apartment", sessionState: turn1.sessionState },
+ *   session
+ * );
+ * console.log(turn2.recommendations); // Breed recommendations
+ * ```
+ *
+ * @param agent - The VAT conversational assistant agent to convert
+ * @param inputSchema - The Zod input schema
+ * @param outputSchema - The Zod output schema
+ * @param llmConfig - Configuration for the LLM (model, temperature, etc.)
+ * @returns An async function that executes the agent with conversation context
+ */
+export function convertConversationalAssistantToFunction(agent, inputSchema, outputSchema, llmConfig) {
+    return async (input, session) => {
+        // Validate input
+        const validatedInput = inputSchema.parse(input);
+        // Initialize session if needed
+        session.history ??= [];
+        // Convert VAT Message format to Vercel AI SDK format
+        const convertToVercelFormat = (messages) => {
+            return messages.map((msg) => ({
+                role: msg.role,
+                content: msg.content,
+            }));
+        };
+        // Create conversation context
+        const callLLM = async (messages) => {
+            const vercelMessages = convertToVercelFormat(messages);
+            // eslint-disable-next-line @typescript-eslint/await-thenable
+            const result = await streamText({
+                model: llmConfig.model,
+                ...(llmConfig.temperature ? { temperature: llmConfig.temperature } : {}),
+                ...(llmConfig.maxTokens ? { maxTokens: llmConfig.maxTokens } : {}),
+                ...llmConfig.additionalSettings,
+                messages: vercelMessages,
+            });
+            // Collect streamed text from the response
+            return await result.text;
+        };
+        const addToHistory = (role, content) => {
+            session.history.push({ role, content });
+        };
+        const context = {
+            mockable: false,
+            history: session.history,
+            addToHistory,
+            callLLM,
+        };
+        // Call the agent's execute function with the conversation context
+        const output = await agent.execute(validatedInput, context);
+        // Validate output
+        return outputSchema.parse(output);
+    };
+}
+export function convertConversationalAssistantsToFunctions(configs, llmConfig) {
+    const functions = {};
+    for (const [name, config] of Object.entries(configs)) {
+        functions[name] = convertConversationalAssistantToFunction(config.agent, config.inputSchema, config.outputSchema, llmConfig);
+    }
+    return functions;
+}
+//# 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":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAgBhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,UAAU,wCAAwC,CACtD,KAA6B,EAC7B,WAA8B,EAC9B,YAAgC,EAChC,SAA4B;IAE5B,OAAO,KAAK,EAAE,KAAa,EAAE,OAA4B,EAAE,EAAE;QAC3D,iBAAiB;QACjB,MAAM,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAEhD,+BAA+B;QAC/B,OAAO,CAAC,OAAO,KAAK,EAAE,CAAC;QAEvB,qDAAqD;QACrD,MAAM,qBAAqB,GAAG,CAAC,QAAmB,EAAE,EAAE;YACpD,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;gBAC5B,IAAI,EAAE,GAAG,CAAC,IAAI;gBACd,OAAO,EAAE,GAAG,CAAC,OAAO;aACrB,CAAC,CAAC,CAAC;QACN,CAAC,CAAC;QAEF,8BAA8B;QAC9B,MAAM,OAAO,GAAG,KAAK,EAAE,QAAmB,EAAE,EAAE;YAC5C,MAAM,cAAc,GAAG,qBAAqB,CAAC,QAAQ,CAAC,CAAC;YAEvD,6DAA6D;YAC7D,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC;gBAC9B,KAAK,EAAE,SAAS,CAAC,KAAK;gBACtB,GAAG,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACxE,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAClE,GAAG,SAAS,CAAC,kBAAkB;gBAC/B,QAAQ,EAAE,cAAc;aACzB,CAAC,CAAC;YAEH,0CAA0C;YAC1C,OAAO,MAAM,MAAM,CAAC,IAAI,CAAC;QAC3B,CAAC,CAAC;QAEF,MAAM,YAAY,GAAG,CAAC,IAAqC,EAAE,OAAe,EAAE,EAAE;YAC9E,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;QAC1C,CAAC,CAAC;QAEF,MAAM,OAAO,GAAG;YACd,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,YAAY;YACZ,OAAO;SACR,CAAC;QAEF,kEAAkE;QAClE,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;AAsDD,MAAM,UAAU,0CAA0C,CAGxD,OAAU,EACV,SAA4B;IAE5B,MAAM,SAAS,GAGX,EAAE,CAAC;IAEP,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACrD,SAAS,CAAC,IAAI,CAAC,GAAG,wCAAwC,CACxD,MAAM,CAAC,KAAK,EACZ,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,YAAY,EACnB,SAAS,CACV,CAAC;IACJ,CAAC;IAED,OAAO,SAGN,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,80 @@
+import type { Agent } from '@vibe-agent-toolkit/agent-runtime';
+import type { z } from 'zod';
+import type { VercelAILLMConfig } from '../types.js';
+/**
+ * Converts a VAT LLM Analyzer agent to a function compatible with Vercel AI SDK.
+ *
+ * LLM analyzers make a single LLM call to analyze input and produce structured output.
+ * They're perfect for classification, extraction, generation, and analysis tasks.
+ *
+ * Example:
+ * ```typescript
+ * import { openai } from '@ai-sdk/openai';
+ * import { nameGeneratorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { NameGeneratorInputSchema, NameSuggestionSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertLLMAnalyzerToFunction } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+ *
+ * const generateName = convertLLMAnalyzerToFunction(
+ *   nameGeneratorAgent,
+ *   NameGeneratorInputSchema,
+ *   NameSuggestionSchema,
+ *   { model: openai('gpt-4'), temperature: 0.9 }
+ * );
+ *
+ * // Use the function
+ * const result = await generateName({
+ *   characteristics: { physical: { furColor: 'Orange' }, behavioral: { personality: ['Mischievous'] } }
+ * });
+ * console.log(result.name); // "Sir Knocksalot"
+ * ```
+ *
+ * @param agent - The VAT LLM analyzer agent to convert
+ * @param inputSchema - The Zod input schema
+ * @param outputSchema - The Zod output schema
+ * @param llmConfig - Configuration for the LLM (model, temperature, etc.)
+ * @returns An async function that executes the agent with the configured LLM
+ */
+export declare function convertLLMAnalyzerToFunction<TInput, TOutput>(agent: Agent<TInput, TOutput>, inputSchema: z.ZodType<TInput>, outputSchema: z.ZodType<TOutput>, llmConfig: VercelAILLMConfig): (input: TInput) => Promise<TOutput>;
+/**
+ * Batch converts multiple LLM analyzer agents to executable functions.
+ *
+ * Useful when you need multiple AI-powered analysis functions with a shared LLM configuration.
+ *
+ * Example:
+ * ```typescript
+ * import { openai } from '@ai-sdk/openai';
+ * import { nameGeneratorAgent, haikuGeneratorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertLLMAnalyzersToFunctions } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+ *
+ * const analyzers = convertLLMAnalyzersToFunctions(
+ *   {
+ *     generateName: {
+ *       agent: nameGeneratorAgent,
+ *       inputSchema: NameGeneratorInputSchema,
+ *       outputSchema: NameSuggestionSchema,
+ *     },
+ *     generateHaiku: {
+ *       agent: haikuGeneratorAgent,
+ *       inputSchema: HaikuGeneratorInputSchema,
+ *       outputSchema: HaikuSchema,
+ *     },
+ *   },
+ *   { model: openai('gpt-4'), temperature: 0.8 }
+ * );
+ *
+ * // Use the functions
+ * const name = await analyzers.generateName({ characteristics });
+ * const haiku = await analyzers.generateHaiku({ characteristics });
+ * ```
+ *
+ * @param configs - Map of function names to conversion configurations
+ * @param llmConfig - Shared LLM configuration for all agents
+ * @returns Map of function names to executable async functions
+ */
+export interface LLMAnalyzerConversionConfig<TInput, TOutput> {
+    agent: Agent<TInput, TOutput>;
+    inputSchema: z.ZodType<TInput>;
+    outputSchema: z.ZodType<TOutput>;
+}
+export declare function convertLLMAnalyzersToFunctions<T extends Record<string, LLMAnalyzerConversionConfig<unknown, unknown>>>(configs: T, llmConfig: VercelAILLMConfig): Record<keyof T, (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,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAE/D,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;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,iBAAiB,GAC3B,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CA0CrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,WAAW,2BAA2B,CAAC,MAAM,EAAE,OAAO;IAC1D,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/B,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;CAClC;AAED,wBAAgB,8BAA8B,CAC5C,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,2BAA2B,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,EAEvE,OAAO,EAAE,CAAC,EACV,SAAS,EAAE,iBAAiB,GAC3B,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAavD"}

package/dist/adapters/llm-analyzer.js

@@ -0,0 +1,81 @@
+import { generateText } from 'ai';
+/**
+ * Converts a VAT LLM Analyzer agent to a function compatible with Vercel AI SDK.
+ *
+ * LLM analyzers make a single LLM call to analyze input and produce structured output.
+ * They're perfect for classification, extraction, generation, and analysis tasks.
+ *
+ * Example:
+ * ```typescript
+ * import { openai } from '@ai-sdk/openai';
+ * import { nameGeneratorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { NameGeneratorInputSchema, NameSuggestionSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertLLMAnalyzerToFunction } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+ *
+ * const generateName = convertLLMAnalyzerToFunction(
+ *   nameGeneratorAgent,
+ *   NameGeneratorInputSchema,
+ *   NameSuggestionSchema,
+ *   { model: openai('gpt-4'), temperature: 0.9 }
+ * );
+ *
+ * // Use the function
+ * const result = await generateName({
+ *   characteristics: { physical: { furColor: 'Orange' }, behavioral: { personality: ['Mischievous'] } }
+ * });
+ * console.log(result.name); // "Sir Knocksalot"
+ * ```
+ *
+ * @param agent - The VAT LLM analyzer agent to convert
+ * @param inputSchema - The Zod input schema
+ * @param outputSchema - The Zod output schema
+ * @param llmConfig - Configuration for the LLM (model, temperature, etc.)
+ * @returns An async function that executes the agent with the configured LLM
+ */
+export function convertLLMAnalyzerToFunction(agent, inputSchema, outputSchema, llmConfig) {
+    return async (input) => {
+        // Validate input
+        const validatedInput = inputSchema.parse(input);
+        // Create LLM context with Vercel AI SDK's generateText
+        const callLLM = async (prompt) => {
+            const result = await generateText({
+                model: llmConfig.model,
+                ...(llmConfig.temperature ? { temperature: llmConfig.temperature } : {}),
+                ...(llmConfig.maxTokens ? { maxTokens: llmConfig.maxTokens } : {}),
+                ...llmConfig.additionalSettings,
+                prompt,
+            });
+            return result.text;
+        };
+        // Execute the agent with mock mode disabled (real LLM call)
+        // Extract model name from LanguageModel union type
+        let modelName;
+        if (typeof llmConfig.model === 'string') {
+            modelName = llmConfig.model;
+        }
+        else if ('provider' in llmConfig.model && llmConfig.model.provider) {
+            modelName = `${llmConfig.model.provider}/${llmConfig.model.modelId}`;
+        }
+        else {
+            modelName = llmConfig.model.modelId ?? 'unknown';
+        }
+        const context = {
+            mockable: false,
+            model: modelName,
+            temperature: llmConfig.temperature ?? 0.7,
+            callLLM,
+        };
+        // Call the agent's execute function with the LLM context
+        const output = await agent.execute(validatedInput, context);
+        // Validate output
+        return outputSchema.parse(output);
+    };
+}
+export function convertLLMAnalyzersToFunctions(configs, llmConfig) {
+    const functions = {};
+    for (const [name, config] of Object.entries(configs)) {
+        functions[name] = convertLLMAnalyzerToFunction(config.agent, config.inputSchema, config.outputSchema, llmConfig);
+    }
+    return functions;
+}
+//# 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":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,IAAI,CAAC;AAKlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,UAAU,4BAA4B,CAC1C,KAA6B,EAC7B,WAA8B,EAC9B,YAAgC,EAChC,SAA4B;IAE5B,OAAO,KAAK,EAAE,KAAa,EAAE,EAAE;QAC7B,iBAAiB;QACjB,MAAM,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAEhD,uDAAuD;QACvD,MAAM,OAAO,GAAG,KAAK,EAAE,MAAc,EAAE,EAAE;YACvC,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC;gBAChC,KAAK,EAAE,SAAS,CAAC,KAAK;gBACtB,GAAG,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACxE,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAClE,GAAG,SAAS,CAAC,kBAAkB;gBAC/B,MAAM;aACP,CAAC,CAAC;YAEH,OAAO,MAAM,CAAC,IAAI,CAAC;QACrB,CAAC,CAAC;QAEF,4DAA4D;QAC5D,mDAAmD;QACnD,IAAI,SAAiB,CAAC;QACtB,IAAI,OAAO,SAAS,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;YACxC,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC;QAC9B,CAAC;aAAM,IAAI,UAAU,IAAI,SAAS,CAAC,KAAK,IAAI,SAAS,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;YACrE,SAAS,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,QAAQ,IAAI,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QACvE,CAAC;aAAM,CAAC;YACN,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,IAAI,SAAS,CAAC;QACnD,CAAC;QAED,MAAM,OAAO,GAAG;YACd,QAAQ,EAAE,KAAK;YACf,KAAK,EAAE,SAAS;YAChB,WAAW,EAAE,SAAS,CAAC,WAAW,IAAI,GAAG;YACzC,OAAO;SACR,CAAC;QAEF,yDAAyD;QACzD,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;AA4CD,MAAM,UAAU,8BAA8B,CAG5C,OAAU,EACV,SAA4B;IAE5B,MAAM,SAAS,GAAyD,EAAE,CAAC;IAE3E,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACrD,SAAS,CAAC,IAAI,CAAC,GAAG,4BAA4B,CAC5C,MAAM,CAAC,KAAK,EACZ,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,YAAY,EACnB,SAAS,CACV,CAAC;IACJ,CAAC;IAED,OAAO,SAAkE,CAAC;AAC5E,CAAC"}

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

@@ -0,0 +1,79 @@
+import type { PureFunctionAgent } from '@vibe-agent-toolkit/agent-runtime';
+import type { z } from 'zod';
+import type { ConversionResult, VercelAITool } from '../types.js';
+/**
+ * Converts a VAT PureFunctionAgent to a Vercel AI SDK tool.
+ *
+ * Pure function tools are synchronous and deterministic - perfect for
+ * structured data validation, transformation, and computation.
+ *
+ * Example:
+ * ```typescript
+ * import { haikuValidatorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { HaikuSchema, HaikuValidationResultSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertPureFunctionToTool } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+ *
+ * const haikuTool = convertPureFunctionToTool(
+ *   haikuValidatorAgent,
+ *   HaikuSchema,
+ *   HaikuValidationResultSchema
+ * );
+ *
+ * // Use with generateText()
+ * const result = await generateText({
+ *   model: openai('gpt-4'),
+ *   tools: { validateHaiku: haikuTool.tool },
+ *   prompt: 'Validate this haiku: ...'
+ * });
+ * ```
+ *
+ * @param agent - The VAT pure function agent to convert
+ * @param inputSchema - The Zod input schema
+ * @param outputSchema - The Zod output schema
+ * @returns Vercel AI SDK tool definition with metadata
+ */
+export declare function convertPureFunctionToTool<TInput, TOutput>(agent: PureFunctionAgent<TInput, TOutput>, inputSchema: z.ZodType<TInput>, outputSchema: z.ZodType<TOutput>): ConversionResult<TInput, TOutput>;
+/**
+ * Configuration for batch tool conversion
+ */
+export interface ToolConversionConfig<TInput, TOutput> {
+    agent: PureFunctionAgent<TInput, TOutput>;
+    inputSchema: z.ZodType<TInput>;
+    outputSchema: z.ZodType<TOutput>;
+}
+/**
+ * Batch converts multiple pure function agents to Vercel AI SDK tools.
+ *
+ * Useful when you want to provide multiple tools to an LLM in one call.
+ *
+ * Example:
+ * ```typescript
+ * import { haikuValidatorAgent, nameValidatorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { HaikuSchema, HaikuValidationResultSchema, NameValidationInputSchema, NameValidationResultSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertPureFunctionsToTools } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+ *
+ * const tools = convertPureFunctionsToTools({
+ *   validateHaiku: {
+ *     agent: haikuValidatorAgent,
+ *     inputSchema: HaikuSchema,
+ *     outputSchema: HaikuValidationResultSchema,
+ *   },
+ *   validateName: {
+ *     agent: nameValidatorAgent,
+ *     inputSchema: NameValidationInputSchema,
+ *     outputSchema: NameValidationResultSchema,
+ *   },
+ * });
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4'),
+ *   tools,
+ *   prompt: 'Validate these cat names and haikus...'
+ * });
+ * ```
+ *
+ * @param configs - Map of tool names to conversion configurations
+ * @returns Map of tool names to Vercel AI SDK tools
+ */
+export declare function convertPureFunctionsToTools(configs: Record<string, ToolConversionConfig<unknown, unknown>>): Record<string, VercelAITool>;
+//# 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,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;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,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC,CA2BnC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,MAAM,EAAE,OAAO;IACnD,KAAK,EAAE,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/B,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,GAC9D,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAa9B"}

package/dist/adapters/pure-function.js

@@ -0,0 +1,101 @@
+import { tool } from 'ai';
+/**
+ * Converts a VAT PureFunctionAgent to a Vercel AI SDK tool.
+ *
+ * Pure function tools are synchronous and deterministic - perfect for
+ * structured data validation, transformation, and computation.
+ *
+ * Example:
+ * ```typescript
+ * import { haikuValidatorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { HaikuSchema, HaikuValidationResultSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertPureFunctionToTool } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+ *
+ * const haikuTool = convertPureFunctionToTool(
+ *   haikuValidatorAgent,
+ *   HaikuSchema,
+ *   HaikuValidationResultSchema
+ * );
+ *
+ * // Use with generateText()
+ * const result = await generateText({
+ *   model: openai('gpt-4'),
+ *   tools: { validateHaiku: haikuTool.tool },
+ *   prompt: 'Validate this haiku: ...'
+ * });
+ * ```
+ *
+ * @param agent - The VAT pure function agent to convert
+ * @param inputSchema - The Zod input schema
+ * @param outputSchema - The Zod output schema
+ * @returns Vercel AI SDK tool definition with metadata
+ */
+export function convertPureFunctionToTool(agent, inputSchema, outputSchema) {
+    const { manifest } = agent;
+    // AI SDK v6: Use inputSchema instead of parameters, add options parameter to execute
+    // Type assertion needed because generic z.ZodType<TInput> doesn't satisfy tool()'s
+    // compile-time type constraints (FlexibleSchema<INPUT>), but works correctly at runtime
+    const vercelTool = tool({
+        description: manifest.description,
+        inputSchema: inputSchema,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        execute: async (args, _options) => {
+            // The schema validates the input at runtime
+            return agent.execute(args);
+        },
+    });
+    return {
+        tool: vercelTool,
+        inputSchema,
+        outputSchema,
+        metadata: {
+            name: manifest.name,
+            description: manifest.description,
+            version: manifest.version,
+            archetype: manifest.archetype,
+        },
+    };
+}
+/**
+ * Batch converts multiple pure function agents to Vercel AI SDK tools.
+ *
+ * Useful when you want to provide multiple tools to an LLM in one call.
+ *
+ * Example:
+ * ```typescript
+ * import { haikuValidatorAgent, nameValidatorAgent } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { HaikuSchema, HaikuValidationResultSchema, NameValidationInputSchema, NameValidationResultSchema } from '@vibe-agent-toolkit/vat-example-cat-agents';
+ * import { convertPureFunctionsToTools } from '@vibe-agent-toolkit/runtime-vercel-ai-sdk';
+ *
+ * const tools = convertPureFunctionsToTools({
+ *   validateHaiku: {
+ *     agent: haikuValidatorAgent,
+ *     inputSchema: HaikuSchema,
+ *     outputSchema: HaikuValidationResultSchema,
+ *   },
+ *   validateName: {
+ *     agent: nameValidatorAgent,
+ *     inputSchema: NameValidationInputSchema,
+ *     outputSchema: NameValidationResultSchema,
+ *   },
+ * });
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4'),
+ *   tools,
+ *   prompt: 'Validate these cat names and haikus...'
+ * });
+ * ```
+ *
+ * @param configs - Map of tool names to conversion configurations
+ * @returns Map of tool names to Vercel AI SDK tools
+ */
+export function convertPureFunctionsToTools(configs) {
+    const tools = {};
+    for (const [name, config] of Object.entries(configs)) {
+        const converted = convertPureFunctionToTool(config.agent, config.inputSchema, config.outputSchema);
+        tools[name] = converted.tool;
+    }
+    return tools;
+}
+//# 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":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAK1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,yBAAyB,CACvC,KAAyC,EACzC,WAA8B,EAC9B,YAAgC;IAEhC,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;IAE3B,qFAAqF;IACrF,mFAAmF;IACnF,wFAAwF;IACxF,MAAM,UAAU,GAAG,IAAI,CAAC;QACtB,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,WAAW,EAAE,WAAW;QACxB,8DAA8D;QAC9D,OAAO,EAAE,KAAK,EAAE,IAAS,EAAE,QAAa,EAAE,EAAE;YAC1C,4CAA4C;YAC5C,OAAO,KAAK,CAAC,OAAO,CAAC,IAAc,CAAC,CAAC;QACvC,CAAC;KACuC,CAAC,CAAC;IAE5C,OAAO;QACL,IAAI,EAAE,UAAqC;QAC3C,WAAW;QACX,YAAY;QACZ,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;KACF,CAAC;AACJ,CAAC;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,2BAA2B,CACzC,OAA+D;IAE/D,MAAM,KAAK,GAAiC,EAAE,CAAC;IAE/C,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACrD,MAAM,SAAS,GAAG,yBAAyB,CACzC,MAAM,CAAC,KAAK,EACZ,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,YAAY,CACpB,CAAC;QACF,KAAK,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC;IAC/B,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @vibe-agent-toolkit/runtime-vercel-ai-sdk
+ *
+ * Vercel AI SDK runtime adapter for VAT (Vibe Agent Toolkit) agents.
+ *
+ * Converts VAT archetype agents to Vercel AI SDK primitives:
+ * - PureFunctionAgent → tool() for structured data operations
+ * - LLMAnalyzerAgent → generateText() for AI-powered analysis
+ *
+ * Supports OpenAI, Anthropic, and other providers via Vercel AI SDK.
+ */
+export { convertPureFunctionToTool, convertPureFunctionsToTools, type ToolConversionConfig, } from './adapters/pure-function.js';
+export { convertLLMAnalyzerToFunction, convertLLMAnalyzersToFunctions, type LLMAnalyzerConversionConfig, } from './adapters/llm-analyzer.js';
+export { convertConversationalAssistantToFunction, convertConversationalAssistantsToFunctions, type ConversationalAssistantConversionConfig, type ConversationSession, } from './adapters/conversational-assistant.js';
+export type { VercelAITool, VercelAILLMConfig, ConversionResult, } 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":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EACL,yBAAyB,EACzB,2BAA2B,EAC3B,KAAK,oBAAoB,GAC1B,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,4BAA4B,EAC5B,8BAA8B,EAC9B,KAAK,2BAA2B,GACjC,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,wCAAwC,EACxC,0CAA0C,EAC1C,KAAK,uCAAuC,EAC5C,KAAK,mBAAmB,GACzB,MAAM,wCAAwC,CAAC;AAGhD,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * @vibe-agent-toolkit/runtime-vercel-ai-sdk
+ *
+ * Vercel AI SDK runtime adapter for VAT (Vibe Agent Toolkit) agents.
+ *
+ * Converts VAT archetype agents to Vercel AI SDK primitives:
+ * - PureFunctionAgent → tool() for structured data operations
+ * - LLMAnalyzerAgent → generateText() for AI-powered analysis
+ *
+ * Supports OpenAI, Anthropic, and other providers via Vercel AI SDK.
+ */
+// Adapters
+export { convertPureFunctionToTool, convertPureFunctionsToTools, } from './adapters/pure-function.js';
+export { convertLLMAnalyzerToFunction, convertLLMAnalyzersToFunctions, } from './adapters/llm-analyzer.js';
+export { convertConversationalAssistantToFunction, convertConversationalAssistantsToFunctions, } from './adapters/conversational-assistant.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;;;;;;;;;;GAUG;AAEH,WAAW;AACX,OAAO,EACL,yBAAyB,EACzB,2BAA2B,GAE5B,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,4BAA4B,EAC5B,8BAA8B,GAE/B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,wCAAwC,EACxC,0CAA0C,GAG3C,MAAM,wCAAwC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+import type { LanguageModel, tool as toolFunction } from 'ai';
+import type { z } from 'zod';
+/**
+ * Vercel AI SDK tool definition
+ * Compatible with generateText() and streamText()
+ */
+export type VercelAITool = ReturnType<typeof toolFunction>;
+/**
+ * Configuration for LLM calls via Vercel AI SDK
+ */
+export interface VercelAILLMConfig {
+    /**
+     * The language model to use
+     * Can be from any provider (OpenAI, Anthropic, etc.)
+     */
+    model: LanguageModel;
+    /**
+     * Temperature for generation (0-1)
+     * @default 0.7
+     */
+    temperature?: number;
+    /**
+     * Maximum tokens to generate
+     */
+    maxTokens?: number;
+    /**
+     * Additional model-specific settings
+     */
+    additionalSettings?: Record<string, unknown>;
+}
+/**
+ * Result from converting a VAT agent to Vercel AI SDK format
+ */
+export interface ConversionResult<TInput, TOutput> {
+    /**
+     * The Vercel AI SDK tool definition
+     */
+    tool: VercelAITool;
+    /**
+     * Original input schema for reference
+     */
+    inputSchema: z.ZodType<TInput>;
+    /**
+     * Original output schema for reference
+     */
+    outputSchema: z.ZodType<TOutput>;
+    /**
+     * Agent metadata
+     */
+    metadata: {
+        name: string;
+        description: string;
+        version: string;
+        archetype: string;
+    };
+}
+//# 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,IAAI,IAAI,YAAY,EAAE,MAAM,IAAI,CAAC;AAC9D,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;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;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,MAAM,EAAE,OAAO;IAC/C;;OAEG;IACH,IAAI,EAAE,YAAY,CAAC;IAEnB;;OAEG;IACH,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE/B;;OAEG;IACH,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAEjC;;OAEG;IACH,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH"}

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,54 @@
+{
+  "name": "@vibe-agent-toolkit/runtime-vercel-ai-sdk",
+  "version": "0.1.2-rc.4",
+  "description": "Vercel AI 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",
+    "llm-demo": "tsx examples/llm-agent-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": {
+    "@ai-sdk/provider": "^3.0.4",
+    "@ai-sdk/provider-utils": "^4.0.8",
+    "@vibe-agent-toolkit/agent-runtime": "0.1.2-rc.4",
+    "ai": "^6.0.39",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@ai-sdk/anthropic": "^3.0.15",
+    "@ai-sdk/openai": "^3.0.12",
+    "@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",
+    "vercel-ai-sdk",
+    "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-vercel-ai-sdk"
+  }
+}