@crewai-ts/core 0.1.2 → 0.1.5

package/dist/tools.d.ts

@@ -0,0 +1,563 @@
+import type { InputValues, MaybePromise, Tool, ToolContext } from "./types.js";
+import { sanitizeToolName } from "./string-utils.js";
+import { AgentAction } from "./agent-parser.js";
+export declare const OPENAI_BIGGER_MODELS: readonly ["gpt-4", "gpt-4o", "gpt-4.1"];
+export type ToolArgumentType = "string" | "number" | "boolean" | "object" | "array" | "unknown";
+export type ToolArgumentSpec = {
+    type?: ToolArgumentType;
+    description?: string;
+    required?: boolean;
+    default?: unknown;
+};
+export type ToolArgsSchema = Record<string, ToolArgumentSpec>;
+export type ToolInvocationInput = string | Record<string, unknown> | ToolContext | undefined;
+export type ToolHookContextOptions = {
+    agent?: unknown;
+    task?: unknown;
+    crew?: unknown;
+};
+export type ToolCacheReadResult = {
+    hit: true;
+    value: unknown;
+} | {
+    hit: false;
+};
+export type ToolCache = {
+    read(toolName: string, input: string): ToolCacheReadResult;
+    write(toolName: string, input: string, output: unknown): void;
+    clear?(): void;
+};
+export type BaseToolOptions = {
+    name: string;
+    description: string;
+    argsSchema?: ToolArgsSchema;
+    args_schema?: ToolArgsSchema;
+    envVars?: readonly EnvVar[];
+    env_vars?: readonly EnvVar[];
+    descriptionUpdated?: boolean;
+    description_updated?: boolean;
+    resultAsAnswer?: boolean;
+    result_as_answer?: boolean;
+    maxUsageCount?: number | null;
+    max_usage_count?: number | null;
+    currentUsageCount?: number;
+    current_usage_count?: number;
+    cacheFunction?: (args: Record<string, unknown>, result: unknown) => boolean;
+    cache_function?: (args: Record<string, unknown>, result: unknown) => boolean;
+    cache?: ToolCache | false;
+};
+export type AgentLikeForTool = {
+    role: string;
+    executeTask?: (task: unknown, context?: string | null) => MaybePromise<unknown>;
+    execute_task?: (task: unknown, context?: string | null) => MaybePromise<unknown>;
+};
+export type StructuredToolOptions = BaseToolOptions & {
+    func: (args: Record<string, unknown>) => MaybePromise<unknown>;
+    originalTool?: BaseTool | null;
+    original_tool?: BaseTool | null;
+};
+export type StructuredToolFromFunctionOptions = Omit<ToolDecoratorOptions, "resultAsAnswer" | "result_as_answer"> & {
+    returnDirect?: boolean;
+    return_direct?: boolean;
+    inferSchema?: boolean;
+    infer_schema?: boolean;
+    args_schema?: ToolArgsSchema;
+};
+export type EnvVarOptions = {
+    name: string;
+    description: string;
+    required?: boolean;
+    default?: string | null;
+};
+export declare class EnvVar {
+    readonly name: string;
+    readonly description: string;
+    readonly required: boolean;
+    readonly default: string | null;
+    constructor(options: EnvVarOptions);
+}
+export type ToolFunction<TArgs extends readonly unknown[] = readonly unknown[]> = (...args: TArgs) => MaybePromise<unknown>;
+export type ToolDecoratorOptions = {
+    name?: string;
+    description?: string;
+    argsSchema?: ToolArgsSchema;
+    args_schema?: ToolArgsSchema;
+    envVars?: readonly EnvVar[];
+    env_vars?: readonly EnvVar[];
+    resultAsAnswer?: boolean;
+    result_as_answer?: boolean;
+    maxUsageCount?: number | null;
+    max_usage_count?: number | null;
+    cacheFunction?: (args: Record<string, unknown>, result: unknown) => boolean;
+    cache?: ToolCache | false;
+};
+export type ToolCalling = {
+    toolName: string;
+    tool_name?: string;
+    arguments?: Record<string, unknown> | null;
+};
+export type ToolCallingOptions = {
+    toolName?: string;
+    tool_name?: string;
+    arguments?: Record<string, unknown> | null;
+};
+export declare const ToolCalling: {
+    new (options: ToolCallingOptions): {
+        readonly toolName: string;
+        readonly tool_name: string;
+        readonly arguments: Record<string, unknown> | null;
+    };
+};
+export declare const InstructorToolCalling: {
+    new (options: ToolCallingOptions): {
+        readonly toolName: string;
+        readonly tool_name: string;
+        readonly arguments: Record<string, unknown> | null;
+    };
+};
+export type InstructorToolCalling = ToolCalling;
+export type ToolCallingLike = {
+    toolName?: string;
+    tool_name?: string;
+    arguments?: Record<string, unknown> | null;
+};
+export type ToolResultOptions = {
+    result: unknown;
+    resultAsAnswer?: boolean;
+    result_as_answer?: boolean;
+};
+export declare class _ArgsSchemaPlaceholder {
+    readonly kind = "_ArgsSchemaPlaceholder";
+}
+export declare function _default_cache_function(_args?: unknown, _result?: unknown): boolean;
+export declare function _is_async_callable(func: unknown): boolean;
+export declare function _is_awaitable<T = unknown>(value: T | PromiseLike<T>): value is PromiseLike<T>;
+export declare function _serialize_schema(schema: ToolArgsSchema | null | undefined): ToolArgsSchema | null;
+export declare function _deserialize_schema(value: unknown): ToolArgsSchema | null;
+export declare class ToolResult {
+    readonly result: unknown;
+    readonly resultAsAnswer: boolean;
+    readonly result_as_answer: boolean;
+    constructor(options: ToolResultOptions);
+    constructor(result: unknown, resultAsAnswer?: boolean);
+}
+export declare function build_schema_hint(argsSchema?: ToolArgsSchema | null): string;
+export declare class ToolUsageLimitExceededError extends Error {
+    constructor(message: string);
+}
+export declare class ToolValidationError extends Error {
+    constructor(message: string);
+}
+export declare class InMemoryToolCache implements ToolCache {
+    private readonly cache;
+    read(toolName: string, input: string): ToolCacheReadResult;
+    write(toolName: string, input: string, output: unknown): void;
+    clear(): void;
+}
+export declare class CacheHandler {
+    private readonly cache;
+    add(tool: string, input: string, output: unknown): void;
+    read(tool: string, input: string): unknown;
+    clear(): void;
+    asToolCache(): ToolCache;
+}
+export type ToolsHandlerOptions = {
+    cache?: CacheHandler | null;
+    lastUsedTool?: ToolCallingLike | null;
+    last_used_tool?: ToolCallingLike | null;
+};
+export declare class ToolsHandler {
+    cache: CacheHandler | null;
+    lastUsedTool: ToolCallingLike | null;
+    last_used_tool: ToolCallingLike | null;
+    constructor(options?: ToolsHandlerOptions);
+    onToolUse(calling: ToolCallingLike, output: string, shouldCache?: boolean): void;
+    on_tool_use(calling: ToolCallingLike, output: string, should_cache?: boolean): void;
+}
+export declare abstract class BaseTool implements Tool {
+    readonly name: string;
+    readonly description: string;
+    readonly envVars: readonly EnvVar[];
+    readonly argsSchema: ToolArgsSchema;
+    readonly descriptionUpdated: boolean;
+    readonly resultAsAnswer: boolean;
+    readonly maxUsageCount: number | null;
+    readonly cacheFunction: (args: Record<string, unknown>, result: unknown) => boolean;
+    readonly cache: ToolCache | null;
+    currentUsageCount: number;
+    constructor(options: BaseToolOptions);
+    static validateMaxUsageCount(value: number | null): number | null;
+    static validate_max_usage_count(value: number | null): number | null;
+    static defaultArgsSchema(value: ToolArgsSchema | null | undefined): ToolArgsSchema;
+    static _default_args_schema(value: ToolArgsSchema | null | undefined): ToolArgsSchema;
+    static fromLangchain(tool: {
+        name?: string;
+        description?: string;
+        func?: (...args: never[]) => MaybePromise<unknown>;
+        args_schema?: ToolArgsSchema;
+        argsSchema?: ToolArgsSchema;
+    }): StructuredTool;
+    static from_langchain(tool: {
+        name?: string;
+        description?: string;
+        func?: (...args: never[]) => MaybePromise<unknown>;
+        args_schema?: ToolArgsSchema;
+        argsSchema?: ToolArgsSchema;
+    }): StructuredTool;
+    get toolType(): string;
+    get tool_type(): string;
+    modelPostInit(_context?: unknown): void;
+    model_post_init(_context?: unknown): void;
+    setArgsSchema(): ToolArgsSchema;
+    _set_args_schema(): ToolArgsSchema;
+    generateDescription(): string;
+    _generate_description(): string;
+    serializeArgsSchema(schema?: ToolArgsSchema | null): ToolArgsSchema | null;
+    _serialize_args_schema(schema?: ToolArgsSchema | null): ToolArgsSchema | null;
+    _claim_usage(): string | null;
+    validateKwargs(kwargs: Record<string, unknown>): Record<string, unknown>;
+    _validate_kwargs(kwargs: Record<string, unknown>): Record<string, unknown>;
+    get env_vars(): readonly EnvVar[];
+    get args_schema(): ToolArgsSchema;
+    get args(): ToolArgsSchema;
+    get description_updated(): boolean;
+    get result_as_answer(): boolean;
+    get max_usage_count(): number | null;
+    get current_usage_count(): number;
+    set current_usage_count(value: number);
+    get cache_function(): (args: Record<string, unknown>, result: unknown) => boolean;
+    run(input?: ToolInvocationInput, hookContext?: ToolHookContextOptions): MaybePromise<unknown>;
+    private runWithHooks;
+    arun(input?: ToolInvocationInput): Promise<unknown>;
+    invoke(input?: ToolInvocationInput, _config?: Record<string, unknown> | null): MaybePromise<unknown>;
+    ainvoke(input?: ToolInvocationInput, _config?: Record<string, unknown> | null): Promise<unknown>;
+    hasReachedMaxUsageCount(): boolean;
+    has_reached_max_usage_count(): boolean;
+    resetUsageCount(): void;
+    reset_usage_count(): void;
+    clearCache(): void;
+    clear_cache(): void;
+    toStructuredTool(): StructuredTool;
+    to_structured_tool(): StructuredTool;
+    toLangChain(): StructuredTool;
+    to_langchain(): StructuredTool;
+    withCache(cache: ToolCache | false): StructuredTool;
+    renderDescription(): string;
+    protected abstract _run(args: Record<string, unknown>): MaybePromise<unknown>;
+    protected _arun(args: Record<string, unknown>): Promise<unknown>;
+    protected parseArgs(input: ToolInvocationInput): Record<string, unknown>;
+    private claimUsage;
+    protected onUsageClaimed(): void;
+    private writeCache;
+    private emitToolFinished;
+    private emitToolError;
+}
+export declare function to_langchain(tool: BaseTool): StructuredTool;
+export declare function to_langchain(tools: (BaseTool | StructuredTool)[]): StructuredTool[];
+export declare class StructuredTool extends BaseTool {
+    private readonly func;
+    private readonly originalTool;
+    constructor(options: StructuredToolOptions);
+    static fromFunction(func: ToolFunction, options?: StructuredToolFromFunctionOptions): StructuredTool;
+    static fromFunction(func: ToolFunction, name?: string | null, description?: string | null, returnDirect?: boolean, argsSchema?: ToolArgsSchema | null, inferSchema?: boolean): StructuredTool;
+    static from_function(func: ToolFunction, options?: StructuredToolFromFunctionOptions): StructuredTool;
+    static from_function(func: ToolFunction, name?: string | null, description?: string | null, returnDirect?: boolean, argsSchema?: ToolArgsSchema | null, inferSchema?: boolean): StructuredTool;
+    protected _run(args: Record<string, unknown>): MaybePromise<unknown>;
+    protected parseArgs(input: ToolInvocationInput): Record<string, unknown>;
+    invoke(input?: ToolInvocationInput, _config?: Record<string, unknown> | null): MaybePromise<unknown>;
+    ainvoke(input?: ToolInvocationInput, _config?: Record<string, unknown> | null): Promise<unknown>;
+    arun(input?: ToolInvocationInput): Promise<unknown>;
+    _validate_func(): this;
+    static _create_schema_from_function(name: string, func: ToolFunction): ToolArgsSchema;
+    _validate_function_signature(): void;
+    _parseArgs(input: ToolInvocationInput): Record<string, unknown>;
+    _parse_args(input: ToolInvocationInput): Record<string, unknown>;
+    _incrementUsageCount(): void;
+    _increment_usage_count(): void;
+    private callStructuredFunction;
+    __repr__(): string;
+    toString(): string;
+    protected onUsageClaimed(): void;
+}
+export declare const CrewStructuredTool: typeof StructuredTool;
+export type CrewStructuredTool = StructuredTool;
+export declare const AddImageToolSchema: {
+    image_url: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    action: {
+        type: "string";
+        required: false;
+        description: string;
+    };
+};
+export declare class AddImageTool extends BaseTool {
+    constructor(options?: Partial<BaseToolOptions>);
+    protected _run(args: Record<string, unknown>): Record<string, unknown>;
+}
+export declare const ReadFileToolSchema: {
+    file_name: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+};
+export declare class ReadFileTool extends BaseTool {
+    private files;
+    constructor(options?: Partial<BaseToolOptions> & {
+        files?: Record<string, {
+            read(): Uint8Array | Buffer | string;
+            content_type?: string;
+            contentType?: string;
+            filename?: string | null;
+        }> | null;
+    });
+    setFiles(files: Record<string, {
+        read(): Uint8Array | Buffer | string;
+        content_type?: string;
+        contentType?: string;
+        filename?: string | null;
+    }> | null): void;
+    set_files(files: Record<string, {
+        read(): Uint8Array | Buffer | string;
+        content_type?: string;
+        contentType?: string;
+        filename?: string | null;
+    }> | null): void;
+    protected _run(args: Record<string, unknown>): MaybePromise<string>;
+}
+export declare class BaseAgentTool extends BaseTool {
+    readonly agents: readonly AgentLikeForTool[];
+    constructor(options?: Partial<BaseToolOptions> & {
+        agents?: readonly AgentLikeForTool[];
+    });
+    sanitizeAgentName(name: string): string;
+    sanitize_agent_name(name: string): string;
+    static _getCoworker(coworker: unknown, args?: Record<string, unknown>): string | null;
+    static _get_coworker(coworker: unknown, args?: Record<string, unknown>): string | null;
+    _getCoworker(coworker: unknown, args?: Record<string, unknown>): string | null;
+    _get_coworker(coworker: unknown, args?: Record<string, unknown>): string | null;
+    protected _execute(agentName: string | null, task: string, context?: string | null): MaybePromise<string>;
+    protected _run(args: Record<string, unknown>): MaybePromise<unknown>;
+    private formatCoworkers;
+}
+export declare const AskQuestionToolSchema: {
+    question: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    context: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    coworker: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+};
+export declare class AskQuestionTool extends BaseAgentTool {
+    constructor(options?: Partial<BaseToolOptions> & {
+        agents?: readonly AgentLikeForTool[];
+    });
+    protected _run(args: Record<string, unknown>): MaybePromise<string>;
+}
+export declare const DelegateWorkToolSchema: {
+    task: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    context: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    coworker: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+};
+export declare class DelegateWorkTool extends BaseAgentTool {
+    constructor(options?: Partial<BaseToolOptions> & {
+        agents?: readonly AgentLikeForTool[];
+    });
+    protected _run(args: Record<string, unknown>): MaybePromise<string>;
+}
+export type AgentToolsOptions = {
+    agents: readonly AgentLikeForTool[];
+};
+export declare class AgentTools {
+    readonly agents: readonly AgentLikeForTool[];
+    constructor(agentsOrOptions: readonly AgentLikeForTool[] | AgentToolsOptions);
+    tools(): BaseTool[];
+}
+export declare class CacheTools {
+    readonly cacheHandler: CacheHandler;
+    readonly cache_handler: CacheHandler;
+    constructor(cacheHandler?: CacheHandler);
+    tool(): StructuredTool;
+    hitCache(key: string): unknown;
+    hit_cache(key: string): unknown;
+}
+export type MCPNativeToolOptions = {
+    clientFactory?: () => unknown;
+    client_factory?: () => unknown;
+    toolName?: string;
+    tool_name?: string;
+    toolSchema?: Record<string, unknown>;
+    tool_schema?: Record<string, unknown>;
+    serverName?: string;
+    server_name?: string;
+    originalToolName?: string | null;
+    original_tool_name?: string | null;
+};
+export declare class MCPNativeTool extends BaseTool {
+    private readonly clientFactory;
+    private readonly originalToolNameValue;
+    private readonly serverNameValue;
+    constructor(options: MCPNativeToolOptions);
+    constructor(clientFactory: () => unknown, toolName: string, toolSchema: Record<string, unknown>, serverName: string, originalToolName?: string | null);
+    get originalToolName(): string;
+    get original_tool_name(): string;
+    get serverName(): string;
+    get server_name(): string;
+    protected _run(args: Record<string, unknown>): Promise<string>;
+    protected _arun(args: Record<string, unknown>): Promise<string>;
+    runAsync(args?: Record<string, unknown>): Promise<string>;
+    _run_async(args?: Record<string, unknown>): Promise<string>;
+}
+export type MCPToolWrapperOptions = {
+    mcpServerParams?: Record<string, unknown>;
+    mcp_server_params?: Record<string, unknown>;
+    toolName?: string;
+    tool_name?: string;
+    toolSchema?: Record<string, unknown>;
+    tool_schema?: Record<string, unknown>;
+    serverName?: string;
+    server_name?: string;
+};
+type MCPWrapperOperation = (args?: Record<string, unknown>) => Promise<string>;
+export declare class MCPToolWrapper extends BaseTool {
+    private readonly mcpServerParamsValue;
+    private readonly originalToolNameValue;
+    private readonly serverNameValue;
+    constructor(options: MCPToolWrapperOptions);
+    constructor(mcpServerParams: Record<string, unknown>, toolName: string, toolSchema: Record<string, unknown>, serverName: string);
+    get mcpServerParams(): Record<string, unknown>;
+    get mcp_server_params(): Record<string, unknown>;
+    get originalToolName(): string;
+    get original_tool_name(): string;
+    get serverName(): string;
+    get server_name(): string;
+    protected _run(args: Record<string, unknown>): Promise<string>;
+    protected _arun(args: Record<string, unknown>): Promise<string>;
+    runAsync(args?: Record<string, unknown>): Promise<string>;
+    _run_async(args?: Record<string, unknown>): Promise<string>;
+    _retry_with_exponential_backoff(operationFunc: MCPWrapperOperation, args?: Record<string, unknown>): Promise<string>;
+    _execute_single_attempt(operationFunc: MCPWrapperOperation, args?: Record<string, unknown>): Promise<[string | null, string, boolean]>;
+    _execute_tool_with_timeout(args?: Record<string, unknown>): Promise<string>;
+    _execute_tool(args?: Record<string, unknown>): Promise<string>;
+    _do_mcp_call(args?: Record<string, unknown>): Promise<string>;
+}
+export declare class ToolUsageError extends Error {
+    constructor(message: string);
+}
+export type ToolUsageOptions = {
+    toolsHandler?: ToolsHandler | null;
+    tools_handler?: ToolsHandler | null;
+    tools?: readonly Tool[];
+    task?: unknown;
+    functionCallingLlm?: unknown;
+    function_calling_llm?: unknown;
+    agent?: unknown;
+    action?: AgentAction | null;
+    fingerprintContext?: Record<string, string> | null;
+    fingerprint_context?: Record<string, string> | null;
+};
+export declare class ToolUsage {
+    private runAttempts;
+    private readonly maxParsingAttempts;
+    private readonly rememberFormatAfterUsages;
+    readonly toolsHandler: ToolsHandler | null;
+    readonly tools_handler: ToolsHandler | null;
+    readonly tools: readonly Tool[];
+    readonly task: unknown;
+    readonly functionCallingLlm: unknown;
+    readonly function_calling_llm: unknown;
+    readonly agent: unknown;
+    readonly action: AgentAction | null;
+    readonly fingerprintContext: Record<string, string>;
+    readonly fingerprint_context: Record<string, string>;
+    constructor(options?: ToolUsageOptions);
+    get run_attempts(): number;
+    get _run_attempts(): number;
+    get _max_parsing_attempts(): number;
+    get _remember_format_after_usages(): number;
+    parseToolCalling(toolString: string): ToolCalling | ToolUsageError;
+    parse_tool_calling(toolString: string): ToolCalling | ToolUsageError;
+    use(calling: ToolCalling | ToolUsageError, toolString?: string): Promise<string>;
+    ause(calling: ToolCalling | ToolUsageError, toolString?: string): Promise<string>;
+    _ause(toolString: string, tool: Tool, calling: ToolCallingLike): Promise<string>;
+    _format_result(result: unknown): string;
+    _should_remember_format(): boolean;
+    _remember_format(result: unknown): string;
+    _check_tool_repeated_usage(calling: ToolCallingLike): boolean;
+    static _check_usage_limit(tool: unknown, toolName: string): string | null;
+    _check_usage_limit(tool: unknown, toolName: string): string | null;
+    _select_tool(toolName: string): Tool;
+    _render(): string;
+    _function_calling(toolString: string): Promise<ToolCalling>;
+    _original_tool_calling(_toolString: string, raiseError?: boolean): ToolCalling | ToolUsageError;
+    _tool_calling(toolString: string): Promise<ToolCalling | ToolUsageError>;
+    _validate_tool_input(toolInput: string | null | undefined): Record<string, unknown>;
+    _emit_validate_input_error(finalError: string): void;
+    _prepare_event_data(tool: unknown, toolCalling: ToolCallingLike): Record<string, unknown>;
+    _build_fingerprint_config(): Record<string, unknown>;
+    onToolError(tool: unknown, toolCalling: ToolCallingLike, error: unknown): void;
+    on_tool_error(tool: unknown, toolCalling: ToolCallingLike, error: unknown): void;
+    onToolUseFinished(tool: unknown, toolCalling: ToolCallingLike, fromCache: boolean, startedAt: number, result: unknown): void;
+    on_tool_use_finished(tool: unknown, toolCalling: ToolCallingLike, fromCache: boolean, startedAt: number, result: unknown): void;
+    private prepareEventData;
+    private toolUsageErrorEventContext;
+}
+export declare function createTool(options: StructuredToolOptions): StructuredTool;
+export declare function functionTool<TArgs extends readonly unknown[]>(func: ToolFunction<TArgs>): StructuredTool;
+export declare function functionTool(name: string, options?: Omit<ToolDecoratorOptions, "name">): <TArgs extends readonly unknown[]>(func: ToolFunction<TArgs>) => StructuredTool;
+export declare function functionTool(options: ToolDecoratorOptions): <TArgs extends readonly unknown[]>(func: ToolFunction<TArgs>) => StructuredTool;
+export declare const create_tool: typeof createTool;
+export declare const createFunctionTool: typeof functionTool;
+export declare const create_function_tool: typeof functionTool;
+export declare function _make_tool<TArgs extends readonly unknown[]>(func: ToolFunction<TArgs>): StructuredTool;
+export declare function _make_with_name(name: string, options?: Omit<ToolDecoratorOptions, "name">): <TArgs extends readonly unknown[]>(func: ToolFunction<TArgs>) => StructuredTool;
+export declare function _resolve_tool_dict(value: Record<string, unknown>): StructuredTool;
+export declare function isToolCalling(value: unknown): value is ToolCalling;
+export declare function normalizeToolCalling(value: unknown): ToolCalling | null;
+export declare function aexecuteToolAndCheckFinality(agentAction: AgentAction, tools: readonly Tool[], options?: {
+    agentKey?: string | null;
+    agent_key?: string | null;
+    agentRole?: string | null;
+    agent_role?: string | null;
+    toolsHandler?: ToolsHandler | null;
+    tools_handler?: ToolsHandler | null;
+    task?: unknown;
+    agent?: unknown;
+    functionCallingLlm?: unknown;
+    function_calling_llm?: unknown;
+    fingerprintContext?: Record<string, string> | null;
+    fingerprint_context?: Record<string, string> | null;
+    crew?: unknown;
+}): Promise<ToolResult>;
+export declare const aexecute_tool_and_check_finality: typeof aexecuteToolAndCheckFinality;
+export declare function executeToolAndCheckFinality(agentAction: AgentAction, tools: readonly Tool[], options?: Parameters<typeof aexecuteToolAndCheckFinality>[2]): Promise<ToolResult>;
+export declare const execute_tool_and_check_finality: typeof executeToolAndCheckFinality;
+export declare function renderToolsDescription(tools: readonly Tool[]): string;
+export { sanitizeToolName };
+export declare function normalizeToolInput(input: ToolInvocationInput): Record<string, unknown>;
+export declare function validateArgs(toolName: string, schema: ToolArgsSchema, args: Record<string, unknown>): Record<string, unknown>;
+export declare function buildToolContext(input: string, inputs: InputValues): ToolContext;

