illuma-agents 1.0.2

package/src/proto/log_stream.ts

@@ -0,0 +1,202 @@
+import fs from 'fs/promises';
+import { pull } from 'langchain/hub';
+import { ChatOpenAI } from '@langchain/openai';
+import type { ChatPromptTemplate } from '@langchain/core/prompts';
+import { AgentExecutor, createOpenAIFunctionsAgent, AgentStep } from 'langchain/agents';
+import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
+import type { RunLogPatch } from '@langchain/core/tracers/log_stream';
+import dotenv from 'dotenv';
+
+type ExtractedJSONPatchOperation = Pick<RunLogPatch, 'ops'>;
+type OperationType = ExtractedJSONPatchOperation extends { ops: (infer T)[] } ? T : never;
+
+// Load environment variables from .env file
+dotenv.config();
+
+// Define the tools the agent will have access to.
+const tools = [new TavilySearchResults({})];
+
+const llm = new ChatOpenAI({
+    model: 'gpt-3.5-turbo-1106',
+    temperature: 0,
+    streaming: true,
+});
+
+// Get the prompt to use - you can modify this!
+// If you want to see the prompt in full, you can at:
+// https://smith.langchain.com/hub/hwchase17/openai-functions-agent
+const prompt = await pull<ChatPromptTemplate>(
+    'hwchase17/openai-functions-agent'
+);
+
+const agent = await createOpenAIFunctionsAgent({
+    llm,
+    tools,
+    prompt,
+});
+
+const agentExecutor = new AgentExecutor({
+    agent,
+    tools,
+});
+
+const logStream = await agentExecutor.streamLog({
+    input: 'what are the current US election polls 2024. today is 7/6/24',
+});
+
+const finalState: RunLogPatch[] = [];
+const outputs: RunLogPatch[] = [];
+let accumulatedOutput = '';
+let accumulatedArguments = '';
+
+let functionName: string | undefined = undefined;
+
+function processStreamedOutput(op: any) {
+    let output = '';
+    if (op.value.text !== undefined) {
+        output += op.value.text;
+    }
+    if (op.value.message && op.value.message.kwargs) {
+        const kwargs = op.value.message.kwargs;
+        if (kwargs.content) {
+            output += kwargs.content;
+        }
+    }
+    if (output) {
+        accumulatedOutput += output;
+        process.stdout.write(output);
+    }
+}
+
+// A helper function to handle the event pattern for logged arguments
+function handleLoggedArgument(loggedArgument: any) {
+    if (loggedArgument.value?.message?.additional_kwargs?.function_call) {
+        const functionCall = loggedArgument.value.message.additional_kwargs.function_call;
+
+        if (functionCall.name) {
+            functionName = functionCall.name;
+            process.stdout.write(`Logged Function Name:
+        ${JSON.stringify(functionCall, null, 2)}
+      `);
+        }
+
+        if (functionCall.arguments) {
+            accumulatedArguments += functionCall.arguments;
+            // Print the part of the argument as it comes
+            // process.stdout.write(`Logged Argument: { "arguments": "${functionCall.arguments}" }\n`);
+            process.stdout.write(`Logged Argument:\n${JSON.stringify(functionCall, null, 2)}`);
+        }
+
+        // Check if the full arguments string has been accumulated
+        if (accumulatedArguments.startsWith('{') && accumulatedArguments.endsWith('}')) {
+            // Build the final logged argument string
+            const completeArguments = accumulatedArguments;
+            const namePart = functionName ? `"name": "${functionName}", ` : '';
+
+            console.log(`\nLogged Argument: {\n  ${namePart}"arguments": ${completeArguments}\n}\n`);
+
+            // Reset accumulators
+            accumulatedArguments = '';
+            functionName = undefined;
+        }
+    }
+}
+
+for await (const chunk of logStream) {
+    finalState.push(chunk);
+    outputs.push(chunk);
+
+    if (!chunk.ops) continue;
+
+    for (const op of chunk.ops) {
+        if (isStreamedOutput(op)) {
+            processStreamedOutput(op);
+            if (hasFunctionCall(op)) {
+                handleLoggedArgument(op);
+            }
+        } else if (isFinalOutput(op)) {
+            printFinalOutput(op);
+        }
+    }
+}
+
+function isStreamedOutput(op: OperationType) {
+    return op.op === 'add' && (
+        op.path.includes('/streamed_output/-') ||
+    op.path.includes('/streamed_output_str/-')
+    );
+}
+
+function hasFunctionCall(op: OperationType) {
+    return (op as any)?.value?.message?.additional_kwargs?.function_call;
+}
+
+function isFinalOutput(op: OperationType) {
+    return op.op === 'add' &&
+         op.value?.output &&
+         op.path?.startsWith('/logs/') &&
+         op.path?.endsWith('final_output') &&
+         !op.path?.includes('Runnable');
+}
+
+function printFinalOutput(op: OperationType) {
+    process.stdout.write(JSON.stringify(op, null, 2));
+    process.stdout.write(`
+
+########################_START_##########################
+        ${JSON.stringify((op as any)?.value?.output, null, 2)}
+########################__END__##########################
+
+        `);
+}
+
+// Define types for the final output structure
+interface FinalOutput {
+  id: string;
+  streamed_output: Array<{
+    intermediateSteps?: AgentStep[];
+    output?: string;
+  }>;
+  final_output?: {
+    output: string;
+  };
+  logs: Record<string, any>;
+}
+
+// Process finalState to create FinalOutput
+const finalOutput: FinalOutput = {
+    id: '',
+    streamed_output: [],
+    logs: {},
+};
+
+for (const patch of finalState) {
+    if (patch.ops) {
+        for (const op of patch.ops) {
+            if (op.op === 'add' || op.op === 'replace') {
+                if (op.path === '/id') {
+                    finalOutput.id = op.value;
+                } else if (op.path === '/streamed_output/-') {
+                    finalOutput.streamed_output.push(op.value);
+                } else if (op.path === '/final_output') {
+                    finalOutput.final_output = op.value;
+                } else if (op.path.startsWith('/logs/')) {
+                    const logKey = op.path.split('/')[2];
+                    finalOutput.logs[logKey] = op.value;
+                }
+            }
+        }
+    }
+}
+
+// Save outputs to a JSON file
+await fs.writeFile('outputs.json', JSON.stringify(outputs, null, 2));
+console.log('\n\nOutputs have been saved to outputs.json');
+
+// Save the final state separately
+await fs.writeFile('final_output.json', JSON.stringify(finalOutput, null, 2));
+console.log('\n\nFinal output has been saved to final_output.json');
+
+// Save the cleaned-up accumulated output
+await fs.writeFile('cleaned_output.txt', accumulatedOutput);
+console.log('\n\nCleaned output has been saved to cleaned_output.txt');

