illuma-agents 1.0.2

package/dist/types/types/graph.d.ts

@@ -0,0 +1,138 @@
+import type { StateGraphArgs, StateGraph, CompiledStateGraph } from '@langchain/langgraph';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { BaseMessage, AIMessageChunk } from '@langchain/core/messages';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { GoogleAIToolType } from '@langchain/google-common';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ToolMap, GenericTool } from '@/types/tools';
+import type { ClientOptions } from '@/types/llm';
+import type { Providers } from '@/common';
+import type { Graph } from '@/graphs';
+export type BaseGraphState = {
+    messages: BaseMessage[];
+};
+export type IState = BaseGraphState;
+export interface EventHandler {
+    handle(event: string, data: StreamEventData | ModelEndData, metadata?: Record<string, unknown>, graph?: Graph): void;
+}
+export type GraphStateChannels<T extends BaseGraphState> = StateGraphArgs<T>['channels'];
+export type Workflow<T extends BaseGraphState = BaseGraphState, U extends Partial<T> = Partial<T>, N extends string = string> = StateGraph<T, U, N>;
+export type CompiledWorkflow<T extends BaseGraphState = BaseGraphState, U extends Partial<T> = Partial<T>, N extends string = string> = CompiledStateGraph<T, U, N>;
+export type EventStreamCallbackHandlerInput = Parameters<CompiledWorkflow['streamEvents']>[2] extends Omit<infer T, 'autoClose'> ? T : never;
+export type StreamChunk = (ChatGenerationChunk & {
+    message: AIMessageChunk;
+}) | AIMessageChunk;
+/**
+ * Data associated with a StreamEvent.
+ */
+export type StreamEventData = {
+    /**
+     * The input passed to the runnable that generated the event.
+     * Inputs will sometimes be available at the *START* of the runnable, and
+     * sometimes at the *END* of the runnable.
+     * If a runnable is able to stream its inputs, then its input by definition
+     * won't be known until the *END* of the runnable when it has finished streaming
+     * its inputs.
+     */
+    input?: unknown;
+    /**
+     * The output of the runnable that generated the event.
+     * Outputs will only be available at the *END* of the runnable.
+     * For most runnables, this field can be inferred from the `chunk` field,
+     * though there might be some exceptions for special cased runnables (e.g., like
+     * chat models), which may return more information.
+     */
+    output?: unknown;
+    /**
+     * A streaming chunk from the output that generated the event.
+     * chunks support addition in general, and adding them up should result
+     * in the output of the runnable that generated the event.
+     */
+    chunk?: StreamChunk;
+    /**
+     * Runnable config for invoking other runnables within handlers.
+     */
+    config?: RunnableConfig;
+    /**
+     * Custom result from the runnable that generated the event.
+     */
+    result?: unknown;
+};
+/**
+ * A streaming event.
+ *
+ * Schema of a streaming event which is produced from the streamEvents method.
+ */
+export type StreamEvent = {
+    /**
+     * Event names are of the format: on_[runnable_type]_(start|stream|end).
+     *
+     * Runnable types are one of:
+     * - llm - used by non chat models
+     * - chat_model - used by chat models
+     * - prompt --  e.g., ChatPromptTemplate
+     * - tool -- LangChain tools
+     * - chain - most Runnables are of this type
+     *
+     * Further, the events are categorized as one of:
+     * - start - when the runnable starts
+     * - stream - when the runnable is streaming
+     * - end - when the runnable ends
+     *
+     * start, stream and end are associated with slightly different `data` payload.
+     *
+     * Please see the documentation for `EventData` for more details.
+     */
+    event: string;
+    /** The name of the runnable that generated the event. */
+    name: string;
+    /**
+     * An randomly generated ID to keep track of the execution of the given runnable.
+     *
+     * Each child runnable that gets invoked as part of the execution of a parent runnable
+     * is assigned its own unique ID.
+     */
+    run_id: string;
+    /**
+     * Tags associated with the runnable that generated this event.
+     * Tags are always inherited from parent runnables.
+     */
+    tags?: string[];
+    /** Metadata associated with the runnable that generated this event. */
+    metadata: Record<string, unknown>;
+    /**
+     * Event data.
+     *
+     * The contents of the event data depend on the event type.
+     */
+    data: StreamEventData;
+};
+export type GraphConfig = {
+    provider: string;
+    thread_id?: string;
+    run_id?: string;
+};
+export type PartMetadata = {
+    progress?: number;
+    asset_pointer?: string;
+    status?: string;
+    action?: boolean;
+    output?: string;
+};
+export type ModelEndData = (StreamEventData & {
+    output: AIMessageChunk | undefined;
+}) | undefined;
+export type GraphTools = GenericTool[] | BindToolsInput[] | GoogleAIToolType[];
+export type StandardGraphInput = {
+    runId?: string;
+    toolEnd?: boolean;
+    toolMap?: ToolMap;
+    provider: Providers;
+    signal?: AbortSignal;
+    instructions?: string;
+    streamBuffer?: number;
+    clientOptions: ClientOptions;
+    additional_instructions?: string;
+    reasoningKey?: 'reasoning_content' | 'reasoning';
+    tools?: GraphTools;
+};

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

