illuma-agents 1.0.2

package/src/proto/main_collab_global_analysis.ts

@@ -0,0 +1,122 @@
+// src/main_collab_global_analysis.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 { WeatherDataTool, TimeZoneTool, CurrencyConversionTool, IPGeolocationTool } from '@/tools/global_analysis_tools';
+import { supervisorPrompt } from '@/prompts/collab';
+import { GraphEvents, Providers } from '@/common';
+import { setupLogging } from '@/utils/logging';
+
+dotenv.config();
+
+// Setup logging
+setupLogging('global_analysis.log');
+
+async function testCollaborativeGlobalAnalysis() {
+    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: 'weather_analyst',
+            systemPrompt: 'You are a weather analyst. Use the Weather Data tool to provide weather information for different cities.',
+            tools: [WeatherDataTool],
+            llmConfig: {
+                provider: Providers.OPENAI,
+                modelName: 'gpt-4o',
+                temperature: 0,
+            },
+        },
+        {
+            name: 'time_zone_expert',
+            systemPrompt: 'You are a time zone expert. Use the Time Zone tool to provide time information for different locations.',
+            tools: [TimeZoneTool],
+            llmConfig: {
+                provider: Providers.OPENAI,
+                modelName: 'gpt-4o',
+                temperature: 0.2,
+            },
+        },
+        {
+            name: 'currency_converter',
+            systemPrompt: 'You are a currency conversion expert. Use the Currency Conversion tool to convert between different currencies.',
+            tools: [CurrencyConversionTool],
+            llmConfig: {
+                provider: Providers.OPENAI,
+                modelName: 'gpt-4o',
+                temperature: 0.2,
+            },
+        },
+        {
+            name: 'ip_analyst',
+            systemPrompt: 'You analyze IP addresses. Use the IP Geolocation tool to provide information about IP addresses.',
+            tools: [IPGeolocationTool],
+            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-global-analysis-1' },
+        streamMode: 'events',
+        version: 'v2',
+    };
+
+    console.log('\nCollaborative Test: Perform global analysis');
+
+    const input = {
+        messages: [new HumanMessage('Analyze the weather in New York and Tokyo, compare their time zones, convert 3500 USD to EUR, and provide geolocation information for the IP address 8.8.8.8.')],
+    };
+
+    await collaborativeProcessor.processStream(input, config);
+}
+
+async function main() {
+    await testCollaborativeGlobalAnalysis();
+}
+
+main().catch(console.error);

package/src/proto/main_collab_hackathon_event.ts

@@ -0,0 +1,153 @@
+// src/main_collab_hackathon_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 { EmailNotifier, FileManager, UniqueIDGenerator, DatetimeFormatter } from '@/tools/hackathon_tools';
+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('hackathon_event.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 testCollaborativeHackathonEvent() {
+    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: 'email_notifier',
+            systemPrompt: 'You are responsible for sending out email notifications regarding the hackathon event.',
+            tools: [EmailNotifier],
+            llmConfig: {
+                provider: Providers.OPENAI,
+                modelName: 'gpt-4o',
+                temperature: 0,
+            },
+        },
+        {
+            name: 'file_manager',
+            systemPrompt: 'You manage the file storage for hackathon materials. You can create, read, and delete files as needed.',
+            tools: [FileManager],
+            llmConfig: {
+                provider: Providers.OPENAI,
+                modelName: 'gpt-4o',
+                temperature: 0.2,
+            },
+        },
+        {
+            name: 'unique_id_generator',
+            systemPrompt: 'You generate unique IDs for participants and teams to ensure everyone has a unique identifier.',
+            tools: [UniqueIDGenerator],
+            llmConfig: {
+                provider: Providers.OPENAI,
+                modelName: 'gpt-4o',
+                temperature: 0.2,
+            },
+        },
+        {
+            name: 'datetime_formatter',
+            systemPrompt: 'You format and manipulate dates and times for scheduling purposes.',
+            tools: [DatetimeFormatter],
+            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-hackathon-planning-1' },
+        streamMode: 'events',
+        version: 'v2',
+    };
+
+    console.log('\nCollaborative Test: Plan a hackathon event');
+
+    const input = {
+        messages: [new HumanMessage('Organize a hackathon event including sending invitations, managing files, generating unique IDs, and scheduling sessions.')],
+    };
+
+    await collaborativeProcessor.processStream(input, config);
+}
+
+async function main() {
+    await testCollaborativeHackathonEvent();
+}
+
+main().catch(console.error).finally(() => {
+    logFile.end();
+});

