@illuma-ai/agents 1.0.81

package/src/scripts/search.ts

@@ -0,0 +1,146 @@
+/* eslint-disable no-console */
+// src/scripts/cli.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { createSearchTool } from '@/tools/search';
+
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+import { GraphEvents, Callback, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+
+const conversationHistory: BaseMessage[] = [];
+async function testStandardStreaming(): Promise<void> {
+  const { userName, location, provider, currentDate } = await getArgs();
+  const { contentParts, aggregateContent } = createContentAggregator();
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        // console.dir(data, { depth: null });
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (
+        _event: string,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('====== TOOL_START ======');
+        // console.dir(data, { depth: null });
+      },
+    },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  if (llmConfig.provider === Providers.BEDROCK) {
+    (llmConfig as t.BedrockAnthropicInput).promptCache = true;
+  }
+
+  const run = await Run.create<t.IState>({
+    runId: 'test-run-id',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [
+        createSearchTool({
+          scraperProvider: 'serper',
+        }),
+      ],
+      instructions:
+        'You are a friendly AI assistant. Always address the user by their name.',
+      // additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+    },
+    returnContent: true,
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider,
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log('Test 1: Search query (search tool test)');
+
+  // const userMessage = `
+  // Make a search for the weather in ${location} today, which is ${currentDate}.
+  // Before making the search, please let me know what you're about to do, then immediately start searching without hesitation.
+  // Make sure to always refer to me by name, which is ${userName}.
+  // After giving me a thorough summary, tell me a joke about the weather forecast we went over.
+  // `;
+  // const userMessage = 'Are massage guns good?';
+  // const userMessage = 'What is functional programming?';
+  const userMessage = "Get me today's trending news.";
+  // const userMessage = "search recent italy earthquake volcano activity";
+  // const userMessage =
+  //   "use 'Trump' as the exact search query and tell me what you find.";
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  const inputs = {
+    messages: conversationHistory,
+  };
+  const finalContentParts = await run.processStream(inputs, config);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+    console.dir(conversationHistory, { depth: null });
+  }
+  // console.dir(finalContentParts, { depth: null });
+  console.log('\n\n====================\n\n');
+  // console.dir(contentParts, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.warn('Unhandled Rejection (non-fatal):', reason);
+});
+
+testStandardStreaming().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});

package/src/scripts/sequential-full-metadata-test.ts

