@toolprint/sdk/dist/index.d.ts

<div align="center"> <img src="../../assets/toolprint.png" alt="Toolprint Logo" width="200"/>

import * as _repo_utils from '@repo/utils';
export { getEnv, getEnvIssues } from '@repo/utils';
import { client, McpToolServerClient, BlaxelToolServerClient, SmitheryToolServerClient, ComposioToolServerClient, InitializeResponse, AuthenticationStatus, AccountInformation, ToolServerProvider, ToolServer, Tool, ToolProperties, ToolResource, SearchRequest, SearchResponseScoredItemTool, SearchResponseScoredItemRegisteredToolprintReadable, ToolprintRecommendationReadable, ToolprintInput, RegisteredToolprintReadable, ToolprintOutput, Policy, Prompt } from '@toolprint/api-client';
import { Client, ClientOptions } from '@modelcontextprotocol/sdk/client/index.js';
import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
import { Implementation, TextContent, ImageContent, EmbeddedResource, CallToolResult } from '@modelcontextprotocol/sdk/types.js';
import { settings } from '@blaxel/core';
import * as zod from 'zod';
import { z } from 'zod';
import * as ajv from 'ajv';
import { Ajv } from 'ajv';
import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
import { SmitheryUrlOptions } from '@smithery/sdk/shared/config.js';
import { StructuredTool } from '@langchain/core/tools';
import { SystemMessage } from '@langchain/core/messages';

declare const log: _repo_utils.Logger;
declare const useRootLoggerAsConsole: () => void;

declare const getChildLogger: (loggerName: string, logLevelName?: string) => _repo_utils.Logger;
declare const getConfigDir: () => string;
declare const initConfigDir: () => string;

type OneGrepApiClient = typeof client;
type ToolServerClient = McpToolServerClient | BlaxelToolServerClient | SmitheryToolServerClient | ComposioToolServerClient;

declare class OneGrepApiHighLevelClient {
    private readonly apiClient;
    constructor(apiClient: OneGrepApiClient);
    healthCheck(): Promise<boolean>;
    getAiTxt(): Promise<string>;
    initialize(): Promise<InitializeResponse>;
    authStatus(): Promise<AuthenticationStatus>;
    getAccountInformation(): Promise<AccountInformation>;
    createAccountByInvitation(invitationCode: string, email: string): Promise<AccountInformation>;
    getFlags(): Promise<Record<string, boolean | string>>;
    getSecret(secretName: string): Promise<any>;
    upsertSecret(secretName: string, secret: string): Promise<boolean>;
    getAllProviders(): Promise<ToolServerProvider[]>;
    getServerName(serverId: string): Promise<string>;
    getAllServers(): Promise<Record<string, ToolServer>>;
    getAllServerNames(): Promise<string[]>;
    getAllServersForProvider(providerName: string): Promise<Record<string, ToolServer>>;
    getServerClient(serverId: string): Promise<ToolServerClient>;
    listTools(): Promise<Tool[]>;
    getTool(toolId: string): Promise<Tool>;
    getToolProperties(toolId: string): Promise<ToolProperties>;
    upsertToolTags(integrationName: string, toolNames: string[], tags: Record<string, any>): Promise<Array<ToolResource>>;
    getToolResource(toolId: string): Promise<ToolResource>;
    getToolResourcesBatch(toolIds: string[]): Promise<Map<string, ToolResource>>;
    getToolResourcesForIntegration(integrationName: string): Promise<ToolResource[]>;
    searchTools(query: string, options?: SearchRequest): Promise<SearchResponseScoredItemTool>;
    searchToolprints(query: string, options?: SearchRequest): Promise<SearchResponseScoredItemRegisteredToolprintReadable>;
    recommendToolprint(goal: string): Promise<ToolprintRecommendationReadable>;
    newToolprint(toolprint: ToolprintInput): Promise<RegisteredToolprintReadable>;
    newToolprintFromJson(json: string): Promise<ToolprintOutput>;
    newToolprintFromYaml(yaml: string): Promise<RegisteredToolprintReadable>;
    validateToolprint(toolprint: ToolprintInput): Promise<boolean>;
    validateToolprintInJson(json: string): Promise<boolean>;
    validateToolprintInYaml(yaml: string): Promise<boolean>;
    getToolprintJsonSchema(): Promise<object>;
    getToolprintTemplate(): Promise<string>;
    getToolprintAiTxt(): Promise<string>;
}