@@ -0,0 +1,5 @@
+export * from './graph';
+export * from './llm';
+export * from './run';
+export * from './stream';
+export * from './tools';

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

@@ -0,0 +1,102 @@
+import { ChatOllama } from '@langchain/ollama';
+import { ChatAnthropic } from '@langchain/anthropic';
+import { ChatMistralAI } from '@langchain/mistralai';
+import { ChatBedrockConverse } from '@langchain/aws';
+import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
+import type { BindToolsInput, BaseChatModelParams } from '@langchain/core/language_models/chat_models';
+import type { OpenAIChatInput, ChatOpenAIFields, AzureOpenAIInput, ClientOptions as OAIClientOptions } from '@langchain/openai';
+import type { BedrockChatFields } from '@langchain/community/chat_models/bedrock/web';
+import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
+import type { GeminiGenerationConfig } from '@langchain/google-common';
+import type { ChatVertexAIInput } from '@langchain/google-vertexai';
+import type { ChatDeepSeekCallOptions } from '@langchain/deepseek';
+import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
+import type { ChatBedrockConverseInput } from '@langchain/aws';
+import type { ChatMistralAIInput } from '@langchain/mistralai';
+import type { RequestOptions } from '@google/generative-ai';
+import type { StructuredTool } from '@langchain/core/tools';
+import type { AnthropicInput } from '@langchain/anthropic';
+import type { Runnable } from '@langchain/core/runnables';
+import type { ChatOllamaInput } from '@langchain/ollama';
+import type { OpenAI as OpenAIClient } from 'openai';
+import type { ChatXAIInput } from '@langchain/xai';
+import { AzureChatOpenAI, ChatDeepSeek, ChatOpenAI, ChatXAI } from '@/llm/openai';
+import { CustomChatGoogleGenerativeAI } from '@/llm/google';
+import { ChatOpenRouter } from '@/llm/openrouter';
+import { ChatVertexAI } from '@/llm/vertexai';
+import { Providers } from '@/common';
+export type AzureClientOptions = Partial<OpenAIChatInput> & Partial<AzureOpenAIInput> & {
+    openAIApiKey?: string;
+    openAIApiVersion?: string;
+    openAIBasePath?: string;
+    deploymentName?: string;
+} & BaseChatModelParams & {
+    configuration?: OAIClientOptions;
+};
+export type ThinkingConfig = AnthropicInput['thinking'];
+export type ChatOpenAIToolType = BindToolsInput | OpenAIClient.ChatCompletionTool;
+export type CommonToolType = StructuredTool | ChatOpenAIToolType;
+export type AnthropicReasoning = {
+    thinking?: ThinkingConfig | boolean;
+    thinkingBudget?: number;
+};
+export type OpenAIClientOptions = ChatOpenAIFields;
+export type OllamaClientOptions = ChatOllamaInput;
+export type AnthropicClientOptions = AnthropicInput;
+export type MistralAIClientOptions = ChatMistralAIInput;
+export type VertexAIClientOptions = ChatVertexAIInput & {
+    includeThoughts?: boolean;
+};
+export type BedrockClientOptions = BedrockChatFields;
+export type BedrockAnthropicInput = ChatBedrockConverseInput & {
+    additionalModelRequestFields?: ChatBedrockConverseInput['additionalModelRequestFields'] & AnthropicReasoning;
+};
+export type BedrockConverseClientOptions = ChatBedrockConverseInput;
+export type GoogleClientOptions = GoogleGenerativeAIChatInput & {
+    customHeaders?: RequestOptions['customHeaders'];
+    thinkingConfig?: GeminiGenerationConfig['thinkingConfig'];
+};
+export type DeepSeekClientOptions = ChatDeepSeekCallOptions;
+export type XAIClientOptions = ChatXAIInput;
+export type ClientOptions = OpenAIClientOptions | AzureClientOptions | OllamaClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions | GoogleClientOptions | DeepSeekClientOptions | XAIClientOptions;
+export type SharedLLMConfig = {
+    provider: Providers;
+};
+export type LLMConfig = SharedLLMConfig & ClientOptions;
+export type ProviderOptionsMap = {
+    [Providers.AZURE]: AzureClientOptions;
+    [Providers.OPENAI]: OpenAIClientOptions;
+    [Providers.OLLAMA]: OllamaClientOptions;
+    [Providers.GOOGLE]: GoogleClientOptions;
+    [Providers.VERTEXAI]: VertexAIClientOptions;
+    [Providers.DEEPSEEK]: DeepSeekClientOptions;
+    [Providers.ANTHROPIC]: AnthropicClientOptions;
+    [Providers.MISTRALAI]: MistralAIClientOptions;
+    [Providers.MISTRAL]: MistralAIClientOptions;
+    [Providers.OPENROUTER]: ChatOpenRouterCallOptions;
+    [Providers.BEDROCK_LEGACY]: BedrockClientOptions;
+    [Providers.BEDROCK]: BedrockConverseClientOptions;
+    [Providers.XAI]: XAIClientOptions;
+};
+export type ChatModelMap = {
+    [Providers.XAI]: ChatXAI;
+    [Providers.OPENAI]: ChatOpenAI;
+    [Providers.OLLAMA]: ChatOllama;
+    [Providers.AZURE]: AzureChatOpenAI;
+    [Providers.DEEPSEEK]: ChatDeepSeek;
+    [Providers.VERTEXAI]: ChatVertexAI;
+    [Providers.ANTHROPIC]: ChatAnthropic;
+    [Providers.MISTRALAI]: ChatMistralAI;
+    [Providers.MISTRAL]: ChatMistralAI;
+    [Providers.OPENROUTER]: ChatOpenRouter;
+    [Providers.BEDROCK_LEGACY]: BedrockChat;
+    [Providers.BEDROCK]: ChatBedrockConverse;
+    [Providers.GOOGLE]: CustomChatGoogleGenerativeAI;
+};
+export type ChatModelConstructorMap = {
+    [P in Providers]: new (config: ProviderOptionsMap[P]) => ChatModelMap[P];
+};
+export type ChatModelInstance = ChatModelMap[Providers];
+export type ModelWithTools = ChatModelInstance & {
+    bindTools(tools: CommonToolType[]): Runnable;
+};

