illuma-agents 1.0.8 → 1.0.10

package/src/llm/ollama/utils.ts

@@ -1,193 +0,0 @@
-import {
-  AIMessage,
-  AIMessageChunk,
-  BaseMessage,
-  HumanMessage,
-  MessageContentText,
-  SystemMessage,
-  ToolMessage,
-  UsageMetadata,
-} from '@langchain/core/messages';
-import type {
-  Message as OllamaMessage,
-  ToolCall as OllamaToolCall,
-} from 'ollama';
-import { v4 as uuidv4 } from 'uuid';
-
-export function convertOllamaMessagesToLangChain(
-  messages: OllamaMessage,
-  extra?: {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    responseMetadata?: Record<string, any>;
-    usageMetadata?: UsageMetadata;
-  }
-): AIMessageChunk {
-  const additional_kwargs: BaseMessage['additional_kwargs'] = {};
-  if ('thinking' in messages) {
-    additional_kwargs.reasoning_content = messages.thinking as string;
-  }
-  return new AIMessageChunk({
-    content: messages.content || '',
-    tool_call_chunks: messages.tool_calls?.map((tc) => ({
-      name: tc.function.name,
-      args: JSON.stringify(tc.function.arguments),
-      type: 'tool_call_chunk',
-      index: 0,
-      id: uuidv4(),
-    })),
-    response_metadata: extra?.responseMetadata,
-    usage_metadata: extra?.usageMetadata,
-    additional_kwargs,
-  });
-}
-
-function extractBase64FromDataUrl(dataUrl: string): string {
-  const match = dataUrl.match(/^data:.*?;base64,(.*)$/);
-  return match ? match[1] : '';
-}
-
-function convertAMessagesToOllama(messages: AIMessage): OllamaMessage[] {
-  if (typeof messages.content === 'string') {
-    return [
-      {
-        role: 'assistant',
-        content: messages.content,
-      },
-    ];
-  }
-
-  const textFields = messages.content.filter(
-    (c) => c.type === 'text' && typeof c.text === 'string'
-  );
-  const textMessages = (textFields as MessageContentText[]).map((c) => ({
-    role: 'assistant',
-    content: c.text,
-  }));
-  let toolCallMsgs: OllamaMessage | undefined;
-
-  if (
-    messages.content.find((c) => c.type === 'tool_use') &&
-    messages.tool_calls?.length
-  ) {
-    // `tool_use` content types are accepted if the message has tool calls
-    const toolCalls: OllamaToolCall[] | undefined = messages.tool_calls.map(
-      (tc) => ({
-        id: tc.id,
-        type: 'function',
-        function: {
-          name: tc.name,
-          arguments: tc.args,
-        },
-      })
-    );
-
-    if (toolCalls) {
-      toolCallMsgs = {
-        role: 'assistant',
-        tool_calls: toolCalls,
-        content: '',
-      };
-    }
-  } else if (
-    messages.content.find((c) => c.type === 'tool_use') &&
-    !messages.tool_calls?.length
-  ) {
-    throw new Error(
-      '\'tool_use\' content type is not supported without tool calls.'
-    );
-  }
-
-  return [...textMessages, ...(toolCallMsgs ? [toolCallMsgs] : [])];
-}
-
-function convertHumanGenericMessagesToOllama(
-  message: HumanMessage
-): OllamaMessage[] {
-  if (typeof message.content === 'string') {
-    return [
-      {
-        role: 'user',
-        content: message.content,
-      },
-    ];
-  }
-  return message.content.map((c) => {
-    if (c.type === 'text') {
-      return {
-        role: 'user',
-        content: c.text,
-      };
-    } else if (c.type === 'image_url') {
-      if (typeof c.image_url === 'string') {
-        return {
-          role: 'user',
-          content: '',
-          images: [extractBase64FromDataUrl(c.image_url)],
-        };
-      } else if (c.image_url.url && typeof c.image_url.url === 'string') {
-        return {
-          role: 'user',
-          content: '',
-          images: [extractBase64FromDataUrl(c.image_url.url)],
-        };
-      }
-    }
-    throw new Error(`Unsupported content type: ${c.type}`);
-  });
-}
-
-function convertSystemMessageToOllama(message: SystemMessage): OllamaMessage[] {
-  if (typeof message.content === 'string') {
-    return [
-      {
-        role: 'system',
-        content: message.content,
-      },
-    ];
-  } else if (
-    message.content.every(
-      (c) => c.type === 'text' && typeof c.text === 'string'
-    )
-  ) {
-    return (message.content as MessageContentText[]).map((c) => ({
-      role: 'system',
-      content: c.text,
-    }));
-  } else {
-    throw new Error(
-      `Unsupported content type(s): ${message.content
-        .map((c) => c.type)
-        .join(', ')}`
-    );
-  }
-}
-
-function convertToolMessageToOllama(message: ToolMessage): OllamaMessage[] {
-  if (typeof message.content !== 'string') {
-    throw new Error('Non string tool message content is not supported');
-  }
-  return [
-    {
-      role: 'tool',
-      content: message.content,
-    },
-  ];
-}
-
-export function convertToOllamaMessages(
-  messages: BaseMessage[]
-): OllamaMessage[] {
-  return messages.flatMap((msg) => {
-    if (['human', 'generic'].includes(msg._getType())) {
-      return convertHumanGenericMessagesToOllama(msg);
-    } else if (msg._getType() === 'ai') {
-      return convertAMessagesToOllama(msg);
-    } else if (msg._getType() === 'system') {
-      return convertSystemMessageToOllama(msg);
-    } else if (msg._getType() === 'tool') {
-      return convertToolMessageToOllama(msg as ToolMessage);
-    } else {
-      throw new Error(`Unsupported message type: ${msg._getType()}`);
-    }
-  });
-}