type Flags = Record<string, FlagValue>;
type FlagValue = string | boolean;
declare class FlagsProvider {
    private readonly apiClient;
    private flagsCache;
    constructor(apiClient: OneGrepApiHighLevelClient);
    private getAuthenticatedUserId;
    all(): Promise<Flags>;
    value(flagName: string): Promise<FlagValue | undefined>;
}
declare const getFlagsProvider: (apiClient: OneGrepApiHighLevelClient) => FlagsProvider;

declare function createUnauthenticatedClient(baseUrl: string): OneGrepApiClient;
declare function createApiClientFromParams(clientParams: {
    baseUrl: string;
    apiKey?: string;
    accessToken?: string;
}): OneGrepApiClient;
declare function clientFromConfig(): OneGrepApiClient;

type ToolServerProviderId = string;
type ToolServerId = string;
type ToolId = string;
type JsonSchema = Record<string, any> | boolean;
type ToolCallArgs = Record<string, any>;
interface ToolCallApproval {
}
interface ToolCallInput {
    args: ToolCallArgs;
    approval: ToolCallApproval | undefined;
}
interface ResultContent {
    type: 'text' | 'object' | 'binary';
}
interface TextResultContent extends ResultContent {
    type: 'text';
    text: string;
}
interface ObjectResultContent extends ResultContent {
    type: 'object';
    data: Record<string, any>;
}
interface BinaryResultContent extends ResultContent {
    type: 'binary';
    data: string;
    mime_type: string;
}
type ToolCallResultContent = Array<ResultContent>;
interface ToolCallError {
    isError: true;
    message: string;
}
type ToolCallOutputMode = 'single' | 'multiple';
interface ToolCallOutput<T> {
    isError: false;
    content: ToolCallResultContent;
    mode: ToolCallOutputMode;
    toZod: () => T;
}
type ToolCallResponse<T> = ToolCallOutput<T> | ToolCallError;
interface BasicToolDetails {
    id: ToolId;
    name: string;
    description: string;
    serverId: string;
    integrationName: string;
    inputSchema: JsonSchema;
    iconUrl?: URL;
}
interface ToolDetails extends BasicToolDetails {
    properties: ToolProperties;
    policy: Policy;
    equip: () => Promise<EquippedTool>;
}
interface Recommendation {
    goal: string;
    tools: ToolDetails[];
    messages: Prompt[];
}
interface ToolHandle {
    call: (input: ToolCallInput) => Promise<ToolCallResponse<any>>;
    callSync: (input: ToolCallInput) => ToolCallResponse<any>;
}
interface ToolServerConnection {
    initialize: () => Promise<void>;
    getHandle: (toolDetails: BasicToolDetails) => Promise<ToolHandle>;
    close: () => Promise<void>;
}
interface ConnectionManager {
    connect: (client: ToolServerClient) => Promise<ToolServerConnection>;
    close: () => Promise<void>;
}
interface EquippedTool {
    details: ToolDetails;
    handle: ToolHandle;
}
interface ToolFilter {
    integrationName: string;
    toolName: string;
}
interface FilterOptions {
    serverIds?: string[];
    integrationNames?: string[];
    tools?: ToolFilter[];
}
interface ScoredResult<T> {
    score: number;
    result: T;
}
interface ToolDetailsStore {
    listTools(): Promise<Map<ToolId, BasicToolDetails>>;
    listIntegrations(): Promise<string[]>;
    filterTools(toolFilter?: FilterOptions): Promise<Map<ToolId, ToolDetails>>;
}
interface ToolCache extends ToolDetailsStore {
    get(toolId: ToolId): Promise<ToolDetails>;
    getMultiple(toolIds: ToolId[]): Promise<Map<ToolId, ToolDetails>>;
    search(query: string): Promise<Array<ScoredResult<ToolDetails>>>;
    recommend(goal: string): Promise<Recommendation>;
    refresh(): Promise<boolean>;
    refreshTool(toolId: ToolId): Promise<ToolDetails>;
    cleanup(): Promise<void>;
}
interface BaseToolbox<T, R> extends ToolDetailsStore {
    recommend(goal: string): Promise<R>;
    get(toolId: ToolId): Promise<T>;
    getMultiple(toolIds: ToolId[]): Promise<Map<ToolId, T>>;
    search(query: string): Promise<Array<ScoredResult<T>>>;
    close(): Promise<void>;
}
interface BaseToolPrinter {
    validate(content: string, format: 'json' | 'yaml'): Promise<ToolprintInput>;
    register(toolprint: ToolprintInput): Promise<RegisteredToolprintReadable>;
}

