illuma-agents 1.0.8 → 1.0.9

package/src/proto/collab_design_v5.ts

@@ -1,251 +0,0 @@
-// src/collab_design_v5.ts
-import 'dotenv/config';
-import { 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 { Runnable, RunnableConfig } from '@langchain/core/runnables';
-import { JsonOutputToolsParser } from 'langchain/output_parsers';
-import { HandlerRegistry } from '@/events';
-import { ChatOpenAI } from '@langchain/openai';
-import { ChatBedrockConverse } from '@langchain/aws';
-import { ChatAnthropic } from '@langchain/anthropic';
-import { ChatMistralAI } from '@langchain/mistralai';
-import { ChatVertexAI } from '@langchain/google-vertexai';
-import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
-import { supervisorPrompt } from '@/prompts/collab';
-import type * as t from '@/types';
-import { Providers } from '@/common';
-
-interface AgentStateChannels {
-  messages: BaseMessage[];
-  next: string;
-}
-
-export interface Member {
-  name: string;
-  systemPrompt: string;
-  tools: any[];
-  llmConfig: LLMConfig;
-}
-
-interface LLMConfig {
-  provider: Providers;
-  [key: string]: any;
-}
-
-interface SupervisorConfig {
-  systemPrompt?: string;
-  llmConfig: LLMConfig;
-}
-
-const llmProviders: Record<Providers, any> = {
-  [Providers.OPENAI]: ChatOpenAI,
-  [Providers.VERTEXAI]: ChatVertexAI,
-  [Providers.BEDROCK_LEGACY]: BedrockChat,
-  [Providers.MISTRALAI]: ChatMistralAI,
-  [Providers.BEDROCK]: ChatBedrockConverse,
-  [Providers.ANTHROPIC]: ChatAnthropic,
-};
-
-export class CollaborativeProcessor {
-  graph: t.CompiledWorkflow | null = null;
-  private handlerRegistry: HandlerRegistry;
-  private members: Member[];
-  private supervisorConfig: SupervisorConfig;
-
-  constructor(
-    members: Member[],
-    supervisorConfig: SupervisorConfig,
-    customHandlers?: Record<string, any>
-  ) {
-    this.members = members;
-    this.supervisorConfig = supervisorConfig;
-    this.handlerRegistry = new HandlerRegistry();
-    if (customHandlers) {
-      for (const [eventType, handler] of Object.entries(customHandlers)) {
-        this.handlerRegistry.register(eventType, handler);
-      }
-    }
-  }
-
-  async initialize(): Promise<void> {
-    this.graph = await this.createGraph();
-  }
-
-  private async createGraph(): Promise<t.CompiledWorkflow> {
-    const agentStateChannels: StateGraphArgs<AgentStateChannels>['channels'] = {
-      messages: {
-        value: (x?: BaseMessage[], y?: BaseMessage[]) => (x ?? []).concat(y ?? []),
-        default: () => [],
-      },
-      next: {
-        value: (x?: string, y?: string) => y ?? x ?? END,
-        default: () => END,
-      },
-    };
-
-    async function createAgent(
-      llmConfig: LLMConfig,
-      tools: any[],
-      systemPrompt: string
-    ): Promise<AgentExecutor> {
-      const { provider, ...clientOptions } = llmConfig;
-      const LLMClass = llmProviders[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 });
-    }
-
-    const memberNames = this.members.map(member => member.name);
-
-    const systemPrompt = this.supervisorConfig.systemPrompt || supervisorPrompt;
-    const options = [END, ...memberNames];
-
-    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: memberNames.join(', '),
-    });
-
-    const { provider, ...clientOptions } = this.supervisorConfig.llmConfig;
-    const LLMClass = llmProviders[provider];
-    if (!LLMClass) {
-      throw new Error(`Unsupported LLM provider for supervisor: ${provider}`);
-    }
-    const llm = new LLMClass(clientOptions);
-
-    const supervisorChain = formattedPrompt
-      .pipe(llm.bindTools(
-        [toolDef],
-        {
-          tool_choice: { 'type': 'function', 'function': { 'name': 'route' } },
-        },
-      ))
-      .pipe(new JsonOutputToolsParser())
-      .pipe((x) => (x[0].args));
-
-    const workflow = new StateGraph({
-      channels: agentStateChannels,
-    });
-
-    // Dynamically create agents and add nodes for each member
-    for (const member of this.members) {
-      const agent = await createAgent(member.llmConfig, member.tools, member.systemPrompt);
-      const node = async (
-        state: AgentStateChannels,
-        config?: RunnableConfig,
-      ) => {
-        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: AgentStateChannels,
-      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`]);
-      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 supervisorChain.invoke(state, config);
-      return result;
-    };
-
-    workflow.addNode('supervisor', supervisorNode);
-
-    workflow.addConditionalEdges(
-      'supervisor',
-      (x: AgentStateChannels) => x.next,
-    );
-
-    workflow.addEdge(START, 'supervisor');
-
-    const memory = new MemorySaver();
-    return workflow.compile({ checkpointer: memory });
-  }
-
-  async processStream(
-    inputs: { messages: BaseMessage[] },
-    config: Partial<RunnableConfig> & { version: 'v1' | 'v2' },
-  ) {
-    if (!this.graph) {
-      throw new Error('CollaborativeProcessor not initialized. Call initialize() first.');
-    }
-    const stream = this.graph.streamEvents(inputs, config);
-    for await (const event of stream) {
-      const handler = this.handlerRegistry.getHandler(event.event);
-      if (handler) {
-        handler.handle(event.event, event.data);
-      }
-    }
-  }
-}

package/src/proto/collab_graph.ts

@@ -1,181 +0,0 @@
-import 'dotenv/config';
-import { BaseMessage, HumanMessage } from '@langchain/core/messages';
-import { END, StateGraphArgs, START, StateGraph } from '@langchain/langgraph';
-import { chartTool, tavilyTool } from '@/tools/example';
-import { AgentExecutor, createOpenAIToolsAgent } from 'langchain/agents';
-import {
-    ChatPromptTemplate,
-    MessagesPlaceholder,
-} from '@langchain/core/prompts';
-import { ChatOpenAI } from '@langchain/openai';
-import { Runnable, RunnableConfig } from '@langchain/core/runnables';
-import { JsonOutputToolsParser } from 'langchain/output_parsers';
-
-interface AgentStateChannels {
-  messages: BaseMessage[];
-  next: string;
-}
-
-(async function() {
-    const agentStateChannels: StateGraphArgs['channels'] = {
-        messages: {
-            value: (x?: BaseMessage[], y?: BaseMessage[]) => (x ?? []).concat(y ?? []),
-            default: () => [],
-        },
-        next: {
-            value: (x?: string, y?: string) => y ?? x ?? END,
-            default: () => END,
-        },
-    };
-
-    async function createAgent(
-        llm: ChatOpenAI,
-        tools: any[],
-        systemPrompt: string
-    ): Promise<AgentExecutor> {
-        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 });
-    }
-
-    const members = ['researcher', 'chart_generator'];
-
-    const systemPrompt =
-    'You are a supervisor tasked with managing a conversation between the' +
-    ' following workers: {members}. Given the following user request,' +
-    ' respond with the worker to act next. Each worker will perform a' +
-    ' task and respond with their results and status. When finished,' +
-    ' respond with FINISH.';
-    const options = [END, ...members];
-
-    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: members.join(', '),
-    });
-
-    const llm = new ChatOpenAI({
-        modelName: 'gpt-4',
-        temperature: 0,
-    });
-
-    const supervisorChain = formattedPrompt
-        .pipe(llm.bindTools(
-            [toolDef],
-            {
-                tool_choice: { 'type': 'function', 'function': { 'name': 'route' } },
-            },
-        ))
-        .pipe(new JsonOutputToolsParser())
-        .pipe((x) => (x[0].args));
-
-    const researcherAgent = await createAgent(
-        llm,
-        [tavilyTool],
-        'You are a web researcher. You may use the Tavily search engine to search the web for' +
-      ' important information, so the Chart Generator in your team can make useful plots.',
-    );
-
-    const researcherNode = async (
-        state: AgentStateChannels,
-        config?: RunnableConfig,
-    ) => {
-        const result = await researcherAgent.invoke(state, config);
-        return {
-            messages: [
-                new HumanMessage({ content: result.output, name: 'Researcher' }),
-            ],
-        };
-    };
-
-    const chartGenAgent = await createAgent(
-        llm,
-        [chartTool],
-        'You excel at generating bar charts. Use the researcher\'s information to generate the charts.',
-    );
-
-    const chartGenNode = async (
-        state: AgentStateChannels,
-        config?: RunnableConfig,
-    ) => {
-        const result = await chartGenAgent.invoke(state, config);
-        return {
-            messages: [
-                new HumanMessage({ content: result.output, name: 'ChartGenerator' }),
-            ],
-        };
-    };
-
-    const workflow = new StateGraph({
-        channels: agentStateChannels,
-    })
-        .addNode('researcher', researcherNode)
-        .addNode('chart_generator', chartGenNode)
-        .addNode('supervisor', supervisorChain);
-
-    members.forEach((member) => {
-        workflow.addEdge(member, 'supervisor');
-    });
-
-    workflow.addConditionalEdges(
-        'supervisor',
-        (x: AgentStateChannels) => x.next,
-    );
-
-    workflow.addEdge(START, 'supervisor');
-
-    const graph = workflow.compile();
-
-    try {
-        const stream = graph.streamEvents({
-            messages: [new HumanMessage('Create a chart showing the population growth of the top 5 most populous countries over the last 50 years.')],
-        }, {
-            version: 'v2',
-            streamMode: 'values',
-        });
-
-        for await (const event of stream) {
-            console.log(event.event);
-            console.dir(event.data, { depth: null });
-        }
-
-    } catch (error) {
-        console.error('An error occurred:', error);
-    }
-})();

package/src/proto/collab_original.ts

@@ -1,123 +0,0 @@
-// src/main_collaborative.ts
-import dotenv from 'dotenv';
-import { HumanMessage } from '@langchain/core/messages';
-import type * as t from '@/types';
-import {
-  ChatModelStreamHandler,
-  LLMStreamHandler,
-} from '@/stream';
-import { Processor } from '@/processor';
-import { AgentStateChannels } from '@/graphs/CollabGraph';
-import { tavilyTool, chartTool } from '@/tools/example';
-import { supervisorPrompt } from '@/prompts/collab';
-import { GraphEvents, Providers } from '@/common';
-import fs from 'fs';
-import util from 'util';
-
-dotenv.config();
-
-// Create a write stream
-const logFile = fs.createWriteStream('output.log', { flags: 'a' });
-
-// Redirect console.log and console.error
-const originalConsoleLog = console.log;
-const originalConsoleError = console.error;
-
-console.log = function(...args) {
-  logFile.write(util.format.apply(null, args) + '\n');
-  originalConsoleLog.apply(console, args);
-};
-
-console.error = function(...args) {
-  logFile.write(util.format.apply(null, args) + '\n');
-  originalConsoleError.apply(console, args);
-};
-
-async function testCollaborativeStreaming() {
-  const customHandlers = {
-    [GraphEvents.LLM_STREAM]: new LLMStreamHandler(),
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-    [GraphEvents.LLM_START]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.log('LLM Start:', event);
-      }
-    },
-    [GraphEvents.LLM_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.log('LLM End:', event);
-      }
-    },
-    [GraphEvents.CHAT_MODEL_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.log('Chat Model End:', event);
-      }
-    },
-    [GraphEvents.TOOL_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.log('Tool End:', event);
-        console.dir(data, { depth: null });
-      }
-    },
-  };
-
-  const processor = await Processor.create<AgentStateChannels>({
-    graphConfig: {
-      type: 'collaborative',
-      members: [
-        {
-          name: 'researcher',
-          systemPrompt: 'You are a web researcher. You may use the Tavily search engine to search the web for important information, so the Chart Generator in your team can make useful plots.',
-          tools: [tavilyTool],
-          llmConfig: {
-            provider: Providers.OPENAI,
-
-            model: 'gpt-4o',
-            temperature: 0,
-          },
-        },
-        {
-          name: 'chart_generator',
-          systemPrompt: 'You excel at generating bar charts. Use the researcher\'s information to generate the charts.',
-          tools: [chartTool],
-          llmConfig: {
-            provider: Providers.OPENAI,
-
-            model: 'gpt-4o',
-            temperature: 0.2,
-          },
-        },
-      ],
-      supervisorConfig: {
-        systemPrompt: supervisorPrompt,
-        llmConfig: {
-          provider: Providers.OPENAI,
-          model: 'gpt-4o',
-          temperature: 0,
-        },
-      },
-    },
-    customHandlers,
-  });
-
-  const config = {
-    configurable: { thread_id: 'collaborative-conversation-1' },
-    streamMode: 'values',
-    version: 'v2' as const,
-  };
-
-  console.log('\nCollaborative Test: Create a chart');
-
-  const input = {
-    messages: [new HumanMessage('Create a chart showing the population growth of the top 5 most populous countries over the last 50 years.')],
-  };
-
-  await processor.processStream(input, config);
-}
-
-async function main() {
-  await testCollaborativeStreaming();
-}
-
-main().catch(console.error).finally(() => {
-  logFile.end();
-});

package/src/proto/example.ts

@@ -1,93 +0,0 @@
-import dotenv from 'dotenv';
-import { ChatOpenAI } from '@langchain/openai';
-import { AIMessage } from '@langchain/core/messages';
-import { BaseMessage } from '@langchain/core/messages';
-import { ToolNode } from '@langchain/langgraph/prebuilt';
-import { RunnableConfig } from '@langchain/core/runnables';
-import { END, START, StateGraph } from '@langchain/langgraph';
-import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
-import { HandlerRegistry, LLMStreamHandler, GraphStreamProcessor } from '@/proto/stream';
-import type * as t from '@/types/graph';
-
-dotenv.config();
-
-const graphState: t.GraphStateChannels = {
-    messages: {
-        value: (x: BaseMessage[], y: BaseMessage[]) => x.concat(y),
-        default: () => [],
-    },
-};
-
-// Set up the tools
-const tools = [new TavilySearchResults({})];
-
-// Create the ToolNode
-const toolNode = new ToolNode<{ messages: BaseMessage[] }>(tools);
-
-// Set up the model
-const model = new ChatOpenAI({ model: 'gpt-4o' });
-const boundModel = model.bindTools(tools);
-
-// Define the graph
-const routeMessage = (state: t.IState) => {
-    const { messages } = state;
-    const lastMessage = messages[messages.length - 1] as AIMessage;
-    if (!lastMessage?.tool_calls?.length) {
-        return END;
-    }
-    return 'tools';
-};
-
-const callModel = async (
-    state: t.IState,
-    config?: RunnableConfig,
-) => {
-    const { messages } = state;
-    const responseMessage = await boundModel.invoke(messages, config);
-    return { messages: [responseMessage] };
-};
-
-const workflow: t.Workflow = new StateGraph<t.IState>({
-    channels: graphState,
-})
-    .addNode('agent', callModel)
-    .addNode('tools', toolNode)
-    .addEdge(START, 'agent')
-    .addConditionalEdges('agent', routeMessage)
-    .addEdge('tools', 'agent');
-
-const graph = workflow.compile();
-
-// Test the streaming functionality
-async function testStreaming() {
-    const handlerRegistry = new HandlerRegistry();
-    handlerRegistry.register('on_llm_stream', new LLMStreamHandler());
-
-    // Register custom handlers
-    handlerRegistry.register('on_llm_start', {
-        handle: (event, data) => {
-            console.log(event);
-            console.dir(data, { depth: null });
-        }
-    });
-
-    const processor = new GraphStreamProcessor(handlerRegistry);
-
-    const config: Partial<RunnableConfig> & { version: 'v1' | 'v2', streamMode: string } = {
-        configurable: { thread_id: 'conversation-num-1' },
-        streamMode: 'values',
-        version: 'v1' as const,
-    };
-
-    console.log('Test 1: Initial greeting');
-    let inputs = { messages: [['user', 'Hi I\'m Jo.']] };
-    // await processor.processStream(graph, inputs, config);
-    console.log('\n');
-
-    console.log('Test 2: Weather query');
-    inputs = { messages: [['user', 'Make a search for the weather in new york today, which is 7/7/24']] };
-    await processor.processStream(graph, inputs, config);
-    console.log('\n');
-}
-
-testStreaming();