@elevasis/core 0.1.0

package/src/execution/core/types.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared execution types used by Task Scheduler, Command Queue, and other execution systems.
+ */
+
+/**
+ * Target resource to execute (agent or workflow).
+ * Used by both TaskScheduler and CommandQueue.
+ */
+export interface ExecutionTarget {
+  resourceType: 'agent' | 'workflow'
+  resourceId: string
+  payload: unknown
+}
+
+/**
+ * Origin resource type - where an execution/task originated from.
+ * Used for audit trails and tracking execution lineage.
+ */
+export type OriginResourceType = 'agent' | 'workflow' | 'scheduler' | 'api'
+
+/**
+ * Origin tracking metadata - who/what created this execution/task.
+ * Used by both TaskScheduler and CommandQueue for complete audit trails.
+ */
+export interface OriginTracking {
+  originExecutionId: string
+  originResourceType: OriginResourceType
+  originResourceId: string
+}

package/src/execution/engine/__tests__/fixtures/index.ts

@@ -0,0 +1,2 @@
+export * from './test-agents'
+export * from './mock-scenarios'

package/src/execution/engine/__tests__/fixtures/mock-scenarios.ts

@@ -0,0 +1,60 @@
+import type { MockAdapterConfig } from '../../llm/adapters/mock-adapter'
+
+/**
+ * Single tool call scenario
+ */
+export const singleToolScenario: MockAdapterConfig = {
+  responses: [
+    {
+      reasoning: 'I need to use the tool',
+      nextActions: [{ type: 'tool-call', id: 'call-1', name: 'test_tool', input: { data: 'test' } }]
+    },
+    {
+      reasoning: 'Tool executed successfully',
+      nextActions: [{ type: 'complete' }]
+    }
+  ],
+  completionOutput: { status: 'success' }
+}
+
+/**
+ * Knowledge map navigation scenario
+ */
+export const knowledgeNavigationScenario: MockAdapterConfig = {
+  responses: [
+    {
+      reasoning: 'I need access to test tools',
+      nextActions: [{ type: 'navigate-knowledge', id: 'nav-1', nodeId: 'test-tools' }]
+    },
+    {
+      reasoning: 'Tools loaded, now I can use them',
+      nextActions: [{ type: 'tool-call', id: 'call-1', name: 'test_tool_1', input: { input: 'test' } }]
+    },
+    {
+      reasoning: 'Task complete',
+      nextActions: [{ type: 'complete' }]
+    }
+  ],
+  completionOutput: { result: 'Task completed with loaded tools' }
+}
+
+/**
+ * Multi-tool chaining scenario
+ */
+export const multiToolScenario: MockAdapterConfig = {
+  responses: [
+    {
+      reasoning: 'First, request approval',
+      nextActions: [{ type: 'tool-call', id: 'call-1', name: 'request_approval', input: { amount: 1000 } }]
+    },
+    {
+      reasoning: 'Approval sent, now notify user',
+      nextActions: [{ type: 'tool-call', id: 'call-2', name: 'notify_user', input: { title: 'Approval Sent' } }]
+    },
+    {
+      reasoning: 'All tasks complete',
+      nextActions: [{ type: 'complete' }]
+    }
+  ],
+  completionOutput: { status: 'completed', approvalId: 'task-123', notificationId: 'notif-456' }
+}

package/src/execution/engine/__tests__/fixtures/test-agents.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod'
+import type { AgentDefinition } from '../../agent/core/types'
+import type { KnowledgeMap } from '../../agent/knowledge-map/types'
+import { createApprovalTool } from '../../tools/platform'
+
+/**
+ * Create test agent with platform tools
+ */
+export function createPlatformToolAgent(): AgentDefinition {
+  return {
+    config: {
+      resourceId: 'platform-tool-agent',
+      name: 'Platform Tool Agent',
+      description: 'Test agent with platform tools for approval workflows',
+      systemPrompt: 'You help with approvals and notifications',
+      type: 'agent',
+      status: 'dev',
+      version: '1.0.0'
+    },
+    contract: {
+      inputSchema: z.object({ task: z.string() }),
+      outputSchema: z.object({ status: z.string(), taskId: z.string().optional() })
+    },
+    tools: [
+      createApprovalTool({
+        name: 'request_approval',
+        description: 'Request approval',
+        inputSchema: z.object({ amount: z.number() }),
+        outputSchema: z.object({ taskId: z.string() }),
+        approveTargetResourceId: 'payment-processor'
+      })
+    ],
+    modelConfig: { provider: 'mock', model: 'mock', apiKey: 'test-api-key' }
+  }
+}
+
+/**
+ * Create test knowledge map with mock nodes
+ */
+export function createTestKnowledgeMap(): KnowledgeMap {
+  return {
+    nodes: {
+      'test-tools': {
+        id: 'test-tools',
+        description: 'Test tool set for validation',
+        load: async (_context) => ({
+          prompt: '# Test Tools\n\nYou have access to test tools.',
+          tools: [
+            {
+              name: 'test_tool_1',
+              description: 'Test tool 1',
+              inputSchema: z.object({ input: z.string() }),
+              outputSchema: z.object({ output: z.string() }),
+              execute: async ({ input }) => ({ output: `Result: ${(input as { input: string }).input}` })
+            }
+          ]
+        })
+      }
+    }
+  }
+}
+
+/**
+ * Create test agent with knowledge map
+ */
+export function createKnowledgeMapAgent(): AgentDefinition {
+  return {
+    config: {
+      resourceId: 'knowledge-agent',
+      name: 'Knowledge Map Agent',
+      description: 'Test agent with knowledge map for dynamic capability loading',
+      systemPrompt: 'You can load knowledge nodes as needed',
+      type: 'agent',
+      status: 'dev',
+      version: '1.0.0'
+    },
+    contract: {
+      inputSchema: z.object({ task: z.string() }),
+      outputSchema: z.object({ result: z.string() })
+    },
+    tools: [],
+    knowledgeMap: createTestKnowledgeMap(),
+    modelConfig: { provider: 'mock', model: 'mock', apiKey: 'test-api-key' }
+  }
+}