type ClientWithCallbacksPingResult = Awaited<ReturnType<typeof Client.prototype.ping>>;
type ClientWithCallbacksListToolsResult = Awaited<ReturnType<typeof Client.prototype.listTools>>;
type ClientWithCallbacksCallToolResult = Awaited<ReturnType<typeof Client.prototype.callTool>>;
declare class ClientWithCallbacks extends Client {
    private callbacks;
    private supportedMethods;
    constructor(_clientInfo: Implementation, options?: ClientOptions);
    registerCallback(method: string, callback: () => Promise<void>): void;
    ping(options?: any): Promise<ClientWithCallbacksPingResult>;
    listTools(params?: any, options?: any): Promise<ClientWithCallbacksListToolsResult>;
    callTool(params: any, options?: any): Promise<ClientWithCallbacksCallToolResult>;
}
interface ClientSession {
    get client(): Client;
    get sessionId(): string | undefined;
    connect(): Promise<void>;
    close(): Promise<void>;
    onConnect?(): Promise<void>;
    onClose?(): Promise<void>;
}
interface AutoCloseableClientSession extends ClientSession {
    resetAutoCloseTimer(): void;
}
interface RefreshableClientSession extends ClientSession {
    refresh(): Promise<void>;
}
declare class SingleTransportClientSession implements AutoCloseableClientSession {
    private mcpClient;
    private transport;
    private autoCloseTimer;
    constructor(transport: Transport, clientOptions?: ClientOptions, autoCloseTimeoutMs?: number);
    get client(): Client<{
        method: string;
        params?: {
            [x: string]: unknown;
            _meta?: {
                [x: string]: unknown;
                progressToken?: string | number | undefined;
            } | undefined;
        } | undefined;
    }, {
        method: string;
        params?: {
            [x: string]: unknown;
            _meta?: {
                [x: string]: unknown;
            } | undefined;
        } | undefined;
    }, {
        [x: string]: unknown;
        _meta?: {
            [x: string]: unknown;
        } | undefined;
    }>;
    get sessionId(): string | undefined;
    connect(): Promise<void>;
    onConnect: () => Promise<void>;
    resetAutoCloseTimer(): void;
    close(): Promise<void>;
    onClose: () => Promise<void>;
}
declare class MultiTransportClientSession implements AutoCloseableClientSession {
    private mcpClient;
    private transports;
    private autoCloseTimer;
    constructor(transports: Transport[], clientOptions?: ClientOptions, autoCloseTimeoutMs?: number);
    get client(): Client<{
        method: string;
        params?: {
            [x: string]: unknown;
            _meta?: {
                [x: string]: unknown;
                progressToken?: string | number | undefined;
            } | undefined;
        } | undefined;
    }, {
        method: string;
        params?: {
            [x: string]: unknown;
            _meta?: {
                [x: string]: unknown;
            } | undefined;
        } | undefined;
    }, {
        [x: string]: unknown;
        _meta?: {
            [x: string]: unknown;
        } | undefined;
    }>;
    get sessionId(): string | undefined;
    private connectTransport;
    connect(): Promise<void>;
    onConnect: () => Promise<void>;
    resetAutoCloseTimer(): void;
    close(): Promise<void>;
    onClose: () => Promise<void>;
}
declare class RefreshableMultiTransportClientSession extends MultiTransportClientSession {
    private refreshCallback;
    constructor(transports: Transport[], clientOptions?: ClientOptions, autoCloseTimeoutMs?: number);
    refresh(): Promise<void>;
}
interface ClientSessionFactory<C, V extends ClientSession> {
    create(config: C): Promise<V>;
}
declare class ClientSessionManager<C, V extends ClientSession> {
    private factory;
    private sessions;
    private keyExtractor;
    constructor(factory: ClientSessionFactory<C, V>, keyExtractor?: (config: C) => Promise<string>);
    private new;
    getSession(config: C): Promise<V>;
    close(): Promise<void>;
}

