@crewai-ts/core 0.1.2 → 0.1.3

package/dist/agent-executors.d.ts

@@ -0,0 +1,508 @@
+import { Agent, type AgentExecutionOptions } from "./agent.js";
+import type { CheckpointConfig } from "./state.js";
+import type { Crew } from "./crew.js";
+import { PlanStep, StepObservation, TodoItem, TodoList } from "./agent-planning.js";
+import { AgentAction, AgentFinish, parseAgentOutput } from "./agent-parser.js";
+import { Converter } from "./converter.js";
+import { UsageMetrics } from "./llm.js";
+import { StepExecutionContext, StepResult } from "./step-execution-context.js";
+import type { InputValues, LLMMessage, MaybePromise, Tool } from "./types.js";
+export declare const ACTION_INPUT_REGEX: RegExp;
+export declare const ACTION_REGEX: RegExp;
+export declare const ACTION_INPUT_ONLY_REGEX: RegExp;
+export type PlatformApp = Record<string, unknown>;
+export declare const PlatformApp: Readonly<{
+    kind: "PlatformApp";
+}>;
+export type PlatformAppOrAction = PlatformApp | string | ((...args: unknown[]) => unknown);
+export declare const PlatformAppOrAction: Readonly<{
+    kind: "PlatformAppOrAction";
+}>;
+export declare class BaseAgent extends Agent {
+    static fromCheckpoint(config: CheckpointConfig): Promise<BaseAgent>;
+    static from_checkpoint(config: CheckpointConfig): Promise<BaseAgent>;
+    static fork(config: CheckpointConfig, branch?: string | null): Promise<BaseAgent>;
+    static coerceSkillStrings(skills: unknown): unknown;
+    static coerce_skill_strings(skills: unknown): unknown;
+    static processModelConfig(values: Record<string, unknown>): Record<string, unknown>;
+    static process_model_config(values: Record<string, unknown>): Record<string, unknown>;
+    get key(): string;
+    getRole(): string;
+    get_role(): string;
+    copy(): BaseAgent;
+    executeTask(prompt: string, inputs?: {}, taskTools?: readonly Tool[], options?: AgentExecutionOptions): Promise<string>;
+    execute_task(promptOrOptions: Parameters<Agent["execute_task"]>[0], context?: string | null, tools?: readonly Tool[]): Promise<string>;
+    aexecuteTask(prompt: string, inputs?: InputValues, tools?: readonly Tool[], options?: AgentExecutionOptions): Promise<string>;
+    aexecuteTask(promptOrOptions: Parameters<Agent["execute_task"]>[0], context?: string | null, tools?: readonly Tool[]): Promise<string>;
+    aexecute_task(promptOrOptions: Parameters<Agent["aexecute_task"]>[0], context?: string | null, tools?: readonly Tool[]): Promise<string>;
+    createAgentExecutor(): unknown;
+    create_agent_executor(): unknown;
+    getDelegationTools(): readonly Tool[];
+    get_delegation_tools(): readonly Tool[];
+    getPlatformTools(): readonly Tool[];
+    get_platform_tools(): readonly Tool[];
+    getMcpTools(): readonly Tool[];
+    get_mcp_tools(): readonly Tool[];
+    interpolateInputs(inputs: Record<string, unknown>): void;
+    interpolate_inputs(inputs: Record<string, unknown>): void;
+    resolveMemory(): ReturnType<Agent["resolveMemory"]>;
+    resolve_memory(): ReturnType<Agent["resolveMemory"]>;
+    setCacheHandler(cacheHandler: Parameters<Agent["setCacheHandler"]>[0]): void;
+    set_cache_handler(cacheHandler: Parameters<Agent["setCacheHandler"]>[0]): void;
+    setKnowledge(knowledge: Parameters<Agent["setKnowledge"]>[0]): void;
+    set_knowledge(knowledge: Parameters<Agent["setKnowledge"]>[0]): void;
+    setPrivateAttrs(): this;
+    set_private_attrs(): this;
+    setRpmController(controller: Parameters<Agent["setRpmController"]>[0]): void;
+    set_rpm_controller(controller: Parameters<Agent["setRpmController"]>[0]): void;
+    setSkills(resolvedCrewSkills?: readonly unknown[] | null): void;
+    set_skills(resolvedCrewSkills?: readonly unknown[] | null): void;
+    validateAndSetAttributes(): this;
+    validate_and_set_attributes(): this;
+    validateApps(): this;
+    validate_apps(): this;
+    validateMcps(): this;
+    validate_mcps(): this;
+    validateTools(): this;
+    validate_tools(): this;
+}
+export type BaseAgentExecutorOptions = {
+    crew?: Crew | null;
+    agent?: Agent | null;
+    task?: unknown;
+    tools?: readonly Tool[];
+    originalTools?: readonly Tool[];
+    original_tools?: readonly Tool[];
+    maxIter?: number;
+    max_iter?: number;
+    messages?: readonly LLMMessage[];
+    llm?: unknown;
+    prompt?: Record<string, string> | null;
+    toolsNames?: string;
+    tools_names?: string;
+    toolsDescription?: string;
+    tools_description?: string;
+    stop?: readonly string[];
+    stop_words?: readonly string[];
+    requestWithinRpmLimit?: (() => boolean | Promise<boolean>) | null;
+    request_within_rpm_limit?: (() => boolean | Promise<boolean>) | null;
+    callbacks?: readonly unknown[];
+    stepCallback?: ((value: AgentAction | AgentFinish) => unknown) | null;
+    step_callback?: ((value: AgentAction | AgentFinish) => unknown) | null;
+    responseModel?: unknown;
+    response_model?: unknown;
+    respectContextWindow?: boolean;
+    respect_context_window?: boolean;
+};
+export declare class BaseAgentExecutor {
+    readonly executorType: string;
+    readonly executor_type: string;
+    readonly crew: Crew | null;
+    readonly agent: Agent | null;
+    readonly task: unknown;
+    readonly tools: readonly Tool[];
+    readonly originalTools: readonly Tool[];
+    readonly original_tools: readonly Tool[];
+    readonly llm: unknown;
+    readonly prompt: Record<string, string> | null;
+    readonly stop: readonly string[];
+    readonly stop_words: readonly string[];
+    readonly requestWithinRpmLimit: (() => boolean | Promise<boolean>) | null;
+    readonly request_within_rpm_limit: (() => boolean | Promise<boolean>) | null;
+    readonly callbacks: readonly unknown[];
+    readonly stepCallback: ((value: AgentAction | AgentFinish) => unknown) | null;
+    readonly step_callback: ((value: AgentAction | AgentFinish) => unknown) | null;
+    responseModel: unknown;
+    response_model: unknown;
+    readonly respectContextWindow: boolean;
+    readonly respect_context_window: boolean;
+    readonly maxIter: number;
+    readonly max_iter: number;
+    iterations: number;
+    messages: LLMMessage[];
+    constructor(options?: BaseAgentExecutorOptions);
+    invoke(input?: string | readonly LLMMessage[]): MaybePromise<unknown>;
+    ainvoke(input?: string | readonly LLMMessage[]): Promise<unknown>;
+    _save_to_memory(output: AgentFinish): void;
+}
+export declare class AgentExecutorState {
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    messages: LLMMessage[];
+    iterations: number;
+    current_answer: unknown;
+    is_finished: boolean;
+    ask_for_human_input: boolean;
+    use_native_tools: boolean;
+    pending_tool_calls: unknown[];
+    plan: string | null;
+    plan_ready: boolean;
+    todos: TodoList;
+    replan_count: number;
+    last_replan_reason: string | null;
+    observations: Record<number, StepObservation>;
+    execution_log: Array<Record<string, unknown>>;
+    constructor(options?: {
+        messages?: readonly LLMMessage[];
+        iterations?: number;
+    });
+}
+export declare class AgentExecutor extends BaseAgentExecutor {
+    readonly executorType = "experimental";
+    readonly executor_type = "experimental";
+    readonly state: AgentExecutorState;
+    private lastParserError;
+    private lastContextError;
+    private finalizeCalled;
+    private isExecuting;
+    private kickoffInput;
+    private plannerObserver;
+    private stepExecutor;
+    constructor(options?: BaseAgentExecutorOptions & {
+        state?: AgentExecutorState;
+    });
+    private bindStateBackedCompatibilityProperties;
+    get use_stop_words(): boolean;
+    generatePlan(): void;
+    generate_plan(): void;
+    _create_todos_from_plan(steps: readonly PlanStep[]): void;
+    observeStepResult(): "step_observed_low" | "step_observed_medium" | "step_observed_high";
+    observe_step_result(): ReturnType<AgentExecutor["observeStepResult"]>;
+    handleStepObservedLow(): "continue_plan" | "replan_now";
+    handle_step_observed_low(): ReturnType<AgentExecutor["handleStepObservedLow"]>;
+    handleStepObservedMedium(): "continue_plan" | "replan_now";
+    handle_step_observed_medium(): ReturnType<AgentExecutor["handleStepObservedMedium"]>;
+    decideNextAction(): "goal_achieved" | "replan_now" | "refine_and_continue" | "continue_plan";
+    decide_next_action(): ReturnType<AgentExecutor["decideNextAction"]>;
+    handleRefineAndContinue(): "has_todos";
+    handle_refine_and_continue(): "has_todos";
+    handleContinuePlan(): "has_todos" | "all_todos_complete";
+    handle_continue_plan(): ReturnType<AgentExecutor["handleContinuePlan"]>;
+    handleGoalAchieved(): "all_todos_complete";
+    handle_goal_achieved(): "all_todos_complete";
+    handleReplanNow(): "has_todos" | "all_todos_complete";
+    handle_replan_now(): ReturnType<AgentExecutor["handleReplanNow"]>;
+    checkTodosAvailable(): "has_todos" | "no_todos" | "planning_disabled";
+    check_todos_available(): ReturnType<AgentExecutor["checkTodosAvailable"]>;
+    getReadyTodosMethod(): "single_todo_ready" | "multiple_todos_ready" | "all_todos_complete" | "needs_replan";
+    get_ready_todos_method(): ReturnType<AgentExecutor["getReadyTodosMethod"]>;
+    executeTodoSequential(): MaybePromise<"step_executed" | "todo_injected">;
+    execute_todo_sequential(): ReturnType<AgentExecutor["executeTodoSequential"]>;
+    executeTodosParallel(): Promise<"parallel_todos_complete">;
+    execute_todos_parallel(): Promise<"parallel_todos_complete">;
+    afterParallelExecution(): "has_todos" | "all_todos_complete" | "needs_replan";
+    after_parallel_execution(): ReturnType<AgentExecutor["afterParallelExecution"]>;
+    initializeReasoning(): "initialized";
+    initialize_reasoning(): "initialized";
+    ensureForceFinalAnswer(): "agent_finished";
+    ensure_force_final_answer(): "agent_finished";
+    callLlmAndParse(): "parsed" | "parser_error" | "context_error";
+    call_llm_and_parse(): ReturnType<AgentExecutor["callLlmAndParse"]>;
+    callLlmNativeTools(): "native_tool_calls" | "native_finished" | "context_error" | "todo_satisfied";
+    call_llm_native_tools(): ReturnType<AgentExecutor["callLlmNativeTools"]>;
+    routeByAnswerType(): "execute_tool" | "agent_finished" | "todo_satisfied";
+    route_by_answer_type(): ReturnType<AgentExecutor["routeByAnswerType"]>;
+    executeToolAction(): "tool_completed" | "tool_result_is_final";
+    execute_tool_action(): ReturnType<AgentExecutor["executeToolAction"]>;
+    executeNativeTool(): "native_tool_completed" | "tool_result_is_final";
+    execute_native_tool(): ReturnType<AgentExecutor["executeNativeTool"]>;
+    checkNativeTodoCompletion(): "todo_satisfied" | "todo_not_satisfied";
+    check_native_todo_completion(): ReturnType<AgentExecutor["checkNativeTodoCompletion"]>;
+    continueIteration(): "check_iteration";
+    continue_iteration(): "check_iteration";
+    checkMaxIterations(): "force_final_answer" | "continue_reasoning" | "continue_reasoning_native";
+    check_max_iterations(): ReturnType<AgentExecutor["checkMaxIterations"]>;
+    checkTodoCompletion(): "todo_satisfied" | "todo_not_satisfied";
+    check_todo_completion(): ReturnType<AgentExecutor["checkTodoCompletion"]>;
+    markTodoComplete(): "todo_marked";
+    mark_todo_complete(): "todo_marked";
+    private todoCompletionResult;
+    checkMoreTodos(): "has_todos" | "all_todos_complete" | "needs_replan";
+    check_more_todos(): ReturnType<AgentExecutor["checkMoreTodos"]>;
+    incrementAndContinue(): "initialized";
+    increment_and_continue(): "initialized";
+    finalize(): "completed" | "skipped";
+    private canUseLastTodoResultAsFinalAnswer;
+    private synthesizeFinalAnswerFromTodos;
+    private promptString;
+    handleReplan(): "has_todos" | "no_todos";
+    handle_replan(): ReturnType<AgentExecutor["handleReplan"]>;
+    recoverFromParserError(): "initialized";
+    recover_from_parser_error(): "initialized";
+    recoverFromContextLength(): MaybePromise<"initialized">;
+    recover_from_context_length(): MaybePromise<"initialized">;
+    invoke(input?: string | readonly LLMMessage[] | Record<string, unknown>): MaybePromise<unknown>;
+    invokeAsync(inputs: Record<string, unknown>): Promise<Record<string, unknown>>;
+    invoke_async(inputs: Record<string, unknown>): Promise<Record<string, unknown>>;
+    ainvoke(input?: string | readonly LLMMessage[] | Record<string, unknown>): Promise<unknown>;
+    private invokeFromInputs;
+    private invokeFromInputsAsync;
+    private resetInvocationState;
+    injectFilesFromInputs(inputs: Record<string, unknown>): void;
+    _inject_files_from_inputs(inputs: Record<string, unknown>): void;
+    ainjectFilesFromInputs(inputs: Record<string, unknown>): Promise<void>;
+    _ainject_files_from_inputs(inputs: Record<string, unknown>): Promise<void>;
+    private collectFilesFromInputs;
+    private collectFilesFromInputsAsync;
+    private storedFiles;
+    private attachFilesToLastUserMessage;
+    private withLlmStopWords;
+    private withLlmStopWordsAsync;
+    private isPlanningEnabled;
+    private applyHumanFeedback;
+    _append_message_to_state(text: string, role?: "user" | "assistant" | "system"): void;
+    _is_training_mode(): boolean;
+    _handle_crew_training_output(result: unknown, humanFeedback?: string | null): void;
+    _show_start_logs(): void;
+    _show_logs(formattedAnswer: AgentAction | AgentFinish): void;
+    private invokeStepCallback;
+    private injectTodoContext;
+    private buildTodoPrompt;
+    private applyHumanFeedbackAsync;
+    private hasOriginalTools;
+    private activeResponseModel;
+    private openAiToolsForNativeCall;
+    private callExecutorLlm;
+    private callLlmWithMessages;
+    _getReasoningEffort(): "low" | "medium" | "high";
+    _get_reasoning_effort(): ReturnType<AgentExecutor["_getReasoningEffort"]>;
+    _shouldObserveSteps(): boolean;
+    _should_observe_steps(): boolean;
+    private planningConfigRecord;
+    _stepSuccessFromLog(stepNumber: number): boolean | null;
+    _step_success_from_log(step_number: number): boolean | null;
+    _ensurePlannerObserver(): PlannerObserver;
+    _ensure_planner_observer(): PlannerObserver;
+    _observeCompletedStep(options: {
+        completedStep?: TodoItem;
+        completed_step?: TodoItem;
+        result?: unknown;
+        allCompleted?: readonly TodoItem[];
+        all_completed?: readonly TodoItem[];
+        remainingTodos?: readonly TodoItem[];
+        remaining_todos?: readonly TodoItem[];
+        stepSuccess?: boolean | null;
+        step_success?: boolean | null;
+    }): StepObservation;
+    _observe_completed_step(options: Parameters<AgentExecutor["_observeCompletedStep"]>[0]): StepObservation;
+    _ensureStepExecutor(): StepExecutor;
+    _ensure_step_executor(): StepExecutor;
+    _buildContextForTodo(todo: TodoItem): StepExecutionContext;
+    _build_context_for_todo(todo: TodoItem): StepExecutionContext;
+    private _executePlanningTodo;
+    private routeFinishWithTodos;
+    private finishCurrentObservedTodo;
+    private shouldReplan;
+    private getMaxReplans;
+    private getMaxStepIterations;
+    private getStepTimeout;
+    private executeNativeToolCall;
+    private emitNativeToolUsageError;
+    private availableNativeFunctions;
+    private nativeToolByName;
+    private nativeToolMaxUsageLimit;
+    private nativeToolResultAsAnswer;
+    private incrementTaskToolErrors;
+    private triggerReplan;
+    private buildReplanContext;
+    private enhanceTaskForReplan;
+    private applyReplanOutput;
+    private reasoningEffort;
+}
+export declare class CrewAgentExecutorFlow extends AgentExecutor {
+}
+export declare class CrewAgentExecutor extends BaseAgentExecutor {
+    readonly llm: unknown;
+    readonly prompt: Record<string, string> | null;
+    readonly originalTools: readonly Tool[];
+    readonly original_tools: readonly Tool[];
+    readonly toolsNames: string;
+    readonly tools_names: string;
+    readonly toolsDescription: string;
+    readonly tools_description: string;
+    readonly stop: readonly string[];
+    askForHumanInput: boolean;
+    ask_for_human_input: boolean;
+    constructor(options?: BaseAgentExecutorOptions);
+    get use_stop_words(): boolean;
+    invoke(input?: string | readonly LLMMessage[] | Record<string, unknown>): MaybePromise<unknown>;
+    ainvoke(input?: string | readonly LLMMessage[] | Record<string, unknown>): Promise<unknown>;
+    _setup_messages(inputs: Record<string, unknown>): void;
+    static _format_prompt(prompt: string, inputs: Record<string, unknown>): string;
+    _format_prompt(prompt: string, inputs: Record<string, unknown>): string;
+    _invoke_loop(): MaybePromise<AgentFinish>;
+    _ainvoke_loop(): Promise<AgentFinish>;
+    _invoke_loop_react(): AgentFinish;
+    _ainvoke_loop_react(): Promise<AgentFinish>;
+    _invoke_loop_native_tools(): Promise<AgentFinish>;
+    _ainvoke_loop_native_tools(): Promise<AgentFinish>;
+    _invoke_loop_native_no_tools(): AgentFinish;
+    _ainvoke_loop_native_no_tools(): Promise<AgentFinish>;
+    _is_tool_call_list(response: readonly unknown[]): boolean;
+    _handle_human_feedback(formattedAnswer: AgentFinish): AgentFinish;
+    _ahandle_human_feedback(formattedAnswer: AgentFinish): Promise<AgentFinish>;
+    _is_training_mode(): boolean;
+    _format_feedback_message(feedback: string): LLMMessage;
+    _inject_multimodal_files(inputs?: {
+        files?: Record<string, unknown>;
+    } | null): void;
+    _ainject_multimodal_files(inputs?: {
+        files?: Record<string, unknown>;
+    } | null): Promise<void>;
+    _parse_native_tool_call(toolCall: unknown): [string, string, string | Record<string, unknown>] | null;
+    _append_assistant_tool_calls_message(parsedCalls: readonly [string, string, string | Record<string, unknown>][]): void;
+    _handle_native_tool_calls(toolCalls: readonly unknown[], availableFunctions: Record<string, (input?: unknown) => MaybePromise<unknown>>): Promise<AgentFinish | null>;
+    private shouldParallelizeNativeToolCalls;
+    _append_tool_result_and_check_finality(executionResult: {
+        callId?: string | null;
+        call_id?: string | null;
+        funcName?: string | null;
+        func_name?: string | null;
+        result?: unknown;
+    }): AgentFinish | null;
+    _execute_single_native_tool_call(options: {
+        callId?: string;
+        call_id?: string;
+        funcName?: string;
+        func_name?: string;
+        funcArgs?: string | Record<string, unknown>;
+        func_args?: string | Record<string, unknown>;
+        availableFunctions?: Record<string, (input?: unknown) => MaybePromise<unknown>>;
+        available_functions?: Record<string, (input?: unknown) => MaybePromise<unknown>>;
+        originalTool?: Tool | null;
+        original_tool?: Tool | null;
+        shouldExecute?: boolean;
+        should_execute?: boolean;
+    }): Promise<Record<string, unknown>>;
+    _invoke_step_callback(formattedAnswer: AgentAction | AgentFinish): void;
+    _ainvoke_step_callback(formattedAnswer: AgentAction | AgentFinish): Promise<void>;
+    _append_message(text: string, role?: "user" | "assistant" | "system"): void;
+    _append_message_to_state(text: string, role?: "user" | "assistant" | "system"): void;
+    _handle_agent_action(formattedAnswer: AgentAction, toolResult: {
+        result?: unknown;
+        result_as_answer?: boolean;
+        resultAsAnswer?: boolean;
+    }): AgentAction | AgentFinish;
+    _show_logs(_formattedAnswer: AgentAction | AgentFinish): void;
+    _handle_crew_training_output(result: unknown, humanFeedback?: string | null): void;
+    _show_start_logs(): void;
+}
+export type StepExecutorOptions = {
+    agent?: Agent | null;
+    task?: unknown;
+    tools?: readonly Tool[];
+    availableFunctions?: Record<string, unknown>;
+    available_functions?: Record<string, unknown>;
+    callbacks?: readonly unknown[];
+    requestWithinRpmLimit?: (() => boolean | Promise<boolean>) | null;
+    request_within_rpm_limit?: (() => boolean | Promise<boolean>) | null;
+};
+export declare class StepExecutor {
+    readonly agent: Agent | null;
+    readonly task: unknown;
+    readonly tools: readonly Tool[];
+    readonly availableFunctions: Record<string, unknown>;
+    readonly available_functions: Record<string, unknown>;
+    readonly callbacks: readonly unknown[];
+    readonly requestWithinRpmLimit: (() => boolean | Promise<boolean>) | null;
+    readonly request_within_rpm_limit: (() => boolean | Promise<boolean>) | null;
+    constructor(options?: StepExecutorOptions);
+    _parse_tool_args(toolInput: unknown): Record<string, unknown>;
+    static _parse_vision_sentinel(raw: string): [string, string] | null;
+    static _build_observation_message(toolResult: string): LLMMessage;
+    _build_observation_message(toolResult: string): LLMMessage;
+    _validate_expected_tool_usage(todo: TodoItem, toolCallsMade: readonly string[]): void;
+    _buildIsolatedMessages(todo: TodoItem, context: StepExecutionContext): LLMMessage[];
+    _build_isolated_messages(todo: TodoItem, context: StepExecutionContext): LLMMessage[];
+    _buildSystemPrompt(): string;
+    _build_system_prompt(): string;
+    _buildUserPrompt(todo: TodoItem, context: StepExecutionContext): string;
+    _build_user_prompt(todo: TodoItem, context: StepExecutionContext): string;
+    _executeTextParsed(messages: LLMMessage[], toolCallsMade: string[], maxStepIterations?: number, stepTimeout?: number | null, startTime?: number | null): Promise<string>;
+    _execute_text_parsed(messages: LLMMessage[], toolCallsMade: string[], maxStepIterations?: number, stepTimeout?: number | null, startTime?: number | null): Promise<string>;
+    _executeTextToolWithEvents(formatted: AgentAction): Promise<string>;
+    _execute_text_tool_with_events(formatted: AgentAction): Promise<string>;
+    _executeNativeToolCalls(toolCalls: readonly unknown[], messages: LLMMessage[], toolCallsMade: string[]): Promise<string>;
+    _execute_native_tool_calls(toolCalls: readonly unknown[], messages: LLMMessage[], toolCallsMade: string[]): Promise<string>;
+    _executeNative(messages: LLMMessage[], toolCallsMade: string[], maxStepIterations?: number, stepTimeout?: number | null, startTime?: number | null): Promise<string>;
+    _execute_native(messages: LLMMessage[], toolCallsMade: string[], maxStepIterations?: number, stepTimeout?: number | null, startTime?: number | null): Promise<string>;
+    executeStep(step: string, context?: StepExecutionContext, maxStepIterations?: number, stepTimeout?: number | null): Promise<StepResult>;
+    execute_step(step: string, context?: StepExecutionContext, max_step_iterations?: number, step_timeout?: number | null): Promise<StepResult>;
+    execute(todo: string | TodoItem, context?: StepExecutionContext, maxStepIterations?: number, stepTimeout?: number | null): Promise<StepResult>;
+    private executeTodoItem;
+    private hasNativeStepTools;
+    private _buildObservationMessage;
+    private callStepLlm;
+    private buildNativeStepLlmOptions;
+    private buildStepLlmOptions;
+    private runToolByName;
+}
+export declare class PlannerObserver {
+    readonly agent: unknown;
+    readonly task: unknown;
+    readonly kickoffInput: string;
+    readonly kickoff_input: string;
+    readonly llm: unknown;
+    constructor(agent?: unknown, task?: unknown, kickoffInput?: string);
+    _resolveLlm(): unknown;
+    _resolve_llm(): unknown;
+    observe(stepOrOptions: string | TodoItem | {
+        completedStep?: TodoItem;
+        completed_step?: TodoItem;
+        result?: unknown;
+        allCompleted?: readonly TodoItem[];
+        all_completed?: readonly TodoItem[];
+        remainingTodos?: readonly TodoItem[];
+        remaining_todos?: readonly TodoItem[];
+    }, result?: unknown, allCompleted?: readonly TodoItem[], remainingTodos?: readonly TodoItem[]): StepObservation;
+    static heuristicObservation(options: {
+        stepSuccess?: boolean;
+        step_success?: boolean;
+        result?: unknown;
+    }): StepObservation;
+    static heuristic_observation(options: {
+        step_success?: boolean;
+        stepSuccess?: boolean;
+        result?: unknown;
+    }): StepObservation;
+    heuristicObservation(step: string, result: unknown): StepObservation;
+    heuristic_observation(step: string, result: unknown): StepObservation;
+    applyRefinements(observation: StepObservation, remainingTodos: TodoItem[]): TodoItem[];
+    apply_refinements(observation: StepObservation, remaining_todos: TodoItem[]): TodoItem[];
+    _buildObservationMessages(completedStep: TodoItem, result: string, allCompleted: readonly TodoItem[], remainingTodos: readonly TodoItem[]): LLMMessage[];
+    _build_observation_messages(completed_step: TodoItem, result: string, all_completed: readonly TodoItem[], remaining_todos: readonly TodoItem[]): LLMMessage[];
+    static _parseObservationResponse(response: unknown): StepObservation;
+    _parseObservationResponse(response: unknown): StepObservation;
+    static _parse_observation_response(response: unknown): StepObservation;
+    _parse_observation_response(response: unknown): StepObservation;
+}
+export declare class OutputConverter<T = unknown> extends Converter<T> {
+    to_pydantic(currentAttempt?: number): Promise<T>;
+    to_json(currentAttempt?: number): Promise<string | import("./converter.js").ConverterError>;
+}
+export declare class TokenProcess {
+    readonly summary: UsageMetrics;
+    constructor(summary?: UsageMetrics);
+    get totalTokens(): number;
+    get total_tokens(): number;
+    get promptTokens(): number;
+    get prompt_tokens(): number;
+    get cachedPromptTokens(): number;
+    get cached_prompt_tokens(): number;
+    get completionTokens(): number;
+    get completion_tokens(): number;
+    get successfulRequests(): number;
+    get successful_requests(): number;
+    sumPromptTokens(tokensOrMessages: number | readonly LLMMessage[]): number;
+    sum_prompt_tokens(tokensOrMessages: number | readonly LLMMessage[]): number;
+    sumCompletionTokens(tokens: number): void;
+    sum_completion_tokens(tokens: number): void;
+    sumCachedPromptTokens(tokens: number): void;
+    sum_cached_prompt_tokens(tokens: number): void;
+    sumSuccessfulRequests(requests: number): void;
+    sum_successful_requests(requests: number): void;
+    process(text: string): UsageMetrics;
+    getSummary(): UsageMetrics;
+    get_summary(): UsageMetrics;
+}
+export declare function parseAgentStep(text: string): ReturnType<typeof parseAgentOutput>;
+export declare const parse_agent_step: typeof parseAgentStep;

