@alveus-ai/std 0.1.0

package/dist/agents/basic-chat.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Basic Chat Agent Factory
+ *
+ * Creates reusable chat agents with a configurable system prompt.
+ * The agent is model-agnostic - it works with any LLM provider.
+ *
+ * @example
+ * ```ts
+ * // Create a helpful assistant
+ * const assistant = createChatAgent('You are a helpful assistant.');
+ *
+ * // Create a code reviewer with specific model
+ * const reviewer = createChatAgent(
+ *   'You are a senior engineer reviewing code for bugs and improvements.',
+ *   { model: 'gpt-4o', provider: 'openai' }
+ * );
+ *
+ * // Execute via runtime
+ * const result = await runtime.execute({
+ *   hash: assistant.definition.hash,
+ *   state: {},
+ *   event: { message: 'Hello, how can you help me?' }
+ * });
+ * ```
+ */
+import type { ChatOptions, ExecutionContext } from '@alveus-ai/core';
+/**
+ * Input event for chat agents
+ */
+export interface ChatInput {
+    /** The user's message */
+    message: string;
+    /** Optional conversation history */
+    history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>;
+}
+/**
+ * Output from chat agents
+ */
+export interface ChatOutput {
+    /** The assistant's reply */
+    reply: string;
+    /** Provider used for this response */
+    provider?: string;
+    /** Model used for this response */
+    model?: string;
+}
+/**
+ * Options for creating a chat agent
+ */
+export interface ChatAgentOptions extends ChatOptions {
+    /** Name for the agent (for debugging/logging) */
+    name?: string;
+    /** Description of the agent's purpose */
+    description?: string;
+}
+/**
+ * Create a chat agent with a configurable system prompt
+ *
+ * @param systemPrompt - The system prompt defining the agent's behavior
+ * @param options - Optional configuration for provider, model, etc.
+ * @returns An Agent that can be executed via any Alveus runtime
+ */
+export declare function createChatAgent(systemPrompt: string, options?: ChatAgentOptions): import("@alveus-ai/core").Agent<Record<string, unknown>, ChatInput, ExecutionContext, ChatOutput>;
+/**
+ * Create a JSON-structured chat agent
+ *
+ * Forces the LLM to respond with valid JSON, useful for structured outputs.
+ *
+ * @param systemPrompt - The system prompt (should describe the expected JSON format)
+ * @param options - Optional configuration
+ * @returns An Agent that returns structured JSON responses
+ */
+export declare function createJsonChatAgent<T = unknown>(systemPrompt: string, options?: ChatAgentOptions): import("@alveus-ai/core").Agent<Record<string, unknown>, ChatInput, ExecutionContext, {
+    data: T;
+    raw: string;
+}>;
+//# sourceMappingURL=basic-chat.d.ts.map

package/dist/agents/basic-chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-chat.d.ts","sourceRoot":"","sources":["../../src/agents/basic-chat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;IAEhB,oCAAoC;IACpC,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClE;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IAEd,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,mCAAmC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,yCAAyC;IACzC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB,qGAoCnF;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,GAAG,OAAO,EAC7C,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,gBAAqB;UAST,CAAC;SAAO,MAAM;GA2BpC"}

package/dist/agents/basic-chat.js

