@limo-labs/deity 0.2.0-alpha.0 → 0.2.0

package/dist/{jsx-dev-runtime-CKrGWO-8.d.cts → jsx-dev-runtime-Dg782FK5.d.cts}

@@ -208,6 +208,8 @@ interface SessionData {
     stats: ExecutionStats;
     /** Stage outputs (checkpoint data) */
     stageOutputs: Record<string, unknown>;
+    /** Application state (isolated from AI memory) */
+    appState?: Record<string, unknown>;
     /** Session metadata */
     metadata: SessionMetadata;
 }
@@ -517,6 +519,52 @@ declare class LimoMemoryManager {
      * Get detailed memories
      */
     getDetailedMemories(): Memory[];
+    /**
+     * Get all memory keys (core + detailed)
+     *
+     * @returns Array of all memory keys
+     */
+    getAllKeys(): string[];
+    /**
+     * Get all Memory objects (core + detailed)
+     *
+     * @returns Array of all Memory entries
+     */
+    getAllMemories(): Memory[];
+    /**
+     * Get raw Memory object by key (without triggering access metadata update)
+     *
+     * @param key - Memory key
+     * @returns Memory object or undefined
+     */
+    getMemory(key: string): Memory | undefined;
+    /**
+     * Update an existing memory entry
+     *
+     * @param key - Memory key to update
+     * @param updates - Partial updates (content, importance, category, tags)
+     * @returns true if updated, false if key not found
+     */
+    update(key: string, updates: Partial<{
+        content: string;
+        importance: number;
+        category: string;
+        tags: string[];
+    }>): Promise<boolean>;
+    /**
+     * Promote a memory to core by key
+     *
+     * @param key - Memory key to promote
+     * @returns true if promoted, false if key not found or already in core
+     */
+    promoteToCoreByKey(key: string): boolean;
+    /**
+     * Demote a memory from core to detailed by key
+     *
+     * @param key - Memory key to demote
+     * @returns true if demoted, false if key not found in core
+     */
+    demoteFromCore(key: string): boolean;
     /**
      * Get memory statistics
      */
@@ -705,7 +753,7 @@ interface ToolResult<T = unknown> {
 /**
  * Tool definition
  */
-interface Tool<TInput = unknown, TOutput = unknown> {
+interface ToolSpec<TInput = unknown, TOutput = unknown> {
     name: string;
     description: string;
     inputSchema: ZodSchema<TInput>;
@@ -805,7 +853,7 @@ type TraceEntry = {
 } | {
     type: 'llm_call';
     messages: Message[];
-    tools?: Tool[];
+    tools?: ToolSpec[];
     timestamp: Date;
 } | {
     type: 'llm_response';
@@ -882,6 +930,8 @@ interface ExecutionContext<I = unknown> {
     ui?: UIUpdateBridge;
     /** Session store (optional) */
     session?: SessionStore;
+    /** Application state store (optional, isolated from AI memory) */
+    appState?: StateStore;
     /** Execution statistics (consensus requirement) */
     stats: ExecutionStats;
     /** Current stage ID (for UI updates) */
@@ -980,8 +1030,16 @@ interface AgentComponent<I = unknown, O = unknown> {
     /**
      * Tool definitions (declarative)
      * Component declares available tools, runtime executes them
+     *
+     * Tools that need ExecutionContext (e.g., memory tools) receive it
+     * automatically as the second argument to their execute() function.
+     *
+     * @example
+     * ```typescript
+     * tools: [readFileTool, writeFileTool]
+     * ```
      */
-    tools?: Tool[];
+    tools?: ToolSpec[];
     /**
      * Retry configuration (declarative with dynamic conditions)
      * Component declares retry rules, runtime controls loop
@@ -1097,7 +1155,7 @@ interface ToolCall {
  * LLM adapter interface
  */
 interface LLMAdapter {
-    generate(messages: Message[], tools?: Tool[], config?: GenerationConfig, ctx?: ExecutionContext): Promise<LLMResponse>;
+    generate(messages: Message[], tools?: ToolSpec[], config?: GenerationConfig, ctx?: ExecutionContext): Promise<LLMResponse>;
 }
 /**
  * Result from LLM execution loop
@@ -1139,16 +1197,23 @@ interface WorkflowEnhancements {
     ui?: UIUpdateBridge;
     /** Session store */
     session?: SessionStore;
+    /** Application state store (isolated from AI memory) */
+    appState?: StateStore;
 }
 /**
  * Execution node (for workflow graph)
  */
 interface ExecutionNode {
-    type: 'step' | 'sequence' | 'parallel' | 'conditional' | 'loop';
+    type: 'step' | 'sequence' | 'parallel' | 'conditional' | 'loop' | 'foreach';
     component?: AgentComponent;
     children?: ExecutionNode[];
     condition?: (ctx: ExecutionContext) => boolean | Promise<boolean>;
     maxIterations?: number;
+    itemsAccessor?: unknown[] | ((ctx: ExecutionContext) => unknown[] | Promise<unknown[]>);
+    itemMode?: 'merge' | 'replace' | 'property';
+    itemKey?: string;
+    errorMode?: 'stop' | 'continue' | 'skip';
+    collectResults?: boolean;
 }
 /**
  * Workflow configuration (consensus requirement)
@@ -1221,11 +1286,11 @@ interface AgentNode<I = unknown, O = unknown> extends ASTNode {
             /** Timeout in milliseconds */
             timeout?: number;
         };
-        /** Optional tool definitions */
-        tools?: Tool[];
+        /** Optional tool definitions (static array) */
+        tools?: ToolSpec[];
     };
     /** Child nodes (Prompt is required, others are optional) */
-    children: (PromptNode | ObserveNode | ResultNode | ValidateNode | RetryNode)[];
+    children: (PromptNode | ObserveNode | ResultNode | ValidateNode | RetryNode | ToolsNode)[];
 }
 /**
  * Prompt Node - Container for system and user prompts
@@ -1241,6 +1306,7 @@ interface PromptNode extends ASTNode {
  * - File (source: 'file:path/to/prompt.md')
  * - Inline (content: 'text')
  * - Computed (compute: (ctx) => string)
+ * - Mixed template (templateParts: TemplatePart[]) - for ToolRef support
  */
 interface SystemNode extends ASTNode {
     type: 'System';
@@ -1253,6 +1319,8 @@ interface SystemNode extends ASTNode {
         content?: string;
         /** Computed content (function) */
         compute?: (ctx: ExecutionContext) => string | Promise<string>;
+        /** Template parts (for mixed text/computed/toolref content) */
+        templateParts?: TemplatePart[];
     };
 }
 /**
@@ -1261,6 +1329,7 @@ interface SystemNode extends ASTNode {
  * Can be:
  * - Inline (content: 'text')
  * - Computed (compute: (ctx) => string)
+ * - Mixed template (templateParts: TemplatePart[]) - for ToolRef support
  */
 interface UserNode extends ASTNode {
     type: 'User';
@@ -1269,6 +1338,42 @@ interface UserNode extends ASTNode {
         content?: string;
         /** Computed content (function) */
         compute?: (ctx: ExecutionContext) => string | Promise<string>;
+        /** Template parts (for mixed text/computed/toolref content) */
+        templateParts?: TemplatePart[];
+    };
+}
+/**
+ * Template Part - Single part of a mixed-content template
+ *
+ * Used by System and User nodes to support inline ToolRef nodes.
+ */
+type TemplatePart = {
+    kind: 'text';
+    value: string;
+} | {
+    kind: 'computed';
+    compute: (ctx: ExecutionContext) => string | Promise<string>;
+} | {
+    kind: 'toolref';
+    toolName: string;
+};
+/**
+ * ToolRef Node - Reference to a tool name in prompt text
+ *
+ * This node acts as a placeholder that gets replaced with the tool's
+ * runtime ID during prompt compilation.
+ *
+ * @example
+ * ```tsx
+ * <User>Use <ToolRef tool={MemoryStore} /> to save data.</User>
+ * // Compiles to: "Use memory_store to save data."
+ * ```
+ */
+interface ToolRefNode extends ASTNode {
+    type: 'ToolRef';
+    props: {
+        /** The tool's runtime ID (e.g., 'memory_store') */
+        toolName: string;
     };
 }
 /**
@@ -1375,6 +1480,43 @@ interface RetryNode extends ASTNode {
         feedbackErrorToLLM?: boolean;
     };
 }
+/**
+ * Tools Container Node - Groups tool definitions for an agent
+ *
+ * Contains static tool definitions via <ToolDef> or <Tool> children.
+ *
+ * @example
+ * ```tsx
+ * <Tools>
+ *   <MemoryStore />
+ *   <MemoryRecall />
+ *   <Tool name="my_tool" description="..." input={Schema}>
+ *     {async (params) => ({ ... })}
+ *   </Tool>
+ * </Tools>
+ * ```
+ */
+interface ToolsNode extends ASTNode {
+    type: 'Tools';
+    props: Record<string, never>;
+    /** Child ToolDef nodes */
+    children: ToolDefNode[];
+}
+/**
+ * Tool Definition Node - Wraps a single Tool object
+ *
+ * @example
+ * ```tsx
+ * <ToolDef tool={createFileListTool(context)} />
+ * ```
+ */
+interface ToolDefNode extends ASTNode {
+    type: 'Tools:Def';
+    props: {
+        /** The tool object */
+        tool: ToolSpec;
+    };
+}
 /**
  * Check if a node is an AgentNode
  */
@@ -1407,6 +1549,160 @@ declare function isValidateNode(node: ASTNode): node is ValidateNode;
  * Check if a node is a RetryNode
  */
 declare function isRetryNode(node: ASTNode): node is RetryNode;
+/**
+ * Check if a node is a ToolsNode
+ */
+declare function isToolsNode(node: ASTNode): node is ToolsNode;
+/**
+ * Check if a node is a ToolDefNode
+ */
+declare function isToolDefNode(node: ASTNode): node is ToolDefNode;
+/**
+ * Check if a node is a ToolRefNode
+ */
+declare function isToolRefNode(node: ASTNode): node is ToolRefNode;
+/**
+ * Workflow Sequence Node - Execute children in order
+ */
+interface WorkflowSequenceNode extends ASTNode {
+    type: 'WorkflowSequence';
+    children: WorkflowChildNode[];
+}
+/**
+ * Workflow Parallel Node - Execute children concurrently
+ */
+interface WorkflowParallelNode extends ASTNode {
+    type: 'WorkflowParallel';
+    children: WorkflowChildNode[];
+}
+/**
+ * Workflow Conditional Node - Execute children based on condition
+ */
+interface WorkflowConditionalNode extends ASTNode {
+    type: 'WorkflowConditional';
+    props: {
+        /** Condition function (true = first child, false = second child) */
+        condition: (ctx: ExecutionContext) => boolean | Promise<boolean>;
+    };
+    children: [WorkflowChildNode] | [WorkflowChildNode, WorkflowChildNode];
+}
+/**
+ * Workflow Loop Node - Execute child N times
+ */
+interface WorkflowLoopNode extends ASTNode {
+    type: 'WorkflowLoop';
+    props: {
+        /** Number of iterations */
+        iterations: number;
+    };
+    children: [WorkflowChildNode];
+}
+/**
+ * Workflow ForEach Node - Execute child for each item in array
+ */
+interface WorkflowForEachNode extends ASTNode {
+    type: 'WorkflowForEach';
+    props: {
+        /** Array of items or function to resolve items */
+        items: unknown[] | ((ctx: ExecutionContext) => unknown[] | Promise<unknown[]>);
+        /** How to inject item into context ('property' | 'merge' | 'replace') */
+        itemMode: string;
+        /** Property key for 'property' mode */
+        itemKey: string;
+        /** Error handling mode ('stop' | 'continue' | 'skip') */
+        errorMode: string;
+        /** Whether to collect results */
+        collectResults: boolean;
+    };
+    children: [WorkflowChildNode];
+}
+/**
+ * Union type for workflow child nodes
+ * Can be either an Agent or a workflow structure node
+ */
+type WorkflowChildNode = AgentNode | WorkflowSequenceNode | WorkflowParallelNode | WorkflowConditionalNode | WorkflowLoopNode | WorkflowForEachNode;
+/**
+ * Check if a node is a WorkflowSequenceNode
+ */
+declare function isWorkflowSequenceNode(node: ASTNode): node is WorkflowSequenceNode;
+/**
+ * Check if a node is a WorkflowParallelNode
+ */
+declare function isWorkflowParallelNode(node: ASTNode): node is WorkflowParallelNode;
+/**
+ * Check if a node is a WorkflowConditionalNode
+ */
+declare function isWorkflowConditionalNode(node: ASTNode): node is WorkflowConditionalNode;
+/**
+ * Check if a node is a WorkflowLoopNode
+ */
+declare function isWorkflowLoopNode(node: ASTNode): node is WorkflowLoopNode;
+/**
+ * Check if a node is a WorkflowForEachNode
+ */
+declare function isWorkflowForEachNode(node: ASTNode): node is WorkflowForEachNode;
+/**
+ * Workflow Node - Top-level workflow container
+ *
+ * Contains the complete workflow configuration including:
+ * - Name and description
+ * - Default model configuration
+ * - Workflow graph (Sequence, Parallel, Conditional, Loop, or Agent)
+ * - Optional enhancements (conversation, memory, session, UI)
+ */
+interface WorkflowNode extends ASTNode {
+    type: 'Workflow';
+    props: {
+        /** Workflow name */
+        name: string;
+        /** Optional description */
+        description?: string;
+        /** Default LLM model configuration */
+        defaultModel?: {
+            adapter: any;
+            config?: any;
+        };
+        /** Optional state storage */
+        state?: {
+            store: any;
+        };
+        /** Optional enhancements */
+        enhancements?: {
+            /** Conversation management */
+            conversation?: {
+                maxTokens: number;
+                pruneThreshold: number;
+                messageRetentionPolicy?: unknown;
+            };
+            /** Memory management */
+            memory?: {
+                coreBudget: {
+                    maxItems: number;
+                    maxTotalSize: number;
+                };
+                detailedBudget?: {
+                    maxItems: number;
+                    maxTotalSize: number;
+                };
+            };
+            /** Session persistence */
+            session?: {
+                directory: string;
+                autoSave?: boolean;
+            };
+            /** UI updates */
+            ui?: any;
+            /** Application state store (isolated from AI memory) */
+            appState?: any;
+        };
+    };
+    /** Single child representing the workflow graph */
+    children: [WorkflowChildNode];
+}
+/**
+ * Check if a node is a WorkflowNode
+ */
+declare function isWorkflowNode(node: ASTNode): node is WorkflowNode;
 
 /**
  * Deity TSX - JSX Runtime
@@ -1481,10 +1777,10 @@ declare global {
         /**
          * Element type (return type of JSX expressions)
          *
-         * We use ASTNode as the base type, but TypeScript will infer
-         * the specific node type based on the component function's return type.
+         * Instead of fixing this to ASTNode, we leave it generic so TypeScript
+         * can infer the specific return type from the component function.
          */
-        type Element = ASTNode;
+        type Element = any;
         /**
          * Intrinsic elements (built-in HTML-like elements)
          *
@@ -1500,7 +1796,7 @@ declare global {
          * Deity TSX only uses function components.
          */
         interface ElementClass {
-            render(): ASTNode;
+            render(): any;
         }
         /**
          * Element attributes property
@@ -1517,4 +1813,4 @@ declare global {
     }
 }
 
-export { type AgentNode as A, isAgentNode as B, ConversationManager as C, isObserveNode as D, type ExecutionContext as E, isPromptNode as F, type GenerationConfig as G, isResultNode as H, isRetryNode as I, type JSXComponent as J, isSystemNode as K, type LLMLoopResult as L, type Message as M, isUserNode as N, type ObserveNode as O, type PromptNode as P, isValidateNode as Q, type ResultNode as R, type SystemNode as S, type Tool as T, type UserNode as U, type Validator as V, type WorkflowConfig as W, Fragment as X, jsx as Y, jsxs as Z, type ValidationRules as a, type ValidateNode as b, type RetryNode as c, type AgentComponent as d, type ValidationResult as e, type LLMAdapter as f, type ExecutionNode as g, type StateStore as h, type TraceLogger as i, type TraceEntry as j, type ExecutionStats as k, LimoMemoryManager as l, type UIUpdateBridge as m, type SessionStore as n, type ConversationConfig as o, type MemoryConfig as p, type SessionConfig as q, type ASTNode as r, type JSXElementType as s, type JSXProps as t, type LLMLoopState as u, type LLMResponse as v, type MessageRole as w, type ToolCall as x, type ToolResult as y, type ValidationRule as z };
+export { isObserveNode as $, type AgentNode as A, type MemoryConfig as B, ConversationManager as C, type SessionConfig as D, type ExecutionContext as E, type JSXElementType as F, type GenerationConfig as G, type JSXProps as H, type LLMLoopState as I, type JSXComponent as J, type LLMResponse as K, type LLMLoopResult as L, type Message as M, type MessageRole as N, type ObserveNode as O, type PromptNode as P, type TemplatePart as Q, type ResultNode as R, type SystemNode as S, type ToolSpec as T, type UserNode as U, type Validator as V, type WorkflowChildNode as W, type ToolCall as X, type ToolResult as Y, type ValidationRule as Z, isAgentNode as _, type ValidationRules as a, isPromptNode as a0, isResultNode as a1, isRetryNode as a2, isSystemNode as a3, isToolDefNode as a4, isToolRefNode as a5, isToolsNode as a6, isUserNode as a7, isValidateNode as a8, isWorkflowConditionalNode as a9, isWorkflowForEachNode as aa, isWorkflowLoopNode as ab, isWorkflowNode as ac, isWorkflowParallelNode as ad, isWorkflowSequenceNode as ae, Fragment as af, jsx as ag, jsxs as ah, type ValidateNode as b, type RetryNode as c, type ToolDefNode as d, type ToolsNode as e, type ToolRefNode as f, type WorkflowSequenceNode as g, type WorkflowParallelNode as h, type WorkflowConditionalNode as i, type WorkflowLoopNode as j, type WorkflowForEachNode as k, type WorkflowNode as l, type AgentComponent as m, type WorkflowConfig as n, type ExecutionNode as o, type ASTNode as p, type ValidationResult as q, type LLMAdapter as r, type StateStore as s, type TraceLogger as t, type TraceEntry as u, type ExecutionStats as v, LimoMemoryManager as w, type UIUpdateBridge as x, type SessionStore as y, type ConversationConfig as z };