@crewai-ts/core 0.1.2 → 0.1.5

package/dist/crew.d.ts

@@ -0,0 +1,424 @@
+import type { PathLike } from "node:fs";
+import { Agent } from "./agent.js";
+import { FlowTrackable, type ExecutionContext } from "./context.js";
+import type { HumanInputProvider } from "./human-input.js";
+import { Knowledge, type KnowledgeSource } from "./knowledge.js";
+import { type UsageMetrics } from "./llm.js";
+import { Memory, MemoryScope } from "./memory.js";
+import { CrewOutput, TaskOutput } from "./outputs.js";
+import { type Fingerprint, type SecurityConfig } from "./security.js";
+import { type CheckpointConfig, type CheckpointOption } from "./state.js";
+import { ConditionalTask, Task, type TaskInputFiles } from "./task.js";
+import { TaskOutputStorageHandler } from "./task-output-storage.js";
+import { Process, type AgentStepCallback, type CrewKickoffCallback, type InputValues, type TaskCallback, type Tool } from "./types.js";
+import type { LLM } from "./types.js";
+import type { EmbedderConfig } from "./rag.js";
+type PathLikeString = PathLike | {
+    toString(): string;
+};
+export type KickoffOptions = {
+    inputs?: InputValues;
+    inputFiles?: TaskInputFiles;
+    input_files?: TaskInputFiles;
+};
+export type KickoffInput = KickoffOptions | InputValues;
+export type KickoffForEachOptions = {
+    inputs: readonly InputValues[];
+    inputFiles?: TaskInputFiles;
+    input_files?: TaskInputFiles;
+};
+export type KickoffForEachInput = KickoffForEachOptions | readonly InputValues[];
+export type TaskExecutionLog = {
+    task: {
+        id: string;
+        name: string | null;
+        description: string;
+        expectedOutput: string;
+    };
+    output: {
+        description: string;
+        summary?: string;
+        raw: string;
+        pydantic: unknown;
+        jsonDict: Record<string, unknown> | null;
+        outputFormat: string;
+        agent: string;
+        messages?: readonly unknown[];
+    };
+    taskIndex: number;
+    inputs: InputValues;
+    wasReplayed?: boolean;
+};
+type PendingTaskExecution = {
+    task: Task;
+    taskIndex: number;
+    inputs: InputValues;
+    promise: Promise<TaskOutput>;
+};
+type PendingTaskTuple = readonly [Task, Promise<TaskOutput>, number];
+export type ReplayTaskRef = string | number | Task;
+export type ReplayOptions = {
+    taskId?: ReplayTaskRef;
+    task_id?: ReplayTaskRef;
+    inputs?: InputValues;
+};
+export type ResetMemoriesCommandType = "memory" | "knowledge" | "agent_knowledge" | "kickoff_outputs" | "all" | "long" | "short" | "entity" | "external";
+type NormalizedResetMemoriesCommandType = Exclude<ReturnType<typeof normalizeResetMemoriesCommandType>, "all">;
+type MemorySystemConfig = {
+    system: Memory | MemoryScope | readonly Knowledge[] | Crew | null;
+    name: string;
+    reset: (system: Memory | MemoryScope | readonly Knowledge[] | Crew) => void;
+};
+export declare function _resolve_agent(value: unknown, _info?: unknown): unknown;
+export declare function _resolve_agents(value: unknown, info?: unknown): unknown;
+export declare function default_reset(memory: {
+    reset: () => unknown;
+}): unknown;
+export declare function knowledge_reset(crew: {
+    resetKnowledge?: (knowledges: readonly Knowledge[]) => void;
+    reset_knowledge?: (knowledges: readonly Knowledge[]) => void;
+}, knowledges: readonly Knowledge[]): void;
+export type CrewOptions = {
+    id?: string;
+    fromCheckpoint?: boolean;
+    from_checkpoint?: boolean;
+    name?: string | null;
+    config?: string | Record<string, unknown> | null;
+    agents?: readonly Agent[];
+    tasks?: readonly Task[];
+    process?: Process;
+    verbose?: boolean;
+    cache?: boolean;
+    embedder?: EmbedderConfig | null;
+    usageMetrics?: UsageMetrics | null;
+    usage_metrics?: UsageMetrics | null;
+    tokenUsage?: UsageMetrics | null;
+    token_usage?: UsageMetrics | null;
+    maxRpm?: number | null;
+    max_rpm?: number | null;
+    outputLogFile?: boolean | string | null;
+    output_log_file?: boolean | string | null;
+    taskExecutionOutputJsonFiles?: readonly string[] | null;
+    task_execution_output_json_files?: readonly string[] | null;
+    promptFile?: string | null;
+    prompt_file?: string | null;
+    shareCrew?: boolean | null;
+    share_crew?: boolean | null;
+    memory?: boolean | Memory | MemoryScope;
+    knowledge?: Knowledge | null;
+    knowledgeSources?: readonly KnowledgeSource[];
+    knowledge_sources?: readonly KnowledgeSource[];
+    managerAgent?: Agent | null;
+    manager_agent?: Agent | null;
+    managerLlm?: LLM | string | null;
+    manager_llm?: LLM | string | null;
+    functionCallingLlm?: LLM | string | null;
+    function_calling_llm?: LLM | string | null;
+    planning?: boolean | null;
+    stream?: boolean;
+    planningLlm?: LLM | string | null;
+    planning_llm?: LLM | string | null;
+    chatLlm?: LLM | string | null;
+    chat_llm?: LLM | string | null;
+    skills?: readonly unknown[];
+    humanInputProvider?: HumanInputProvider | null;
+    human_input_provider?: HumanInputProvider | null;
+    stepCallback?: AgentStepCallback | null;
+    step_callback?: AgentStepCallback | null;
+    taskCallback?: TaskCallback | null;
+    task_callback?: TaskCallback | null;
+    beforeKickoffCallbacks?: readonly CrewKickoffCallback<InputValues>[];
+    before_kickoff_callbacks?: readonly CrewKickoffCallback<InputValues>[];
+    afterKickoffCallbacks?: readonly CrewKickoffCallback<CrewOutput>[];
+    after_kickoff_callbacks?: readonly CrewKickoffCallback<CrewOutput>[];
+    securityConfig?: SecurityConfig | null;
+    security_config?: SecurityConfig | null;
+    checkpoint?: CheckpointOption;
+    tracing?: boolean | null;
+    executionContext?: ExecutionContext | null;
+    execution_context?: ExecutionContext | null;
+    checkpointInputs?: InputValues | null;
+    checkpoint_inputs?: InputValues | null;
+    checkpointTrain?: boolean | null;
+    checkpoint_train?: boolean | null;
+    checkpointKickoffEventId?: string | null;
+    checkpoint_kickoff_event_id?: string | null;
+    taskOutputStorageHandler?: TaskOutputStorageHandler | null;
+    task_output_storage_handler?: TaskOutputStorageHandler | null;
+    trainedAgentsFile?: PathLikeString | null;
+    trained_agents_file?: PathLikeString | null;
+};
+export declare class Crew extends FlowTrackable {
+    readonly entityType = "crew";
+    readonly entity_type = "crew";
+    readonly id: string;
+    name: string | null;
+    config: Record<string, unknown> | null;
+    agents: Agent[];
+    tasks: Task[];
+    process: Process;
+    verbose: boolean;
+    cache: boolean;
+    embedder: EmbedderConfig | null;
+    maxRpm: number | null;
+    outputLogFile: boolean | string | null;
+    taskExecutionOutputJsonFiles: readonly string[] | null;
+    promptFile: string | null;
+    prompt_file: string | null;
+    shareCrew: boolean | null;
+    share_crew: boolean | null;
+    executionLogs: TaskExecutionLog[];
+    memory: boolean | Memory | MemoryScope;
+    knowledge: Knowledge | null;
+    knowledgeSources: readonly KnowledgeSource[];
+    managerAgent: Agent | null;
+    manager_agent: Agent | null;
+    managerLlm: LLM | string | null;
+    functionCallingLlm: LLM | string | null;
+    function_calling_llm: LLM | string | null;
+    planning: boolean;
+    stream: boolean;
+    planningLlm: LLM | string | null;
+    chatLlm: LLM | string | null;
+    chat_llm: LLM | string | null;
+    skills: readonly unknown[];
+    humanInputProvider: HumanInputProvider | null;
+    stepCallback: AgentStepCallback | null;
+    taskCallback: TaskCallback | null;
+    usageMetrics: UsageMetrics;
+    usage_metrics: UsageMetrics;
+    tokenUsage: UsageMetrics;
+    token_usage: UsageMetrics;
+    private planningUsageMetrics;
+    private readonly rpmController;
+    private readonly cacheHandler;
+    private readonly fileHandler;
+    private readonly resolvedMemory;
+    beforeKickoffCallbacks: CrewKickoffCallback<InputValues>[];
+    afterKickoffCallbacks: CrewKickoffCallback<CrewOutput>[];
+    readonly securityConfig: SecurityConfig;
+    readonly security_config: SecurityConfig;
+    checkpoint: CheckpointConfig | false | null;
+    tracing: boolean | null;
+    executionContext: ExecutionContext | null;
+    execution_context: ExecutionContext | null;
+    checkpointInputs: InputValues | null;
+    checkpoint_inputs: InputValues | null;
+    checkpointTrain: boolean | null;
+    checkpoint_train: boolean | null;
+    checkpointKickoffEventId: string | null;
+    checkpoint_kickoff_event_id: string | null;
+    readonly taskOutputStorageHandler: TaskOutputStorageHandler | null;
+    readonly task_output_storage_handler: TaskOutputStorageHandler | null;
+    trainedAgentsFile: string | null;
+    trained_agents_file: string | null;
+    constructor(options?: CrewOptions);
+    static fromCheckpoint(config: CheckpointConfig): Promise<Crew>;
+    static from_checkpoint(config: CheckpointConfig): Promise<Crew>;
+    static fork(config: CheckpointConfig, branch?: string | null): Promise<Crew>;
+    static dropUnresolvableCallbacks<T>(value: T[] | T): T[] | T;
+    static _drop_unresolvable_callbacks<T>(value: T[] | T): T[] | T;
+    static denyUserSetId(value: string | null | undefined, context?: {
+        fromCheckpoint?: boolean;
+        from_checkpoint?: boolean;
+    } | null): string | null | undefined;
+    static _deny_user_set_id(value: string | null | undefined, context?: {
+        fromCheckpoint?: boolean;
+        from_checkpoint?: boolean;
+    } | null): string | null | undefined;
+    static coerceSkillStrings(skills: unknown): unknown;
+    static coerce_skill_strings(skills: unknown): unknown;
+    static checkConfigType(value: string | Record<string, unknown> | null): Record<string, unknown> | null;
+    static check_config_type(value: string | Record<string, unknown> | null): Record<string, unknown> | null;
+    get fingerprint(): Fingerprint;
+    get key(): string;
+    toJSON(): Record<string, unknown>;
+    setPrivateAttrs(): this;
+    restoreRuntime(): void;
+    _restore_runtime(): void;
+    rebindMemoryViews(): void;
+    _rebind_memory_views(): void;
+    restoreEventScope(): void;
+    _restore_event_scope(): void;
+    set_private_attrs(): this;
+    createCrewMemory(): this;
+    create_crew_memory(): this;
+    createCrewKnowledge(): this;
+    create_crew_knowledge(): this;
+    checkManagerLlm(): this;
+    check_manager_llm(): this;
+    checkConfig(): this;
+    check_config(): this;
+    validateTasks(): this;
+    validate_tasks(): this;
+    validateEndWithAtMostOneAsyncTask(): this;
+    validate_end_with_at_most_one_async_task(): this;
+    validateMustHaveNonConditionalTask(): this;
+    validate_must_have_non_conditional_task(): this;
+    validateFirstTask(): this;
+    validate_first_task(): this;
+    validateAsyncTasksNotAsync(): this;
+    validate_async_tasks_not_async(): this;
+    validateAsyncTaskCannotIncludeSequentialAsyncTasksInContext(): this;
+    validate_async_task_cannot_include_sequential_async_tasks_in_context(): this;
+    validateContextNoFutureTasks(): this;
+    validate_context_no_future_tasks(): this;
+    private setUsageMetrics;
+    configureAgents(): void;
+    kickoff(options?: KickoffInput, inputFiles?: TaskInputFiles | null): Promise<CrewOutput>;
+    kickoffAsync(options?: KickoffInput, inputFiles?: TaskInputFiles | null): Promise<CrewOutput>;
+    kickoff_async(options?: KickoffInput, inputFiles?: TaskInputFiles | null): Promise<CrewOutput>;
+    akickoff(options?: KickoffInput, inputFiles?: TaskInputFiles | null): Promise<CrewOutput>;
+    kickoffForEach(options: KickoffForEachInput): Promise<CrewOutput[]>;
+    kickoff_for_each(options: KickoffForEachInput): Promise<CrewOutput[]>;
+    kickoffForEachAsync(options: KickoffForEachInput): Promise<CrewOutput[]>;
+    kickoff_for_each_async(options: KickoffForEachInput): Promise<CrewOutput[]>;
+    akickoffForEach(options: KickoffForEachInput): Promise<CrewOutput[]>;
+    akickoff_for_each(options: KickoffForEachInput): Promise<CrewOutput[]>;
+    train(nIterations: number, filename: string, inputs?: InputValues | null): Promise<void>;
+    test(nIterations: number, evalLlm: LLM | string | null, inputs?: InputValues | null): Promise<string>;
+    replay(taskRef: ReplayTaskRef | ReplayOptions, inputs?: InputValues): Promise<CrewOutput>;
+    private restoreReplayTaskOutputs;
+    copy(): Crew;
+    runSequentialProcessCompat(inputs?: InputValues, inputFiles?: TaskInputFiles): Promise<CrewOutput>;
+    _run_sequential_process(inputs?: InputValues, input_files?: TaskInputFiles): Promise<CrewOutput>;
+    arunSequentialProcess(inputs?: InputValues, inputFiles?: TaskInputFiles): Promise<CrewOutput>;
+    _arun_sequential_process(inputs?: InputValues, input_files?: TaskInputFiles): Promise<CrewOutput>;
+    runHierarchicalProcessCompat(inputs?: InputValues, inputFiles?: TaskInputFiles): Promise<CrewOutput>;
+    _run_hierarchical_process(inputs?: InputValues, input_files?: TaskInputFiles): Promise<CrewOutput>;
+    arunHierarchicalProcess(inputs?: InputValues, inputFiles?: TaskInputFiles): Promise<CrewOutput>;
+    _arun_hierarchical_process(inputs?: InputValues, input_files?: TaskInputFiles): Promise<CrewOutput>;
+    createManagerAgent(): Agent;
+    _create_manager_agent(): Agent;
+    getExecutionStartIndex(tasks?: readonly Task[]): number | null;
+    _get_execution_start_index(tasks?: readonly Task[]): number | null;
+    processAsyncTaskResults(pendingTasks: readonly (PendingTaskExecution | PendingTaskTuple)[], wasReplayed?: boolean): Promise<TaskOutput[]>;
+    _process_async_tasks(pending_tasks: readonly (PendingTaskExecution | PendingTaskTuple)[], was_replayed?: boolean): Promise<TaskOutput[]>;
+    logTaskStartCompat(task: Task, role?: string | Agent | null): void;
+    _log_task_start(task: Task, role?: string | Agent | null): Promise<void>;
+    storeExecutionLogCompat(task: Task, output: TaskOutput, taskIndex: number, wasReplayed?: boolean, inputs?: InputValues): Promise<void>;
+    _store_execution_log(task: Task, output: TaskOutput, task_index: number, was_replayed?: boolean, inputs?: InputValues): Promise<void>;
+    private runProcess;
+    setupFromConfigCompat(): void;
+    _setup_from_config(): void;
+    createTask(taskConfig: Record<string, unknown>): Task;
+    _create_task(task_config: Record<string, unknown>): Task;
+    setupForTraining(filename: string): Promise<void>;
+    _setup_for_training(filename: string): Promise<void>;
+    postKickoff(result: CrewOutput): CrewOutput;
+    _post_kickoff(result: CrewOutput): CrewOutput;
+    aexecuteTasks(tasks?: readonly Task[], startIndex?: number | null, wasReplayed?: boolean, inputs?: InputValues, inputFiles?: TaskInputFiles): Promise<CrewOutput>;
+    _aexecute_tasks(tasks?: readonly Task[], start_index?: number | null, was_replayed?: boolean): Promise<CrewOutput>;
+    ahandleConditionalTask(task: ConditionalTask, taskOutputs: TaskOutput[], pendingTasks?: (PendingTaskExecution | PendingTaskTuple)[], taskIndex?: number, wasReplayed?: boolean): Promise<TaskOutput | null>;
+    _ahandle_conditional_task(task: ConditionalTask, task_outputs: TaskOutput[], pending_tasks?: (PendingTaskExecution | PendingTaskTuple)[], task_index?: number, was_replayed?: boolean): Promise<TaskOutput | null>;
+    aprocessAsyncTasks(pendingTasks: readonly (PendingTaskExecution | PendingTaskTuple)[], wasReplayed?: boolean): Promise<TaskOutput[]>;
+    _aprocess_async_tasks(pending_tasks: readonly (PendingTaskExecution | PendingTaskTuple)[], was_replayed?: boolean): Promise<TaskOutput[]>;
+    handleCrewPlanningCompat(): Promise<void>;
+    _handle_crew_planning(): Promise<void>;
+    executeTasks(tasks?: readonly Task[], startIndex?: number | null, wasReplayed?: boolean, inputs?: InputValues, inputFiles?: TaskInputFiles): Promise<CrewOutput>;
+    _execute_tasks(tasks?: readonly Task[], start_index?: number | null, was_replayed?: boolean): Promise<CrewOutput>;
+    setTasksCallbacks(): void;
+    _set_tasks_callbacks(): void;
+    interpolateInputs(inputs: InputValues, options?: {
+        strictMissing?: boolean;
+    }): void;
+    _interpolate_inputs(inputs: InputValues): void;
+    finishExecution(finalStringOutput?: string): void;
+    _finish_execution(final_string_output?: string): void;
+    static showTracingDisabledMessage(): void;
+    static _show_tracing_disabled_message(): void;
+    private setupFromConfig;
+    private agentForTaskConfig;
+    private withStreamDisabled;
+    private createForEachStreamingOutputs;
+    private handleCrewPlanning;
+    private runSequentialProcess;
+    private runHierarchicalProcess;
+    private processAsyncTasks;
+    private logTaskStart;
+    private logTaskResult;
+    private storeExecutionLog;
+    private validateSequentialTasks;
+    private validateConditionalTasks;
+    private handleConditionalTask;
+    private contextForTask;
+    private triggerPayloadForTask;
+    private replaySequentialProcess;
+    private replayHierarchicalProcess;
+    private findReplayStartIndex;
+    private validateHierarchicalProcess;
+    private getManagerAgent;
+    private resolveMemory;
+    queryKnowledge(query: string | readonly string[], resultsLimit?: number, scoreThreshold?: number): import("./knowledge.js").KnowledgeSearchResult[] | null;
+    query_knowledge(query: string | readonly string[], results_limit?: number, score_threshold?: number): import("./knowledge.js").KnowledgeSearchResult[] | null;
+    aqueryKnowledge(query: string | readonly string[], resultsLimit?: number, scoreThreshold?: number): Promise<import("./knowledge.js").KnowledgeSearchResult[] | null>;
+    aquery_knowledge(query: string | readonly string[], results_limit?: number, score_threshold?: number): Promise<import("./knowledge.js").KnowledgeSearchResult[] | null>;
+    resetMemories(commandType: ResetMemoriesCommandType): void;
+    reset_memories(commandType: ResetMemoriesCommandType): void;
+    resetMemorySystem(system: Memory | MemoryScope | readonly Knowledge[] | Crew, _name: string, resetFn: (system: Memory | MemoryScope | readonly Knowledge[] | Crew) => void): void;
+    _reset_memory_system(system: Memory | MemoryScope | readonly Knowledge[] | Crew, name: string, reset_fn: (system: Memory | MemoryScope | readonly Knowledge[] | Crew) => void): void;
+    resetAllMemories(): void;
+    _reset_all_memories(): void;
+    resetSpecificMemory(memoryType: NormalizedResetMemoriesCommandType): void;
+    _reset_specific_memory(memory_type: NormalizedResetMemoriesCommandType): void;
+    getMemorySystems(): Record<NormalizedResetMemoriesCommandType, MemorySystemConfig>;
+    _get_memory_systems(): Record<NormalizedResetMemoriesCommandType, MemorySystemConfig>;
+    fetchInputs(): Set<string>;
+    fetch_inputs(): Set<string>;
+    resetKnowledge(knowledges: readonly Knowledge[]): void;
+    reset_knowledge(knowledges: readonly Knowledge[]): void;
+    setAllowCrewaiTriggerContextForFirstTask(inputs?: InputValues | null): void;
+    _set_allow_crewai_trigger_context_for_first_task(inputs?: InputValues | null): void;
+    getAgentToUse(task: Task): Agent | null;
+    _get_agent_to_use(task: Task): Agent | null;
+    static mergeTools(existingTools: readonly Tool[], newTools: readonly Tool[]): Tool[];
+    static _merge_tools(existing_tools: readonly Tool[], new_tools: readonly Tool[]): Tool[];
+    prepareTools(agent: Agent | null, task: Task, tools: readonly Tool[]): Tool[];
+    _prepare_tools(agent: Agent | null, task: Task, tools: readonly Tool[]): Tool[];
+    injectDelegationTools(tools: readonly Tool[], taskAgent: Agent, agents: readonly Agent[]): Tool[];
+    _inject_delegation_tools(tools: readonly Tool[], task_agent: Agent, agents: readonly Agent[]): Tool[];
+    injectPlatformTools(tools: readonly Tool[], taskAgent: Agent): Tool[];
+    _inject_platform_tools(tools: readonly Tool[], task_agent: Agent): Tool[];
+    injectMcpTools(tools: readonly Tool[], taskAgent: Agent): Tool[];
+    _inject_mcp_tools(tools: readonly Tool[], task_agent: Agent): Tool[];
+    addMultimodalTools(agent: Agent, tools: readonly Tool[]): Tool[];
+    _add_multimodal_tools(agent: Agent, tools: readonly Tool[]): Tool[];
+    addCodeExecutionTools(agent: Agent, tools: readonly Tool[]): Tool[];
+    _add_code_execution_tools(agent: Agent, tools: readonly Tool[]): Tool[];
+    addMemoryTools(tools: readonly Tool[], memory: Memory | MemoryScope): Tool[];
+    _add_memory_tools(tools: readonly Tool[], memory: Memory | MemoryScope): Tool[];
+    addFileTools(tools: readonly Tool[], files: TaskInputFiles): Tool[];
+    _add_file_tools(tools: readonly Tool[], files: TaskInputFiles): Tool[];
+    addDelegationTools(task: Task, tools: readonly Tool[]): Tool[];
+    _add_delegation_tools(task: Task, tools: readonly Tool[]): Tool[];
+    addPlatformTools(task: Task, tools: readonly Tool[]): Tool[];
+    _add_platform_tools(task: Task, tools: readonly Tool[]): Tool[];
+    addMcpTools(task: Task, tools: readonly Tool[]): Tool[];
+    _add_mcp_tools(task: Task, tools: readonly Tool[]): Tool[];
+    updateManagerTools(task: Task, tools: readonly Tool[]): Tool[];
+    _update_manager_tools(task: Task, tools: readonly Tool[]): Tool[];
+    getContext(task: Task, taskOutputs: readonly TaskOutput[]): string;
+    _get_context(task: Task, task_outputs: readonly TaskOutput[]): string;
+    handleConditionalTaskCompat(task: ConditionalTask, taskOutputs: TaskOutput[], pendingTasks?: (PendingTaskExecution | PendingTaskTuple)[], taskIndex?: number, wasReplayed?: boolean): Promise<TaskOutput | null>;
+    _handle_conditional_task(task: ConditionalTask, task_outputs: TaskOutput[], pending_tasks?: (PendingTaskExecution | PendingTaskTuple)[], task_index?: number, was_replayed?: boolean): Promise<TaskOutput | null>;
+    processTaskResult(task: Task, output: TaskOutput): Promise<void>;
+    _process_task_result(task: Task, output: TaskOutput): Promise<void>;
+    createCrewOutput(taskOutputs: readonly TaskOutput[]): CrewOutput;
+    _create_crew_output(task_outputs: readonly TaskOutput[]): CrewOutput;
+    static findTaskIndex(taskId: string, storedOutputs: readonly unknown[]): number | null;
+    static _find_task_index(task_id: string, stored_outputs: readonly unknown[]): number | null;
+    private toolsForTask;
+    private toolsForHierarchicalTask;
+    private applyCrewCache;
+    private stepCallbacksFor;
+    private coworkersFor;
+    private resetAvailableMemorySystems;
+    private resetSpecificMemorySystem;
+    private buildMemorySystems;
+    calculateUsageMetrics(): UsageMetrics;
+    calculate_usage_metrics(): UsageMetrics;
+    toString(): string;
+    __repr__(): string;
+}
+declare function normalizeResetMemoriesCommandType(commandType: ResetMemoriesCommandType): "memory" | "all" | "kickoff_outputs" | "knowledge" | "agent_knowledge";
+export {};

