@illuma-ai/agents 1.0.81

package/dist/types/llm/vertexai/index.d.ts

@@ -0,0 +1,293 @@
+import { ChatGoogle } from '@langchain/google-gauth';
+import type { GoogleAIModelRequestParams, GoogleAbstractedClient } from '@langchain/google-common';
+import type { VertexAIClientOptions } from '@/types';
+/**
+ * Integration with Google Vertex AI chat models.
+ *
+ * Setup:
+ * Install `@langchain/google-vertexai` and set your stringified
+ * Vertex AI credentials as an environment variable named `GOOGLE_APPLICATION_CREDENTIALS`.
+ *
+ * ```bash
+ * npm install @langchain/google-vertexai
+ * export GOOGLE_APPLICATION_CREDENTIALS="path/to/credentials"
+ * ```
+ *
+ * ## [Constructor args](https://api.js.langchain.com/classes/_langchain_google_vertexai.index.ChatVertexAI.html#constructor.new_ChatVertexAI)
+ *
+ * ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_google_common_types.GoogleAIBaseLanguageModelCallOptions.html)
+ *
+ * Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.
+ * They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:
+ *
+ * ```typescript
+ * // When calling `.withConfig`, call options should be passed via the first argument
+ * const llmWithArgsBound = llm.withConfig({
+ *   stop: ["\n"],
+ *   tools: [...],
+ * });
+ *
+ * // When calling `.bindTools`, call options should be passed via the second argument
+ * const llmWithTools = llm.bindTools(
+ *   [...],
+ *   {
+ *     tool_choice: "auto",
+ *   }
+ * );
+ * ```
+ *
+ * ## Examples
+ *
+ * <details open>
+ * <summary><strong>Instantiate</strong></summary>
+ *
+ * ```typescript
+ * import { ChatVertexAI } from '@langchain/google-vertexai';
+ *
+ * const llm = new ChatVertexAI({
+ *   model: "gemini-1.5-pro",
+ *   temperature: 0,
+ *   // other params...
+ * });
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Invoking</strong></summary>
+ *
+ * ```typescript
+ * const input = `Translate "I love programming" into French.`;
+ *
+ * // Models also accept a list of chat messages or a formatted prompt
+ * const result = await llm.invoke(input);
+ * console.log(result);
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"J'adore programmer\" \n\nHere's why this is the best translation:\n\n* **J'adore** means \"I love\" and conveys a strong passion.\n* **Programmer** is the French verb for \"to program.\"\n\nThis translation is natural and idiomatic in French. \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 63,
+ *     "total_tokens": 72
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Streaming Chunks</strong></summary>
+ *
+ * ```typescript
+ * for await (const chunk of await llm.stream(input)) {
+ *   console.log(chunk);
+ * }
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "J'adore programmer\" \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {
+ *     "finishReason": "stop"
+ *   },
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 8,
+ *     "total_tokens": 17
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Aggregate Streamed Chunks</strong></summary>
+ *
+ * ```typescript
+ * import { AIMessageChunk } from '@langchain/core/messages';
+ * import { concat } from '@langchain/core/utils/stream';
+ *
+ * const stream = await llm.stream(input);
+ * let full: AIMessageChunk | undefined;
+ * for await (const chunk of stream) {
+ *   full = !full ? chunk : concat(full, chunk);
+ * }
+ * console.log(full);
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"J'adore programmer\" \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {
+ *     "finishReason": "stop"
+ *   },
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 8,
+ *     "total_tokens": 17
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Bind tools</strong></summary>
+ *
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const GetWeather = {
+ *   name: "GetWeather",
+ *   description: "Get the current weather in a given location",
+ *   schema: z.object({
+ *     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+ *   }),
+ * }
+ *
+ * const GetPopulation = {
+ *   name: "GetPopulation",
+ *   description: "Get the current population in a given location",
+ *   schema: z.object({
+ *     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+ *   }),
+ * }
+ *
+ * const llmWithTools = llm.bindTools([GetWeather, GetPopulation]);
+ * const aiMsg = await llmWithTools.invoke(
+ *   "Which city is hotter today and which is bigger: LA or NY?"
+ * );
+ * console.log(aiMsg.tool_calls);
+ * ```
+ *
+ * ```txt
+ * [
+ *   {
+ *     name: 'GetPopulation',
+ *     args: { location: 'New York City, NY' },
+ *     id: '33c1c1f47e2f492799c77d2800a43912',
+ *     type: 'tool_call'
+ *   }
+ * ]
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Structured Output</strong></summary>
+ *
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const Joke = z.object({
+ *   setup: z.string().describe("The setup of the joke"),
+ *   punchline: z.string().describe("The punchline to the joke"),
+ *   rating: z.number().optional().describe("How funny the joke is, from 1 to 10")
+ * }).describe('Joke to tell user.');
+ *
+ * const structuredLlm = llm.withStructuredOutput(Joke, { name: "Joke" });
+ * const jokeResult = await structuredLlm.invoke("Tell me a joke about cats");
+ * console.log(jokeResult);
+ * ```
+ *
+ * ```txt
+ * {
+ *   setup: 'What do you call a cat that loves to bowl?',
+ *   punchline: 'An alley cat!'
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Usage Metadata</strong></summary>
+ *
+ * ```typescript
+ * const aiMsgForMetadata = await llm.invoke(input);
+ * console.log(aiMsgForMetadata.usage_metadata);
+ * ```
+ *
+ * ```txt
+ * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Stream Usage Metadata</strong></summary>
+ *
+ * ```typescript
+ * const streamForMetadata = await llm.stream(
+ *   input,
+ *   {
+ *     streamUsage: true
+ *   }
+ * );
+ * let fullForMetadata: AIMessageChunk | undefined;
+ * for await (const chunk of streamForMetadata) {
+ *   fullForMetadata = !fullForMetadata ? chunk : concat(fullForMetadata, chunk);
+ * }
+ * console.log(fullForMetadata?.usage_metadata);
+ * ```
+ *
+ * ```txt
+ * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
+ * ```
+ * </details>
+ *
+ * <br />
+ */
+export declare class ChatVertexAI extends ChatGoogle {
+    lc_namespace: string[];
+    dynamicThinkingBudget: boolean;
+    static lc_name(): 'IllumaVertexAI';
+    constructor(fields?: VertexAIClientOptions);
+    invocationParams(options?: this['ParsedCallOptions'] | undefined): GoogleAIModelRequestParams;
+    buildConnection(fields: VertexAIClientOptions, client: GoogleAbstractedClient): void;
+}

