illuma-agents 1.0.8 → 1.0.10

package/src/proto/log_stream.ts

@@ -1,202 +0,0 @@
-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

@@ -1,133 +0,0 @@
-// 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

@@ -1,96 +0,0 @@
-// 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

@@ -1,100 +0,0 @@
-// 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

@@ -1,135 +0,0 @@
-// 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();
-});