package/src/proto/main_collab_community_event.ts

@@ -0,0 +1,133 @@
+// src/main_collab_community_event.ts
+import dotenv from 'dotenv';
+import { HumanMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import {
+    ChatModelStreamHandler,
+    LLMStreamHandler,
+} from '@/stream';
+import { CollaborativeProcessor, Member } from '@/collab_design_v5';
+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('event_log.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);
+};
+
+// Redirect process.stdout.write
+const originalStdoutWrite = process.stdout.write;
+process.stdout.write = function(chunk: string | Uint8Array, encoding?: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean {
+    logFile.write(chunk, encoding);
+    return originalStdoutWrite.apply(process.stdout, [chunk, encoding, callback]);
+} as any;
+
+// Redirect process.stderr.write
+const originalStderrWrite = process.stderr.write;
+process.stderr.write = function(chunk: string | Uint8Array, encoding?: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean {
+    logFile.write(chunk, encoding);
+    return originalStderrWrite.apply(process.stderr, [chunk, encoding, callback]);
+} as any;
+
+async function testCollaborativeCommunityEvent() {
+    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 });
+            }
+        },
+    };
+
+    // Define the collaborative members
+    const members: Member[] = [
+        {
+            name: 'resource_finder',
+            systemPrompt: 'You are a resource finder. You utilize the Tavily search engine to gather necessary resources and contacts needed for the community event.',
+            tools: [tavilyTool],
+            llmConfig: {
+                provider: Providers.OPENAI,
+                modelName: 'gpt-4o',
+                temperature: 0,
+            },
+        },
+        {
+            name: 'event_scheduler',
+            systemPrompt: 'You are an event scheduler. You manage the timeline of the event activities using the Chart Generator to visualize the schedule.',
+            tools: [chartTool],
+            llmConfig: {
+                provider: Providers.OPENAI,
+                modelName: 'gpt-4o',
+                temperature: 0.2,
+            },
+        },
+    ];
+
+    const supervisorConfig = {
+        systemPrompt: supervisorPrompt,
+        llmConfig: {
+            provider: Providers.OPENAI,
+            modelName: 'gpt-4o',
+            temperature: 0,
+        },
+    };
+
+    const collaborativeProcessor = new CollaborativeProcessor(members, supervisorConfig, customHandlers);
+    await collaborativeProcessor.initialize();
+
+    const config = {
+        configurable: { thread_id: 'collaborative-event-planning-1' },
+        streamMode: 'events',
+        version: 'v2',
+    };
+
+    console.log('\nCollaborative Test: Plan a community event');
+
+    const input = {
+        messages: [new HumanMessage('Plan a community fair including activities for all ages, food vendors, and a performance stage.')],
+    };
+
+    await collaborativeProcessor.processStream(input, config);
+}
+
+async function main() {
+    await testCollaborativeCommunityEvent();
+}
+
+main().catch(console.error).finally(() => {
+    logFile.end();
+});