package/dist/types/types/run.d.ts

@@ -0,0 +1,74 @@
+import type * as z from 'zod';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { StructuredTool } from '@langchain/core/tools';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { BaseCallbackHandler, CallbackHandlerMethods } from '@langchain/core/callbacks/base';
+import type * as graph from '@/graphs/Graph';
+import type * as s from '@/types/stream';
+import type * as e from '@/common/enum';
+import type * as g from '@/types/graph';
+import type * as l from '@/types/llm';
+export type ZodObjectAny = z.ZodObject<any, any, any, any>;
+export type BaseGraphConfig = {
+    type?: 'standard';
+    llmConfig: l.LLMConfig;
+    provider?: e.Providers;
+    clientOptions?: l.ClientOptions;
+};
+export type StandardGraphConfig = BaseGraphConfig & Omit<g.StandardGraphInput, 'provider' | 'clientOptions'>;
+export type RunTitleOptions = {
+    inputText: string;
+    provider: e.Providers;
+    contentParts: (s.MessageContentComplex | undefined)[];
+    titlePrompt?: string;
+    skipLanguage?: boolean;
+    clientOptions?: l.ClientOptions;
+    chainOptions?: Partial<RunnableConfig> | undefined;
+    omitOptions?: Set<string>;
+    titleMethod?: e.TitleMethod;
+    titlePromptTemplate?: string;
+};
+export interface AgentStateChannels {
+    messages: BaseMessage[];
+    next: string;
+    [key: string]: unknown;
+    instructions?: string;
+    additional_instructions?: string;
+}
+export interface Member {
+    name: string;
+    systemPrompt: string;
+    tools: StructuredTool[];
+    llmConfig: l.LLMConfig;
+}
+export type CollaborativeGraphConfig = {
+    type: 'collaborative';
+    members: Member[];
+    supervisorConfig: {
+        systemPrompt?: string;
+        llmConfig: l.LLMConfig;
+    };
+};
+export type TaskManagerGraphConfig = {
+    type: 'taskmanager';
+    members: Member[];
+    supervisorConfig: {
+        systemPrompt?: string;
+        llmConfig: l.LLMConfig;
+    };
+};
+export type RunConfig = {
+    runId: string;
+    graphConfig: StandardGraphConfig | CollaborativeGraphConfig | TaskManagerGraphConfig;
+    customHandlers?: Record<string, g.EventHandler>;
+    returnContent?: boolean;
+};
+export type ProvidedCallbacks = (BaseCallbackHandler | CallbackHandlerMethods)[] | undefined;
+export type TokenCounter = (message: BaseMessage) => number;
+export type EventStreamOptions = {
+    callbacks?: graph.ClientCallbacks;
+    keepContent?: boolean;
+    maxContextTokens?: number;
+    tokenCounter?: TokenCounter;
+    indexTokenCountMap?: Record<string, number>;
+};