@@ -0,0 +1,91 @@
+/**
+ * Basic Chat Agent Factory
+ *
+ * Creates reusable chat agents with a configurable system prompt.
+ * The agent is model-agnostic - it works with any LLM provider.
+ *
+ * @example
+ * ```ts
+ * // Create a helpful assistant
+ * const assistant = createChatAgent('You are a helpful assistant.');
+ *
+ * // Create a code reviewer with specific model
+ * const reviewer = createChatAgent(
+ *   'You are a senior engineer reviewing code for bugs and improvements.',
+ *   { model: 'gpt-4o', provider: 'openai' }
+ * );
+ *
+ * // Execute via runtime
+ * const result = await runtime.execute({
+ *   hash: assistant.definition.hash,
+ *   state: {},
+ *   event: { message: 'Hello, how can you help me?' }
+ * });
+ * ```
+ */
+import { agent$ } from '@alveus-ai/core';
+/**
+ * Create a chat agent with a configurable system prompt
+ *
+ * @param systemPrompt - The system prompt defining the agent's behavior
+ * @param options - Optional configuration for provider, model, etc.
+ * @returns An Agent that can be executed via any Alveus runtime
+ */
+export function createChatAgent(systemPrompt, options = {}) {
+    const { name, description, ...chatOptions } = options;
+    return agent$(async (_state, event, ctx) => {
+        // Build the message array
+        const messages = [
+            { role: 'system', content: systemPrompt },
+        ];
+        // Add conversation history if provided
+        if (event.history) {
+            messages.push(...event.history);
+        }
+        // Add the current user message
+        messages.push({ role: 'user', content: event.message });
+        // Generate response using the injected LLM capability
+        const reply = await ctx.llm.chat(messages, chatOptions);
+        return {
+            reply,
+            provider: chatOptions.provider,
+            model: chatOptions.model,
+        };
+    }, {
+        name: name || 'chat-agent',
+        description: description || 'A basic chat agent',
+    });
+}
+/**
+ * Create a JSON-structured chat agent
+ *
+ * Forces the LLM to respond with valid JSON, useful for structured outputs.
+ *
+ * @param systemPrompt - The system prompt (should describe the expected JSON format)
+ * @param options - Optional configuration
+ * @returns An Agent that returns structured JSON responses
+ */
+export function createJsonChatAgent(systemPrompt, options = {}) {
+    const { name, description, ...chatOptions } = options;
+    return agent$(async (_state, event, ctx) => {
+        const messages = [
+            { role: 'system', content: systemPrompt },
+        ];
+        if (event.history) {
+            messages.push(...event.history);
+        }
+        messages.push({ role: 'user', content: event.message });
+        // Force JSON mode
+        const reply = await ctx.llm.chat(messages, {
+            ...chatOptions,
+            jsonMode: true,
+        });
+        // Parse the JSON response
+        const data = JSON.parse(reply);
+        return { data, raw: reply };
+    }, {
+        name: name || 'json-chat-agent',
+        description: description || 'A structured JSON chat agent',
+    });
+}
+//# sourceMappingURL=basic-chat.js.map

package/dist/agents/basic-chat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-chat.js","sourceRoot":"","sources":["../../src/agents/basic-chat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAuCzC;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,YAAoB,EAAE,UAA4B,EAAE;IAClF,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,GAAG,OAAO,CAAC;IAEtD,OAAO,MAAM,CACX,KAAK,EACH,MAA+B,EAC/B,KAAgB,EAChB,GAAqB,EACA,EAAE;QACvB,0BAA0B;QAC1B,MAAM,QAAQ,GAAsE;YAClF,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,EAAE;SAC1C,CAAC;QAEF,uCAAuC;QACvC,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YAClB,QAAQ,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC;QAED,+BAA+B;QAC/B,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAExD,sDAAsD;QACtD,MAAM,KAAK,GAAG,MAAM,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAExD,OAAO;YACL,KAAK;YACL,QAAQ,EAAE,WAAW,CAAC,QAAQ;YAC9B,KAAK,EAAE,WAAW,CAAC,KAAK;SACzB,CAAC;IACJ,CAAC,EACD;QACE,IAAI,EAAE,IAAI,IAAI,YAAY;QAC1B,WAAW,EAAE,WAAW,IAAI,oBAAoB;KACjD,CACF,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CACjC,YAAoB,EACpB,UAA4B,EAAE;IAE9B,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,GAAG,OAAO,CAAC;IAEtD,OAAO,MAAM,CACX,KAAK,EACH,MAA+B,EAC/B,KAAgB,EAChB,GAAqB,EACc,EAAE;QACrC,MAAM,QAAQ,GAAsE;YAClF,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,EAAE;SAC1C,CAAC;QAEF,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YAClB,QAAQ,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC;QAED,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAExD,kBAAkB;QAClB,MAAM,KAAK,GAAG,MAAM,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE;YACzC,GAAG,WAAW;YACd,QAAQ,EAAE,IAAI;SACf,CAAC,CAAC;QAEH,0BAA0B;QAC1B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAM,CAAC;QAEpC,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC;IAC9B,CAAC,EACD;QACE,IAAI,EAAE,IAAI,IAAI,iBAAiB;QAC/B,WAAW,EAAE,WAAW,IAAI,8BAA8B;KAC3D,CACF,CAAC;AACJ,CAAC"}