package/src/proto/main_collab_design_v2.ts

@@ -0,0 +1,96 @@
+// src/collaborative_main.ts
+import dotenv from 'dotenv';
+import { HumanMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import {
+    ChatModelStreamHandler,
+    LLMStreamHandler,
+} from '@/stream';
+import { CollaborativeProcessor, Member } from '@/collab_design_v5';
+import { tavilyTool, chartTool } from '@/tools/example';
+import { GraphEvents, Providers } from '@/common';
+
+dotenv.config();
+
+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);
+                // console.dir(data, { depth: null });
+            }
+        },
+        [GraphEvents.LLM_END]: {
+            handle: (event: string, data: t.StreamEventData) => {
+                console.log('LLM End:', event);
+                // console.dir(data, { depth: null });
+            }
+        },
+        [GraphEvents.CHAT_MODEL_END]: {
+            handle: (event: string, data: t.StreamEventData) => {
+                console.log('Chat Model End:', event);
+                // console.dir(data, { depth: null });
+            }
+        },
+        [GraphEvents.TOOL_END]: {
+            handle: (event: string, data: t.StreamEventData) => {
+                console.log('Tool End:', event);
+                // console.dir(data, { depth: null });
+            }
+        },
+    };
+
+    const members: Member[] = [
+        {
+            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,
+                modelName: '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,
+                modelName: 'gpt-4o',
+                temperature: 0.2,
+            },
+        },
+    ];
+
+    const collaborativeProcessor = new CollaborativeProcessor(members, {
+        llmConfig: {
+            provider: Providers.OPENAI,
+            modelName: 'gpt-4o',
+            temperature: 0.5,
+        },
+    }, customHandlers);
+    await collaborativeProcessor.initialize();
+
+    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 collaborativeProcessor.processStream(input, config);
+}
+
+async function main() {
+    await testCollaborativeStreaming();
+}
+
+main().catch(console.error);

package/src/proto/main_collab_design_v4.ts