package/dist/types/types/stream.d.ts

@@ -0,0 +1,293 @@
+import type OpenAITypes from 'openai';
+import type { MessageContentImageUrl, MessageContentText, ToolMessage, BaseMessage } from '@langchain/core/messages';
+import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
+import type { LLMResult, Generation } from '@langchain/core/outputs';
+import type { AnthropicContentBlock } from '@/llm/anthropic/types';
+import type { ToolEndEvent } from '@/types/tools';
+import { StepTypes, ContentTypes, GraphEvents } from '@/common/enum';
+export type HandleLLMEnd = (output: LLMResult, runId: string, parentRunId?: string, tags?: string[]) => void;
+export type MetadataAggregatorResult = {
+    handleLLMEnd: HandleLLMEnd;
+    collected: Record<string, unknown>[];
+};
+export type StreamGeneration = Generation & {
+    text?: string;
+    message?: BaseMessage;
+};
+/** Event names are of the format: on_[runnable_type]_(start|stream|end).
+
+Runnable types are one of:
+
+llm - used by non chat models
+chat_model - used by chat models
+prompt -- e.g., ChatPromptTemplate
+tool -- LangChain tools
+chain - most Runnables are of this type
+Further, the events are categorized as one of:
+
+start - when the runnable starts
+stream - when the runnable is streaming
+end - when the runnable ends
+start, stream and end are associated with slightly different data payload.
+
+Please see the documentation for EventData for more details. */
+export type EventName = string;
+export type RunStep = {
+    type: StepTypes;
+    id: string;
+    runId?: string;
+    index: number;
+    stepIndex?: number;
+    stepDetails: StepDetails;
+    usage?: null | object;
+};
+/**
+ * Represents a run step delta i.e. any changed fields on a run step during
+ * streaming.
+ */
+export interface RunStepDeltaEvent {
+    /**
+     * The identifier of the run step, which can be referenced in API endpoints.
+     */
+    id: string;
+    /**
+     * The delta containing the fields that have changed on the run step.
+     */
+    delta: ToolCallDelta;
+}
+export type StepDetails = MessageCreationDetails | ToolCallsDetails;
+export type StepCompleted = ToolCallCompleted;
+export type MessageCreationDetails = {
+    type: StepTypes.MESSAGE_CREATION;
+    message_creation: {
+        message_id: string;
+    };
+};
+export type ToolEndData = {
+    input: string | Record<string, unknown>;
+    output?: ToolMessage;
+};
+export type ToolErrorData = {
+    id: string;
+    name: string;
+    error?: Error;
+} & Pick<ToolEndData, 'input'>;
+export type ToolEndCallback = (data: ToolEndData, metadata?: Record<string, unknown>) => void;
+export type ProcessedToolCall = {
+    name: string;
+    args: string | Record<string, unknown>;
+    id: string;
+    output: string;
+    progress: number;
+};
+export type ProcessedContent = {
+    type: ContentType;
+    text?: string;
+    tool_call?: ProcessedToolCall;
+};
+export type ToolCallCompleted = {
+    type: 'tool_call';
+    tool_call: ProcessedToolCall;
+};
+export type ToolCompleteEvent = ToolCallCompleted & {
+    /** The Step Id of the Tool Call */
+    id: string;
+    /** The content index of the tool call */
+    index: number;
+    type: 'tool_call';
+};
+export type ToolCallsDetails = {
+    type: StepTypes.TOOL_CALLS;
+    tool_calls?: AgentToolCall[];
+};
+export type ToolCallDelta = {
+    type: StepTypes;
+    tool_calls?: ToolCallChunk[];
+};
+export type AgentToolCall = {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string | object;
+    };
+} | ToolCall;
+export interface ExtendedMessageContent {
+    type?: string;
+    text?: string;
+    input?: string;
+    index?: number;
+    id?: string;
+    name?: string;
+}
+export type AgentUpdate = {
+    type: ContentTypes.AGENT_UPDATE;
+    agent_update: {
+        index: number;
+        runId: string;
+        agentId: string;
+    };
+};
+/**
+ * Represents a message delta i.e. any changed fields on a message during
+ * streaming.
+ */
+export interface MessageDeltaEvent {
+    /**
+     * The identifier of the message, which can be referenced in API endpoints.
+     */
+    id: string;
+    /**
+     * The delta containing the fields that have changed on the Message.
+     */
+    delta: MessageDelta;
+}
+/**
+ * The delta containing the fields that have changed on the Message.
+ */
+export interface MessageDelta {
+    /**
+     * The content of the message in array of text and/or images.
+     */
+    content?: MessageContentComplex[];
+    /**
+     * The tool call ids associated with the message.
+     */
+    tool_call_ids?: string[];
+}
+/**
+ * Represents a reasoning delta i.e. any changed fields on a message during
+ * streaming.
+ */
+export interface ReasoningDeltaEvent {
+    /**
+     * The identifier of the message, which can be referenced in API endpoints.
+     */
+    id: string;
+    /**
+     * The delta containing the fields that have changed.
+     */
+    delta: ReasoningDelta;
+}
+/**
+ * The reasoning delta containing the fields that have changed on the Message.
+ */
+export interface ReasoningDelta {
+    /**
+     * The content of the message in array of text and/or images.
+     */
+    content?: MessageContentComplex[];
+}
+export type MessageDeltaUpdate = {
+    type: ContentTypes.TEXT;
+    text: string;
+    tool_call_ids?: string[];
+};
+export type ReasoningDeltaUpdate = {
+    type: ContentTypes.THINK;
+    think: string;
+};
+export type ContentType = 'text' | 'image_url' | 'tool_call' | 'think' | string;
+export type ReasoningContentText = {
+    type: ContentTypes.THINK;
+    think: string;
+};
+/** Vertex AI / Google Common - Reasoning Content Block Format */
+export type GoogleReasoningContentText = {
+    type: ContentTypes.REASONING;
+    reasoning: string;
+};
+/** Anthropic's Reasoning Content Block Format */
+export type ThinkingContentText = {
+    type: ContentTypes.THINKING;
+    index?: number;
+    signature?: string;
+    thinking?: string;
+};
+/** Bedrock's Reasoning Content Block Format */
+export type BedrockReasoningContentText = {
+    type: ContentTypes.REASONING_CONTENT;
+    index?: number;
+    reasoningText: {
+        text?: string;
+        signature?: string;
+    };
+};
+/**
+ * A call to a tool.
+ */
+export type ToolCallPart = {
+    /** Type ("tool_call") according to Assistants Tool Call Structure */
+    type: ContentTypes.TOOL_CALL;
+    /** The name of the tool to be called */
+    name: string;
+    /** The arguments to the tool call */
+    args?: string | Record<string, any>;
+    /** If provided, an identifier associated with the tool call */
+    id?: string;
+    /** If provided, the output of the tool call */
+    output?: string;
+    /** Auth URL */
+    auth?: string;
+    /** Expiration time */
+    expires_at?: number;
+};
+export type ToolCallContent = {
+    type: ContentTypes.TOOL_CALL;
+    tool_call?: ToolCallPart;
+};
+export type ToolResultContent = {
+    content: string | Record<string, unknown> | Array<string | Record<string, unknown>> | AnthropicContentBlock[];
+    type: 'tool_result' | 'web_search_result' | 'web_search_tool_result';
+    tool_use_id?: string;
+    input?: string | Record<string, unknown>;
+    index?: number;
+};
+export type MessageContentComplex = (ToolResultContent | ThinkingContentText | AgentUpdate | ToolCallContent | ReasoningContentText | MessageContentText | MessageContentImageUrl | (Record<string, any> & {
+    type?: 'text' | 'image_url' | 'think' | 'thinking' | string;
+}) | (Record<string, any> & {
+    type?: never;
+})) & {
+    tool_call_ids?: string[];
+};
+export interface TMessage {
+    role?: string;
+    content?: MessageContentComplex[] | string;
+    [key: string]: unknown;
+}
+export type TPayload = Array<Partial<TMessage>>;
+export type CustomChunkDelta = null | undefined | (Partial<OpenAITypes.Chat.Completions.ChatCompletionChunk.Choice.Delta> & {
+    reasoning?: string | null;
+    reasoning_content?: string | null;
+});
+export type CustomChunkChoice = Partial<Omit<OpenAITypes.Chat.Completions.ChatCompletionChunk.Choice, 'delta'> & {
+    delta?: CustomChunkDelta;
+}>;
+export type CustomChunk = Partial<OpenAITypes.ChatCompletionChunk> & {
+    choices?: Partial<Array<CustomChunkChoice>>;
+};
+export type SplitStreamHandlers = Partial<{
+    [GraphEvents.ON_RUN_STEP]: ({ event, data, }: {
+        event: GraphEvents;
+        data: RunStep;
+    }) => void;
+    [GraphEvents.ON_MESSAGE_DELTA]: ({ event, data, }: {
+        event: GraphEvents;
+        data: MessageDeltaEvent;
+    }) => void;
+    [GraphEvents.ON_REASONING_DELTA]: ({ event, data, }: {
+        event: GraphEvents;
+        data: ReasoningDeltaEvent;
+    }) => void;
+}>;
+export type ContentAggregator = ({ event, data, }: {
+    event: GraphEvents;
+    data: RunStep | MessageDeltaEvent | RunStepDeltaEvent | {
+        result: ToolEndEvent;
+    };
+}) => void;
+export type ContentAggregatorResult = {
+    stepMap: Map<string, RunStep | undefined>;
+    contentParts: Array<MessageContentComplex | undefined>;
+    aggregateContent: ContentAggregator;
+};

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