package/src/proto/CollabGraph.ts

@@ -1,269 +0,0 @@
-// src/graphs/CollabGraph.ts
-import { AIMessageChunk, BaseMessage, HumanMessage } from '@langchain/core/messages';
-import { END, StateGraphArgs, START, StateGraph, MemorySaver } from '@langchain/langgraph';
-import { AgentExecutor, createOpenAIToolsAgent } from 'langchain/agents';
-import { ChatPromptTemplate, MessagesPlaceholder } from '@langchain/core/prompts';
-import type { StructuredTool } from '@langchain/core/tools';
-import { Runnable, RunnableConfig } from '@langchain/core/runnables';
-import { JsonOutputToolsParser } from 'langchain/output_parsers';
-import { Providers } from '@/common';
-import { getChatModelClass } from '@/llm/providers';
-import { Graph } from '../graphs/Graph';
-import type * as t from '@/types';
-import { supervisorPrompt } from '@/prompts/collab';
-
-export interface CollabAgentStateChannels {
-  messages: BaseMessage[];
-  next: string;
-  [key: string]: any;
-}
-
-export interface CollabMember {
-  name: string;
-  systemPrompt: string;
-  tools: any[];
-  llmConfig: t.LLMConfig;
-}
-
-interface SupervisorConfig {
-  systemPrompt?: string;
-  llmConfig: t.LLMConfig;
-}
-
-export class CollabGraph extends Graph<CollabAgentStateChannels, string> {
-  resetValues(): void {
-    throw new Error('Method not implemented.');
-  }
-  getFinalMessage(): AIMessageChunk | undefined {
-    throw new Error('Method not implemented.');
-  }
-  generateStepId(stepKey: string): [string, number] {
-    throw new Error('Method not implemented.');
-  }
-  getKeyList(metadata: Record<string, unknown> | undefined): (string | number | undefined)[] {
-    throw new Error('Method not implemented.');
-  }
-  getStepKey(metadata: Record<string, unknown> | undefined): string {
-    throw new Error('Method not implemented.');
-  }
-  checkKeyList(keyList: (string | number | undefined)[]): boolean {
-    throw new Error('Method not implemented.');
-  }
-  getStepIdByKey(stepKey: string, index?: number): string {
-    throw new Error('Method not implemented.');
-  }
-  getRunStep(stepId: string): t.RunStep | undefined {
-    throw new Error('Method not implemented.');
-  }
-  dispatchRunStep(stepKey: string, stepDetails: t.StepDetails): void {
-    throw new Error('Method not implemented.');
-  }
-  dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): void {
-    throw new Error('Method not implemented.');
-  }
-  dispatchMessageDelta(id: string, delta: t.MessageDelta): void {
-    throw new Error('Method not implemented.');
-  }
-  private graph: t.CompiledWorkflow<CollabAgentStateChannels, Partial<CollabAgentStateChannels>, string> | null = null;
-  private members: t.Member[];
-  private supervisorConfig: SupervisorConfig;
-  private supervisorChain: Runnable | null = null;
-
-  constructor(members: t.Member[], supervisorConfig: SupervisorConfig) {
-    super();
-    this.members = members;
-    this.supervisorConfig = supervisorConfig;
-  }
-
-  async initialize(): Promise<void> {
-    const memberNames = this.members.map(member => member.name);
-    const systemPrompt = this.supervisorConfig.systemPrompt || supervisorPrompt;
-    const options = [END, ...memberNames];
-    this.supervisorChain = await this.createSupervisorChain(systemPrompt, options);
-  }
-
-  createGraphState(): StateGraphArgs<CollabAgentStateChannels>['channels'] {
-    return {
-      messages: {
-        value: (x?: BaseMessage[], y?: BaseMessage[]) => (x ?? []).concat(y ?? []),
-        default: () => [],
-      },
-      next: {
-        value: (x?: string, y?: string) => y ?? x ?? END,
-        default: () => END,
-      },
-    };
-  }
-
-  initializeTools(tools: StructuredTool[]): any {
-    // This method is not used in the collaborative graph
-    return null;
-  }
-
-  initializeModel(provider: Providers, clientOptions: Record<string, unknown>, tools: any[]) {
-    const LLMClass = getChatModelClass(provider);
-    if (!LLMClass) {
-      throw new Error(`Unsupported LLM provider: ${provider}`);
-    }
-    return new LLMClass(clientOptions);
-  }
-
-  createCallModel(boundModel: any) {
-    // This method is not directly used in the collaborative graph
-    return async (state: CollabAgentStateChannels, config?: RunnableConfig) => {
-      return { messages: [] };
-    };
-  }
-
-  private async createAgent(
-    llmConfig: t.LLMConfig,
-    tools: any[],
-    systemPrompt: string
-  ): Promise<AgentExecutor> {
-    const { provider, ...clientOptions } = llmConfig;
-    const LLMClass = getChatModelClass(provider);
-    if (!LLMClass) {
-      throw new Error(`Unsupported LLM provider: ${provider}`);
-    }
-    const llm = new LLMClass(clientOptions);
-
-    const prompt = await ChatPromptTemplate.fromMessages([
-      ['system', systemPrompt],
-      new MessagesPlaceholder('messages'),
-      new MessagesPlaceholder('agent_scratchpad'),
-    ]);
-    const agent = await createOpenAIToolsAgent({ llm, tools, prompt });
-    return new AgentExecutor({ agent, tools });
-  }
-
-  createWorkflow(
-    graphState: StateGraphArgs<CollabAgentStateChannels>['channels'],
-    callModel?: any,
-    toolNode?: any
-  ): t.CompiledWorkflow<CollabAgentStateChannels, Partial<CollabAgentStateChannels>, string> {
-    if (!this.supervisorChain) {
-      throw new Error('CollabGraph not initialized. Call initialize() first.');
-    }
-
-    const workflow = new StateGraph<CollabAgentStateChannels, Partial<CollabAgentStateChannels>, string>({
-      channels: graphState,
-    });
-
-    // Dynamically create agents and add nodes for each member
-    for (const member of this.members) {
-      const node = async (
-        state: CollabAgentStateChannels,
-        config?: RunnableConfig,
-      ) => {
-        const agent = await this.createAgent(member.llmConfig, member.tools, member.systemPrompt);
-        const agentPromise = agent.invoke(state, config);
-
-        // Store the promise in the state
-        await this.graph?.updateState(config ?? {}, {
-          [`${member.name}Promise`]: agentPromise,
-        });
-
-        const result = await agentPromise;
-        return {
-          messages: [
-            new HumanMessage({ content: result.output, name: member.name }),
-          ],
-        };
-      };
-      workflow.addNode(member.name, node);
-      workflow.addEdge(member.name, 'supervisor');
-    }
-
-    const supervisorNode = async (
-      state: CollabAgentStateChannels,
-      config?: RunnableConfig,
-    ) => {
-      // Get the current state
-      const currentState = await this.graph?.getState(config ?? {});
-
-      // Wait for all member promises to resolve
-      const memberPromises = this.members.map(member => currentState?.[`${member.name}Promise` as keyof typeof currentState]);
-      await Promise.all(memberPromises);
-
-      // Clear the promises for the next iteration
-      for (const member of this.members) {
-        await this.graph?.updateState(config ?? {}, {
-          [`${member.name}Promise`]: undefined,
-        });
-      }
-
-      const result = await this.supervisorChain?.invoke(state, config);
-      return result;
-    };
-
-    workflow.addNode('supervisor', supervisorNode);
-
-    workflow.addConditionalEdges(
-      'supervisor',
-      (x: CollabAgentStateChannels) => x.next,
-    );
-
-    workflow.addEdge(START, 'supervisor');
-
-    const memory = new MemorySaver();
-    this.graph = workflow.compile({ checkpointer: memory });
-    return this.graph;
-  }
-
-  private async createSupervisorChain(systemPrompt: string, options: string[]): Promise<Runnable> {
-    const functionDef = {
-      name: 'route',
-      description: 'Select the next role.',
-      parameters: {
-        title: 'routeSchema',
-        type: 'object',
-        properties: {
-          next: {
-            title: 'Next',
-            anyOf: [
-              { enum: options },
-            ],
-          },
-        },
-        required: ['next'],
-      },
-    };
-
-    const toolDef = {
-      type: 'function',
-      function: functionDef,
-    } as const;
-
-    const prompt = ChatPromptTemplate.fromMessages([
-      ['system', systemPrompt],
-      new MessagesPlaceholder('messages'),
-      [
-        'system',
-        'Given the conversation above, who should act next?' +
-        ' Or should we FINISH? Select one of: {options}',
-      ],
-    ]);
-
-    const formattedPrompt = await prompt.partial({
-      options: options.join(', '),
-      members: this.members.map(m => m.name).join(', '),
-    });
-
-    const { provider, ...clientOptions } = this.supervisorConfig.llmConfig;
-    const LLMClass = getChatModelClass(provider);
-    if (!LLMClass) {
-      throw new Error(`Unsupported LLM provider for supervisor: ${provider}`);
-    }
-    const llm = new LLMClass(clientOptions);
-
-    return formattedPrompt
-      .pipe(llm.bindTools(
-        [toolDef],
-        {
-          tool_choice: { type: 'function', function: { name: 'route' } } as any,
-        },
-      ))
-      .pipe(new JsonOutputToolsParser())
-      .pipe((x: any) => (x[0].args));
-  }
-}