package/dist/tracing-utils.d.ts

@@ -0,0 +1,56 @@
+export { hasUserDeclinedTracing, has_user_declined_tracing, isTracingEnabled, is_tracing_enabled, updateUserData, update_user_data, } from "./settings.js";
+export type TracingEnabledToken = {
+    readonly previous: boolean | null;
+};
+export type SuppressTracingMessagesToken = {
+    readonly previous: boolean;
+};
+export type GenericSystemIdOptions = {
+    hostname?: () => string;
+    username?: () => string;
+    machine?: () => string;
+    processor?: () => string;
+};
+export type MachineIdOptions = {
+    linuxMachineIdPaths?: readonly string[];
+    genericSystemId?: () => string | null;
+    macAddress?: () => string | null;
+    fallbackId?: string;
+};
+export declare function setTracingEnabled(enabled: boolean): TracingEnabledToken;
+export declare const set_tracing_enabled: typeof setTracingEnabled;
+export declare function resetTracingEnabled(token: TracingEnabledToken): void;
+export declare const reset_tracing_enabled: typeof resetTracingEnabled;
+export declare function isTracingEnabledInContext(): boolean;
+export declare const is_tracing_enabled_in_context: typeof isTracingEnabledInContext;
+export declare function setSuppressTracingMessages(suppress: boolean): SuppressTracingMessagesToken;
+export declare const set_suppress_tracing_messages: typeof setSuppressTracingMessages;
+export declare function shouldSuppressTracingMessages(): boolean;
+export declare const should_suppress_tracing_messages: typeof shouldSuppressTracingMessages;
+export declare function shouldEnableTracing(options?: {
+    override?: boolean | null;
+}): boolean;
+export declare const should_enable_tracing: typeof shouldEnableTracing;
+export declare function onFirstExecutionTracingConfirmation(): boolean;
+export declare const on_first_execution_tracing_confirmation: typeof onFirstExecutionTracingConfirmation;
+export declare function getUserId(): string;
+export declare const get_user_id: typeof getUserId;
+export declare function isFirstExecution(): boolean;
+export declare const is_first_execution: typeof isFirstExecution;
+export declare function markFirstExecutionDone(userConsented?: boolean): void;
+export declare const mark_first_execution_done: typeof markFirstExecutionDone;
+export declare function markFirstExecutionCompleted(userConsented?: boolean): void;
+export declare const mark_first_execution_completed: typeof markFirstExecutionCompleted;
+export declare function safeSerializeToDict(obj: unknown, exclude?: Set<string> | readonly string[] | null): Record<string, unknown>;
+export declare const safe_serialize_to_dict: typeof safeSerializeToDict;
+export declare function truncateMessages<T extends Record<string, unknown>>(messages: readonly T[], maxContentLength?: number, maxMessages?: number): T[];
+export declare const truncate_messages: typeof truncateMessages;
+export declare function shouldAutoCollectFirstTimeTraces(): boolean;
+export declare const should_auto_collect_first_time_traces: typeof shouldAutoCollectFirstTimeTraces;
+export declare function setFirstTimeTraceHook(hook: (() => boolean) | null): void;
+export declare const set_first_time_trace_hook: typeof setFirstTimeTraceHook;
+export declare function promptUserForTraceViewing(timeoutSeconds?: number): boolean;
+export declare const prompt_user_for_trace_viewing: typeof promptUserForTraceViewing;
+export declare function _get_machine_id(options?: MachineIdOptions): string;
+export declare function _get_linux_machine_id(paths?: readonly string[]): string | null;
+export declare function _get_generic_system_id(options?: GenericSystemIdOptions): string | null;