package/dist/agents/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Standard Agent Factories
+ *
+ * Pre-built agent factories for common use cases.
+ */
+export { createChatAgent, createJsonChatAgent, type ChatInput, type ChatOutput, type ChatAgentOptions, } from './basic-chat.js';
+export { ReActLogic, createReActAgent, availableTools, type ReActInput, type ReActOutput, type ReActStep, type ReActAgentOptions, } from './react.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/agents/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,gBAAgB,GACtB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAEL,UAAU,EAEV,gBAAgB,EAEhB,cAAc,EAEd,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,iBAAiB,GACvB,MAAM,YAAY,CAAC"}

package/dist/agents/index.js

@@ -0,0 +1,14 @@
+/**
+ * Standard Agent Factories
+ *
+ * Pre-built agent factories for common use cases.
+ */
+export { createChatAgent, createJsonChatAgent, } from './basic-chat.js';
+export { 
+// The master logic (compiled agent)
+ReActLogic, 
+// The factory (returns VirtualAgent)
+createReActAgent, 
+// Available tools list
+availableTools, } from './react.js';
+//# sourceMappingURL=index.js.map

package/dist/agents/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,eAAe,EACf,mBAAmB,GAIpB,MAAM,iBAAiB,CAAC;AAEzB,OAAO;AACL,oCAAoC;AACpC,UAAU;AACV,qCAAqC;AACrC,gBAAgB;AAChB,uBAAuB;AACvB,cAAc,GAMf,MAAM,YAAY,CAAC"}

package/dist/agents/react.d.ts

@@ -0,0 +1,153 @@
+/**
+ * ReAct Agent Pattern - Using the "Curried Agent" (VirtualAgent) Pattern
+ *
+ * Tools are Agents!
+ *
+ * Custom tools must be wrapped in agent$() so they are:
+ * - Durable (the runtime handles retries)
+ * - Distributed (can run on different workers)
+ * - Serializable (only the hash is passed, not the function)
+ *
+ * @example
+ * ```ts
+ * import { agent$ } from '@alveus-ai/core';
+ * import { createReActAgent } from '@alveus-ai/std';
+ *
+ * // 1. Define custom tool as an Agent
+ * const HNTool = agent$(
+ *   async (state, event) => {
+ *     const stories = await fetch('https://...').then(r => r.json());
+ *     return stories.map(s => s.title).join('\n');
+ *   },
+ *   { name: 'hn-tool', description: 'Fetches Hacker News stories' }
+ * );
+ *
+ * // 2. Create ReAct agent with custom tools
+ * const ResearchAgent = createReActAgent({
+ *   systemPrompt: 'You are a researcher.',
+ *   tools: {
+ *     'get_news': { agent: HNTool, description: 'Fetches top HN stories' }
+ *   }
+ * });
+ * ```
+ */
+import type { Agent, ExecutionContext, VirtualAgent } from '@alveus-ai/core';
+/**
+ * Tool definition for ReAct agents
+ *
+ * Tools can be:
+ * - Built-in (calculator, string) - executed inline
+ * - Custom Agents - executed via ctx.call() for durability
+ */
+export interface ToolDefinition {
+    /** The tool agent to call (or 'builtin:calculator', 'builtin:string') */
+    agent: Agent | string;
+    /** Human-readable description for the LLM */
+    description: string;
+    /** JSON Schema for parameters (as string for LLM prompt) */
+    parameters?: string;
+}
+/**
+ * Input schema for the ReAct Logic
+ */
+export interface ReActInput {
+    /** System prompt defining the agent's behavior */
+    systemPrompt: string;
+    /**
+     * Tools available to the agent
+     *
+     * Map of tool name -> tool config (hash + description)
+     * The hash is used to call the tool agent via ctx.call()
+     */
+    tools: Record<string, {
+        /** Agent hash (or 'builtin:calculator', 'builtin:string') */
+        hash: string;
+        /** Description for the LLM */
+        description: string;
+        /** Parameter schema for the LLM */
+        parameters?: string;
+    }>;
+    /** The user's query/input */
+    input: string;
+    /** Optional context for the query */
+    context?: string;
+    /** Maximum iterations (default: 10) */
+    maxIterations?: number;
+}
+/**
+ * A single step in the ReAct execution trace
+ */
+export interface ReActStep {
+    type: 'thought' | 'action' | 'observation';
+    content: string;
+    tool?: string;
+    params?: Record<string, any>;
+}
+/**
+ * Output from ReAct agents
+ */
+export interface ReActOutput {
+    answer: string;
+    steps: ReActStep[];
+    iterations: number;
+}
+/**
+ * The ReAct Logic - Compiled and frozen ONCE at build time
+ *
+ * This is the "master brain" that gets reused for all ReAct agents.
+ * Configuration (systemPrompt, tools) comes from the event input.
+ *
+ * Tools are called via ctx.call() for durability,
+ * except for built-in tools which are executed inline.
+ */
+export declare const ReActLogic: Agent<{}, ReActInput, ExecutionContext, any>;
+/**
+ * Options for creating a ReAct agent
+ */
+export interface ReActAgentOptions {
+    /** System prompt defining the agent's behavior */
+    systemPrompt: string;
+    /**
+     * Tools available to this agent
+     *
+     * Can be:
+     * - Built-in tool names: 'calculator', 'string'
+     * - Custom tool agents: { agent: MyToolAgent, description: '...' }
+     */
+    tools?: Record<string, ToolDefinition | string>;
+    /** Maximum iterations before giving up (default: 10) */
+    maxIterations?: number;
+}
+/**
+ * Create a ReAct agent with the given configuration
+ *
+ * This returns a VirtualAgent that points to the pre-compiled ReActLogic
+ * with pre-filled configuration. No new code is generated.
+ *
+ * @param options - Agent configuration
+ * @returns A VirtualAgent ready for execution
+ *
+ * @example
+ * ```ts
+ * // With built-in tools only
+ * const mathAgent = createReActAgent({
+ *   systemPrompt: 'You are a math assistant.',
+ *   tools: { calculator: 'calculator', string: 'string' }
+ * });
+ *
+ * // With custom tool agents
+ * const researchAgent = createReActAgent({
+ *   systemPrompt: 'You are a researcher.',
+ *   tools: {
+ *     calculator: 'calculator', // built-in
+ *     get_news: { agent: HNToolAgent, description: 'Fetches HN stories' }
+ *   }
+ * });
+ * ```
+ */
+export declare function createReActAgent(options: ReActAgentOptions): VirtualAgent<ReActInput>;
+/**
+ * List of available built-in tools
+ */
+export declare const availableTools: string[];
+//# sourceMappingURL=react.d.ts.map