package/src/proto/main_collab_space_mission.ts

@@ -0,0 +1,153 @@
+// src/main_collab_space_mission.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 { NasaAPODTool, ISSLocationTool, LaunchScheduleTool, MissionIDGenerator } from '@/tools/space_mission_tools';
+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('space_mission.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 testCollaborativeSpaceMission() {
+    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: 'astronomy_expert',
+            systemPrompt: 'You are an astronomy expert. Use the NASA APOD tool to provide interesting astronomical information for the mission.',
+            tools: [NasaAPODTool],
+            llmConfig: {
+                provider: Providers.OPENAI,
+                modelName: 'gpt-4o',
+                temperature: 0,
+            },
+        },
+        {
+            name: 'iss_tracker',
+            systemPrompt: 'You track the International Space Station. Use the ISS Location tool to provide updates on its position.',
+            tools: [ISSLocationTool],
+            llmConfig: {
+                provider: Providers.OPENAI,
+                modelName: 'gpt-4o',
+                temperature: 0.2,
+            },
+        },
+        {
+            name: 'launch_coordinator',
+            systemPrompt: 'You coordinate space launches. Use the Launch Schedule tool to plan mission launches around other scheduled events.',
+            tools: [LaunchScheduleTool],
+            llmConfig: {
+                provider: Providers.OPENAI,
+                modelName: 'gpt-4o',
+                temperature: 0.2,
+            },
+        },
+        {
+            name: 'mission_id_assigner',
+            systemPrompt: 'You assign unique IDs to space missions. Use the Mission ID Generator to create identifiers for new missions.',
+            tools: [MissionIDGenerator],
+            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-space-mission-planning-1' },
+        streamMode: 'events',
+        version: 'v2',
+    };
+
+    console.log('\nCollaborative Test: Plan a space mission');
+
+    const input = {
+        messages: [new HumanMessage('Plan a space mission to observe a newly discovered exoplanet. Consider astronomical events, ISS positioning, launch schedules, and assign a unique mission ID.')],
+    };
+
+    await collaborativeProcessor.processStream(input, config);
+}
+
+async function main() {
+    await testCollaborativeSpaceMission();
+}
+
+main().catch(console.error).finally(() => {
+    logFile.end();
+});

package/src/proto/main_philosophy.ts

