@crewai-ts/core 0.1.2 → 0.1.3

package/dist/llms-hooks-transport.d.ts

@@ -1,2 +1 @@
-export { h as AsyncHTTPTransport, H as HTTPTransport, q as HTTPTransportKwargs, q as HTTPTransportKwargsType } from './llms-hooks-transport-ChGiFBiU.js';
-import './state-provider-core-Be9RKRAm.js';
+export { AsyncHTTPTransport, HTTPTransport, HTTPTransportKwargs, type HTTPTransportKwargs as HTTPTransportKwargsType, } from "./hooks.js";

package/dist/lock-store.d.ts

@@ -0,0 +1,14 @@
+export type LockBackend = <T>(name: string, fn: () => T | Promise<T>, options: {
+    timeout: number;
+}) => T | Promise<T>;
+export declare function lock<T>(name: string, fn: () => T | Promise<T>, options?: {
+    timeout?: number;
+}): Promise<T>;
+export declare const withLock: typeof lock;
+export declare const with_lock: typeof lock;
+export declare function setLockBackend(backend: LockBackend | null): void;
+export declare const set_lock_backend: typeof setLockBackend;
+export declare function clearNamedLocks(): void;
+export declare const clear_named_locks: typeof clearNamedLocks;
+export declare function getLockName(name: string): string;
+export declare const get_lock_name: typeof getLockName;

package/dist/logger.d.ts

@@ -0,0 +1,55 @@
+export type PrinterColor = "purple" | "bold_purple" | "green" | "bold_green" | "cyan" | "bold_cyan" | "magenta" | "bold_magenta" | "yellow" | "bold_yellow" | "red" | "blue" | "bold_blue";
+export declare const PrinterColor: Readonly<{
+    readonly purple: "purple";
+    readonly bold_purple: "bold_purple";
+    readonly green: "green";
+    readonly bold_green: "bold_green";
+    readonly cyan: "cyan";
+    readonly bold_cyan: "bold_cyan";
+    readonly magenta: "magenta";
+    readonly bold_magenta: "bold_magenta";
+    readonly yellow: "yellow";
+    readonly bold_yellow: "bold_yellow";
+    readonly red: "red";
+    readonly blue: "blue";
+    readonly bold_blue: "bold_blue";
+}>;
+export type ColoredText = {
+    text: string;
+    color?: PrinterColor | null;
+};
+export declare const ColoredText: Readonly<{
+    kind: "ColoredText";
+}>;
+export type LoggerOptions = {
+    verbose?: boolean;
+    defaultColor?: PrinterColor;
+    default_color?: PrinterColor;
+    writer?: (message: string) => void;
+};
+export declare class Logger {
+    verbose: boolean;
+    defaultColor: PrinterColor;
+    default_color: PrinterColor;
+    private readonly writer;
+    constructor(options?: LoggerOptions);
+    log(level: string, message: string, color?: PrinterColor | null): void;
+}
+export declare class Printer {
+    private readonly writer;
+    constructor(writer?: (message: string) => void);
+    print(content: string | readonly ColoredText[], color?: PrinterColor | null, _sep?: string, end?: string): void;
+}
+export declare const PRINTER: Printer;
+export declare function setSuppressConsoleOutput(suppress: boolean): boolean;
+export declare const set_suppress_console_output: typeof setSuppressConsoleOutput;
+export declare function shouldSuppressConsoleOutput(): boolean;
+export declare const should_suppress_console_output: typeof shouldSuppressConsoleOutput;
+export declare function suppressLogging<T>(fn: () => T | Promise<T>): Promise<T>;
+export declare const suppress_logging: typeof suppressLogging;
+export declare function suppressWarnings<T>(fn: () => T | Promise<T>): Promise<T>;
+export declare const suppress_warnings: typeof suppressWarnings;
+export declare function withSuppressedOutput<T>(fn: () => T | Promise<T>): Promise<T>;
+export declare const with_suppressed_output: typeof withSuppressedOutput;
+export declare function renderColoredText(parts: readonly ColoredText[], colorize?: boolean): string;
+export declare const render_colored_text: typeof renderColoredText;

package/dist/mcp.d.ts

