@illuma-ai/agents 1.0.81

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

@@ -0,0 +1,308 @@
+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 { Command } from '@langchain/langgraph';
+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;
+    agentId?: string;
+    /**
+     * Group ID - incrementing number (1, 2, 3...) reflecting execution order.
+     * Agents with the same groupId run in parallel and should be rendered together.
+     * undefined means the agent runs sequentially (not part of any parallel group).
+     *
+     * Example for: researcher -> [analyst1, analyst2, analyst3] -> summarizer
+     * - researcher: undefined (sequential)
+     * - analyst1, analyst2, analyst3: 1 (first parallel group)
+     * - summarizer: undefined (sequential)
+     */
+    groupId?: number;
+    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 | Command;
+};
+export type ToolErrorData = {
+    id: string;
+    name: string;
+    error?: Error;
+} & Pick<ToolEndData, 'input'>;
+export type ToolEndCallback = (data: ToolEndData, metadata?: Record<string, unknown>) => Promise<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[];
+    agentId?: string;
+    groupId?: number;
+};
+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,296 @@
+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) & {
+    mcp?: boolean;
+};
+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>) => Promise<void>;
+    /** Tool registry for lazy computation of programmatic tools and tool search */
+    toolRegistry?: LCToolRegistry;
+    /** Reference to Graph's sessions map for automatic session injection */
+    sessions?: ToolSessionMap;
+    /** When true, dispatches ON_TOOL_EXECUTE events instead of invoking tools directly */
+    eventDrivenMode?: boolean;
+    /** Tool definitions for event-driven mode (used for context, not invocation) */
+    toolDefinitions?: Map<string, LCTool>;
+    /** Agent ID for event-driven mode (used to identify which agent's context to use) */
+    agentId?: string;
+};
+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;
+    /** Session ID this file belongs to (for multi-session file tracking) */
+    session_id?: string;
+};
+export type FileRefs = FileRef[];
+export type ExecuteResult = {
+    session_id: string;
+    stdout: string;
+    stderr: string;
+    files?: FileRefs;
+};
+/** JSON Schema type definition for tool parameters */
+export type JsonSchemaType = {
+    type: 'string' | 'number' | 'integer' | 'float' | 'boolean' | 'array' | 'object';
+    enum?: string[];
+    items?: JsonSchemaType;
+    properties?: Record<string, JsonSchemaType>;
+    required?: string[];
+    description?: string;
+    additionalProperties?: boolean | JsonSchemaType;
+};
+/**
+ * Specifies which contexts can invoke a tool (inspired by Anthropic's allowed_callers)
+ * - 'direct': Only callable directly by the LLM (default if omitted)
+ * - 'code_execution': Only callable from within programmatic code execution
+ */
+export type AllowedCaller = 'direct' | 'code_execution';
+/** Tool definition with optional deferred loading and caller restrictions */
+export type LCTool = {
+    name: string;
+    description?: string;
+    parameters?: JsonSchemaType;
+    /** When true, tool is not loaded into context initially (for tool search) */
+    defer_loading?: boolean;
+    /**
+     * Which contexts can invoke this tool.
+     * Default: ['direct'] (only callable directly by LLM)
+     * Options: 'direct', 'code_execution'
+     */
+    allowed_callers?: AllowedCaller[];
+    /** Response format for the tool output */
+    responseFormat?: 'content' | 'content_and_artifact';
+    /** Server name for MCP tools */
+    serverName?: string;
+    /** Tool type classification */
+    toolType?: 'builtin' | 'mcp' | 'action';
+};
+/** Single tool call within a batch request for event-driven execution */
+export type ToolCallRequest = {
+    /** Tool call ID from the LLM */
+    id: string;
+    /** Tool name */
+    name: string;
+    /** Tool arguments */
+    args: Record<string, unknown>;
+    /** Step ID for tracking */
+    stepId?: string;
+    /** Usage turn count for this tool */
+    turn?: number;
+};
+/** Batch request containing ALL tool calls for a graph step */
+export type ToolExecuteBatchRequest = {
+    /** All tool calls from the AIMessage */
+    toolCalls: ToolCallRequest[];
+    /** User ID for context */
+    userId?: string;
+    /** Agent ID for context */
+    agentId?: string;
+    /** Runtime configurable from RunnableConfig (includes user, userMCPAuthMap, etc.) */
+    configurable?: Record<string, unknown>;
+    /** Runtime metadata from RunnableConfig (includes thread_id, run_id, provider, etc.) */
+    metadata?: Record<string, unknown>;
+    /** Promise resolver - handler calls this with ALL results */
+    resolve: (results: ToolExecuteResult[]) => void;
+    /** Promise rejector - handler calls this on fatal error */
+    reject: (error: Error) => void;
+};
+/** Result for a single tool call in event-driven execution */
+export type ToolExecuteResult = {
+    /** Matches ToolCallRequest.id */
+    toolCallId: string;
+    /** Tool output content */
+    content: string | unknown[];
+    /** Optional artifact (for content_and_artifact format) */
+    artifact?: unknown;
+    /** Execution status */
+    status: 'success' | 'error';
+    /** Error message if status is 'error' */
+    errorMessage?: string;
+};
+/** Map of tool names to tool definitions */
+export type LCToolRegistry = Map<string, LCTool>;
+export type ProgrammaticCache = {
+    toolMap: ToolMap;
+    toolDefs: LCTool[];
+};
+/** Search mode: code_interpreter uses external sandbox, local uses safe substring matching */
+export type ToolSearchMode = 'code_interpreter' | 'local';
+/** Parameters for creating a Tool Search tool */
+export type ToolSearchParams = {
+    apiKey?: string;
+    toolRegistry?: LCToolRegistry;
+    onlyDeferred?: boolean;
+    baseUrl?: string;
+    /** Search mode: 'code_interpreter' (default) uses sandbox for regex, 'local' uses safe substring matching */
+    mode?: ToolSearchMode;
+    /** Filter tools to only those from specific MCP server(s). Can be a single name or array of names. */
+    mcpServer?: string | string[];
+    [key: string]: unknown;
+};
+/** Simplified tool metadata for search purposes */
+export type ToolMetadata = {
+    name: string;
+    description: string;
+    parameters?: JsonSchemaType;
+};
+/** Individual search result for a matching tool */
+export type ToolSearchResult = {
+    tool_name: string;
+    match_score: number;
+    matched_field: string;
+    snippet: string;
+};
+/** Response from the tool search operation */
+export type ToolSearchResponse = {
+    tool_references: ToolSearchResult[];
+    total_tools_searched: number;
+    pattern_used: string;
+};
+/** Artifact returned alongside the formatted search results */
+export type ToolSearchArtifact = {
+    tool_references: ToolSearchResult[];
+    metadata: {
+        total_searched: number;
+        pattern: string;
+        error?: string;
+    };
+};
+/**
+ * Tool call requested by the Code API during programmatic execution
+ */
+export type PTCToolCall = {
+    /** Unique ID like "call_001" */
+    id: string;
+    /** Tool name */
+    name: string;
+    /** Input parameters */
+    input: Record<string, any>;
+};
+/**
+ * Tool result sent back to the Code API
+ */
+export type PTCToolResult = {
+    /** Matches PTCToolCall.id */
+    call_id: string;
+    /** Tool execution result (any JSON-serializable value) */
+    result: any;
+    /** Whether tool execution failed */
+    is_error: boolean;
+    /** Error details if is_error=true */
+    error_message?: string;
+};
+/**
+ * Response from the Code API for programmatic execution
+ */
+export type ProgrammaticExecutionResponse = {
+    status: 'tool_call_required' | 'completed' | 'error' | unknown;
+    session_id?: string;
+    /** Present when status='tool_call_required' */
+    continuation_token?: string;
+    tool_calls?: PTCToolCall[];
+    /** Present when status='completed' */
+    stdout?: string;
+    stderr?: string;
+    files?: FileRefs;
+    /** Present when status='error' */
+    error?: string;
+};
+/**
+ * Artifact returned by the PTC tool
+ */
+export type ProgrammaticExecutionArtifact = {
+    session_id?: string;
+    files?: FileRefs;
+};
+/**
+ * Initialization parameters for the PTC tool
+ */
+export type ProgrammaticToolCallingParams = {
+    /** Code API key (or use CODE_API_KEY env var) */
+    apiKey?: string;
+    /** Code API base URL (or use CODE_BASEURL env var) */
+    baseUrl?: string;
+    /** Safety limit for round-trips (default: 20) */
+    maxRoundTrips?: number;
+    /** HTTP proxy URL */
+    proxy?: string;
+    /** Enable debug logging (or set PTC_DEBUG=true env var) */
+    debug?: boolean;
+    /** Environment variable key for API key */
+    [key: string]: unknown;
+};
+/**
+ * Tracks code execution session state for automatic file persistence.
+ * Stored in Graph.sessions and injected into subsequent tool invocations.
+ */
+export type CodeSessionContext = {
+    /** Session ID from the code execution environment */
+    session_id: string;
+    /** Files generated in this session (for context/tracking) */
+    files: FileRefs;
+    /** Timestamp of last update */
+    lastUpdated: number;
+};
+/**
+ * Artifact structure returned by code execution tools (CodeExecutor, PTC).
+ * Used to extract session context after tool completion.
+ */
+export type CodeExecutionArtifact = {
+    session_id?: string;
+    files?: FileRefs;
+};
+/**
+ * Generic session context union type for different tool types.
+ * Extend this as new tool session types are added.
+ */
+export type ToolSessionContext = CodeSessionContext;
+/**
+ * Map of tool names to their session contexts.
+ * Keys are tool constants (e.g., Constants.EXECUTE_CODE, Constants.PROGRAMMATIC_TOOL_CALLING).
+ */
+export type ToolSessionMap = Map<string, ToolSessionContext>;

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

