illuma-agents 1.0.49 → 1.0.50

package/src/deepagents/types.ts

@@ -1,118 +0,0 @@
-/**
- * Deep Agents Types
- * 
- * Type definitions for deep agent integration
- * 
- * Uses generic/unknown types to avoid version conflicts between
- * langchain dependencies in deepagents vs illuma-agents.
- */
-
-/** Status of a todo item */
-export type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'cancelled';
-
-/** A todo item tracked by the deep agent */
-export interface DeepAgentTodo {
-  /** Unique identifier */
-  id: string;
-  /** Task description */
-  content: string;
-  /** Current status */
-  status: TodoStatus;
-  /** Order index */
-  order?: number;
-  /** When created */
-  createdAt?: string;
-  /** When last updated */
-  updatedAt?: string;
-}
-
-/** A subagent spawned by the deep agent */
-export interface DeepAgentSubagent {
-  /** Unique identifier */
-  id: string;
-  /** Subagent name/purpose */
-  name: string;
-  /** Description of what it's doing */
-  description?: string;
-  /** Current status */
-  status: 'pending' | 'running' | 'completed' | 'failed';
-  /** When started */
-  startedAt?: string;
-  /** When completed */
-  completedAt?: string;
-}
-
-/** State of a deep agent session */
-export interface DeepAgentState {
-  /** Whether deep research mode is active */
-  enabled: boolean;
-  /** Current todos */
-  todos: DeepAgentTodo[];
-  /** Active subagents */
-  subagents: DeepAgentSubagent[];
-  /** Overall progress (0-100) */
-  progress: number;
-  /** Whether currently executing */
-  isRunning: boolean;
-  /** Workspace path for file operations */
-  workspacePath?: string;
-}
-
-/** Options for creating a deep agent runtime */
-export interface DeepAgentRuntimeOptions {
-  /** The LLM model to use (BaseChatModel or model name string) */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  model: any;
-  /** Thread ID for checkpointing */
-  threadId: string;
-  /** Conversation ID for event tracking */
-  conversationId: string;
-  /** Workspace path for file operations (optional) */
-  workspacePath?: string;
-  /** Custom system prompt to prepend */
-  systemPrompt?: string;
-  /** Checkpointer for state persistence (BaseCheckpointSaver) */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  checkpointer?: any;
-  /** SSE response object for streaming updates */
-  sseResponse?: {
-    write: (data: string) => void;
-    headersSent?: boolean;
-  };
-  /** Callback for todo updates */
-  onTodoUpdate?: (todos: DeepAgentTodo[]) => void;
-  /** Callback for subagent updates */
-  onSubagentUpdate?: (subagents: DeepAgentSubagent[]) => void;
-  /** Whether to require human approval for shell commands */
-  requireApproval?: boolean;
-  /** Code executor URL for sandboxed execution */
-  codeExecutorUrl?: string;
-}
-
-/** Events emitted by the deep agent */
-export interface DeepAgentEvent {
-  type: 'todo_update' | 'subagent_update' | 'file_change' | 'execution';
-  conversationId: string;
-  data: {
-    todos?: DeepAgentTodo[];
-    subagents?: DeepAgentSubagent[];
-    files?: Array<{ path: string; action: 'read' | 'write' | 'delete' }>;
-    execution?: { command: string; output: string; exitCode: number | null };
-  };
-}
-
-/** Calculate progress from todos */
-export function calculateTodoProgress(todos: DeepAgentTodo[]): number {
-  if (todos.length === 0) return 0;
-  const completed = todos.filter(t => t.status === 'completed').length;
-  return Math.round((completed / todos.length) * 100);
-}
-
-/** Default state for deep agent */
-export const defaultDeepAgentState: DeepAgentState = {
-  enabled: false,
-  todos: [],
-  subagents: [],
-  progress: 0,
-  isRunning: false,
-};

package/src/specs/deepagents.test.ts

