@elevasis/core 0.7.0 → 0.8.0

package/src/execution/engine/agent/actions/processor.ts

@@ -1,116 +1,116 @@
-/**
- * Action Phase Processor
- * Orchestrates execution of LLM-planned actions
- */
-
-import type { IterationContext } from '../core/types'
-import type { LLMIterationResponse } from '../reasoning/types'
-import type { AgentAction, ToolCallAction } from './types'
-import { executeToolCall } from './executor'
-import { executeNavigateKnowledge } from './navigate-knowledge-executor'
-
-/**
- * Validate action sequence for correctness
- * Ensures no invalid patterns that would cause undefined behavior
- *
- * Rules:
- * - No multiple 'complete' actions
- * - 'complete' cannot mix with 'navigate-knowledge' (loading knowledge without
- *   reasoning about it is always wasteful — the LLM should iterate instead)
- * - 'complete' CAN mix with 'tool-call' (side-effect tools like navigate_user,
- *   update_filters are fire-and-forget — tool calls execute first via
- *   Promise.allSettled before completion is signaled)
- * - 'message' actions ARE allowed before 'complete' (user-facing communication)
- *
- * @param actions - Action array to validate
- * @throws Error if validation fails
- */
-function validateActionSequence(actions: AgentAction[]): void {
-  // Count completion actions
-  const completeActions = actions.filter((a) => a.type === 'complete')
-
-  // Rule 1: No duplicate completions
-  if (completeActions.length > 1) {
-    throw new Error('Multiple complete actions not allowed in single iteration')
-  }
-
-  // Rule 2: Completion cannot mix with navigate-knowledge
-  // (tool-call + complete is allowed — side-effect tools execute before completion)
-  if (completeActions.length === 1) {
-    const hasNavigateKnowledge = actions.some((a) => a.type === 'navigate-knowledge')
-    if (hasNavigateKnowledge) {
-      throw new Error('Complete action cannot mix with navigate-knowledge actions')
-    }
-  }
-}
-
-/**
- * Process all actions from LLM response
- * Executes tool calls in parallel, handles completion, and messages sequentially
- *
- * Tool calls are parallelized using Promise.allSettled() for performance:
- * - Independent tool calls execute concurrently (up to 5x faster)
- * - Partial failures don't abort successful tools
- * - Results added to memory as they complete
- *
- * Other actions (navigate-knowledge, message, complete) remain sequential
- * because they are order-dependent.
- *
- * @param iterationContext - Agent execution context
- * @param response - LLM response with actions to execute
- * @returns Object with shouldComplete flag (no finalAnswer - generated in completion phase)
- */
-export async function processActions(
-  iterationContext: IterationContext,
-  response: LLMIterationResponse
-): Promise<{ shouldComplete: boolean }> {
-  // Validate action sequence before processing
-  validateActionSequence(response.nextActions)
-
-  let shouldComplete = false
-
-  // Group actions by parallelizability
-  const toolCalls: ToolCallAction[] = []
-  const otherActions: AgentAction[] = []
-
-  for (const action of response.nextActions) {
-    if (action.type === 'tool-call') {
-      toolCalls.push(action)
-    } else {
-      otherActions.push(action)
-    }
-  }
-
-  // Execute tool calls in parallel (if any)
-  // Uses Promise.allSettled() for partial success handling:
-  // - If 4/5 tools succeed, we get those results
-  // - Each tool handles errors independently and adds to memory
-  // - No result aggregation needed (each tool call adds to memory directly)
-  if (toolCalls.length > 0) {
-    await Promise.allSettled(toolCalls.map((action) => executeToolCall(iterationContext, action)))
-  }
-
-  // Execute other actions sequentially (order matters)
-  for (const action of otherActions) {
-    switch (action.type) {
-      case 'navigate-knowledge':
-        await executeNavigateKnowledge(iterationContext, action)
-        break
-
-      case 'complete':
-        shouldComplete = true
-        break
-
-      case 'message': {
-        // Emit assistant message event (immediate persistence + streaming)
-        await iterationContext.executionContext.onMessageEvent?.({
-          type: 'assistant_message',
-          text: action.text
-        })
-        break
-      }
-    }
-  }
-
-  return { shouldComplete }
-}
+/**
+ * Action Phase Processor
+ * Orchestrates execution of LLM-planned actions
+ */
+
+import type { IterationContext } from '../core/types'
+import type { LLMIterationResponse } from '../reasoning/types'
+import type { AgentAction, ToolCallAction } from './types'
+import { executeToolCall } from './executor'
+import { executeNavigateKnowledge } from './navigate-knowledge-executor'
+
+/**
+ * Validate action sequence for correctness
+ * Ensures no invalid patterns that would cause undefined behavior
+ *
+ * Rules:
+ * - No multiple 'complete' actions
+ * - 'complete' cannot mix with 'navigate-knowledge' (loading knowledge without
+ *   reasoning about it is always wasteful — the LLM should iterate instead)
+ * - 'complete' CAN mix with 'tool-call' (side-effect tools like navigate_user,
+ *   update_filters are fire-and-forget — tool calls execute first via
+ *   Promise.allSettled before completion is signaled)
+ * - 'message' actions ARE allowed before 'complete' (user-facing communication)
+ *
+ * @param actions - Action array to validate
+ * @throws Error if validation fails
+ */
+function validateActionSequence(actions: AgentAction[]): void {
+  // Count completion actions
+  const completeActions = actions.filter((a) => a.type === 'complete')
+
+  // Rule 1: No duplicate completions
+  if (completeActions.length > 1) {
+    throw new Error('Multiple complete actions not allowed in single iteration')
+  }
+
+  // Rule 2: Completion cannot mix with navigate-knowledge
+  // (tool-call + complete is allowed — side-effect tools execute before completion)
+  if (completeActions.length === 1) {
+    const hasNavigateKnowledge = actions.some((a) => a.type === 'navigate-knowledge')
+    if (hasNavigateKnowledge) {
+      throw new Error('Complete action cannot mix with navigate-knowledge actions')
+    }
+  }
+}
+
+/**
+ * Process all actions from LLM response
+ * Executes tool calls in parallel, handles completion, and messages sequentially
+ *
+ * Tool calls are parallelized using Promise.allSettled() for performance:
+ * - Independent tool calls execute concurrently (up to 5x faster)
+ * - Partial failures don't abort successful tools
+ * - Results added to memory as they complete
+ *
+ * Other actions (navigate-knowledge, message, complete) remain sequential
+ * because they are order-dependent.
+ *
+ * @param iterationContext - Agent execution context
+ * @param response - LLM response with actions to execute
+ * @returns Object with shouldComplete flag (no finalAnswer - generated in completion phase)
+ */
+export async function processActions(
+  iterationContext: IterationContext,
+  response: LLMIterationResponse
+): Promise<{ shouldComplete: boolean }> {
+  // Validate action sequence before processing
+  validateActionSequence(response.nextActions)
+
+  let shouldComplete = false
+
+  // Group actions by parallelizability
+  const toolCalls: ToolCallAction[] = []
+  const otherActions: AgentAction[] = []
+
+  for (const action of response.nextActions) {
+    if (action.type === 'tool-call') {
+      toolCalls.push(action)
+    } else {
+      otherActions.push(action)
+    }
+  }
+
+  // Execute tool calls in parallel (if any)
+  // Uses Promise.allSettled() for partial success handling:
+  // - If 4/5 tools succeed, we get those results
+  // - Each tool handles errors independently and adds to memory
+  // - No result aggregation needed (each tool call adds to memory directly)
+  if (toolCalls.length > 0) {
+    await Promise.allSettled(toolCalls.map((action) => executeToolCall(iterationContext, action)))
+  }
+
+  // Execute other actions sequentially (order matters)
+  for (const action of otherActions) {
+    switch (action.type) {
+      case 'navigate-knowledge':
+        await executeNavigateKnowledge(iterationContext, action)
+        break
+
+      case 'complete':
+        shouldComplete = true
+        break
+
+      case 'message': {
+        // Emit assistant message event (immediate persistence + streaming)
+        await iterationContext.executionContext.onMessageEvent?.({
+          type: 'assistant_message',
+          text: action.text
+        })
+        break
+      }
+    }
+  }
+
+  return { shouldComplete }
+}