package/dist/agents/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/agents/react.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE7E;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;IAEtB,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC;IAEpB,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CACX,MAAM,EACN;QACE,6DAA6D;QAC7D,IAAI,EAAE,MAAM,CAAC;QACb,8BAA8B;QAC9B,WAAW,EAAE,MAAM,CAAC;QACpB,mCAAmC;QACnC,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CACF,CAAC;IAEF,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IAEd,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,uCAAuC;IACvC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,aAAa,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,8CAqNtB,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAAC,CAAC;IAEhD,wDAAwD;IACxD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,YAAY,CAAC,UAAU,CAAC,CAoCrF;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,UAA6B,CAAC"}

package/dist/agents/react.js

@@ -0,0 +1,298 @@
+/**
+ * ReAct Agent Pattern - Using the "Curried Agent" (VirtualAgent) Pattern
+ *
+ * Tools are Agents!
+ *
+ * Custom tools must be wrapped in agent$() so they are:
+ * - Durable (the runtime handles retries)
+ * - Distributed (can run on different workers)
+ * - Serializable (only the hash is passed, not the function)
+ *
+ * @example
+ * ```ts
+ * import { agent$ } from '@alveus-ai/core';
+ * import { createReActAgent } from '@alveus-ai/std';
+ *
+ * // 1. Define custom tool as an Agent
+ * const HNTool = agent$(
+ *   async (state, event) => {
+ *     const stories = await fetch('https://...').then(r => r.json());
+ *     return stories.map(s => s.title).join('\n');
+ *   },
+ *   { name: 'hn-tool', description: 'Fetches Hacker News stories' }
+ * );
+ *
+ * // 2. Create ReAct agent with custom tools
+ * const ResearchAgent = createReActAgent({
+ *   systemPrompt: 'You are a researcher.',
+ *   tools: {
+ *     'get_news': { agent: HNTool, description: 'Fetches top HN stories' }
+ *   }
+ * });
+ * ```
+ */
+import { agent$ } from '@alveus-ai/core';
+/**
+ * The ReAct Logic - Compiled and frozen ONCE at build time
+ *
+ * This is the "master brain" that gets reused for all ReAct agents.
+ * Configuration (systemPrompt, tools) comes from the event input.
+ *
+ * Tools are called via ctx.call() for durability,
+ * except for built-in tools which are executed inline.
+ */
+export const ReActLogic = agent$(async (_state, event, ctx) => {
+    // ===== BUILT-IN TOOL EXECUTORS =====
+    // These run inline (not as separate agents) for simplicity
+    const BUILTIN_EXECUTORS = {
+        'builtin:calculator': async ({ expression }) => {
+            const sanitized = String(expression).replace(/[^0-9+\-*/().%\s]/g, '');
+            if (sanitized !== String(expression)) {
+                throw new Error('Invalid characters in expression');
+            }
+            try {
+                const result = new Function(`return ${sanitized}`)();
+                return String(result);
+            }
+            catch {
+                throw new Error(`Failed to evaluate: ${expression}`);
+            }
+        },
+        'builtin:string': async ({ operation, text }) => {
+            switch (operation) {
+                case 'length':
+                    return String(text.length);
+                case 'uppercase':
+                    return text.toUpperCase();
+                case 'lowercase':
+                    return text.toLowerCase();
+                case 'reverse':
+                    return text.split('').reverse().join('');
+                default:
+                    throw new Error(`Unknown operation: ${operation}`);
+            }
+        },
+    };
+    // ===== BUILD SYSTEM PROMPT =====
+    const buildPrompt = (basePrompt, tools) => {
+        const toolDescriptions = Object.entries(tools)
+            .map(([name, tool]) => {
+            const params = tool.parameters || '{ ... }';
+            return `- ${name}: ${tool.description}\n  Parameters: ${params}`;
+        })
+            .join('\n');
+        return `${basePrompt}
+
+Available tools:
+${toolDescriptions}
+
+You MUST respond with a JSON object in this exact format:
+{
+  "thought": "Your reasoning about what to do next",
+  "action": { "tool": "tool_name", "params": { ... } } OR null if you have the final answer,
+  "answer": "Your final answer to the user" OR null if you need to use a tool
+}
+
+Rules:
+1. Always start with a thought explaining your reasoning
+2. If you need information or need to calculate something, use a tool by setting "action"
+3. When you have enough information, set "answer" and leave "action" null
+4. Use exactly one tool per response
+5. Never make up information - use tools to get facts`;
+    };
+    const buildMsgs = (sysPrompt, userInput, steps) => {
+        const messages = [
+            { role: 'system', content: sysPrompt },
+            { role: 'user', content: userInput },
+        ];
+        for (const step of steps) {
+            if (step.type === 'thought') {
+                messages.push({
+                    role: 'assistant',
+                    content: JSON.stringify({
+                        thought: step.content,
+                        action: step.tool ? { tool: step.tool, params: step.params } : null,
+                        answer: null,
+                    }),
+                });
+            }
+            else if (step.type === 'observation') {
+                messages.push({
+                    role: 'user',
+                    content: `Tool result: ${step.content}`,
+                });
+            }
+        }
+        return messages;
+    };
+    // ===== EXECUTE TOOL =====
+    const executeTool = async (toolName, hash, params) => {
+        // Check if it's a built-in tool
+        if (hash.startsWith('builtin:')) {
+            const executor = BUILTIN_EXECUTORS[hash];
+            if (!executor) {
+                throw new Error(`Unknown built-in tool: ${hash}`);
+            }
+            return await executor(params);
+        }
+        // It's a custom tool agent - call via ctx.call() for durability!
+        ctx.logger.info(`Calling tool agent: ${toolName}`, { hash: hash.slice(0, 16), params });
+        const result = await ctx.call(hash, params);
+        // Tool agents should return a string or something stringifiable
+        return typeof result === 'string' ? result : JSON.stringify(result);
+    };
+    // ===== MAIN REACT LOOP =====
+    const { systemPrompt, tools, input, context, maxIterations = 10 } = event;
+    const steps = [];
+    let iterations = 0;
+    const fullPrompt = buildPrompt(systemPrompt, tools);
+    const fullInput = context ? `Context: ${context}\n\nQuestion: ${input}` : input;
+    ctx.logger.info('Starting ReAct loop', { maxIterations, toolCount: Object.keys(tools).length });
+    while (iterations < maxIterations) {
+        iterations++;
+        const messages = buildMsgs(fullPrompt, fullInput, steps);
+        // Get LLM response with JSON mode
+        const responseText = await ctx.llm.chat(messages, { jsonMode: true });
+        // Parse response
+        let response;
+        try {
+            response = JSON.parse(responseText);
+        }
+        catch {
+            steps.push({
+                type: 'observation',
+                content: 'Error: Invalid JSON response. Please respond with valid JSON.',
+            });
+            continue;
+        }
+        // Record thought
+        if (response.thought) {
+            ctx.logger.info(`Thought: ${response.thought.slice(0, 100)}...`);
+            steps.push({ type: 'thought', content: response.thought });
+        }
+        // Check for final answer
+        if (response.answer && !response.action) {
+            ctx.logger.info('ReAct completed with answer', { iterations });
+            return { answer: response.answer, steps, iterations };
+        }
+        // Execute action
+        if (response.action) {
+            const toolName = response.action.tool;
+            const toolDef = tools[toolName];
+            if (!toolDef) {
+                steps.push({
+                    type: 'action',
+                    content: `Attempted unknown tool: ${toolName}`,
+                    tool: toolName,
+                    params: response.action.params,
+                });
+                steps.push({
+                    type: 'observation',
+                    content: `Error: Tool "${toolName}" not available. Available tools: ${Object.keys(tools).join(', ')}`,
+                });
+                continue;
+            }
+            steps.push({
+                type: 'action',
+                content: `Using ${toolName}`,
+                tool: toolName,
+                params: response.action.params,
+            });
+            try {
+                const result = await executeTool(toolName, toolDef.hash, response.action.params);
+                steps.push({ type: 'observation', content: result });
+            }
+            catch (error) {
+                steps.push({
+                    type: 'observation',
+                    content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        }
+    }
+    ctx.logger.warn('ReAct hit max iterations', { maxIterations });
+    return {
+        answer: `Unable to complete within ${maxIterations} iterations.`,
+        steps,
+        iterations,
+    };
+}, { name: 'ReActLogic', version: '2.0.0' });
+/**
+ * Built-in tool definitions
+ */
+const BUILTIN_TOOLS = {
+    calculator: {
+        hash: 'builtin:calculator',
+        description: 'Performs arithmetic calculations. Supports +, -, *, /, and parentheses.',
+        parameters: '{ expression: string }',
+    },
+    string: {
+        hash: 'builtin:string',
+        description: 'Performs string operations: length, uppercase, lowercase, reverse',
+        parameters: '{ operation: "length" | "uppercase" | "lowercase" | "reverse", text: string }',
+    },
+};
+/**
+ * Create a ReAct agent with the given configuration
+ *
+ * This returns a VirtualAgent that points to the pre-compiled ReActLogic
+ * with pre-filled configuration. No new code is generated.
+ *
+ * @param options - Agent configuration
+ * @returns A VirtualAgent ready for execution
+ *
+ * @example
+ * ```ts
+ * // With built-in tools only
+ * const mathAgent = createReActAgent({
+ *   systemPrompt: 'You are a math assistant.',
+ *   tools: { calculator: 'calculator', string: 'string' }
+ * });
+ *
+ * // With custom tool agents
+ * const researchAgent = createReActAgent({
+ *   systemPrompt: 'You are a researcher.',
+ *   tools: {
+ *     calculator: 'calculator', // built-in
+ *     get_news: { agent: HNToolAgent, description: 'Fetches HN stories' }
+ *   }
+ * });
+ * ```
+ */
+export function createReActAgent(options) {
+    // Convert tool definitions to the format expected by ReActInput
+    const tools = {};
+    const inputTools = options.tools ?? { calculator: 'calculator', string: 'string' };
+    for (const [name, def] of Object.entries(inputTools)) {
+        if (typeof def === 'string') {
+            // Built-in tool by name
+            const builtin = BUILTIN_TOOLS[def];
+            if (!builtin) {
+                throw new Error(`Unknown built-in tool: ${def}. Available: ${Object.keys(BUILTIN_TOOLS).join(', ')}`);
+            }
+            tools[name] = builtin;
+        }
+        else {
+            // Custom tool agent
+            const agentHash = typeof def.agent === 'string' ? def.agent : def.agent.definition.hash;
+            tools[name] = {
+                hash: agentHash,
+                description: def.description,
+                parameters: def.parameters,
+            };
+        }
+    }
+    return {
+        definition: ReActLogic,
+        defaultInput: {
+            systemPrompt: options.systemPrompt,
+            tools,
+            maxIterations: options.maxIterations ?? 10,
+        },
+    };
+}
+/**
+ * List of available built-in tools
+ */
+export const availableTools = Object.keys(BUILTIN_TOOLS);
+//# sourceMappingURL=react.js.map