package/dist/training-converter.d.ts

@@ -0,0 +1,36 @@
+import type { LLMMessage } from "./types.js";
+export type TrainingConverterField = {
+    description: string;
+    type?: "string" | "list" | "float" | "number" | "unknown";
+};
+export type TrainingConverterModel = Record<string, TrainingConverterField>;
+export type TrainingConverterLLM = {
+    call(messages: readonly LLMMessage[]): string;
+};
+export type TrainingConverterOptions = {
+    llm: TrainingConverterLLM;
+    text: string;
+    model: TrainingConverterModel;
+    instructions?: string;
+};
+export declare class TrainingConverter {
+    readonly llm: TrainingConverterLLM;
+    readonly text: string;
+    readonly model: TrainingConverterModel;
+    readonly instructions: string;
+    constructor(options: TrainingConverterOptions);
+    toPydantic(): Record<string, unknown>;
+    to_pydantic(): Record<string, unknown>;
+    convertFieldByField(): Record<string, unknown>;
+    _convert_field_by_field(): Record<string, unknown>;
+    askLlmForField(fieldName: string, fieldDescription: string): string;
+    _ask_llm_for_field(fieldName: string, fieldDescription: string): string;
+    processFieldValue(response: string, fieldType?: TrainingConverterField["type"]): unknown;
+    _process_field_value(response: string, fieldType?: TrainingConverterField["type"]): unknown;
+    parseList(response: string): unknown[];
+    _parse_list(response: string): unknown[];
+    static parseFloat(response: string): number;
+    static _parse_float(response: string): number;
+    static stripBullet(item: string): string;
+    static _strip_bullet(item: string): string;
+}

package/dist/training-handler.d.ts

@@ -0,0 +1,10 @@
+import { PickleHandler } from "./file-handler.js";
+export type TrainingData = Record<string, unknown>;
+export type TrainingDataStore = Record<string, Record<string, unknown> | TrainingData>;
+export declare class CrewTrainingHandler extends PickleHandler {
+    saveTrainedData(agentId: string, trainedData: TrainingData): void;
+    save_trained_data(agentId: string, trainedData: TrainingData): void;
+    append(trainIteration: number, agentId: string, newData: unknown): void;
+    clear(): void;
+    private loadTrainingData;
+}