@@ -0,0 +1,100 @@
+// src/collaborative_main.ts
+import dotenv from 'dotenv';
+import { HumanMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import {
+    ChatModelStreamHandler,
+    LLMStreamHandler,
+} from '@/stream';
+import { CollaborativeProcessor, Member } from '@/collab_design_v4';
+import { tavilyTool, chartTool } from '@/tools/example';
+import { supervisorPrompt } from '@/prompts/collab';
+import { GraphEvents, Providers } from '@/common';
+
+dotenv.config();
+
+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);
+                // console.dir(data, { depth: null });
+            }
+        },
+        [GraphEvents.LLM_END]: {
+            handle: (event: string, data: t.StreamEventData) => {
+                console.log('LLM End:', event);
+                // console.dir(data, { depth: null });
+            }
+        },
+        [GraphEvents.CHAT_MODEL_END]: {
+            handle: (event: string, data: t.StreamEventData) => {
+                console.log('Chat Model End:', event);
+                // console.dir(data, { depth: null });
+            }
+        },
+        [GraphEvents.TOOL_END]: {
+            handle: (event: string, data: t.StreamEventData) => {
+                console.log('Tool End:', event);
+                console.dir(data, { depth: null });
+            }
+        },
+    };
+
+    const members: Member[] = [
+        {
+            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,
+                modelName: '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,
+                modelName: 'gpt-4o',
+                temperature: 0.2,
+            },
+        },
+    ];
+
+    const supervisorConfig = {
+        systemPrompt: supervisorPrompt,
+        llmConfig: {
+            provider: Providers.OPENAI,
+            modelName: 'gpt-4o',
+            temperature: 0,
+        },
+    };
+
+    const collaborativeProcessor = new CollaborativeProcessor(members, supervisorConfig, customHandlers);
+    await collaborativeProcessor.initialize();
+
+    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 collaborativeProcessor.processStream(input, config);
+}
+
+async function main() {
+    await testCollaborativeStreaming();
+}
+
+main().catch(console.error);

package/src/proto/main_collab_design_v5.ts

@@ -0,0 +1,135 @@
+// src/main_collab_design_v5.ts
+import dotenv from 'dotenv';
+import { HumanMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import {
+    ChatModelStreamHandler,
+    LLMStreamHandler,
+} from '@/stream';
+import { CollaborativeProcessor, Member } from '@/collab_design_v5';
+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);
+};
+
+// Redirect process.stdout.write
+const originalStdoutWrite = process.stdout.write;
+process.stdout.write = function(chunk: string | Uint8Array, encoding?: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean {
+    logFile.write(chunk, encoding);
+    return originalStdoutWrite.apply(process.stdout, [chunk, encoding, callback]);
+} as any;
+
+// Redirect process.stderr.write
+const originalStderrWrite = process.stderr.write;
+process.stderr.write = function(chunk: string | Uint8Array, encoding?: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean {
+    logFile.write(chunk, encoding);
+    return originalStderrWrite.apply(process.stderr, [chunk, encoding, callback]);
+} as any;
+
+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);
+                // console.dir(data, { depth: null });
+            }
+        },
+        [GraphEvents.LLM_END]: {
+            handle: (event: string, data: t.StreamEventData) => {
+                console.log('LLM End:', event);
+                // console.dir(data, { depth: null });
+            }
+        },
+        [GraphEvents.CHAT_MODEL_END]: {
+            handle: (event: string, data: t.StreamEventData) => {
+                console.log('Chat Model End:', event);
+                // console.dir(data, { depth: null });
+            }
+        },
+        [GraphEvents.TOOL_END]: {
+            handle: (event: string, data: t.StreamEventData) => {
+                console.log('Tool End:', event);
+                console.dir(data, { depth: null });
+            }
+        },
+    };
+
+    const members: Member[] = [
+        {
+            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,
+                modelName: '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,
+                modelName: 'gpt-4o',
+                temperature: 0.2,
+            },
+        },
+    ];
+
+    const supervisorConfig = {
+        systemPrompt: supervisorPrompt,
+        llmConfig: {
+            provider: Providers.OPENAI,
+            modelName: 'gpt-4o',
+            temperature: 0,
+        },
+    };
+
+    const collaborativeProcessor = new CollaborativeProcessor(members, supervisorConfig, customHandlers);
+    await collaborativeProcessor.initialize();
+
+    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 collaborativeProcessor.processStream(input, config);
+}
+
+async function main() {
+    await testCollaborativeStreaming();
+}
+
+main().catch(console.error).finally(() => {
+    logFile.end();
+});