@@ -0,0 +1,315 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { type BaseTool } from "./tools.js";
+export declare const TransportType: {
+    readonly STDIO: "stdio";
+    readonly HTTP: "http";
+    readonly STREAMABLE_HTTP: "streamable-http";
+    readonly SSE: "sse";
+};
+export type TransportType = typeof TransportType[keyof typeof TransportType];
+export type MCPToolDefinition = Record<string, unknown> & {
+    name?: string;
+};
+export declare const MCPReadStream: Readonly<{
+    kind: "MCPReadStream";
+}>;
+export declare const MCPWriteStream: Readonly<{
+    kind: "MCPWriteStream";
+}>;
+export type ToolFilterContextOptions = {
+    agent: unknown;
+    serverName?: string;
+    server_name?: string;
+    runContext?: Record<string, unknown> | null;
+    run_context?: Record<string, unknown> | null;
+};
+export declare class ToolFilterContext {
+    readonly agent: unknown;
+    readonly serverName: string;
+    readonly server_name: string;
+    readonly runContext: Record<string, unknown> | null;
+    readonly run_context: Record<string, unknown> | null;
+    constructor(options: ToolFilterContextOptions);
+}
+type MaybePromise<T> = T | Promise<T>;
+export type ToolFilter = ((tool: MCPToolDefinition) => MaybePromise<boolean>) | ((context: ToolFilterContext, tool: MCPToolDefinition) => MaybePromise<boolean>);
+export declare const ToolFilter: Readonly<{
+    kind: "ToolFilter";
+}>;
+export declare class StaticToolFilter {
+    readonly allowedToolNames: ReadonlySet<string>;
+    readonly allowed_tool_names: ReadonlySet<string>;
+    readonly blockedToolNames: ReadonlySet<string>;
+    readonly blocked_tool_names: ReadonlySet<string>;
+    constructor(options?: {
+        allowedToolNames?: readonly string[] | null;
+        allowed_tool_names?: readonly string[] | null;
+        blockedToolNames?: readonly string[] | null;
+        blocked_tool_names?: readonly string[] | null;
+    });
+    filter(tool: MCPToolDefinition): boolean;
+    call(tool: MCPToolDefinition): boolean;
+    __call__(tool: MCPToolDefinition): boolean;
+}
+export declare function createStaticToolFilter(allowedToolNames?: readonly string[] | null, blockedToolNames?: readonly string[] | null): (tool: MCPToolDefinition) => boolean;
+export declare const create_static_tool_filter: typeof createStaticToolFilter;
+export declare function createDynamicToolFilter<TFilter extends (context: ToolFilterContext, tool: MCPToolDefinition) => MaybePromise<boolean>>(filterFunc: TFilter): TFilter;
+export declare const create_dynamic_tool_filter: typeof createDynamicToolFilter;
+export type MCPServerStdioOptions = {
+    command: string;
+    args?: readonly string[];
+    env?: Record<string, string> | null;
+    toolFilter?: ToolFilter | null;
+    tool_filter?: ToolFilter | null;
+    cacheToolsList?: boolean;
+    cache_tools_list?: boolean;
+};
+export declare class MCPServerStdio {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly env: Record<string, string> | null;
+    readonly toolFilter: ToolFilter | null;
+    readonly tool_filter: ToolFilter | null;
+    readonly cacheToolsList: boolean;
+    readonly cache_tools_list: boolean;
+    constructor(options: MCPServerStdioOptions);
+}
+export type MCPServerHTTPOptions = {
+    url: string;
+    headers?: Record<string, string> | null;
+    streamable?: boolean;
+    toolFilter?: ToolFilter | null;
+    tool_filter?: ToolFilter | null;
+    cacheToolsList?: boolean;
+    cache_tools_list?: boolean;
+};
+export declare class MCPServerHTTP {
+    readonly url: string;
+    readonly headers: Record<string, string> | null;
+    readonly streamable: boolean;
+    readonly toolFilter: ToolFilter | null;
+    readonly tool_filter: ToolFilter | null;
+    readonly cacheToolsList: boolean;
+    readonly cache_tools_list: boolean;
+    constructor(options: MCPServerHTTPOptions);
+}
+export type MCPServerSSEOptions = {
+    url: string;
+    headers?: Record<string, string> | null;
+    toolFilter?: ToolFilter | null;
+    tool_filter?: ToolFilter | null;
+    cacheToolsList?: boolean;
+    cache_tools_list?: boolean;
+};
+export declare class MCPServerSSE {
+    readonly url: string;
+    readonly headers: Record<string, string> | null;
+    readonly toolFilter: ToolFilter | null;
+    readonly tool_filter: ToolFilter | null;
+    readonly cacheToolsList: boolean;
+    readonly cache_tools_list: boolean;
+    constructor(options: MCPServerSSEOptions);
+}
+export type MCPServerConfig = MCPServerStdio | MCPServerHTTP | MCPServerSSE;
+export declare const MCPServerConfig: Readonly<{
+    kind: "MCPServerConfig";
+}>;
+export declare abstract class BaseTransport {
+    protected readStreamValue: unknown;
+    protected writeStreamValue: unknown;
+    protected connectedValue: boolean;
+    protected sdkTransportValue: Transport | null;
+    abstract get transportType(): TransportType;
+    protected abstract createSdkTransport(): Transport;
+    get transport_type(): TransportType;
+    get connected(): boolean;
+    get readStream(): unknown;
+    get read_stream(): unknown;
+    get writeStream(): unknown;
+    get write_stream(): unknown;
+    connect(): Promise<this>;
+    disconnect(): Promise<void>;
+    aenter(): Promise<this>;
+    __aenter__(): Promise<this>;
+    aexit(_excType?: unknown, _excVal?: unknown, _excTb?: unknown): Promise<void>;
+    __aexit__(excType?: unknown, excVal?: unknown, excTb?: unknown): Promise<void>;
+    protected setStreams(read: unknown, write: unknown): void;
+    _set_streams(read: unknown, write: unknown): void;
+    protected clearStreams(): void;
+    _clear_streams(): void;
+    markConnectedForClient(): void;
+    clearConnectedForClient(): void;
+    getSdkTransport(): Transport;
+}
+export declare class HTTPTransport extends BaseTransport {
+    readonly url: string;
+    readonly headers: Record<string, string>;
+    readonly streamable: boolean;
+    constructor(options: MCPServerHTTPOptions | string, headers?: Record<string, string> | null, streamable?: boolean);
+    get transportType(): TransportType;
+    protected createSdkTransport(): Transport;
+}
+export declare class SSETransport extends BaseTransport {
+    readonly url: string;
+    readonly headers: Record<string, string>;
+    constructor(options: MCPServerSSEOptions | string, headers?: Record<string, string> | null);
+    get transportType(): TransportType;
+    protected createSdkTransport(): Transport;
+}
+export declare class StdioTransport extends BaseTransport {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly env: Record<string, string>;
+    constructor(options: MCPServerStdioOptions | string, args?: readonly string[] | null, env?: Record<string, string> | null);
+    get transportType(): TransportType;
+    protected createSdkTransport(): Transport;
+}
+export declare function isMCPServerConfig(value: unknown): value is MCPServerConfig;
+export declare const is_mcp_server_config: typeof isMCPServerConfig;
+export declare const MCP_CONNECTION_TIMEOUT = 30;
+export declare const MCP_TOOL_EXECUTION_TIMEOUT = 30;
+export declare const MCP_DISCOVERY_TIMEOUT = 30;
+export declare const MCP_MAX_RETRIES = 3;
+export declare class _MCPToolResult {
+    readonly content: string;
+    readonly isError: boolean;
+    readonly is_error: boolean;
+    constructor(content: string, isError?: boolean);
+}
+type SchemaCacheEntry = {
+    tools: MCPToolDefinition[];
+    createdAt: number;
+};
+export type MCPClientOptions = {
+    connectTimeout?: number;
+    connect_timeout?: number;
+    executionTimeout?: number;
+    execution_timeout?: number;
+    discoveryTimeout?: number;
+    discovery_timeout?: number;
+    maxRetries?: number;
+    max_retries?: number;
+    cacheToolsList?: boolean;
+    cache_tools_list?: boolean;
+};
+export declare class MCPClient {
+    readonly transport: BaseTransport;
+    readonly connectTimeout: number;
+    readonly connect_timeout: number;
+    readonly executionTimeout: number;
+    readonly execution_timeout: number;
+    readonly discoveryTimeout: number;
+    readonly discovery_timeout: number;
+    readonly maxRetries: number;
+    readonly max_retries: number;
+    readonly cacheToolsList: boolean;
+    readonly cache_tools_list: boolean;
+    private client;
+    private initialized;
+    private wasConnected;
+    constructor(transport: BaseTransport, options?: MCPClientOptions);
+    get connected(): boolean;
+    get session(): Client;
+    connect(): Promise<this>;
+    disconnect(): Promise<void>;
+    aenter(): Promise<this>;
+    __aenter__(): Promise<this>;
+    aexit(_excType?: unknown, _excVal?: unknown, _excTb?: unknown): Promise<void>;
+    __aexit__(excType?: unknown, excVal?: unknown, excTb?: unknown): Promise<void>;
+    listTools(useCache?: boolean | null): Promise<MCPToolDefinition[]>;
+    list_tools(useCache?: boolean | null): Promise<MCPToolDefinition[]>;
+    listToolsImpl(): Promise<MCPToolDefinition[]>;
+    _list_tools_impl(): Promise<MCPToolDefinition[]>;
+    callTool(toolName: string, args?: Record<string, unknown> | null): Promise<string>;
+    call_tool(toolName: string, args?: Record<string, unknown> | null): Promise<string>;
+    cleanToolArguments(args: Record<string, unknown>): Record<string, unknown>;
+    _clean_tool_arguments(args: Record<string, unknown>): Record<string, unknown>;
+    callToolImpl(toolName: string, args: Record<string, unknown>): Promise<_MCPToolResult>;
+    _call_tool_impl(toolName: string, args: Record<string, unknown>): Promise<_MCPToolResult>;
+    emitConnectionFailed(serverName: string, serverUrl: string | null, transportType: string | null, error: unknown, errorType: string, startedAt: Date): void;
+    _emit_connection_failed(serverName: string, serverUrl: string | null, transportType: string | null, error: unknown, errorType: string, startedAt: Date): void;
+    listPrompts(): Promise<Record<string, unknown>[]>;
+    listPromptsImpl(): Promise<Record<string, unknown>[]>;
+    _list_prompts_impl(): Promise<Record<string, unknown>[]>;
+    list_prompts(): Promise<Record<string, unknown>[]>;
+    getPrompt(name: string, args?: Record<string, string> | null): Promise<unknown>;
+    getPromptImpl(name: string, args: Record<string, string>): Promise<unknown>;
+    get_prompt(name: string, args?: Record<string, string> | null): Promise<unknown>;
+    _get_prompt_impl(name: string, args: Record<string, string>): Promise<unknown>;
+    listResources(): Promise<Record<string, unknown>[]>;
+    list_resources(): Promise<Record<string, unknown>[]>;
+    readResource(uri: string): Promise<unknown>;
+    read_resource(uri: string): Promise<unknown>;
+    getServerInfo(): [string, string | null, string];
+    _get_server_info(): [string, string | null, string];
+    getCacheKey(kind: string): string;
+    _get_cache_key(kind: string): string;
+    retryOperation<T>(operation: () => Promise<T>, timeout?: number | null): Promise<T>;
+    _retry_operation<T>(operation: () => Promise<T>, timeout?: number | null): Promise<T>;
+    cleanupOnError(): Promise<void>;
+    _cleanup_on_error(): Promise<void>;
+}
+export type MCPToolResolverOptions = {
+    agent?: unknown;
+    logger?: {
+        log(level: string, message: string): void;
+    } | null;
+};
+export declare class MCPToolResolver {
+    private readonly agent;
+    private readonly logger;
+    private readonly clientsValue;
+    constructor(options?: MCPToolResolverOptions);
+    constructor(agent: unknown, logger?: {
+        log(level: string, message: string): void;
+    } | null);
+    get clients(): MCPClient[];
+    resolve(mcps: readonly (string | MCPServerConfig)[] | null | undefined): Promise<BaseTool[]>;
+    cleanup(): Promise<void>;
+    disconnectAll(): Promise<void>;
+    _disconnect_all(): Promise<void>;
+    static parseAmpRef(mcpConfig: string): [string, string | null];
+    static _parse_amp_ref(mcpConfig: string): [string, string | null];
+    parseAmpRef(mcpConfig: string): [string, string | null];
+    _parse_amp_ref(mcpConfig: string): [string, string | null];
+    fetchAmpMcpConfigs(slugs: readonly string[]): Record<string, Record<string, unknown>>;
+    _fetch_amp_mcp_configs(slugs: readonly string[]): Record<string, Record<string, unknown>>;
+    resolveAmp(ampRefs: readonly [string, string | null][]): Promise<[BaseTool[], MCPClient[]]>;
+    _resolve_amp(ampRefs: readonly [string, string | null][]): Promise<[BaseTool[], MCPClient[]]>;
+    resolveNative(config: MCPServerConfig): Promise<BaseTool[]>;
+    _resolve_native(config: MCPServerConfig): Promise<[BaseTool[], MCPClient[]]>;
+    resolveExternal(mcpRef: string): Promise<BaseTool[]>;
+    _resolve_external(mcpRef: string): Promise<BaseTool[]>;
+    static createTransport(config: MCPServerConfig): [BaseTransport, string];
+    static _create_transport(config: MCPServerConfig): [BaseTransport, string];
+    createTransport(config: MCPServerConfig): [BaseTransport, string];
+    _create_transport(config: MCPServerConfig): [BaseTransport, string];
+    static buildMcpConfigFromDict(config: Record<string, unknown>): MCPServerConfig;
+    static _build_mcp_config_from_dict(config: Record<string, unknown>): MCPServerConfig;
+    buildMcpConfigFromDict(config: Record<string, unknown>): MCPServerConfig;
+    _build_mcp_config_from_dict(config: Record<string, unknown>): MCPServerConfig;
+    static extractServerName(serverUrl: string): string;
+    static _extract_server_name(serverUrl: string): string;
+    extractServerName(serverUrl: string): string;
+    _extract_server_name(serverUrl: string): string;
+    setupClientAndListTools(client: MCPClient): Promise<MCPToolDefinition[]>;
+    _setup_client_and_list_tools(client: MCPClient): Promise<MCPToolDefinition[]>;
+    getMcpToolSchemas(serverParams: Record<string, unknown>): Record<string, Record<string, unknown>>;
+    _get_mcp_tool_schemas(serverParams: Record<string, unknown>): Record<string, Record<string, unknown>>;
+    getMcpToolSchemasAsync(serverParams: Record<string, unknown>): Promise<Record<string, Record<string, unknown>>>;
+    _get_mcp_tool_schemas_async(serverParams: Record<string, unknown>): Promise<Record<string, Record<string, unknown>>>;
+    retryMcpDiscovery(operation: (serverUrl: string) => Promise<Record<string, Record<string, unknown>>>, serverUrl: string): Promise<Record<string, Record<string, unknown>>>;
+    _retry_mcp_discovery(operation: (serverUrl: string) => Promise<Record<string, Record<string, unknown>>>, serverUrl: string): Promise<Record<string, Record<string, unknown>>>;
+    attemptMcpDiscovery(operation: (serverUrl: string) => Promise<Record<string, Record<string, unknown>>>, serverUrl: string): Promise<[Record<string, Record<string, unknown>> | null, string, boolean]>;
+    _attempt_mcp_discovery(operation: (serverUrl: string) => Promise<Record<string, Record<string, unknown>>>, serverUrl: string): Promise<[Record<string, Record<string, unknown>> | null, string, boolean]>;
+    discoverMcpToolsWithTimeout(serverUrl: string): Promise<Record<string, Record<string, unknown>>>;
+    _discover_mcp_tools_with_timeout(serverUrl: string): Promise<Record<string, Record<string, unknown>>>;
+    discoverMcpTools(serverUrl: string): Promise<Record<string, Record<string, unknown>>>;
+    _discover_mcp_tools(serverUrl: string): Promise<Record<string, Record<string, unknown>>>;
+    jsonSchemaToPydantic(toolName: string, jsonSchema: Record<string, unknown>): Record<string, unknown>;
+    _json_schema_to_pydantic(toolName: string, jsonSchema: Record<string, unknown>): Record<string, unknown>;
+    private log;
+}
+export declare const mcp_schema_cache: Map<string, SchemaCacheEntry>;
+export {};