package/dist/agent-parser.d.ts

@@ -0,0 +1,44 @@
+export declare const FINAL_ANSWER_ACTION = "Final Answer:";
+export declare const MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE = "I did it wrong. Invalid Format: I missed the 'Action:' after 'Thought:'. I will do right next, and don't use a tool I have already used.\n";
+export declare const MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE = "I did it wrong. Invalid Format: I missed the 'Action Input:' after 'Action:'. I will do right next, and don't use a tool I have already used.\n";
+export declare const FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = "I did it wrong. Tried to both perform Action and give a Final Answer at the same time, I must do one or the other";
+export declare const UNABLE_TO_REPAIR_JSON_RESULTS: Set<string>;
+export declare class AgentAction {
+    readonly thought: string;
+    readonly tool: string;
+    readonly toolInput: string;
+    readonly tool_input: string;
+    readonly text: string;
+    readonly result: string | null;
+    constructor(options: {
+        thought: string;
+        tool: string;
+        toolInput?: string;
+        tool_input?: string;
+        text: string;
+        result?: string | null;
+    });
+}
+export declare class AgentFinish {
+    readonly thought: string;
+    readonly output: unknown;
+    readonly text: string;
+    constructor(options: {
+        thought: string;
+        output: unknown;
+        text: string;
+    });
+}
+export declare class OutputParserError extends Error {
+    readonly error: string;
+    constructor(error: string);
+}
+export declare function parseAgentOutput(text: string): AgentAction | AgentFinish;
+export declare const parse: typeof parseAgentOutput;
+export declare function extractThought(text: string): string;
+export declare function cleanAction(text: string): string;
+export declare function safeRepairJson(toolInput: string): string;
+export declare const parse_agent_output: typeof parseAgentOutput;
+export declare const _extract_thought: typeof extractThought;
+export declare const _clean_action: typeof cleanAction;
+export declare const _safe_repair_json: typeof safeRepairJson;