@@ -0,0 +1,197 @@
+import { config } from 'dotenv';
+config();
+
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { Providers, GraphEvents } from '@/common';
+import { sleep } from '@/utils/run';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Dump ALL metadata for SEQUENTIAL execution to compare with parallel
+ */
+async function testSequentialMetadata() {
+  console.log('Dumping FULL metadata for SEQUENTIAL execution...\n');
+
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  const allMetadata: Array<{
+    event: string;
+    timestamp: number;
+    metadata: Record<string, unknown>;
+  }> = [];
+  const startTime = Date.now();
+
+  // Sequential chain: agent_a -> agent_b
+  const agents: t.AgentInputs[] = [
+    {
+      agentId: 'agent_a',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are Agent A. Just say "Hello from A" in one sentence.`,
+    },
+    {
+      agentId: 'agent_b',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are Agent B. Just say "Hello from B" in one sentence.`,
+    },
+  ];
+
+  // Sequential edge: A -> B (using edgeType not type)
+  const edges: t.GraphEdge[] = [
+    { from: 'agent_a', to: 'agent_b', edgeType: 'direct' },
+  ];
+
+  const captureMetadata = (
+    eventName: string,
+    metadata?: Record<string, unknown>
+  ) => {
+    if (metadata) {
+      allMetadata.push({
+        event: eventName,
+        timestamp: Date.now() - startTime,
+        metadata: { ...metadata },
+      });
+    }
+  };
+
+  const customHandlers = {
+    [GraphEvents.CHAT_MODEL_END]: {
+      handle: (
+        _event: string,
+        _data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        captureMetadata('CHAT_MODEL_END', metadata);
+      },
+    },
+    [GraphEvents.CHAT_MODEL_START]: {
+      handle: (
+        _event: string,
+        _data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        captureMetadata('CHAT_MODEL_START', metadata);
+      },
+    },
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        captureMetadata('ON_RUN_STEP', metadata);
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+  };
+
+  const runConfig: t.RunConfig = {
+    runId: `sequential-metadata-${Date.now()}`,
+    graphConfig: {
+      type: 'multi-agent',
+      agents,
+      edges,
+    },
+    customHandlers,
+    returnContent: true,
+  };
+
+  try {
+    const run = await Run.create(runConfig);
+
+    const userMessage = `Hi`;
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    const config = {
+      configurable: {
+        thread_id: 'sequential-metadata-test-1',
+      },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    await run.processStream({ messages: conversationHistory }, config);
+
+    // Print ALL CHAT_MODEL_START metadata (don't dedupe)
+    console.log(
+      '\n\n========== ALL CHAT_MODEL_START EVENTS (SEQUENTIAL) ==========\n'
+    );
+    for (const entry of allMetadata) {
+      if (entry.event === 'CHAT_MODEL_START') {
+        const node = entry.metadata.langgraph_node as string;
+        console.log(`\n--- ${node} (at ${entry.timestamp}ms) ---`);
+        console.dir(entry.metadata, { depth: null });
+      }
+    }
+
+    console.log('\n\n========== ALL EVENTS ==========\n');
+    for (const entry of allMetadata) {
+      console.log(
+        `[${entry.timestamp}ms] ${entry.event}: ${entry.metadata.langgraph_node}`
+      );
+    }
+
+    // Key comparison
+    console.log(
+      '\n\n========== KEY FIELDS COMPARISON (SEQUENTIAL) ==========\n'
+    );
+
+    const agentMetadataMap = new Map<string, Record<string, unknown>>();
+    for (const entry of allMetadata) {
+      if (entry.event === 'CHAT_MODEL_START') {
+        const node = entry.metadata.langgraph_node as string;
+        if (!agentMetadataMap.has(node)) {
+          agentMetadataMap.set(node, entry.metadata);
+        }
+      }
+    }
+
+    for (const [node, meta] of agentMetadataMap) {
+      console.log(`${node}:`);
+      console.log(`  langgraph_step: ${meta.langgraph_step}`);
+      console.log(
+        `  langgraph_triggers: ${JSON.stringify(meta.langgraph_triggers)}`
+      );
+      console.log(`  checkpoint_ns: ${meta.checkpoint_ns}`);
+      console.log(`  __pregel_task_id: ${meta.__pregel_task_id}`);
+      console.log(`  langgraph_path: ${JSON.stringify(meta.langgraph_path)}`);
+      console.log();
+    }
+
+    await sleep(1000);
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+
+testSequentialMetadata();

package/src/scripts/simple.ts

@@ -0,0 +1,225 @@
+// src/scripts/cli.ts
+import { config } from 'dotenv';
+import { v4 as uuidv4 } from 'uuid';
+config();
+import {
+  HumanMessage,
+  BaseMessage,
+  UsageMetadata,
+} from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import {
+  ToolEndHandler,
+  ModelEndHandler,
+  createMetadataAggregator,
+} from '@/events';
+import { GraphEvents, Providers, TitleMethod } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { sleep } from '@/utils/run';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+let _contentParts: t.MessageContentComplex[] = [];
+let collectedUsage: UsageMetadata[] = [];
+
+async function testStandardStreaming(): Promise<void> {
+  const {
+    userName,
+    location,
+    provider: _provider,
+    currentDate,
+  } = await getArgs();
+  const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts as t.MessageContentComplex[];
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        console.dir(data, { depth: null });
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_MESSAGE_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_REASONING_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_REASONING_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.ReasoningDeltaEvent });
+      },
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (
+        _event: string,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('====== TOOL_START ======');
+        // console.dir(data, { depth: null });
+      },
+    },
+  };
+
+  const llmConfig = getLLMConfig(_provider);
+  if (
+    'configuration' in llmConfig &&
+    (llmConfig as t.OpenAIClientOptions).configuration != null
+  ) {
+    const openAIConfig = llmConfig as t.OpenAIClientOptions;
+    if (openAIConfig.configuration) {
+      openAIConfig.configuration.fetch = (
+        url: string | URL | Request,
+        init?: RequestInit
+      ) => {
+        console.log('Fetching:', url);
+        return fetch(url, init);
+      };
+    }
+  }
+  const provider = llmConfig.provider;
+
+  if (provider === Providers.ANTHROPIC) {
+    (llmConfig as t.AnthropicClientOptions).clientOptions = {
+      defaultHeaders: {
+        'anthropic-beta':
+          'token-efficient-tools-2025-02-19,output-128k-2025-02-19,prompt-caching-2024-07-31',
+      },
+    };
+  }
+
+  const run = await Run.create<t.IState>({
+    runId: uuidv4(),
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      // tools: [],
+      // reasoningKey: 'reasoning',
+      instructions:
+        'You are a friendly AI assistant. Always address the user by their name.',
+      additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+    },
+    returnContent: true,
+    customHandlers,
+  });
+
+  const config = {
+    runId: uuidv4(),
+    configurable: {
+      user_id: 'user-123',
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log('Test 1: Simple message test');
+
+  const userMessage = `hi`;
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  const inputs = {
+    messages: conversationHistory,
+  };
+  const finalContentParts = await run.processStream(inputs, config);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+    console.dir(conversationHistory, { depth: null });
+  }
+  // console.dir(finalContentParts, { depth: null });
+  console.log('\n\n====================\n\n');
+  console.dir(contentParts, { depth: null });
+  const { handleLLMEnd, collected } = createMetadataAggregator();
+  const titleOptions: t.RunTitleOptions = {
+    provider,
+    inputText: userMessage,
+    contentParts,
+    // titleMethod: TitleMethod.STRUCTURED,
+    chainOptions: {
+      configurable: {
+        user_id: 'user-123',
+        thread_id: 'conversation-num-1',
+      },
+      callbacks: [
+        {
+          handleLLMEnd,
+        },
+      ],
+    },
+  };
+  if (provider === Providers.ANTHROPIC) {
+    titleOptions.clientOptions = {
+      model: 'claude-3-5-haiku-latest',
+    };
+  }
+  const titleResult = await run.generateTitle(titleOptions);
+  console.log('Collected usage metadata:', collectedUsage);
+  console.log('Generated Title:', titleResult);
+  console.log('Collected title usage metadata:', collected);
+  await sleep(5000);
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
+testStandardStreaming().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});