type BlaxelSettings = typeof settings;
declare function createBlaxelMcpClientTransports(functionName: string, providedSettings?: BlaxelSettings, headerOverrides?: Record<string, string>): Transport[];

interface SecretManager {
    initialize(): Promise<void>;
    getSecretNames(): Promise<string[]>;
    hasSecret(secretName: string): Promise<boolean>;
    getSecret(secretName: string): Promise<string>;
    getSecrets(secretNames: string[], requireAll: boolean): Promise<Map<string, string>>;
    syncProcessEnvironment(): Promise<void>;
}

declare class DopplerSecretManager implements SecretManager {
    private apiClient;
    private highLevelClient;
    private client;
    private serviceToken;
    private project;
    private config;
    constructor(apiClient: OneGrepApiClient);
    initialize(): Promise<void>;
    private isInitialized;
    private fetchSecrets;
    private parseSecretsResponse;
    getSecrets(secretNames: string[], requireAll?: boolean): Promise<Map<string, string>>;
    syncProcessEnvironment(): Promise<void>;
    private get doppler();
    getSecretNames(): Promise<string[]>;
    hasSecret(secretName: string): Promise<boolean>;
    getSecret(secretName: string): Promise<string>;
}
declare function createDopplerSecretManager(apiClient: OneGrepApiClient): Promise<DopplerSecretManager>;
declare function getDopplerSecretManager(): Promise<DopplerSecretManager>;

declare class ClientSessionError extends Error {
    constructor(message: string);
}
declare class InvalidTransportConfigError extends ClientSessionError {
    constructor(message: string);
}
interface ClientSessionMaker<T extends ToolServerClient> {
    create: (client: T) => Promise<ClientSession>;
}
declare const blaxelClientSessionMaker: ClientSessionMaker<BlaxelToolServerClient>;
declare const apiKeyBlaxelClientSessionMaker: (apiKey: string, workspace: string, providedSettings?: BlaxelSettings) => ClientSessionMaker<BlaxelToolServerClient>;
declare const smitheryClientSessionMaker: ClientSessionMaker<SmitheryToolServerClient>;
declare const apiKeySmitheryClientSessionMaker: (secretManager: SecretManager, apiKey: string, profileId: string) => ClientSessionMaker<SmitheryToolServerClient>;
declare const apiKeyComposioClientSessionMaker: (apiKey: string) => ClientSessionMaker<ComposioToolServerClient>;
declare class RegisteredClientSessionFactory {
    private clientTypeToSessionMaker;
    constructor(sessionMakers?: Map<string, ClientSessionMaker<ToolServerClient>>);
    register(client_type: string, sessionMaker: ClientSessionMaker<ToolServerClient>): void;
    create(client: ToolServerClient): Promise<ClientSession>;
}
declare const defaultToolServerSessionFactory: RegisteredClientSessionFactory;
declare function createToolServerSessionManager(factory?: ClientSessionFactory<ToolServerClient, ClientSession>): ClientSessionManager<ToolServerClient, ClientSession>;
declare class ToolServerConnectionManager implements ConnectionManager {
    private readonly toolServerSessionManager;
    private openConnections;
    constructor(factory?: ClientSessionFactory<ToolServerClient, ClientSession>);
    private removeClosedConnection;
    private newConnection;
    connect(client: ToolServerClient): Promise<ToolServerConnection>;
    close(): Promise<void>;
}

declare class ToolValidator {
    private _ajv;
    private _toolId;
    constructor(ajv: Ajv, toolId: string);
    validateInputData(data: any): boolean | Promise<unknown>;
}
declare class JsonSchemaUtils {
    private _ajv;
    private _toolValidators;
    constructor(ajv?: Ajv);
    validateJsonSchema(schema: JsonSchema): boolean | Promise<unknown>;
    getValidator(schema: JsonSchema): ajv.ValidateFunction<unknown>;
    registerTool(tool: EquippedTool): void;
    getToolValidator(tool: EquippedTool): ToolValidator;
    toZodType(schema: JsonSchema): zod.ZodTypeAny;
}
declare const jsonSchemaUtils: JsonSchemaUtils;

declare class ToolPrinter implements BaseToolPrinter {
    private readonly client;
    constructor(client: OneGrepApiHighLevelClient);
    validate(content: string, format: 'json' | 'yaml'): Promise<ToolprintInput>;
    register(toolprint: ToolprintInput): Promise<RegisteredToolprintReadable>;
}

