@crewai-ts/core 0.1.1 → 0.1.3

package/dist/agent-planning.d.ts

@@ -0,0 +1,358 @@
+import type { LLM, MaybePromise } from "./types.js";
+export type ReasoningEffort = "low" | "medium" | "high";
+export type PlanningConfigOptions = {
+    reasoningEffort?: ReasoningEffort;
+    reasoning_effort?: ReasoningEffort;
+    observeSteps?: boolean | null;
+    observe_steps?: boolean | null;
+    maxAttempts?: number | null;
+    max_attempts?: number | null;
+    maxSteps?: number;
+    max_steps?: number;
+    systemPrompt?: string | null;
+    system_prompt?: string | null;
+    planPrompt?: string | null;
+    plan_prompt?: string | null;
+    refinePrompt?: string | null;
+    refine_prompt?: string | null;
+    maxReplans?: number;
+    max_replans?: number;
+    maxStepIterations?: number;
+    max_step_iterations?: number;
+    stepTimeout?: number | null;
+    step_timeout?: number | null;
+    llm?: LLM | string | null;
+};
+export type AgentPlanStep = {
+    stepNumber?: number;
+    step_number?: number;
+    description: string;
+    toolToUse?: string | null;
+    tool_to_use?: string | null;
+    dependsOn?: readonly number[];
+    depends_on?: readonly number[];
+};
+export type AgentReasoningPlan = {
+    plan: string;
+    steps: readonly AgentPlanStep[];
+    ready: boolean;
+};
+export declare const REASONING_READY_MARKER = "READY: I am ready to execute the task.";
+export declare const TodoStatus: {
+    readonly PENDING: "pending";
+    readonly RUNNING: "running";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+};
+export type TodoStatus = typeof TodoStatus[keyof typeof TodoStatus];
+export declare class PlanStep {
+    readonly stepNumber: number;
+    readonly step_number: number;
+    readonly description: string;
+    readonly toolToUse: string | null;
+    readonly tool_to_use: string | null;
+    readonly dependsOn: readonly number[];
+    readonly depends_on: readonly number[];
+    constructor(options: AgentPlanStep);
+    modelDump(): AgentPlanStep;
+    model_dump(): AgentPlanStep;
+    toJSON(): AgentPlanStep;
+}
+export declare class TodoItem extends PlanStep {
+    readonly id: string;
+    status: TodoStatus;
+    result: string | null;
+    constructor(options: AgentPlanStep & {
+        id?: string;
+        status?: TodoStatus;
+        result?: string | null;
+    });
+    modelDump(): AgentPlanStep & {
+        id: string;
+        status: TodoStatus;
+        result: string | null;
+    };
+    model_dump(): AgentPlanStep & {
+        id: string;
+        status: TodoStatus;
+        result: string | null;
+    };
+    toJSON(): AgentPlanStep & {
+        id: string;
+        status: TodoStatus;
+        result: string | null;
+    };
+}
+export declare class TodoList {
+    items: TodoItem[];
+    constructor(options?: {
+        items?: readonly (TodoItem | (AgentPlanStep & {
+            id?: string;
+            status?: TodoStatus;
+            result?: string | null;
+        }))[];
+    });
+    get currentTodo(): TodoItem | null;
+    get current_todo(): TodoItem | null;
+    get nextPending(): TodoItem | null;
+    get next_pending(): TodoItem | null;
+    get isComplete(): boolean;
+    get is_complete(): boolean;
+    get pendingCount(): number;
+    get pending_count(): number;
+    get completedCount(): number;
+    get completed_count(): number;
+    get runningCount(): number;
+    get running_count(): number;
+    get canParallelize(): boolean;
+    get can_parallelize(): boolean;
+    getByStepNumber(stepNumber: number): TodoItem | null;
+    get_by_step_number(stepNumber: number): TodoItem | null;
+    markRunning(stepNumber: number): void;
+    mark_running(stepNumber: number): void;
+    markCompleted(stepNumber: number, result?: string | null): void;
+    mark_completed(stepNumber: number, result?: string | null): void;
+    markFailed(stepNumber: number, result?: string | null): void;
+    mark_failed(stepNumber: number, result?: string | null): void;
+    getReadyTodos(): TodoItem[];
+    get_ready_todos(): TodoItem[];
+    getCompletedTodos(): TodoItem[];
+    get_completed_todos(): TodoItem[];
+    getFailedTodos(): TodoItem[];
+    get_failed_todos(): TodoItem[];
+    getPendingTodos(): TodoItem[];
+    get_pending_todos(): TodoItem[];
+    replacePendingTodos(newItems: readonly TodoItem[]): void;
+    replace_pending_todos(newItems: readonly TodoItem[]): void;
+    private dependenciesSatisfied;
+    _dependencies_satisfied(item: TodoItem): boolean;
+    modelDump(): {
+        items: Array<ReturnType<TodoItem["modelDump"]>>;
+    };
+    model_dump(): {
+        items: Array<ReturnType<TodoItem["modelDump"]>>;
+    };
+    toJSON(): {
+        items: Array<ReturnType<TodoItem["modelDump"]>>;
+    };
+}
+export declare class StepRefinement {
+    readonly stepNumber: number;
+    readonly step_number: number;
+    readonly newDescription: string;
+    readonly new_description: string;
+    constructor(options: {
+        stepNumber?: number;
+        step_number?: number;
+        newDescription?: string;
+        new_description?: string;
+    });
+}
+type StepRefinementOptions = ConstructorParameters<typeof StepRefinement>[0];
+export declare class StepObservation {
+    readonly stepCompletedSuccessfully: boolean;
+    readonly step_completed_successfully: boolean;
+    readonly keyInformationLearned: string;
+    readonly key_information_learned: string;
+    readonly remainingPlanStillValid: boolean;
+    readonly remaining_plan_still_valid: boolean;
+    readonly suggestedRefinements: readonly StepRefinement[] | null;
+    readonly suggested_refinements: readonly StepRefinement[] | null;
+    readonly needsFullReplan: boolean;
+    readonly needs_full_replan: boolean;
+    readonly replanReason: string | null;
+    readonly replan_reason: string | null;
+    readonly goalAlreadyAchieved: boolean;
+    readonly goal_already_achieved: boolean;
+    static coerceSingleRefinementToList(value: unknown): unknown;
+    static coerce_single_refinement_to_list(value: unknown): unknown;
+    constructor(options?: {
+        stepCompletedSuccessfully?: boolean;
+        step_completed_successfully?: boolean;
+        keyInformationLearned?: string;
+        key_information_learned?: string;
+        remainingPlanStillValid?: boolean;
+        remaining_plan_still_valid?: boolean;
+        suggestedRefinements?: readonly (StepRefinement | StepRefinementOptions)[] | StepRefinement | StepRefinementOptions | null;
+        suggested_refinements?: readonly (StepRefinement | StepRefinementOptions)[] | StepRefinement | StepRefinementOptions | null;
+        needsFullReplan?: boolean;
+        needs_full_replan?: boolean;
+        replanReason?: string | null;
+        replan_reason?: string | null;
+        goalAlreadyAchieved?: boolean;
+        goal_already_achieved?: boolean;
+    });
+}
+export declare class ReasoningPlan {
+    readonly plan: string;
+    readonly steps: readonly PlanStep[];
+    readonly ready: boolean;
+    constructor(options: {
+        plan: string;
+        steps?: readonly (PlanStep | AgentPlanStep)[];
+        ready: boolean;
+    });
+}
+export declare const PlanningPlan: typeof ReasoningPlan;
+export declare const AgentReasoningOutput: {
+    new (options: {
+        plan: ReasoningPlan | {
+            plan: string;
+            steps?: readonly (PlanStep | AgentPlanStep)[];
+            ready: boolean;
+        };
+    }): {
+        readonly plan: ReasoningPlan;
+    };
+};
+export type AgentReasoningOutput = InstanceType<typeof AgentReasoningOutput>;
+export declare const AgentPlanningOutput: {
+    new (options: {
+        plan: ReasoningPlan | {
+            plan: string;
+            steps?: readonly (PlanStep | AgentPlanStep)[];
+            ready: boolean;
+        };
+    }): {
+        readonly plan: ReasoningPlan;
+    };
+};
+export declare const FUNCTION_SCHEMA: {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "create_reasoning_plan";
+        readonly description: "Create or refine a reasoning plan for a task with structured steps";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly plan: {
+                    readonly type: "string";
+                };
+                readonly steps: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly step_number: {
+                                readonly type: "integer";
+                            };
+                            readonly description: {
+                                readonly type: "string";
+                            };
+                            readonly tool_to_use: {
+                                readonly type: readonly ["string", "null"];
+                            };
+                            readonly depends_on: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "integer";
+                                };
+                            };
+                        };
+                        readonly required: readonly ["step_number", "description", "tool_to_use", "depends_on"];
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly ready: {
+                    readonly type: "boolean";
+                };
+            };
+            readonly required: readonly ["plan", "steps", "ready"];
+            readonly additionalProperties: false;
+        };
+    };
+};
+export declare class PlanningConfig {
+    readonly reasoningEffort: ReasoningEffort;
+    readonly reasoning_effort: ReasoningEffort;
+    readonly observeSteps: boolean | null;
+    readonly observe_steps: boolean | null;
+    readonly maxAttempts: number | null;
+    readonly max_attempts: number | null;
+    readonly maxSteps: number;
+    readonly max_steps: number;
+    readonly systemPrompt: string | null;
+    readonly system_prompt: string | null;
+    readonly planPrompt: string | null;
+    readonly plan_prompt: string | null;
+    readonly refinePrompt: string | null;
+    readonly refine_prompt: string | null;
+    readonly maxReplans: number;
+    readonly max_replans: number;
+    readonly maxStepIterations: number;
+    readonly max_step_iterations: number;
+    readonly stepTimeout: number | null;
+    readonly step_timeout: number | null;
+    readonly llm: LLM | string | null;
+    constructor(options?: PlanningConfigOptions);
+}
+export declare function createDefaultPlanningConfigForFlag(): PlanningConfig;
+export declare function normalizePlanningConfig(config: PlanningConfig | PlanningConfigOptions | null | undefined): PlanningConfig | null;
+export declare function createAgentPlanningPrompt(options: {
+    role: string;
+    goal: string;
+    backstory: string;
+    description: string;
+    expectedOutput?: string | null;
+    tools: string;
+    config: PlanningConfig;
+}): string;
+export declare function createAgentRefinePlanningPrompt(options: {
+    role: string;
+    goal: string;
+    backstory: string;
+    currentPlan: string;
+    current_plan?: string;
+    config: PlanningConfig;
+}): string;
+export declare function createAgentPlanningSystemPrompt(options: {
+    role: string;
+    goal: string;
+    backstory: string;
+    config: PlanningConfig;
+}): string;
+export declare function parseAgentPlanningOutput(raw: string): AgentReasoningPlan;
+export declare class AgentReasoning {
+    readonly agent: unknown;
+    readonly task: unknown;
+    readonly config: PlanningConfig;
+    readonly llm: LLM | string | null;
+    readonly description: string;
+    readonly expectedOutput: string;
+    readonly expected_output: string;
+    constructor(agentOrOptions: unknown, task?: unknown, options?: {
+        description?: string | null;
+        expectedOutput?: string | null;
+        expected_output?: string | null;
+    });
+    _get_planning_config(): PlanningConfig;
+    _resolve_llm(): LLM | string | null;
+    handleAgentReasoning(): AgentReasoningOutput | Promise<AgentReasoningOutput>;
+    handle_agent_reasoning(): AgentReasoningOutput | Promise<AgentReasoningOutput>;
+    _execute_planning(): AgentReasoningOutput | Promise<AgentReasoningOutput>;
+    _create_initial_plan(): [string, PlanStep[], boolean] | Promise<[string, PlanStep[], boolean]>;
+    _refine_plan_if_needed(plan: string, steps: PlanStep[], ready: boolean): [string, PlanStep[], boolean] | Promise<[string, PlanStep[], boolean]>;
+    _call_with_function(prompt: string, planType: "create_plan" | "refine_plan"): [string, PlanStep[], boolean] | Promise<[string, PlanStep[], boolean]>;
+    _call_llm_with_prompt(prompt: string, planType: "create_plan" | "refine_plan"): MaybePromise<string>;
+    _get_system_prompt(): string;
+    _get_agent_backstory(): string;
+    _create_planning_prompt(): string;
+    _format_available_tools(): string;
+    _create_refine_prompt(currentPlan: string): string;
+    static _parse_planning_response(response: string): [string, boolean];
+    _parse_planning_response(response: string): [string, boolean];
+    private resolvePlanningOutput;
+    private refinePlanLoop;
+    private textRefinePlan;
+    private parseFunctionPlanResponse;
+    private callPlanningLlm;
+    private llmSupportsFunctionCalling;
+    private agentRole;
+    private agentGoal;
+    private taskId;
+    private emitReasoningStarted;
+    private emitReasoningCompleted;
+    private emitReasoningFailed;
+}
+export declare const AgentPlanning: typeof AgentReasoning;
+export {};