package/src/execution/engine/agent/actions/types.ts

@@ -1,70 +1,70 @@
-/**
- * Action Type Definitions
- * All action-related types and validation schemas
- */
-
-import { z } from 'zod'
-
-/**
- * Agent action types
- * Discriminated union for type-safe action handling
- */
-export type AgentAction =
-  | ToolCallAction
-  | CompleteAction
-  | MessageAction
-  | NavigateKnowledgeAction
-
-export interface ToolCallAction {
-  type: 'tool-call'
-  id: string // Unique ID for tracking tool call/result pairs
-  name: string // Tool name
-  input: Record<string, unknown> // Tool input (validated against tool's inputSchema)
-}
-
-export interface CompleteAction {
-  type: 'complete'
-}
-
-export interface MessageAction {
-  type: 'message'
-  text: string // User-facing message text
-}
-
-export interface NavigateKnowledgeAction {
-  type: 'navigate-knowledge'
-  id: string // Unique ID for tracking action/result pairs
-  nodeId: string // Knowledge node identifier
-}
-
-/**
- * Zod schemas for runtime validation
- */
-export const ToolCallActionSchema = z.object({
-  type: z.literal('tool-call'),
-  id: z.string(),
-  name: z.string(),
-  input: z.any() // Use z.any() instead of z.unknown() for JSON Schema compatibility
-})
-
-export const CompleteActionSchema = z.object({
-  type: z.literal('complete')
-})
-
-export const MessageActionSchema = z.object({
-  type: z.literal('message'),
-  text: z.string()
-})
-
-export const NavigateKnowledgeActionSchema = z.object({
-  type: z.literal('navigate-knowledge'),
-  id: z.string(),
-  nodeId: z.string()
-})
-
-export const AgentActionSchema = z.discriminatedUnion('type', [
-  ToolCallActionSchema,
-  CompleteActionSchema,
-  MessageActionSchema,
-  NavigateKnowledgeActionSchema
-])
+/**
+ * Action Type Definitions
+ * All action-related types and validation schemas
+ */
+
+import { z } from 'zod'
+
+/**
+ * Agent action types
+ * Discriminated union for type-safe action handling
+ */
+export type AgentAction =
+  | ToolCallAction
+  | CompleteAction
+  | MessageAction
+  | NavigateKnowledgeAction
+
+export interface ToolCallAction {
+  type: 'tool-call'
+  id: string // Unique ID for tracking tool call/result pairs
+  name: string // Tool name
+  input: Record<string, unknown> // Tool input (validated against tool's inputSchema)
+}
+
+export interface CompleteAction {
+  type: 'complete'
+}
+
+export interface MessageAction {
+  type: 'message'
+  text: string // User-facing message text
+}
+
+export interface NavigateKnowledgeAction {
+  type: 'navigate-knowledge'
+  id: string // Unique ID for tracking action/result pairs
+  nodeId: string // Knowledge node identifier
+}
+
+/**
+ * Zod schemas for runtime validation
+ */
+export const ToolCallActionSchema = z.object({
+  type: z.literal('tool-call'),
+  id: z.string(),
+  name: z.string(),
+  input: z.any() // Use z.any() instead of z.unknown() for JSON Schema compatibility
+})
+
+export const CompleteActionSchema = z.object({
+  type: z.literal('complete')
+})
+
+export const MessageActionSchema = z.object({
+  type: z.literal('message'),
+  text: z.string()
+})
+
+export const NavigateKnowledgeActionSchema = z.object({
+  type: z.literal('navigate-knowledge'),
+  id: z.string(),
+  nodeId: z.string()
+})
+
+export const AgentActionSchema = z.discriminatedUnion('type', [
+  ToolCallActionSchema,
+  CompleteActionSchema,
+  MessageActionSchema,
+  NavigateKnowledgeActionSchema
+])