@@ -0,0 +1,210 @@
+// src/main_philosophical_cafe.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 { GraphEvents, Providers } from '@/common';
+import fs from 'fs';
+import util from 'util';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+dotenv.config();
+
+// Create a write stream
+const logFile = fs.createWriteStream('philosophical_cafe.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;
+
+// Define tools for thinking and speaking
+const ThinkTool = new DynamicStructuredTool({
+    name: 'think',
+    description: 'Think about the current topic or situation.',
+    schema: z.object({
+        thought: z.string().describe('The character\'s internal thought'),
+    }),
+    func: async ({ thought }) => {
+        return `[Thinking: ${thought}]`;
+    }
+});
+
+const SpeakTool = new DynamicStructuredTool({
+    name: 'speak',
+    description: 'Say something out loud in the conversation.',
+    schema: z.object({
+        speech: z.string().describe('What the character says out loud'),
+    }),
+    func: async ({ speech }) => {
+        return speech;
+    }
+});
+
+async function testPhilosophicalCafe() {
+    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 fictional cafe patrons
+    const members: Member[] = [
+        {
+            name: 'Luna',
+            systemPrompt: 'You are Luna, a free-spirited artist with a penchant for existential questions. You often challenge conventional wisdom and believe in the power of individual expression. Speak casually and use artistic metaphors. Always either think or speak each turn, sometimes both.',
+            tools: [ThinkTool, SpeakTool],
+            llmConfig: {
+                provider: Providers.BEDROCK,
+                model: 'anthropic.claude-3-sonnet-20240229-v1:0',
+                region: process.env.BEDROCK_AWS_REGION,
+                credentials: {
+                    accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
+                    secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,
+                },
+            },
+        },
+        {
+            name: 'Zephyr',
+            systemPrompt: 'You are Zephyr, a tech-savvy futurist who believes in the potential of technology to solve human problems. You\'re optimistic but also concerned about ethical implications. Use tech jargon and futuristic concepts in your speech. Always either think or speak each turn, sometimes both.',
+            tools: [ThinkTool, SpeakTool],
+            llmConfig: {
+                provider: Providers.BEDROCK,
+                model: 'anthropic.claude-3-sonnet-20240229-v1:0',
+                region: process.env.BEDROCK_AWS_REGION,
+                credentials: {
+                    accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
+                    secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,
+                },
+            },
+        },
+        {
+            name: 'Sage',
+            systemPrompt: 'You are Sage, a retired professor with a dry sense of humor. You\'re skeptical of grand theories and prefer practical wisdom. Your speech is peppered with historical references and gentle sarcasm. Always either think or speak each turn, sometimes both.',
+            tools: [ThinkTool, SpeakTool],
+            llmConfig: {
+                provider: Providers.BEDROCK,
+                model: 'anthropic.claude-3-sonnet-20240229-v1:0',
+                region: process.env.BEDROCK_AWS_REGION,
+                credentials: {
+                    accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
+                    secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,
+                },
+            },
+        },
+        {
+            name: 'Nova',
+            systemPrompt: 'You are Nova, an enthusiastic environmental activist with a background in quantum physics. You see interconnections everywhere and often draw parallels between natural systems and human behavior. Your speech is energetic and filled with scientific analogies. Always either think or speak each turn, sometimes both.',
+            tools: [ThinkTool, SpeakTool],
+            llmConfig: {
+                provider: Providers.BEDROCK,
+                model: 'anthropic.claude-3-sonnet-20240229-v1:0',
+                region: process.env.BEDROCK_AWS_REGION,
+                credentials: {
+                    accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
+                    secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,
+                },
+            },
+        },
+    ];
+
+    const supervisorPrompt = `
+You are the author orchestrating a casual, candid conversation between {members} at a local cafe. Your role is to guide the flow of the conversation.
+
+Consider the following:
+1. Encourage natural, overlapping dialogue. Characters can interrupt or talk over each other.
+2. Ensure all characters are actively participating by either speaking or thinking in each turn.
+3. Introduce unexpected elements or topics to keep the conversation lively and unpredictable.
+4. Allow for moments of humor, disagreement, or sudden insights.
+5. Keep the tone casual and fitting for a cafe setting.
+6. Multiple tools can be run at once.
+
+Remember, you're crafting a scene, not moderating a debate. Let the characters' personalities shine through their interactions.
+`;
+
+    const supervisorConfig = {
+        systemPrompt: supervisorPrompt,
+        llmConfig: {
+            provider: Providers.BEDROCK,
+            model: 'anthropic.claude-3-sonnet-20240229-v1:0',
+            region: process.env.BEDROCK_AWS_REGION,
+            credentials: {
+                accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
+                secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,
+            },
+        },
+    };
+
+    const collaborativeProcessor = new CollaborativeProcessor(members, supervisorConfig, customHandlers);
+    await collaborativeProcessor.initialize();
+
+    const config = {
+        configurable: { thread_id: 'philosophical-cafe-1' },
+        streamMode: 'events',
+        version: 'v2',
+    };
+
+    console.log('\nCafe: A Chance Encounter');
+
+    const input = {
+        messages: [new HumanMessage('It\'s a rainy Tuesday afternoon at a Cafe. Luna, Zephyr, Sage, and Nova find themselves sharing a table due to the crowded conditions. The aroma of coffee fills the air as a heated debate about the nature of reality unfolds at a nearby table. What happens next?')],
+    };
+
+    await collaborativeProcessor.processStream(input, config);
+}
+
+async function main() {
+    await testPhilosophicalCafe();
+}
+
+main().catch(console.error).finally(() => {
+    logFile.end();
+});