declare class Toolbox implements BaseToolbox<ToolDetails, Recommendation> {
    private toolCache;
    private highLevelClient;
    constructor(apiClient: OneGrepApiClient, toolCache: ToolCache);
    get api(): OneGrepApiHighLevelClient;
    listTools(): Promise<Map<ToolId, BasicToolDetails>>;
    listIntegrations(): Promise<string[]>;
    filterTools(options?: FilterOptions): Promise<Map<ToolId, ToolDetails>>;
    get(toolId: ToolId): Promise<ToolDetails>;
    getMultiple(toolIds: ToolId[]): Promise<Map<ToolId, ToolDetails>>;
    recommend(goal: string): Promise<Recommendation>;
    search(query: string): Promise<Array<ScoredResult<ToolDetails>>>;
    refresh(): Promise<boolean>;
    close(): Promise<void>;
}
declare function createToolbox(apiClient: OneGrepApiClient, providedToolCache?: ToolCache, providedSecretManager?: SecretManager): Promise<Toolbox>;
declare function getToolbox(): Promise<Toolbox>;

declare class UniversalToolCache implements ToolCache {
    private highLevelClient;
    private connectionManager;
    private serverNameCache;
    private serverClientCache;
    private toolBasicDetailsCache;
    constructor(apiClient: OneGrepApiClient, connectionManager: ConnectionManager);
    private getServerName;
    private getServerClient;
    private convertToolToBasicDetails;
    private getToolBasicDetails;
    private invalidateToolBasicDetailsCache;
    private createToolDetails;
    private getToolDetailsBatch;
    private getToolDetails;
    listTools(): Promise<Map<ToolId, BasicToolDetails>>;
    listIntegrations(): Promise<string[]>;
    clearServerClientCache(): Promise<boolean>;
    filterTools(filterOptions?: FilterOptions): Promise<Map<ToolId, ToolDetails>>;
    get(toolId: ToolId): Promise<ToolDetails>;
    getMultiple(toolIds: ToolId[]): Promise<Map<ToolId, ToolDetails>>;
    recommend(goal: string): Promise<Recommendation>;
    search(query: string): Promise<ScoredResult<ToolDetails>[]>;
    refresh(): Promise<boolean>;
    refreshTool(toolId: ToolId): Promise<ToolDetails>;
    cleanup(): Promise<void>;
}
declare function createToolCache(apiClient: OneGrepApiClient, connectionManager?: ConnectionManager): Promise<UniversalToolCache>;

declare const createGatewaySSETransport: (url: URL, additionalHeaders?: Record<string, string>, apiKey?: string) => SSEClientTransport;

type McpCallToolResultContent = Array<TextContent | ImageContent | EmbeddedResource>;
declare function parseMcpContent(mcpContent: McpCallToolResultContent, attemptStructuredOutput?: boolean): ToolCallResultContent;
declare function parseMcpResult<T>(result: CallToolResult, toolDetails: ToolDetails, mode?: ToolCallOutputMode): ToolCallOutput<T>;
declare const parseResultFunc: (result: CallToolResult) => ToolCallResponse<any>;
declare const mcpCallTool: (mcpClient: Client, toolDetails: BasicToolDetails, toolCallInput: ToolCallInput) => Promise<ToolCallResponse<any>>;

declare const McpToolCallInput: z.ZodObject<{
    toolName: z.ZodString;
    toolArgs: z.ZodRecord<z.ZodString, z.ZodAny>;
}, "strip", z.ZodTypeAny, {
    toolName: string;
    toolArgs: Record<string, any>;
}, {
    toolName: string;
    toolArgs: Record<string, any>;
}>;
type McpToolCallInput = z.infer<typeof McpToolCallInput>;
declare class McpToolCallError extends Error {
    input: McpToolCallInput;
    constructor(input: McpToolCallInput, message: string, options?: ErrorOptions);
}

declare class BlaxelToolServerConnection implements ToolServerConnection {
    private toolServerClient;
    private mcpClientSession;
    private toolsByName;
    constructor(toolServerClient: BlaxelToolServerClient, mcpClientSession?: ClientSession);
    private get useDirectConnection();
    initialize(): Promise<void>;
    private get registeredToolNames();
    getHandle(toolDetails: BasicToolDetails): Promise<ToolHandle>;
    close(): Promise<void>;
}
declare function createBlaxelConnection(client: BlaxelToolServerClient, mcpClientSession?: ClientSession): Promise<ToolServerConnection>;