package/dist/types/messages/cache.d.ts

@@ -0,0 +1,54 @@
+import { BaseMessage, MessageContentComplex } from '@langchain/core/messages';
+import type { AnthropicMessage } from '@/types/messages';
+type MessageWithContent = {
+    content?: string | MessageContentComplex[];
+};
+/**
+ * Anthropic API: Adds cache control to the appropriate user messages in the payload.
+ * Strips ALL existing cache control (both Anthropic and Bedrock formats) from all messages,
+ * then adds fresh cache control to the last 2 user messages in a single backward pass.
+ * This ensures we don't accumulate stale cache points across multiple turns.
+ * Returns a new array - only clones messages that require modification.
+ * @param messages - The array of message objects.
+ * @returns - A new array of message objects with cache control added.
+ */
+export declare function addCacheControl<T extends AnthropicMessage | BaseMessage>(messages: T[]): T[];
+/**
+ * Removes all Anthropic cache_control fields from messages
+ * Used when switching from Anthropic to Bedrock provider
+ * Returns a new array - only clones messages that require modification.
+ */
+export declare function stripAnthropicCacheControl<T extends MessageWithContent>(messages: T[]): T[];
+/**
+ * Removes all Bedrock cachePoint blocks from messages
+ * Used when switching from Bedrock to Anthropic provider
+ * Returns a new array - only clones messages that require modification.
+ */
+export declare function stripBedrockCacheControl<T extends MessageWithContent>(messages: T[]): T[];
+/**
+ * Adds Bedrock Converse API cache points using "Stable Prefix Caching" strategy.
+ *
+ * STRATEGY: Place cache point after the LAST ASSISTANT message only.
+ * This ensures the prefix (everything before the cache point) remains STABLE
+ * as the conversation grows, maximizing cache hits.
+ *
+ * Why this works:
+ * - System message has its own cachePoint (added in AgentContext)
+ * - Tools have their own cachePoint (added in CustomChatBedrockConverse)
+ * - Conversation history grows, but the PREFIX stays the same
+ * - Only the NEW user message is uncached (it's always different)
+ *
+ * Example conversation flow:
+ * Request 1: [System+cachePoint][Tools+cachePoint][User1] → No conversation cache yet
+ * Request 2: [System][Tools][User1][Assistant1+cachePoint][User2] → Cache User1+Assistant1
+ * Request 3: [System][Tools][User1][Assistant1][User2][Assistant2+cachePoint][User3]
+ *            → Cache reads User1+A1+User2+A2, cache writes new portion
+ *
+ * Claude's "Simplified Cache Management" automatically looks back up to 20 content
+ * blocks from the cache checkpoint to find the longest matching prefix.
+ *
+ * @param messages - The array of message objects (excluding system message).
+ * @returns - The updated array with a single cache point after the last assistant message.
+ */
+export declare function addBedrockCacheControl<T extends Partial<BaseMessage> & MessageWithContent>(messages: T[]): T[];
+export {};