package/dist/decorators.d.ts

@@ -0,0 +1,20 @@
+import { Crew } from "./crew.js";
+type AnyMethod<This = unknown, Args extends unknown[] = unknown[], Return = unknown> = (this: This, ...args: Args) => Return;
+export declare const agent: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const task: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const beforeKickoff: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const before_kickoff: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const afterKickoff: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const after_kickoff: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const tool: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const llm: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const callback: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const outputJson: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const output_json: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const outputPydantic: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const output_pydantic: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const cacheHandler: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare const cache_handler: <This extends object, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>) => AnyMethod<This, Args, Return>;
+export declare function crew<This extends object, Args extends unknown[]>(value: AnyMethod<This, Args, Crew>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Crew>>): AnyMethod<This, Args, Crew>;
+export declare function CrewBase<T extends abstract new (...args: never[]) => object>(constructor: T, context: ClassDecoratorContext<T>): T;
+export {};

package/dist/env.d.ts

@@ -0,0 +1,13 @@
+export declare const CC_ENV_VAR = "CLAUDECODE";
+export declare const CODEX_ENV_VARS: readonly ["CODEX_CI", "CODEX_MANAGED_BY_NPM", "CODEX_SANDBOX", "CODEX_SANDBOX_NETWORK_DISABLED", "CODEX_THREAD_ID"];
+export declare const CURSOR_ENV_VARS: readonly ["CURSOR_AGENT", "CURSOR_EXTENSION_HOST_ROLE", "CURSOR_SANDBOX", "CURSOR_TRACE_ID", "CURSOR_WORKSPACE_LABEL"];
+export declare function isCodexEnv(env?: NodeJS.ProcessEnv): boolean;
+export declare const is_codex_env: typeof isCodexEnv;
+export declare const _is_codex_env: typeof isCodexEnv;
+export declare function isCursorEnv(env?: NodeJS.ProcessEnv): boolean;
+export declare const is_cursor_env: typeof isCursorEnv;
+export declare const _is_cursor_env: typeof isCursorEnv;
+export declare function getEnvContext(env?: NodeJS.ProcessEnv): void;
+export declare const get_env_context: typeof getEnvContext;
+export declare function resetEnvContextForTesting(): void;
+export declare const reset_env_context_for_testing: typeof resetEnvContextForTesting;