package/src/proto/TaskManager.ts

@@ -1,243 +0,0 @@
-// src/graphs/TaskManager.ts
-import { JsonOutputToolsParser } from 'langchain/output_parsers';
-import { AgentExecutor, createOpenAIToolsAgent } from 'langchain/agents';
-import { BaseMessage, HumanMessage, AIMessage } from '@langchain/core/messages';
-import { ChatPromptTemplate, MessagesPlaceholder } from '@langchain/core/prompts';
-import { END, START, StateGraph, MemorySaver } from '@langchain/langgraph';
-import type { Runnable, RunnableConfig } from '@langchain/core/runnables';
-import type { ToolNode } from '@langchain/langgraph/prebuilt';
-import type { StructuredTool } from '@langchain/core/tools';
-import type { StateGraphArgs } from '@langchain/langgraph';
-import type * as t from '@/types';
-import {
-  taskManagerPrompt,
-  endProcessFunctionParameters,
-  endProcessFunctionDescription,
-  assignTasksFunctionParameters,
-  assignTasksFunctionDescription,
-} from '@/prompts/taskmanager';
-import { getChatModelClass } from '@/llm/providers';
-import { Providers } from '@/common';
-import { Graph } from '../graphs/Graph';
-
-export interface TaskManagerStateChannels {
-  messages: BaseMessage[];
-  tasks: Task[];
-  completedTasks: string[];
-  next: string;
-}
-
-export interface Task {
-  member: string;
-  description: string;
-  tool?: string;
-}
-
-export interface TaskMember {
-  name: string;
-  systemPrompt: string;
-  tools: StructuredTool[];
-  llmConfig: t.LLMConfig;
-}
-
-interface SupervisorConfig {
-  systemPrompt?: string;
-  llmConfig: t.LLMConfig;
-}
-
-export class TaskManager extends Graph<TaskManagerStateChannels, string> {
-  initializeTools(tools: StructuredTool[]): ToolNode<TaskManagerStateChannels> {
-    throw new Error('Method not implemented.');
-  }
-  initializeModel(provider: Providers, clientOptions: Record<string, unknown>, tools: StructuredTool[]) {
-    throw new Error('Method not implemented.');
-  }
-  createCallModel(boundModel: any): (state: TaskManagerStateChannels, config?: RunnableConfig) => Promise<Partial<TaskManagerStateChannels>> {
-    throw new Error('Method not implemented.');
-  }
-  private graph: t.CompiledWorkflow<TaskManagerStateChannels, Partial<TaskManagerStateChannels>, string> | null = null;
-  private members: TaskMember[];
-  private supervisorConfig: SupervisorConfig;
-  private supervisorChain: Runnable | null = null;
-
-  constructor(members: TaskMember[], supervisorConfig: SupervisorConfig) {
-    super();
-    this.members = members;
-    this.supervisorConfig = supervisorConfig;
-  }
-
-  async initialize(): Promise<void> {
-    const memberNames = this.members.map(member => member.name);
-    const systemPrompt = this.supervisorConfig.systemPrompt || taskManagerPrompt;
-    this.supervisorChain = await this.createSupervisorChain(systemPrompt, memberNames);
-  }
-
-  createGraphState(): StateGraphArgs<TaskManagerStateChannels>['channels'] {
-    return {
-      messages: {
-        value: (x?: BaseMessage[], y?: BaseMessage[]) => (x ?? []).concat(y ?? []),
-        default: () => [],
-      },
-      tasks: {
-        value: (x?: Task[], y?: Task[]) => y ?? x ?? [],
-        default: () => [],
-      },
-      completedTasks: {
-        value: (x?: string[], y?: string[]) => [...new Set([...(x ?? []), ...(y ?? [])])],
-        default: () => [],
-      },
-      next: {
-        value: (x?: string, y?: string) => y ?? x ?? END,
-        default: () => END,
-      },
-    };
-  }
-
-  private async createAgent(
-    llmConfig: t.LLMConfig,
-    tools: StructuredTool[],
-    systemPrompt: string
-  ): Promise<AgentExecutor> {
-    const { provider, ...clientOptions } = llmConfig;
-    const LLMClass = getChatModelClass(provider);
-    if (!LLMClass) {
-      throw new Error(`Unsupported LLM provider: ${provider}`);
-    }
-    const llm = new LLMClass(clientOptions);
-
-    const prompt = ChatPromptTemplate.fromMessages([
-      ['system', systemPrompt],
-      new MessagesPlaceholder('chat_history'),
-      ['human', '{input}'],
-      new MessagesPlaceholder('agent_scratchpad'),
-    ]);
-    const agent = await createOpenAIToolsAgent({ llm, tools, prompt });
-    return new AgentExecutor({ agent, tools });
-  }
-
-  createWorkflow(
-    graphState: StateGraphArgs<TaskManagerStateChannels>['channels'],
-    callModel?: any,
-  ): t.CompiledWorkflow<TaskManagerStateChannels, Partial<TaskManagerStateChannels>, string> {
-    if (!this.supervisorChain) {
-      throw new Error('TaskManager not initialized. Call initialize() first.');
-    }
-
-    const workflow = new StateGraph<TaskManagerStateChannels, Partial<TaskManagerStateChannels>, string>({
-      channels: graphState,
-    });
-
-    const supervisorNode = async (
-      state: TaskManagerStateChannels,
-      config?: RunnableConfig,
-    ) => {
-      const result = await this.supervisorChain?.invoke(state, config) as { tasks?: Task[], reason?: string };
-      console.log('Supervisor Node Output:', result);
-
-      if (result && result.reason) {
-        console.log('Process ending. Reason:', result.reason);
-        return { next: END };
-      }
-
-      const newTasks = (result.tasks || []).filter(task =>
-        !state.completedTasks.includes(`${task.member}:${task.description}`)
-      );
-
-      return {
-        tasks: newTasks,
-        next: newTasks.length > 0 ? 'execute_tasks' : END,
-      };
-    };
-
-    const executeTasksNode = async (
-      state: TaskManagerStateChannels,
-      config?: RunnableConfig,
-    ) => {
-      const results: BaseMessage[] = [];
-      const completedTasks: string[] = [];
-
-      for (const task of state.tasks) {
-        const member = this.members.find(m => m.name === task.member);
-        if (!member) {
-          throw new Error(`TaskMember ${task.member} not found`);
-        }
-
-        const agent = await this.createAgent(member.llmConfig, member.tools, member.systemPrompt);
-        const taskMessage = new HumanMessage(`Task: ${task.description}${task.tool ? ` Use the ${task.tool} tool.` : ''}`);
-        const result = await agent.invoke({
-          input: taskMessage.content,
-          chat_history: state.messages,
-        }, config);
-
-        results.push(new AIMessage({ content: result.output, name: task.member }));
-        completedTasks.push(`${task.member}:${task.description}`);
-      }
-
-      return {
-        messages: state.messages.concat(results),
-        completedTasks: state.completedTasks.concat(completedTasks),
-        tasks: [],
-        next: 'supervisor',
-      };
-    };
-
-    workflow.addNode('supervisor', supervisorNode);
-    workflow.addNode('execute_tasks', executeTasksNode);
-
-    workflow.addEdge(START, 'supervisor');
-    workflow.addConditionalEdges(
-      'supervisor',
-      (x: TaskManagerStateChannels) => x.next,
-    );
-    workflow.addEdge('execute_tasks', 'supervisor');
-
-    const memory = new MemorySaver();
-    this.graph = workflow.compile({ checkpointer: memory });
-    return this.graph;
-  }
-
-  private async createSupervisorChain(systemPrompt: string, memberNames: string[]): Promise<Runnable> {
-    const assignTasksDef = {
-      name: 'assign_tasks',
-      description: assignTasksFunctionDescription,
-      parameters: assignTasksFunctionParameters,
-    };
-
-    const endProcessDef = {
-      name: 'end_process',
-      description: endProcessFunctionDescription,
-      parameters: endProcessFunctionParameters,
-    };
-
-    const toolDefs = [
-      { type: 'function', function: assignTasksDef },
-      { type: 'function', function: endProcessDef },
-    ];
-
-    const prompt = ChatPromptTemplate.fromMessages([
-      ['system', systemPrompt],
-      new MessagesPlaceholder('messages'),
-      new MessagesPlaceholder('completedTasks'),
-      [
-        'human',
-        'Based on the conversation above and the completed tasks, either assign new tasks using the \'assign_tasks\' function or end the process using the \'end_process\' function if the user\'s request is fulfilled. Assign only the most essential tasks to minimize the number of turns. Do not repeat tasks that have already been completed.',
-      ],
-    ]);
-
-    const formattedPrompt = await prompt.partial({
-      members: memberNames.join(', '),
-    });
-
-    const { provider, ...clientOptions } = this.supervisorConfig.llmConfig;
-    const LLMClass = getChatModelClass(provider);
-    if (!LLMClass) {
-      throw new Error(`Unsupported LLM provider for supervisor: ${provider}`);
-    }
-    const llm = new LLMClass(clientOptions);
-
-    return formattedPrompt
-      .pipe(llm.bindTools(toolDefs))
-      .pipe(new JsonOutputToolsParser())
-      .pipe((x: any) => x[0].args);
-  }
-}