@@ -0,0 +1,61 @@
+import type { StructuredToolInterface } from '@langchain/core/tools';
+import type { RunnableToolLike } from '@langchain/core/runnables';
+import type { ToolCall } from '@langchain/core/messages/tool';
+import type { ToolErrorData } from './stream';
+import { EnvVar } from '@/common';
+/** Replacement type for `import type { ToolCall } from '@langchain/core/messages/tool'` in order to have stringified args typed */
+export type CustomToolCall = {
+    name: string;
+    args: string | Record<string, any>;
+    id?: string;
+    type?: 'tool_call';
+    output?: string;
+};
+export type GenericTool = StructuredToolInterface | RunnableToolLike;
+export type ToolMap = Map<string, GenericTool>;
+export type ToolRefs = {
+    tools: GenericTool[];
+    toolMap?: ToolMap;
+};
+export type ToolRefGenerator = (tool_calls: ToolCall[]) => ToolRefs;
+export type ToolNodeOptions = {
+    name?: string;
+    tags?: string[];
+    handleToolErrors?: boolean;
+    loadRuntimeTools?: ToolRefGenerator;
+    toolCallStepIds?: Map<string, string>;
+    errorHandler?: (data: ToolErrorData, metadata?: Record<string, unknown>) => void;
+};
+export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
+export type ToolEndEvent = {
+    /** The Step Id of the Tool Call */
+    id: string;
+    /** The Completed Tool Call */
+    tool_call: ToolCall;
+    /** The content index of the tool call */
+    index: number;
+};
+export type CodeEnvFile = {
+    id: string;
+    name: string;
+    session_id: string;
+};
+export type CodeExecutionToolParams = undefined | {
+    session_id?: string;
+    user_id?: string;
+    apiKey?: string;
+    files?: CodeEnvFile[];
+    [EnvVar.CODE_API_KEY]?: string;
+};
+export type FileRef = {
+    id: string;
+    name: string;
+    path?: string;
+};
+export type FileRefs = FileRef[];
+export type ExecuteResult = {
+    session_id: string;
+    stdout: string;
+    stderr: string;
+    files?: FileRefs;
+};

package/dist/types/utils/graph.d.ts

@@ -0,0 +1,2 @@
+export declare const resetIfNotEmpty: <T>(value: T, resetValue: T) => T;
+export declare const joinKeys: (args: (string | number | undefined)[]) => string;

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

@@ -0,0 +1,5 @@
+export * from './graph';
+export * from './llm';
+export * from './misc';
+export * from './run';
+export * from './tokens';

package/dist/types/utils/llm.d.ts

@@ -0,0 +1,3 @@
+import { Providers } from '@/common';
+export declare function isOpenAILike(provider?: string | Providers): boolean;
+export declare function isGoogleLike(provider?: string | Providers): boolean;