@@ -1,286 +0,0 @@
-/**
- * Deep Agents Unit Tests
- * 
- * Tests for the deep agents integration module
- */
-
-import {
-  DeepAgentBackend,
-  calculateTodoProgress,
-  defaultDeepAgentState,
-  type DeepAgentTodo,
-  type DeepAgentSubagent,
-  type DeepAgentState,
-  type TodoStatus,
-} from '../deepagents';
-
-describe('Deep Agents Types', () => {
-  describe('calculateTodoProgress', () => {
-    it('should return 0 for empty todos', () => {
-      expect(calculateTodoProgress([])).toBe(0);
-    });
-
-    it('should return 0 when no todos are completed', () => {
-      const todos: DeepAgentTodo[] = [
-        { id: '1', content: 'Task 1', status: 'pending' },
-        { id: '2', content: 'Task 2', status: 'in_progress' },
-      ];
-      expect(calculateTodoProgress(todos)).toBe(0);
-    });
-
-    it('should return 50 when half of todos are completed', () => {
-      const todos: DeepAgentTodo[] = [
-        { id: '1', content: 'Task 1', status: 'completed' },
-        { id: '2', content: 'Task 2', status: 'pending' },
-      ];
-      expect(calculateTodoProgress(todos)).toBe(50);
-    });
-
-    it('should return 100 when all todos are completed', () => {
-      const todos: DeepAgentTodo[] = [
-        { id: '1', content: 'Task 1', status: 'completed' },
-        { id: '2', content: 'Task 2', status: 'completed' },
-        { id: '3', content: 'Task 3', status: 'completed' },
-      ];
-      expect(calculateTodoProgress(todos)).toBe(100);
-    });
-
-    it('should round progress correctly', () => {
-      const todos: DeepAgentTodo[] = [
-        { id: '1', content: 'Task 1', status: 'completed' },
-        { id: '2', content: 'Task 2', status: 'pending' },
-        { id: '3', content: 'Task 3', status: 'pending' },
-      ];
-      expect(calculateTodoProgress(todos)).toBe(33); // 33.33... rounds to 33
-    });
-  });
-
-  describe('defaultDeepAgentState', () => {
-    it('should have correct default values', () => {
-      expect(defaultDeepAgentState).toEqual({
-        enabled: false,
-        todos: [],
-        subagents: [],
-        progress: 0,
-        isRunning: false,
-      });
-    });
-
-    it('should be immutable (defensive copy check)', () => {
-      const state = { ...defaultDeepAgentState };
-      state.enabled = true;
-      expect(defaultDeepAgentState.enabled).toBe(false);
-    });
-  });
-
-  describe('TodoStatus type', () => {
-    it('should accept valid status values', () => {
-      const statuses: TodoStatus[] = ['pending', 'in_progress', 'completed', 'cancelled'];
-      expect(statuses).toHaveLength(4);
-    });
-  });
-
-  describe('DeepAgentTodo interface', () => {
-    it('should accept minimal todo', () => {
-      const todo: DeepAgentTodo = {
-        id: '1',
-        content: 'Test task',
-        status: 'pending',
-      };
-      expect(todo.id).toBe('1');
-      expect(todo.content).toBe('Test task');
-      expect(todo.status).toBe('pending');
-    });
-
-    it('should accept todo with optional fields', () => {
-      const todo: DeepAgentTodo = {
-        id: '1',
-        content: 'Test task',
-        status: 'completed',
-        order: 0,
-        createdAt: '2026-01-25T00:00:00Z',
-        updatedAt: '2026-01-25T01:00:00Z',
-      };
-      expect(todo.order).toBe(0);
-      expect(todo.createdAt).toBeDefined();
-      expect(todo.updatedAt).toBeDefined();
-    });
-  });
-
-  describe('DeepAgentSubagent interface', () => {
-    it('should accept minimal subagent', () => {
-      const subagent: DeepAgentSubagent = {
-        id: '1',
-        name: 'Research Agent',
-        status: 'pending',
-      };
-      expect(subagent.id).toBe('1');
-      expect(subagent.name).toBe('Research Agent');
-      expect(subagent.status).toBe('pending');
-    });
-
-    it('should accept subagent with optional fields', () => {
-      const subagent: DeepAgentSubagent = {
-        id: '1',
-        name: 'Research Agent',
-        description: 'Researches topics',
-        status: 'completed',
-        startedAt: '2026-01-25T00:00:00Z',
-        completedAt: '2026-01-25T01:00:00Z',
-      };
-      expect(subagent.description).toBe('Researches topics');
-      expect(subagent.startedAt).toBeDefined();
-      expect(subagent.completedAt).toBeDefined();
-    });
-  });
-});
-
-describe('DeepAgentBackend', () => {
-  describe('constructor', () => {
-    it('should create backend with default options', () => {
-      const backend = new DeepAgentBackend();
-      expect(backend.id).toMatch(/^deep-agent-backend-/);
-    });
-
-    it('should create backend with custom options', () => {
-      const backend = new DeepAgentBackend({
-        rootDir: '/tmp/test',
-        virtualMode: true,
-        timeout: 60000,
-        maxOutputBytes: 50000,
-        conversationId: 'test-convo',
-      });
-      expect(backend.id).toMatch(/^deep-agent-backend-/);
-    });
-  });
-
-  describe('execute', () => {
-    it('should return error for empty command', async () => {
-      const backend = new DeepAgentBackend();
-      const result = await backend.execute('');
-      expect(result.exitCode).toBe(1);
-      expect(result.output).toContain('Error');
-    });
-
-    it('should return warning when no code executor configured', async () => {
-      const backend = new DeepAgentBackend();
-      const result = await backend.execute('echo test');
-      expect(result.exitCode).toBe(1);
-      expect(result.output).toContain('not available');
-    });
-  });
-
-  describe('sendEvent', () => {
-    it('should send event when SSE response is available', () => {
-      const writeData: string[] = [];
-      const mockSseResponse = {
-        write: (data: string) => writeData.push(data),
-        headersSent: false,
-      };
-
-      const backend = new DeepAgentBackend({
-        sseResponse: mockSseResponse,
-        conversationId: 'test-convo',
-      });
-
-      backend.sendEvent('test_event', { foo: 'bar' });
-      
-      expect(writeData.length).toBe(1);
-      expect(writeData[0]).toContain('event: test_event');
-      expect(writeData[0]).toContain('"foo":"bar"');
-    });
-
-    it('should not throw when SSE response is not available', () => {
-      const backend = new DeepAgentBackend();
-      expect(() => backend.sendEvent('test', {})).not.toThrow();
-    });
-  });
-
-  describe('emitTodoUpdate', () => {
-    it('should emit todo update event', () => {
-      const writeData: string[] = [];
-      const mockSseResponse = {
-        write: (data: string) => writeData.push(data),
-        headersSent: false,
-      };
-
-      const todos: DeepAgentTodo[] = [
-        { id: '1', content: 'Task 1', status: 'completed' },
-        { id: '2', content: 'Task 2', status: 'pending' },
-      ];
-
-      const backend = new DeepAgentBackend({
-        sseResponse: mockSseResponse,
-        conversationId: 'test-convo',
-      });
-
-      backend.emitTodoUpdate(todos);
-
-      expect(writeData.length).toBe(1);
-      expect(writeData[0]).toContain('event: deep_research');
-      expect(writeData[0]).toContain('todo_update');
-      expect(writeData[0]).toContain('test-convo');
-    });
-
-    it('should call onTodoUpdate callback', () => {
-      const receivedTodos: DeepAgentTodo[][] = [];
-      const onTodoUpdate = (todos: DeepAgentTodo[]) => receivedTodos.push(todos);
-
-      const todos: DeepAgentTodo[] = [
-        { id: '1', content: 'Task 1', status: 'pending' },
-      ];
-
-      const backend = new DeepAgentBackend({
-        onTodoUpdate,
-      });
-
-      backend.emitTodoUpdate(todos);
-
-      expect(receivedTodos.length).toBe(1);
-      expect(receivedTodos[0]).toEqual(todos);
-    });
-  });
-
-  describe('emitSubagentUpdate', () => {
-    it('should emit subagent update event', () => {
-      const writeData: string[] = [];
-      const mockSseResponse = {
-        write: (data: string) => writeData.push(data),
-        headersSent: false,
-      };
-
-      const subagents: DeepAgentSubagent[] = [
-        { id: '1', name: 'Agent 1', status: 'running' },
-      ];
-
-      const backend = new DeepAgentBackend({
-        sseResponse: mockSseResponse,
-        conversationId: 'test-convo',
-      });
-
-      backend.emitSubagentUpdate(subagents);
-
-      expect(writeData.length).toBe(1);
-      expect(writeData[0]).toContain('event: deep_research');
-      expect(writeData[0]).toContain('subagent_update');
-    });
-
-    it('should call onSubagentUpdate callback', () => {
-      const receivedSubagents: DeepAgentSubagent[][] = [];
-      const onSubagentUpdate = (subagents: DeepAgentSubagent[]) => receivedSubagents.push(subagents);
-
-      const subagents: DeepAgentSubagent[] = [
-        { id: '1', name: 'Agent 1', status: 'running' },
-      ];
-
-      const backend = new DeepAgentBackend({
-        onSubagentUpdate,
-      });
-
-      backend.emitSubagentUpdate(subagents);
-
-      expect(receivedSubagents.length).toBe(1);
-      expect(receivedSubagents[0]).toEqual(subagents);
-    });
-  });
-});