@@ -0,0 +1,37 @@
+/**
+ * Context Analytics Utility
+ *
+ * Provides context analytics data for observability/traces.
+ * No console logging - just data structures for event emission.
+ */
+import type { BaseMessage } from '@langchain/core/messages';
+import type { TokenCounter } from '@/types/run';
+/**
+ * Context analytics data for traces
+ */
+export interface ContextAnalytics {
+    /** Total messages in context */
+    messageCount: number;
+    /** Total tokens in context */
+    totalTokens: number;
+    /** Maximum allowed context tokens */
+    maxContextTokens?: number;
+    /** Instruction/system tokens */
+    instructionTokens?: number;
+    /** Context utilization percentage (0-100) */
+    utilizationPercent?: number;
+    /** Breakdown by message type */
+    breakdown?: Record<string, {
+        tokens: number;
+        percent: number;
+    }>;
+}
+/**
+ * Build context analytics for traces (no logging)
+ */
+export declare function buildContextAnalytics(messages: BaseMessage[], options: {
+    tokenCounter?: TokenCounter;
+    maxContextTokens?: number;
+    instructionTokens?: number;
+    indexTokenCountMap?: Record<string, number | undefined>;
+}): ContextAnalytics;

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

@@ -0,0 +1,6 @@
+import type { RunnableConfig } from '@langchain/core/runnables';
+/**
+ * Safely dispatches a custom event and properly awaits it to avoid
+ * race conditions where events are dispatched after run cleanup.
+ */
+export declare function safeDispatchCustomEvent(event: string, payload: unknown, config?: RunnableConfig): Promise<void>;

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/handlers.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Multi-Agent Handler Utilities
+ *
+ * Provides a simple helper to create handlers with content aggregation for multi-agent scripts.
+ *
+ * Usage:
+ * ```typescript
+ * const { contentParts, aggregateContent, handlers } = createHandlers();
+ *
+ * // With callbacks
+ * const { contentParts, aggregateContent, handlers } = createHandlers({
+ *   onRunStep: (event, data) => console.log('Step:', data),
+ *   onRunStepCompleted: (event, data) => console.log('Completed:', data)
+ * });
+ * ```
+ */
+import { GraphEvents } from '@/common';
+import { createContentAggregator } from '@/stream';
+import type * as t from '@/types';
+interface HandlerCallbacks {
+    onRunStep?: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData) => void;
+    onRunStepCompleted?: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData) => void;
+    onRunStepDelta?: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.StreamEventData) => void;
+    onMessageDelta?: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.StreamEventData) => void;
+}
+/**
+ * Creates handlers with content aggregation for multi-agent scripts
+ */
+export declare function createHandlers(callbacks?: HandlerCallbacks): {
+    contentParts: Array<t.MessageContentComplex | undefined>;
+    aggregateContent: ReturnType<typeof createContentAggregator>['aggregateContent'];
+    handlers: Record<string, t.EventHandler>;
+};
+export {};

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

@@ -0,0 +1,9 @@
+export * from './graph';
+export * from './llm';
+export * from './misc';
+export * from './handlers';
+export * from './run';
+export * from './tokens';
+export * from './toonFormat';
+export * from './contextAnalytics';
+export * from './schema';

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;