package/dist/agent-utils.d.ts

@@ -0,0 +1,210 @@
+import { type JsonSchema } from "./schema-utils.js";
+import { AgentAction, AgentFinish } from "./agent-parser.js";
+import { BaseTool, ToolResult } from "./tools.js";
+import type { LLMMessage, MaybePromise, Tool, ToolContext } from "./types.js";
+import { Printer } from "./logger.js";
+export type ToolRunner = (input?: ToolContext | Record<string, unknown> | string) => MaybePromise<unknown>;
+export type SummaryContent = {
+    content: string;
+};
+export declare const SummaryContent: {
+    new (options?: {
+        content?: string;
+    }): {
+        readonly content: string;
+    };
+};
+export type AgentKnowledgeContextLike = {
+    agentKnowledgeContext?: string | null;
+    agent_knowledge_context?: string | null;
+    crewKnowledgeContext?: string | null;
+    crew_knowledge_context?: string | null;
+};
+export declare const DELEGATION_TOOL_NAMES: readonly string[];
+export type NativeToolCallResultOptions = {
+    text?: string;
+    result?: unknown;
+    resultAsAnswer?: boolean;
+    result_as_answer?: boolean;
+    toolCallId?: string | null;
+    tool_call_id?: string | null;
+    toolName?: string | null;
+    tool_name?: string | null;
+};
+export declare class NativeToolCallResult {
+    readonly text: string;
+    readonly result: unknown;
+    readonly resultAsAnswer: boolean;
+    readonly result_as_answer: boolean;
+    readonly toolCallId: string | null;
+    readonly tool_call_id: string | null;
+    readonly toolName: string | null;
+    readonly tool_name: string | null;
+    constructor(options?: NativeToolCallResultOptions);
+}
+export type OpenAIFunctionToolSchema = {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: JsonSchema;
+        strict: true;
+    };
+};
+export type OpenAIToolConversionResult = [
+    openaiTools: OpenAIFunctionToolSchema[],
+    availableFunctions: Record<string, ToolRunner>,
+    toolNameMapping: Record<string, Tool>
+];
+type SummaryLLM = {
+    call?: (messages: readonly LLMMessage[], options?: Record<string, unknown>) => MaybePromise<unknown>;
+    acall?: (messages: readonly LLMMessage[], options?: Record<string, unknown>) => MaybePromise<unknown>;
+    get_context_window_size?: () => number;
+    getContextWindowSize?: () => number;
+};
+export declare function getToolNames(tools: readonly Tool[]): string;
+export declare function renderTextDescriptionAndArgs(tools: readonly Tool[]): string;
+export declare function convertToolsToOpenAISchema(tools: readonly Tool[]): OpenAIToolConversionResult;
+export declare function extractTaskSection(text: string): string;
+export declare function hasReachedMaxIterations(iterations: number, maxIterations: number): boolean;
+export declare function _executor_stop_words(executorContext: unknown): string[];
+export declare function _llm_stop_words_applied<T>(llm: unknown, executorContext: unknown, callback: () => MaybePromise<T>): Promise<T>;
+export declare function formatMessageForLLM(prompt: string, role?: "user" | "assistant" | "system"): LLMMessage;
+export declare function combineKnowledgeContext(agent: AgentKnowledgeContextLike): string;
+export declare const _combine_knowledge_context: typeof combineKnowledgeContext;
+export declare function isInsideEventLoop(): boolean;
+export declare const is_inside_event_loop: typeof isInsideEventLoop;
+export declare function parseTools(tools: readonly Tool[]): Tool[];
+export declare const parse_tools: typeof parseTools;
+export type MaxIterationsPrinter = {
+    print?: (options: {
+        content: string;
+        color?: string;
+    }) => void;
+};
+export type MaxIterationsLLM = {
+    call?: (messages: readonly LLMMessage[], options?: Record<string, unknown>) => MaybePromise<unknown>;
+};
+export type HandleMaxIterationsExceededOptions = {
+    formattedAnswer?: AgentAction | AgentFinish | null | undefined;
+    formatted_answer?: AgentAction | AgentFinish | null | undefined;
+    printer?: MaxIterationsPrinter | null | undefined;
+    messages?: LLMMessage[] | undefined;
+    llm?: MaxIterationsLLM | null | undefined;
+    callbacks?: readonly unknown[] | undefined;
+    verbose?: boolean | undefined;
+};
+export declare function handleMaxIterationsExceeded(options?: HandleMaxIterationsExceededOptions): AgentFinish | Promise<AgentFinish>;
+export declare function handleMaxIterationsExceeded(formattedAnswer?: AgentAction | AgentFinish | null, printer?: MaxIterationsPrinter | null, messages?: LLMMessage[], llm?: MaxIterationsLLM | null, callbacks?: readonly unknown[], verbose?: boolean): AgentFinish | Promise<AgentFinish>;
+export declare const handle_max_iterations_exceeded: typeof handleMaxIterationsExceeded;
+export declare function formatAnswer(answer: unknown): string;
+export declare const format_answer: typeof formatAnswer;
+export declare function enforceRpmLimit(requestWithinRpmLimit?: (() => boolean | Promise<boolean>) | null): void;
+export declare const enforce_rpm_limit: typeof enforceRpmLimit;
+export type AgentUtilsExecutorContext = {
+    messages?: readonly LLMMessage[];
+    llm?: unknown;
+    agent?: unknown;
+    task?: unknown;
+    crew?: unknown;
+    iterations?: number;
+};
+export declare function _prepare_llm_call(executorContext: AgentUtilsExecutorContext | null | undefined, messages: readonly LLMMessage[]): Promise<LLMMessage[]>;
+export declare function _validate_and_finalize_llm_response(answer: unknown, executorContext?: AgentUtilsExecutorContext | null | undefined, messages?: readonly LLMMessage[]): Promise<unknown>;
+export declare function getLlmResponse(llm: {
+    call?: (messages: readonly LLMMessage[], options?: Record<string, unknown>) => MaybePromise<unknown>;
+}, messages: readonly LLMMessage[], options?: Record<string, unknown>): Promise<unknown>;
+export declare const get_llm_response: typeof getLlmResponse;
+export declare function agetLlmResponse(llm: {
+    acall?: (messages: readonly LLMMessage[], options?: Record<string, unknown>) => MaybePromise<unknown>;
+    call?: (messages: readonly LLMMessage[], options?: Record<string, unknown>) => MaybePromise<unknown>;
+}, messages: readonly LLMMessage[], options?: Record<string, unknown>): Promise<unknown>;
+export declare const aget_llm_response: typeof agetLlmResponse;
+export declare function processLlmResponse(response: unknown, useStopWords?: boolean): unknown;
+export declare const process_llm_response: typeof processLlmResponse;
+export declare function handleAgentActionCore(action: AgentAction, tools: readonly Tool[]): ToolResult;
+export declare function handleAgentActionCore(formattedAnswer: AgentAction, toolResult: ToolResult, messages?: LLMMessage[] | null, stepCallback?: ((toolResult: ToolResult) => MaybePromise<unknown>) | null, showLogs?: ((formattedAnswer: AgentAction) => unknown) | null): AgentAction | AgentFinish | Promise<AgentAction | AgentFinish>;
+export declare const handle_agent_action_core: typeof handleAgentActionCore;
+export declare function handleUnknownError(error: unknown): string;
+export declare function handleUnknownError(printer: Printer, exception: unknown, verbose?: boolean): void;
+export declare const handle_unknown_error: typeof handleUnknownError;
+export declare function handleOutputParserException(error: unknown): string;
+export declare function handleOutputParserException(error: unknown, messages: LLMMessage[], iterations?: number, logErrorAfter?: number): AgentAction;
+export declare const handle_output_parser_exception: typeof handleOutputParserException;
+export declare function isContextLengthExceeded(error: unknown): boolean;
+export declare const is_context_length_exceeded: typeof isContextLengthExceeded;
+export declare function handleContextLength(messages: readonly LLMMessage[], summary: string): LLMMessage[];
+export declare const handle_context_length: typeof handleContextLength;
+export declare function summarizeMessages(messages: readonly LLMMessage[]): SummaryContent;
+export declare function summarizeMessages(messages: LLMMessage[], llm: SummaryLLM, callbacks?: readonly unknown[], verbose?: boolean): Promise<void>;
+export declare const summarize_messages: typeof summarizeMessages;
+export declare function _asummarize_chunks(chunks: readonly (readonly LLMMessage[])[], llm: {
+    acall?: (messages: readonly LLMMessage[], options?: Record<string, unknown>) => MaybePromise<unknown>;
+    call?: (messages: readonly LLMMessage[], options?: Record<string, unknown>) => MaybePromise<unknown>;
+}, callbacks?: readonly unknown[]): Promise<SummaryContent[]>;
+export declare function _estimate_token_count(text: string): number;
+export declare function _format_messages_for_summary(messages: readonly LLMMessage[]): string;
+export declare function _split_messages_into_chunks(messages: readonly LLMMessage[], max_tokens: number): LLMMessage[][];
+export declare function _extract_summary_tags(text: string): string;
+export declare function showAgentLogs(printer: Printer, agentRole: string, formattedAnswer?: AgentAction | AgentFinish | null, taskDescription?: string | null, verbose?: boolean): void;
+export declare function showAgentLogs(agent: unknown, message: string): void;
+export declare const show_agent_logs: typeof showAgentLogs;
+type AgentRepositoryResponse = {
+    status?: number;
+    status_code?: number;
+    ok?: boolean;
+    text?: string | (() => string);
+    json?: Record<string, unknown> | (() => Record<string, unknown>);
+};
+type AgentRepositoryClient = {
+    getAgent?: (repository: string) => AgentRepositoryResponse;
+    get_agent?: (repository: string) => AgentRepositoryResponse;
+};
+export declare function setCreatePlusClientHook(hook: (() => AgentRepositoryClient) | null): void;
+export declare const set_create_plus_client_hook: typeof setCreatePlusClientHook;
+export declare function loadAgentFromRepository(repository: string): Record<string, unknown>;
+export declare const load_agent_from_repository: typeof loadAgentFromRepository;
+export declare function trackDelegationIfNeeded(toolName: string, args: Record<string, unknown>, task?: {
+    incrementDelegations?: (coworker?: unknown) => void;
+} | null): void;
+export declare const track_delegation_if_needed: typeof trackDelegationIfNeeded;
+export declare function extractToolCallInfo(value: unknown): {
+    toolName: string;
+    arguments: Record<string, unknown> | null;
+    argumentParseError: string | null;
+    id: string | null;
+} | null;
+export declare const extract_tool_call_info: typeof extractToolCallInfo;
+export declare function isToolCallList(value: unknown): value is readonly unknown[];
+export declare const is_tool_call_list: typeof isToolCallList;
+export declare function checkNativeToolSupport(llm: unknown, tools: readonly Tool[]): boolean;
+export declare const check_native_tool_support: typeof checkNativeToolSupport;
+export declare function setupNativeTools(tools: readonly Tool[]): OpenAIToolConversionResult;
+export declare const setup_native_tools: typeof setupNativeTools;
+export declare function buildToolCallsAssistantMessage(results: readonly NativeToolCallResult[]): LLMMessage;
+export declare const build_tool_calls_assistant_message: typeof buildToolCallsAssistantMessage;
+export type ExecuteSingleNativeToolCallOptions = {
+    originalTools?: readonly Tool[];
+    original_tools?: readonly Tool[];
+};
+export declare function executeSingleNativeToolCall(toolCall: unknown, availableFunctions: Record<string, ToolRunner>, options?: ExecuteSingleNativeToolCallOptions): Promise<NativeToolCallResult>;
+export declare const execute_single_native_tool_call: typeof executeSingleNativeToolCall;
+export declare function parseToolCallArgs(value: unknown): Record<string, unknown> | null;
+export type ParsedToolCallArgs = [
+    args: Record<string, unknown> | null,
+    error: {
+        call_id: string;
+        func_name: string;
+        result: string;
+        from_cache: false;
+        original_tool: unknown;
+    } | null
+];
+export declare function parse_tool_call_args(value: unknown, func_name?: string, call_id?: string, original_tool?: unknown): ParsedToolCallArgs;
+export declare const get_tool_names: typeof getToolNames;
+export declare const render_text_description_and_args: typeof renderTextDescriptionAndArgs;
+export declare const convert_tools_to_openai_schema: typeof convertToolsToOpenAISchema;
+export declare const extract_task_section: typeof extractTaskSection;
+export declare const has_reached_max_iterations: typeof hasReachedMaxIterations;
+export declare const format_message_for_llm: typeof formatMessageForLLM;
+export type { BaseTool };