declare class SmitheryToolServerConnection implements ToolServerConnection {
    private toolServerClient;
    private mcpClientSession;
    private toolNames;
    constructor(toolServerClient: SmitheryToolServerClient, mcpClientSession: ClientSession);
    initialize(): Promise<void>;
    getHandle(toolDetails: BasicToolDetails): Promise<ToolHandle>;
    close(): Promise<void>;
}
declare function createSmitheryConnection(client: SmitheryToolServerClient, mcpClientSession: ClientSession): Promise<ToolServerConnection>;

declare function createSmitheryTransports(toolServerClient: SmitheryToolServerClient, smitheryUrlOptions: SmitheryUrlOptions): Transport[];

interface StructuredToolsRecommendation {
    goal: string;
    tools: StructuredTool[];
    messages: SystemMessage[];
}

declare class LangchainToolbox implements BaseToolbox<StructuredTool, StructuredToolsRecommendation> {
    toolbox: Toolbox;
    constructor(toolbox: Toolbox);
    listTools(): Promise<Map<ToolId, BasicToolDetails>>;
    filterTools(filterOptions?: FilterOptions): Promise<Map<ToolId, ToolDetails>>;
    listIntegrations(): Promise<string[]>;
    get(toolId: string): Promise<StructuredTool>;
    getMultiple(toolIds: ToolId[]): Promise<Map<ToolId, StructuredTool>>;
    recommend(goal: string): Promise<StructuredToolsRecommendation>;
    search(query: string): Promise<Array<ScoredResult<StructuredTool>>>;
    close(): Promise<void>;
}
declare function createLangchainToolbox(toolbox: Toolbox): Promise<LangchainToolbox>;

export { type AutoCloseableClientSession, type BaseToolPrinter, type BaseToolbox, type BasicToolDetails, type BinaryResultContent, type BlaxelSettings, BlaxelToolServerConnection, type ClientSession, ClientSessionError, type ClientSessionFactory, type ClientSessionMaker, ClientSessionManager, ClientWithCallbacks, type ConnectionManager, DopplerSecretManager, type EquippedTool, type FilterOptions, type FlagValue, type Flags, FlagsProvider, InvalidTransportConfigError, type JsonSchema, LangchainToolbox, type McpCallToolResultContent, McpToolCallError, McpToolCallInput, MultiTransportClientSession, type ObjectResultContent, type OneGrepApiClient, OneGrepApiHighLevelClient, type Recommendation, type RefreshableClientSession, RefreshableMultiTransportClientSession, type ResultContent, type ScoredResult, type SecretManager, SingleTransportClientSession, SmitheryToolServerConnection, type StructuredToolsRecommendation, type TextResultContent, type ToolCache, type ToolCallApproval, type ToolCallArgs, type ToolCallError, type ToolCallInput, type ToolCallOutput, type ToolCallOutputMode, type ToolCallResponse, type ToolCallResultContent, type ToolDetails, type ToolDetailsStore, type ToolFilter, type ToolHandle, type ToolId, ToolPrinter, type ToolServerClient, type ToolServerConnection, ToolServerConnectionManager, type ToolServerId, type ToolServerProviderId, Toolbox, UniversalToolCache, apiKeyBlaxelClientSessionMaker, apiKeyComposioClientSessionMaker, apiKeySmitheryClientSessionMaker, blaxelClientSessionMaker, clientFromConfig, createApiClientFromParams, createBlaxelConnection, createBlaxelMcpClientTransports, createDopplerSecretManager, createGatewaySSETransport, createLangchainToolbox, createSmitheryConnection, createSmitheryTransports, createToolCache, createToolServerSessionManager, createToolbox, createUnauthenticatedClient, defaultToolServerSessionFactory, getChildLogger, getConfigDir, getDopplerSecretManager, getFlagsProvider, getToolbox, initConfigDir, jsonSchemaUtils, log, mcpCallTool, parseMcpContent, parseMcpResult, parseResultFunc, smitheryClientSessionMaker, useRootLoggerAsConsole };