package/dist/types/messages/content.d.ts

@@ -0,0 +1,7 @@
+import type { BaseMessage } from '@langchain/core/messages';
+/**
+ * Formats an array of messages for LangChain, making sure all content fields are strings
+ * @param {Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>} payload - The array of messages to format.
+ * @returns {Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>} - The array of formatted LangChain messages, including ToolMessages for tool calls.
+ */
+export declare const formatContentStrings: (payload: Array<BaseMessage>) => Array<BaseMessage>;

package/dist/types/messages/core.d.ts

@@ -0,0 +1,14 @@
+import { AIMessageChunk, HumanMessage, ToolMessage, AIMessage, BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { Providers } from '@/common';
+export declare function getConverseOverrideMessage({ userMessage, lastMessageX, lastMessageY, }: {
+    userMessage: string[];
+    lastMessageX: AIMessageChunk | null;
+    lastMessageY: ToolMessage;
+}): HumanMessage;
+export declare function modifyDeltaProperties(provider: Providers, obj?: AIMessageChunk): AIMessageChunk | undefined;
+export declare function formatAnthropicMessage(message: AIMessageChunk): AIMessage;
+export declare function convertMessagesToContent(messages: BaseMessage[]): t.MessageContentComplex[];
+export declare function formatAnthropicArtifactContent(messages: BaseMessage[]): void;
+export declare function formatArtifactPayload(messages: BaseMessage[]): void;
+export declare function findLastIndex<T>(array: T[], predicate: (value: T) => boolean): number;

package/dist/types/messages/format.d.ts

@@ -0,0 +1,137 @@
+import { AIMessage, ToolMessage, BaseMessage, HumanMessage, SystemMessage } from '@langchain/core/messages';
+import type { MessageContentImageUrl } from '@langchain/core/messages';
+import type { MessageContentComplex, TPayload } from '@/types';
+import { Providers } from '@/common';
+interface MediaMessageParams {
+    message: {
+        role: string;
+        content: string;
+        name?: string;
+        [key: string]: any;
+    };
+    mediaParts: MessageContentComplex[];
+    endpoint?: Providers;
+}
+/**
+ * Formats a message with media content (images, documents, videos, audios) to API payload format.
+ *
+ * @param params - The parameters for formatting.
+ * @returns - The formatted message.
+ */
+export declare const formatMediaMessage: ({ message, endpoint, mediaParts, }: MediaMessageParams) => {
+    role: string;
+    content: MessageContentComplex[];
+    name?: string;
+    [key: string]: any;
+};
+interface MessageInput {
+    role?: string;
+    _name?: string;
+    sender?: string;
+    text?: string;
+    content?: string | MessageContentComplex[];
+    image_urls?: MessageContentImageUrl[];
+    documents?: MessageContentComplex[];
+    videos?: MessageContentComplex[];
+    audios?: MessageContentComplex[];
+    lc_id?: string[];
+    [key: string]: any;
+}
+interface FormatMessageParams {
+    message: MessageInput;
+    userName?: string;
+    assistantName?: string;
+    endpoint?: Providers;
+    langChain?: boolean;
+}
+interface FormattedMessage {
+    role: string;
+    content: string | MessageContentComplex[];
+    name?: string;
+    [key: string]: any;
+}
+/**
+ * Formats a message to OpenAI payload format based on the provided options.
+ *
+ * @param params - The parameters for formatting.
+ * @returns - The formatted message.
+ */
+export declare const formatMessage: ({ message, userName, endpoint, assistantName, langChain, }: FormatMessageParams) => FormattedMessage | HumanMessage | AIMessage | SystemMessage;
+/**
+ * Formats an array of messages for LangChain.
+ *
+ * @param messages - The array of messages to format.
+ * @param formatOptions - The options for formatting each message.
+ * @returns - The array of formatted LangChain messages.
+ */
+export declare const formatLangChainMessages: (messages: Array<MessageInput>, formatOptions: Omit<FormatMessageParams, "message" | "langChain">) => Array<HumanMessage | AIMessage | SystemMessage>;
+interface LangChainMessage {
+    lc_kwargs?: {
+        additional_kwargs?: Record<string, any>;
+        [key: string]: any;
+    };
+    kwargs?: {
+        additional_kwargs?: Record<string, any>;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+/**
+ * Formats a LangChain message object by merging properties from `lc_kwargs` or `kwargs` and `additional_kwargs`.
+ *
+ * @param message - The message object to format.
+ * @returns - The formatted LangChain message.
+ */
+export declare const formatFromLangChain: (message: LangChainMessage) => Record<string, any>;
+/**
+ * Groups content parts by agent and formats them with agent labels
+ * This preprocesses multi-agent content to prevent identity confusion
+ *
+ * @param contentParts - The content parts from a run
+ * @param agentIdMap - Map of content part index to agent ID
+ * @param agentNames - Optional map of agent ID to display name
+ * @param options - Configuration options
+ * @param options.labelNonTransferContent - If true, labels all agent transitions (for parallel patterns)
+ * @returns Modified content parts with agent labels where appropriate
+ */
+export declare const labelContentByAgent: (contentParts: MessageContentComplex[], agentIdMap?: Record<number, string>, agentNames?: Record<string, string>, options?: {
+    labelNonTransferContent?: boolean;
+}) => MessageContentComplex[];
+/**
+ * Formats an array of messages for LangChain, handling tool calls and creating ToolMessage instances.
+ *
+ * @param payload - The array of messages to format.
+ * @param indexTokenCountMap - Optional map of message indices to token counts.
+ * @param tools - Optional set of tool names that are allowed in the request.
+ * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
+ */
+export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap?: Record<number, number | undefined>, tools?: Set<string>) => {
+    messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
+    indexTokenCountMap?: Record<number, number>;
+};
+/**
+ * Adds a value at key 0 for system messages and shifts all key indices by one in an indexTokenCountMap.
+ * This is useful when adding a system message at the beginning of a conversation.
+ *
+ * @param indexTokenCountMap - The original map of message indices to token counts
+ * @param instructionsTokenCount - The token count for the system message to add at index 0
+ * @returns A new map with the system message at index 0 and all other indices shifted by 1
+ */
+export declare function shiftIndexTokenCountMap(indexTokenCountMap: Record<number, number>, instructionsTokenCount: number): Record<number, number>;
+/**
+ * Ensures compatibility when switching from a non-thinking agent to a thinking-enabled agent.
+ * Converts AI messages with tool calls (that lack thinking/reasoning blocks) into buffer strings,
+ * avoiding the thinking block signature requirement.
+ *
+ * Recognizes the following as valid thinking/reasoning blocks:
+ * - ContentTypes.THINKING (Anthropic)
+ * - ContentTypes.REASONING_CONTENT (Bedrock)
+ * - ContentTypes.REASONING (VertexAI / Google)
+ * - 'redacted_thinking'
+ *
+ * @param messages - Array of messages to process
+ * @param provider - The provider being used (unused but kept for future compatibility)
+ * @returns The messages array with tool sequences converted to buffer strings if necessary
+ */
+export declare function ensureThinkingBlockInMessages(messages: BaseMessage[], _provider: Providers): BaseMessage[];
+export {};

package/dist/types/messages/ids.d.ts

@@ -0,0 +1,3 @@
+import type { Graph } from '@/graphs';
+import type * as t from '@/types';
+export declare const getMessageId: (stepKey: string, graph: Graph<t.BaseGraphState>, returnExistingId?: boolean) => string | undefined;

package/dist/types/messages/index.d.ts

@@ -0,0 +1,7 @@
+export * from './core';
+export * from './ids';
+export * from './prune';
+export * from './format';
+export * from './cache';
+export * from './content';
+export * from './tools';

package/dist/types/messages/prune.d.ts

@@ -0,0 +1,52 @@
+import { BaseMessage, UsageMetadata } from '@langchain/core/messages';
+import type { TokenCounter } from '@/types/run';
+import { ContentTypes, Providers } from '@/common';
+export type PruneMessagesFactoryParams = {
+    provider?: Providers;
+    maxTokens: number;
+    startIndex: number;
+    tokenCounter: TokenCounter;
+    indexTokenCountMap: Record<string, number | undefined>;
+    thinkingEnabled?: boolean;
+};
+export type PruneMessagesParams = {
+    messages: BaseMessage[];
+    usageMetadata?: Partial<UsageMetadata>;
+    startType?: ReturnType<BaseMessage['getType']>;
+};
+/**
+ * Calculates the total tokens from a single usage object
+ *
+ * @param usage The usage metadata object containing token information
+ * @returns An object containing the total input and output tokens
+ */
+export declare function calculateTotalTokens(usage: Partial<UsageMetadata>): UsageMetadata;
+export type PruningResult = {
+    context: BaseMessage[];
+    remainingContextTokens: number;
+    messagesToRefine: BaseMessage[];
+    thinkingStartIndex?: number;
+};
+/**
+ * Processes an array of messages and returns a context of messages that fit within a specified token limit.
+ * It iterates over the messages from newest to oldest, adding them to the context until the token limit is reached.
+ *
+ * @param options Configuration options for processing messages
+ * @returns Object containing the message context, remaining tokens, messages not included, and summary index
+ */
+export declare function getMessagesWithinTokenLimit({ messages: _messages, maxContextTokens, indexTokenCountMap, startType: _startType, thinkingEnabled, tokenCounter, thinkingStartIndex: _thinkingStartIndex, reasoningType, }: {
+    messages: BaseMessage[];
+    maxContextTokens: number;
+    indexTokenCountMap: Record<string, number | undefined>;
+    startType?: string | string[];
+    thinkingEnabled?: boolean;
+    tokenCounter: TokenCounter;
+    thinkingStartIndex?: number;
+    reasoningType?: ContentTypes.THINKING | ContentTypes.REASONING_CONTENT;
+}): PruningResult;
+export declare function checkValidNumber(value: unknown): value is number;
+export declare function createPruneMessages(factoryParams: PruneMessagesFactoryParams): (params: PruneMessagesParams) => {
+    context: BaseMessage[];
+    indexTokenCountMap: Record<string, number | undefined>;
+    messagesToRefine: BaseMessage[];
+};

package/dist/types/messages/reducer.d.ts

@@ -0,0 +1,9 @@
+import { BaseMessage, BaseMessageLike } from '@langchain/core/messages';
+export declare const REMOVE_ALL_MESSAGES = "__remove_all__";
+export type Messages = Array<BaseMessage | BaseMessageLike> | BaseMessage | BaseMessageLike;
+/**
+ * Prebuilt reducer that combines returned messages.
+ * Can handle standard messages and special modifiers like {@link RemoveMessage}
+ * instances.
+ */
+export declare function messagesStateReducer(left: Messages, right: Messages): BaseMessage[];

package/dist/types/messages/tools.d.ts

@@ -0,0 +1,17 @@
+import type { BaseMessage } from '@langchain/core/messages';
+/**
+ * Extracts discovered tool names from tool search results in the current turn.
+ * Only processes tool search messages after the latest AI message with tool calls.
+ *
+ * Similar pattern to formatArtifactPayload - finds relevant messages efficiently
+ * by identifying the latest AI parent and only processing subsequent tool messages.
+ *
+ * @param messages - All messages in the conversation
+ * @returns Array of discovered tool names (empty if no new discoveries)
+ */
+export declare function extractToolDiscoveries(messages: BaseMessage[]): string[];
+/**
+ * Checks if the current turn has any tool search results.
+ * Quick check to avoid full extraction when not needed.
+ */
+export declare function hasToolSearchInCurrentTurn(messages: BaseMessage[]): boolean;

package/dist/types/mockStream.d.ts

@@ -0,0 +1,32 @@
+import type * as t from '@/types';
+export declare const createMockStream: (options?: {
+    text?: string;
+    reasoningText?: string;
+    streamRate?: number;
+    reasoningKey?: "reasoning" | "reasoning_content";
+}) => () => AsyncGenerator<t.CustomChunk>;
+/**
+(async function testStream(): Promise<void> {
+  const runId = nanoid();
+
+  const streamHandler = new SplitStreamHandler({
+    runId,
+    handlers: {
+      [GraphEvents.ON_RUN_STEP]: (data): void => {
+        console.dir(data, { depth: null });
+      },
+      [GraphEvents.ON_MESSAGE_DELTA]: (): void => {
+        // console.dir(data, { depth: null });
+      },
+    },
+  });
+  const stream = createMockStream({
+    reasoningText: 'This is a test reasoning text.',
+    streamRate: 5,
+  })();
+
+  for await (const chunk of stream) {
+    streamHandler.handle(chunk);
+  }
+})();
+ */ 

package/dist/types/prompts/collab.d.ts

@@ -0,0 +1 @@
+export declare const supervisorPrompt = "You are a supervisor tasked with managing a conversation between the\nfollowing workers: {members}. Given the following user request,\nrespond with the worker to act next. Each worker will perform a\ntask and respond with their results and status. Multiple workers can work at once, and they can use multiple tools at once. Each worker can run their tools multiple times per task. When finished,\nrespond with FINISH.";

package/dist/types/prompts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './collab';
+export * from './taskmanager';