package/dist/errors.d.ts

@@ -0,0 +1,27 @@
+export declare class DatabaseOperationError extends Error {
+    readonly originalError: Error | null;
+    readonly original_error: Error | null;
+    constructor(message: string, originalError?: Error | null);
+}
+export declare const DatabaseError: {
+    readonly INIT_ERROR: "Database initialization error: {}";
+    readonly SAVE_ERROR: "Error saving task outputs: {}";
+    readonly UPDATE_ERROR: "Error updating task outputs: {}";
+    readonly LOAD_ERROR: "Error loading task outputs: {}";
+    readonly DELETE_ERROR: "Error deleting task outputs: {}";
+    readonly formatError: (template: string, error: Error) => string;
+    readonly format_error: (template: string, error: Error) => string;
+};
+export declare class AgentRepositoryError extends Error {
+    constructor(message: string);
+}
+export declare const CONTEXT_LIMIT_ERRORS: readonly ["expected a string with maximum length", "maximum context length", "context length exceeded", "context_length_exceeded", "context window full", "too many tokens", "input is too long", "exceeds token limit"];
+export declare class LLMContextLengthExceededError extends Error {
+    readonly originalErrorMessage: string;
+    readonly original_error_message: string;
+    constructor(errorMessage: string);
+    static isContextLimitError(errorMessage: string): boolean;
+    static is_context_limit_error(errorMessage: string): boolean;
+    static getErrorMessage(errorMessage: string): string;
+    static get_error_message(errorMessage: string): string;
+}