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

package/dist/llm-analyzer.d.ts

@@ -0,0 +1,58 @@
+import { type z } from 'zod';
+import type { Agent, LLMAnalyzerContext } from './types.js';
+/**
+ * Configuration for defining an LLM analyzer agent
+ */
+export interface LLMAnalyzerConfig<TInput, TOutput> {
+    /** Unique name for the agent */
+    name: string;
+    /** Human-readable description of what the agent does */
+    description: string;
+    /** Semantic version (e.g., "1.0.0") */
+    version: string;
+    /** Zod schema for input validation */
+    inputSchema: z.ZodType<TInput>;
+    /** Zod schema for output validation */
+    outputSchema: z.ZodType<TOutput>;
+    /** Whether this agent can be mocked in tests (default: true) */
+    mockable?: boolean;
+    /** LLM model identifier (optional) */
+    model?: string;
+    /** Temperature for LLM generation (0-1, optional) */
+    temperature?: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Defines an LLM analyzer agent that uses language models to analyze
+ * and transform data.
+ *
+ * The agent validates inputs and outputs using Zod schemas, provides
+ * LLM context to the handler, and generates a manifest describing its
+ * interface and capabilities.
+ *
+ * @param config - Agent configuration including schemas and LLM parameters
+ * @param handler - Async function that uses LLM context to transform input
+ * @returns Agent with validated execute function and manifest
+ *
+ * @example
+ * ```typescript
+ * const sentimentAgent = defineLLMAnalyzer(
+ *   {
+ *     name: 'sentiment-analyzer',
+ *     description: 'Analyzes sentiment of text',
+ *     version: '1.0.0',
+ *     inputSchema: z.object({ text: z.string() }),
+ *     outputSchema: z.object({ sentiment: z.enum(['positive', 'negative', 'neutral']) }),
+ *     model: 'claude-3-haiku',
+ *     mockable: true,
+ *   },
+ *   async (input, ctx) => {
+ *     const response = await ctx.callLLM(`Analyze sentiment: ${input.text}`);
+ *     return { sentiment: 'positive' }; // Parse response
+ *   }
+ * );
+ * ```
+ */
+export declare function defineLLMAnalyzer<TInput, TOutput>(config: LLMAnalyzerConfig<TInput, TOutput>, handler: (input: TInput, ctx: LLMAnalyzerContext) => Promise<TOutput>): Agent<TInput, TOutput>;
+//# sourceMappingURL=llm-analyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"llm-analyzer.d.ts","sourceRoot":"","sources":["../src/llm-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAG7B,OAAO,KAAK,EAAE,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,MAAM,EAAE,OAAO;IAChD,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IAEb,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAC;IAEpB,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAEhB,sCAAsC;IACtC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE/B,uCAAuC;IACvC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAEjC,gEAAgE;IAChE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,sCAAsC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,qDAAqD;IACrD,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAC/C,MAAM,EAAE,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,kBAAkB,KAAK,OAAO,CAAC,OAAO,CAAC,GACpE,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAyBxB"}

package/dist/llm-analyzer.js

@@ -0,0 +1,53 @@
+import { buildManifest, createAsyncExecuteWrapperWithContext } from './execute-wrapper.js';
+/**
+ * Defines an LLM analyzer agent that uses language models to analyze
+ * and transform data.
+ *
+ * The agent validates inputs and outputs using Zod schemas, provides
+ * LLM context to the handler, and generates a manifest describing its
+ * interface and capabilities.
+ *
+ * @param config - Agent configuration including schemas and LLM parameters
+ * @param handler - Async function that uses LLM context to transform input
+ * @returns Agent with validated execute function and manifest
+ *
+ * @example
+ * ```typescript
+ * const sentimentAgent = defineLLMAnalyzer(
+ *   {
+ *     name: 'sentiment-analyzer',
+ *     description: 'Analyzes sentiment of text',
+ *     version: '1.0.0',
+ *     inputSchema: z.object({ text: z.string() }),
+ *     outputSchema: z.object({ sentiment: z.enum(['positive', 'negative', 'neutral']) }),
+ *     model: 'claude-3-haiku',
+ *     mockable: true,
+ *   },
+ *   async (input, ctx) => {
+ *     const response = await ctx.callLLM(`Analyze sentiment: ${input.text}`);
+ *     return { sentiment: 'positive' }; // Parse response
+ *   }
+ * );
+ * ```
+ */
+export function defineLLMAnalyzer(config, handler) {
+    // Build manifest with LLM-specific metadata
+    const manifest = buildManifest(config, 'llm-analyzer', {
+        mockable: config.mockable ?? true,
+        ...(config.model && { model: config.model }),
+        ...(config.temperature !== undefined && { temperature: config.temperature }),
+    });
+    // Create validated execute function that accepts variable arguments
+    const execute = createAsyncExecuteWrapperWithContext(config, handler, (ctx) => ({
+        mockable: config.mockable ?? true,
+        callLLM: ctx.callLLM,
+        ...(config.model && { model: config.model }),
+        ...(config.temperature !== undefined && { temperature: config.temperature }),
+    }));
+    return {
+        name: config.name,
+        execute,
+        manifest,
+    };
+}
+//# sourceMappingURL=llm-analyzer.js.map

package/dist/llm-analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-analyzer.js","sourceRoot":"","sources":["../src/llm-analyzer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,oCAAoC,EAAE,MAAM,sBAAsB,CAAC;AAmC3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAA0C,EAC1C,OAAqE;IAErE,4CAA4C;IAC5C,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE;QACrD,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;QACjC,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;QAC5C,GAAG,CAAC,MAAM,CAAC,WAAW,KAAK,SAAS,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC;KAC7E,CAAC,CAAC;IAEH,oEAAoE;IACpE,MAAM,OAAO,GAAG,oCAAoC,CAClD,MAAM,EACN,OAAO,EACP,CAAC,GAAuB,EAAsB,EAAE,CAAC,CAAC;QAChD,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;QACjC,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;QAC5C,GAAG,CAAC,MAAM,CAAC,WAAW,KAAK,SAAS,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC;KAC7E,CAAC,CACH,CAAC;IAEF,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,OAAO;QACP,QAAQ;KACT,CAAC;AACJ,CAAC"}

package/dist/llm-coordinator.d.ts

@@ -0,0 +1,62 @@
+import { type z } from 'zod';
+import type { Agent, CoordinatorContext } from './types.js';
+/**
+ * Configuration for defining an LLM coordinator agent
+ */
+export interface LLMCoordinatorConfig<TInput, TOutput> {
+    /** Unique name for the agent */
+    name: string;
+    /** Human-readable description of what the agent does */
+    description: string;
+    /** Semantic version (e.g., "1.0.0") */
+    version: string;
+    /** Zod schema for input validation */
+    inputSchema: z.ZodType<TInput>;
+    /** Zod schema for output validation */
+    outputSchema: z.ZodType<TOutput>;
+    /** Whether this agent can be mocked in tests (default: true) */
+    mockable?: boolean;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Defines an LLM coordinator agent that uses language models to make
+ * decisions about which agents to call and how to coordinate workflows.
+ *
+ * The agent validates inputs and outputs using Zod schemas, provides
+ * access to LLM reasoning and other agents, and supports routing logic.
+ *
+ * @param config - Agent configuration including schemas
+ * @param handler - Async function that coordinates using LLM
+ * @returns Agent with validated execute function and manifest
+ *
+ * @example
+ * ```typescript
+ * const coordinator = defineLLMCoordinator(
+ *   {
+ *     name: 'task-coordinator',
+ *     description: 'Coordinates task execution based on LLM decisions',
+ *     version: '1.0.0',
+ *     inputSchema: z.object({ task: z.string() }),
+ *     outputSchema: z.object({ result: z.string() }),
+ *   },
+ *   async (input, ctx) => {
+ *     // Ask LLM to decide which agent to use
+ *     const decision = await ctx.callLLM(
+ *       `Which agent should handle this task: ${input.task}? Choose: simple, complex, or research`
+ *     );
+ *
+ *     // Route to appropriate agent
+ *     const result = await ctx.route(decision, {
+ *       simple: () => ctx.call('simple-processor', input),
+ *       complex: () => ctx.call('complex-processor', input),
+ *       research: () => ctx.call('research-agent', input),
+ *     });
+ *
+ *     return { result: String(result) };
+ *   }
+ * );
+ * ```
+ */
+export declare function defineLLMCoordinator<TInput, TOutput>(config: LLMCoordinatorConfig<TInput, TOutput>, handler: (input: TInput, ctx: CoordinatorContext) => Promise<TOutput>): Agent<TInput, TOutput>;
+//# sourceMappingURL=llm-coordinator.d.ts.map

package/dist/llm-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-coordinator.d.ts","sourceRoot":"","sources":["../src/llm-coordinator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAG7B,OAAO,KAAK,EAAE,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,MAAM,EAAE,OAAO;IACnD,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IAEb,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAC;IAEpB,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAEhB,sCAAsC;IACtC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE/B,uCAAuC;IACvC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAEjC,gEAAgE;IAChE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAClD,MAAM,EAAE,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7C,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,kBAAkB,KAAK,OAAO,CAAC,OAAO,CAAC,GACpE,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAwBxB"}

package/dist/llm-coordinator.js

@@ -0,0 +1,60 @@
+import { buildManifest, createAsyncExecuteWrapperWithContext } from './execute-wrapper.js';
+/**
+ * Defines an LLM coordinator agent that uses language models to make
+ * decisions about which agents to call and how to coordinate workflows.
+ *
+ * The agent validates inputs and outputs using Zod schemas, provides
+ * access to LLM reasoning and other agents, and supports routing logic.
+ *
+ * @param config - Agent configuration including schemas
+ * @param handler - Async function that coordinates using LLM
+ * @returns Agent with validated execute function and manifest
+ *
+ * @example
+ * ```typescript
+ * const coordinator = defineLLMCoordinator(
+ *   {
+ *     name: 'task-coordinator',
+ *     description: 'Coordinates task execution based on LLM decisions',
+ *     version: '1.0.0',
+ *     inputSchema: z.object({ task: z.string() }),
+ *     outputSchema: z.object({ result: z.string() }),
+ *   },
+ *   async (input, ctx) => {
+ *     // Ask LLM to decide which agent to use
+ *     const decision = await ctx.callLLM(
+ *       `Which agent should handle this task: ${input.task}? Choose: simple, complex, or research`
+ *     );
+ *
+ *     // Route to appropriate agent
+ *     const result = await ctx.route(decision, {
+ *       simple: () => ctx.call('simple-processor', input),
+ *       complex: () => ctx.call('complex-processor', input),
+ *       research: () => ctx.call('research-agent', input),
+ *     });
+ *
+ *     return { result: String(result) };
+ *   }
+ * );
+ * ```
+ */
+export function defineLLMCoordinator(config, handler) {
+    // Build manifest
+    const manifest = buildManifest(config, 'llm-coordinator', {
+        mockable: config.mockable ?? true,
+    });
+    // Create validated execute function
+    const execute = createAsyncExecuteWrapperWithContext(config, handler, (ctx) => ({
+        mockable: config.mockable ?? true,
+        call: ctx.call,
+        callLLM: ctx.callLLM,
+        route: ctx.route,
+        state: ctx.state,
+    }));
+    return {
+        name: config.name,
+        execute,
+        manifest,
+    };
+}
+//# sourceMappingURL=llm-coordinator.js.map

package/dist/llm-coordinator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-coordinator.js","sourceRoot":"","sources":["../src/llm-coordinator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,oCAAoC,EAAE,MAAM,sBAAsB,CAAC;AA6B3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,UAAU,oBAAoB,CAClC,MAA6C,EAC7C,OAAqE;IAErE,iBAAiB;IACjB,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,EAAE,iBAAiB,EAAE;QACxD,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;KAClC,CAAC,CAAC;IAEH,oCAAoC;IACpC,MAAM,OAAO,GAAG,oCAAoC,CAClD,MAAM,EACN,OAAO,EACP,CAAC,GAAuB,EAAsB,EAAE,CAAC,CAAC;QAChD,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;QACjC,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,KAAK,EAAE,GAAG,CAAC,KAAK;KACjB,CAAC,CACH,CAAC;IAEF,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,OAAO;QACP,QAAQ;KACT,CAAC;AACJ,CAAC"}

package/dist/llm-event-handler.d.ts

@@ -0,0 +1,67 @@
+import { type z } from 'zod';
+import type { Agent, LLMEventHandlerContext } from './types.js';
+/**
+ * Configuration for defining an LLM event handler agent
+ */
+export interface LLMEventHandlerConfig<TInput, TOutput> {
+    /** Unique name for the agent */
+    name: string;
+    /** Human-readable description of what the agent does */
+    description: string;
+    /** Semantic version (e.g., "1.0.0") */
+    version: string;
+    /** Zod schema for input validation */
+    inputSchema: z.ZodType<TInput>;
+    /** Zod schema for output validation */
+    outputSchema: z.ZodType<TOutput>;
+    /** Event types this agent subscribes to (optional) */
+    subscribesTo?: string[];
+    /** Whether this agent can be mocked in tests (default: true) */
+    mockable?: boolean;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Defines an LLM event handler agent that reacts to events using
+ * language model reasoning and processing.
+ *
+ * The agent validates inputs and outputs using Zod schemas and provides
+ * access to LLM capabilities, event data, and event emission.
+ *
+ * @param config - Agent configuration including schemas and event subscriptions
+ * @param handler - Async function that handles events using LLM
+ * @returns Agent with validated execute function and manifest
+ *
+ * @example
+ * ```typescript
+ * const handler = defineLLMEventHandler(
+ *   {
+ *     name: 'support-ticket-handler',
+ *     description: 'Analyzes and routes support tickets',
+ *     version: '1.0.0',
+ *     inputSchema: z.object({ ticketId: z.string(), content: z.string() }),
+ *     outputSchema: z.object({ priority: z.string(), category: z.string() }),
+ *     subscribesTo: ['ticket.created'],
+ *   },
+ *   async (input, ctx) => {
+ *     // Use LLM to analyze ticket
+ *     const analysis = await ctx.callLLM(
+ *       `Analyze this support ticket and determine priority and category: ${input.content}`
+ *     );
+ *
+ *     // Store analysis in state
+ *     ctx.state.set(`ticket:${input.ticketId}`, analysis);
+ *
+ *     // Emit routing event
+ *     await ctx.emit('ticket.analyzed', {
+ *       ticketId: input.ticketId,
+ *       analysis,
+ *     });
+ *
+ *     return { priority: 'high', category: 'technical' };
+ *   }
+ * );
+ * ```
+ */
+export declare function defineLLMEventHandler<TInput, TOutput>(config: LLMEventHandlerConfig<TInput, TOutput>, handler: (input: TInput, ctx: LLMEventHandlerContext) => Promise<TOutput>): Agent<TInput, TOutput>;
+//# sourceMappingURL=llm-event-handler.d.ts.map

package/dist/llm-event-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-event-handler.d.ts","sourceRoot":"","sources":["../src/llm-event-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAG7B,OAAO,KAAK,EAAE,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,MAAM,EAAE,OAAO;IACpD,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IAEb,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAC;IAEpB,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAEhB,sCAAsC;IACtC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE/B,uCAAuC;IACvC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAEjC,sDAAsD;IACtD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB,gEAAgE;IAChE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,EACnD,MAAM,EAAE,qBAAqB,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9C,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,sBAAsB,KAAK,OAAO,CAAC,OAAO,CAAC,GACxE,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CA0BxB"}

package/dist/llm-event-handler.js

@@ -0,0 +1,65 @@
+import { buildManifest, createAsyncExecuteWrapperWithContext } from './execute-wrapper.js';
+/**
+ * Defines an LLM event handler agent that reacts to events using
+ * language model reasoning and processing.
+ *
+ * The agent validates inputs and outputs using Zod schemas and provides
+ * access to LLM capabilities, event data, and event emission.
+ *
+ * @param config - Agent configuration including schemas and event subscriptions
+ * @param handler - Async function that handles events using LLM
+ * @returns Agent with validated execute function and manifest
+ *
+ * @example
+ * ```typescript
+ * const handler = defineLLMEventHandler(
+ *   {
+ *     name: 'support-ticket-handler',
+ *     description: 'Analyzes and routes support tickets',
+ *     version: '1.0.0',
+ *     inputSchema: z.object({ ticketId: z.string(), content: z.string() }),
+ *     outputSchema: z.object({ priority: z.string(), category: z.string() }),
+ *     subscribesTo: ['ticket.created'],
+ *   },
+ *   async (input, ctx) => {
+ *     // Use LLM to analyze ticket
+ *     const analysis = await ctx.callLLM(
+ *       `Analyze this support ticket and determine priority and category: ${input.content}`
+ *     );
+ *
+ *     // Store analysis in state
+ *     ctx.state.set(`ticket:${input.ticketId}`, analysis);
+ *
+ *     // Emit routing event
+ *     await ctx.emit('ticket.analyzed', {
+ *       ticketId: input.ticketId,
+ *       analysis,
+ *     });
+ *
+ *     return { priority: 'high', category: 'technical' };
+ *   }
+ * );
+ * ```
+ */
+export function defineLLMEventHandler(config, handler) {
+    // Build manifest
+    const manifest = buildManifest(config, 'llm-event-handler', {
+        mockable: config.mockable ?? true,
+        ...(config.subscribesTo && { subscribesTo: config.subscribesTo }),
+    });
+    // Create validated execute function
+    const execute = createAsyncExecuteWrapperWithContext(config, handler, (ctx) => ({
+        mockable: config.mockable ?? true,
+        eventType: ctx.eventType,
+        eventData: ctx.eventData,
+        callLLM: ctx.callLLM,
+        emit: ctx.emit,
+        state: ctx.state,
+    }));
+    return {
+        name: config.name,
+        execute,
+        manifest,
+    };
+}
+//# sourceMappingURL=llm-event-handler.js.map

package/dist/llm-event-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-event-handler.js","sourceRoot":"","sources":["../src/llm-event-handler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,oCAAoC,EAAE,MAAM,sBAAsB,CAAC;AAgC3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,UAAU,qBAAqB,CACnC,MAA8C,EAC9C,OAAyE;IAEzE,iBAAiB;IACjB,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,EAAE,mBAAmB,EAAE;QAC1D,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;QACjC,GAAG,CAAC,MAAM,CAAC,YAAY,IAAI,EAAE,YAAY,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC;KAClE,CAAC,CAAC;IAEH,oCAAoC;IACpC,MAAM,OAAO,GAAG,oCAAoC,CAClD,MAAM,EACN,OAAO,EACP,CAAC,GAA2B,EAA0B,EAAE,CAAC,CAAC;QACxD,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;QACjC,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,KAAK,EAAE,GAAG,CAAC,KAAK;KACjB,CAAC,CACH,CAAC;IAEF,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,OAAO;QACP,QAAQ;KACT,CAAC;AACJ,CAAC"}

package/dist/pure-function.d.ts

@@ -0,0 +1,34 @@
+import type { BaseAgentConfig, PureFunctionAgent } from './types.js';
+/**
+ * Configuration for defining a pure function agent
+ */
+export type PureFunctionConfig<TInput, TOutput> = BaseAgentConfig<TInput, TOutput>;
+/**
+ * Defines a pure function agent that performs deterministic transformations
+ * without side effects or external dependencies.
+ *
+ * The agent validates inputs and outputs using Zod schemas and generates
+ * a manifest describing its interface.
+ *
+ * @param config - Agent configuration including schemas and metadata
+ * @param handler - Pure function that transforms input to output
+ * @returns Agent with validated execute function and manifest
+ *
+ * @example
+ * ```typescript
+ * const addAgent = definePureFunction(
+ *   {
+ *     name: 'add',
+ *     description: 'Adds two numbers',
+ *     version: '1.0.0',
+ *     inputSchema: z.object({ a: z.number(), b: z.number() }),
+ *     outputSchema: z.number(),
+ *   },
+ *   (input) => input.a + input.b
+ * );
+ *
+ * const result = addAgent.execute({ a: 2, b: 3 }); // 5
+ * ```
+ */
+export declare function definePureFunction<TInput, TOutput>(config: PureFunctionConfig<TInput, TOutput>, handler: (input: TInput) => TOutput): PureFunctionAgent<TInput, TOutput>;
+//# sourceMappingURL=pure-function.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pure-function.d.ts","sourceRoot":"","sources":["../src/pure-function.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,kBAAkB,CAAC,MAAM,EAAE,OAAO,IAAI,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAChD,MAAM,EAAE,kBAAkB,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3C,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAClC,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,CAYpC"}

package/dist/pure-function.js

@@ -0,0 +1,40 @@
+import { buildManifest, createPureExecuteWrapper } from './execute-wrapper.js';
+/**
+ * Defines a pure function agent that performs deterministic transformations
+ * without side effects or external dependencies.
+ *
+ * The agent validates inputs and outputs using Zod schemas and generates
+ * a manifest describing its interface.
+ *
+ * @param config - Agent configuration including schemas and metadata
+ * @param handler - Pure function that transforms input to output
+ * @returns Agent with validated execute function and manifest
+ *
+ * @example
+ * ```typescript
+ * const addAgent = definePureFunction(
+ *   {
+ *     name: 'add',
+ *     description: 'Adds two numbers',
+ *     version: '1.0.0',
+ *     inputSchema: z.object({ a: z.number(), b: z.number() }),
+ *     outputSchema: z.number(),
+ *   },
+ *   (input) => input.a + input.b
+ * );
+ *
+ * const result = addAgent.execute({ a: 2, b: 3 }); // 5
+ * ```
+ */
+export function definePureFunction(config, handler) {
+    // Build manifest
+    const manifest = buildManifest(config, 'pure-function');
+    // Create validated execute function
+    const execute = createPureExecuteWrapper(config, handler);
+    return {
+        name: config.name,
+        execute,
+        manifest,
+    };
+}
+//# sourceMappingURL=pure-function.js.map

package/dist/pure-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure-function.js","sourceRoot":"","sources":["../src/pure-function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAQ/E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAA2C,EAC3C,OAAmC;IAEnC,iBAAiB;IACjB,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAExD,oCAAoC;IACpC,MAAM,OAAO,GAAG,wBAAwB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE1D,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,OAAO;QACP,QAAQ;KACT,CAAC;AACJ,CAAC"}

package/dist/result-helpers.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Helper functions for working with agent results.
+ * Provides Railway-Oriented Programming patterns for orchestration.
+ */
+import { type AgentResult, type OneShotAgentOutput, type StatefulAgentResult } from '@vibe-agent-toolkit/agent-schema';
+/**
+ * Map success value, propagate errors.
+ * Classic functor map operation.
+ *
+ * @example
+ * const result = { status: 'success', data: 5 };
+ * const doubled = mapResult(result, x => x * 2);
+ * // doubled = { status: 'success', data: 10 }
+ */
+export declare function mapResult<T, U, E extends string>(result: AgentResult<T, E>, fn: (data: T) => U): AgentResult<U, E>;
+/**
+ * Chain dependent operations (monadic bind).
+ * Only runs next operation if current succeeded.
+ *
+ * @example
+ * const result1 = await agent1.execute(input);
+ * const result2 = await andThen(result1.result, async (data) => {
+ *   const output = await agent2.execute(data);
+ *   return output.result;
+ * });
+ */
+export declare function andThen<T, U, E extends string>(result: AgentResult<T, E>, fn: (data: T) => Promise<AgentResult<U, E>>): Promise<AgentResult<U, E>>;
+/**
+ * Pattern matching on result status.
+ * Exhaustive handling of all cases.
+ *
+ * @example
+ * const message = match(result, {
+ *   success: (data) => `Success: ${data}`,
+ *   error: (err) => `Error: ${err}`,
+ *   inProgress: () => 'Still working...'
+ * });
+ */
+export declare function match<T, E extends string, R>(result: StatefulAgentResult<T, E>, handlers: {
+    success: (data: T) => R;
+    error: (error: E) => R;
+    inProgress?: (metadata?: unknown) => R;
+}): R | undefined;
+/**
+ * Unwrap result or throw error.
+ * Use when you want to convert to exception-based flow.
+ *
+ * @example
+ * try {
+ *   const data = unwrap(result);
+ *   console.log('Success:', data);
+ * } catch (err) {
+ *   console.error('Failed:', err);
+ * }
+ */
+export declare function unwrap<T, E extends string>(result: AgentResult<T, E>): T;
+/**
+ * Wrap agent execution with retry logic.
+ *
+ * Automatically retries on transient failures (timeouts, rate limits, unavailable),
+ * injects retry count into execution metadata, and uses exponential backoff.
+ *
+ * @example
+ * const agent = createAgent({...});
+ * const withRetries = withRetry(() => agent.execute(input), 5);
+ * const output = await withRetries;
+ * // output.result.execution.retryCount shows how many retries were needed
+ */
+export declare function withRetry<TData, TError extends string>(agentFn: () => Promise<OneShotAgentOutput<TData, TError>>, maxAttempts?: number): Promise<OneShotAgentOutput<TData, TError>>;
+/**
+ * Wrap agent execution with timing metadata.
+ *
+ * Measures execution duration and injects it into ExecutionMetadata.
+ *
+ * @example
+ * const output = await withTiming(() => agent.execute(input));
+ * console.log(`Execution took ${output.result.execution?.durationMs}ms`);
+ */
+export declare function withTiming<TData, TError extends string>(agentFn: () => Promise<OneShotAgentOutput<TData, TError>>): Promise<OneShotAgentOutput<TData, TError>>;
+//# sourceMappingURL=result-helpers.d.ts.map

package/dist/result-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-helpers.d.ts","sourceRoot":"","sources":["../src/result-helpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EASL,KAAK,WAAW,EAIhB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACzB,MAAM,kCAAkC,CAAC;AAE1C;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,MAAM,EAC9C,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GACjB,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAWnB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,MAAM,EAClD,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAC1C,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAK5B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,EAC1C,MAAM,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,EACjC,QAAQ,EAAE;IACR,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;IACxB,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;IACvB,UAAU,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC;CACxC,GACA,CAAC,GAAG,SAAS,CASf;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAKxE;AAmDD;;;;;;;;;;;GAWG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,SAAS,MAAM,EAC1D,OAAO,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,EACzD,WAAW,GAAE,MAAU,GACtB,OAAO,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CA2E5C;AAED;;;;;;;;GAQG;AACH,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,SAAS,MAAM,EAC3D,OAAO,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,GACxD,OAAO,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAmB5C"}