@crewai-ts/core 0.1.2 → 0.1.5

package/dist/metadata.d.ts

@@ -0,0 +1,9 @@
+export type MethodKind = "agent" | "task" | "crew" | "beforeKickoff" | "afterKickoff" | "tool" | "llm" | "callback" | "outputJson" | "outputPydantic" | "cacheHandler";
+export type MethodEntry = {
+    name: string | symbol;
+    kind: MethodKind;
+};
+export type Constructor = abstract new (...args: never[]) => object;
+export declare function registerCrewMethod(target: object, entry: MethodEntry): void;
+export declare function initializeCrewMetadata(constructor: Constructor): void;
+export declare function getCrewMetadata(instanceOrConstructor: object | Constructor): readonly MethodEntry[];

package/dist/misc-compat.d.ts

@@ -0,0 +1,125 @@
+export declare function setSuppressTracingMessages(suppress: boolean): boolean;
+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 setTracingEnabled(enabled: boolean): boolean | null;
+export declare const set_tracing_enabled: typeof setTracingEnabled;
+export declare function resetTracingEnabled(token: boolean | null): 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 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?: ReadonlySet<string> | null): Record<string, unknown>;
+export declare const safe_serialize_to_dict: typeof safeSerializeToDict;
+export declare function truncateMessages(messages: readonly Record<string, unknown>[], maxContentLength?: number, maxMessages?: number): Record<string, unknown>[];
+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 promptUserForTraceViewing(_timeoutSeconds?: number): boolean;
+export declare const prompt_user_for_trace_viewing: typeof promptUserForTraceViewing;
+export declare const CREWAI_ORANGE = "#FF5A50";
+export declare const DARK_GRAY = "#333333";
+export declare const WHITE = "#FFFFFF";
+export declare const GRAY = "#666666";
+export declare const BG_DARK = "#0d1117";
+export declare const BG_CARD = "#161b22";
+export declare const BORDER_SUBTLE = "#30363d";
+export declare const TEXT_PRIMARY = "#e6edf3";
+export declare const TEXT_SECONDARY = "#7d8590";
+export declare const CSSExtension: Readonly<{
+    kind: "CSSExtension";
+}>;
+export declare const JSExtension: Readonly<{
+    kind: "JSExtension";
+}>;
+export type FlowVizStructure = {
+    nodes?: Record<string, Record<string, unknown>>;
+    edges?: readonly Record<string, unknown>[];
+    start_methods?: readonly string[];
+    startMethods?: readonly string[];
+};
+export declare function calculateNodePositions(dag: FlowVizStructure): Record<string, {
+    level: number;
+    x: number;
+    y: number;
+}>;
+export declare const calculate_node_positions: typeof calculateNodePositions;
+export declare function renderInteractive(dag: FlowVizStructure, filename?: string, show?: boolean): string;
+export declare const render_interactive: typeof renderInteractive;
+export declare const ProtocolVersion: readonly string[];
+export declare const Url: StringConstructor;
+export declare const AgentResponseProtocol: Readonly<{
+    kind: "AgentResponseProtocol";
+}>;
+export declare const PartsMetadataDict: Readonly<{
+    kind: "PartsMetadataDict";
+}>;
+export declare const PartsDict: Readonly<{
+    kind: "PartsDict";
+}>;
+export declare const PollingHandlerType: Readonly<{
+    kind: "PollingHandlerType";
+}>;
+export declare const StreamingHandlerType: Readonly<{
+    kind: "StreamingHandlerType";
+}>;
+export declare const PushNotificationHandlerType: Readonly<{
+    kind: "PushNotificationHandlerType";
+}>;
+export declare const HandlerType: Readonly<{
+    kind: "HandlerType";
+}>;
+export declare const HANDLER_REGISTRY: Map<unknown, unknown>;
+export declare class CommonParams {
+    readonly turn_number: number;
+    readonly is_multiturn: boolean;
+    readonly agent_role: string | null;
+    readonly endpoint: string;
+    readonly a2a_agent_name: string | null;
+    readonly context_id: string | null;
+    readonly from_task: unknown;
+    readonly from_agent: unknown;
+    constructor(options: {
+        turn_number?: number;
+        is_multiturn?: boolean;
+        agent_role?: string | null;
+        endpoint: string;
+        a2a_agent_name?: string | null;
+        context_id?: string | null;
+        from_task?: unknown;
+        from_agent?: unknown;
+    });
+}
+export declare const BaseHandlerKwargs: Readonly<{
+    kind: "BaseHandlerKwargs";
+}>;
+export declare const PollingHandlerKwargs: Readonly<{
+    kind: "PollingHandlerKwargs";
+}>;
+export declare const StreamingHandlerKwargs: Readonly<{
+    kind: "StreamingHandlerKwargs";
+}>;
+export declare const PushNotificationHandlerKwargs: Readonly<{
+    kind: "PushNotificationHandlerKwargs";
+}>;
+export declare const PushNotificationResultStore: Readonly<{
+    kind: "PushNotificationResultStore";
+}>;
+export declare const UpdateHandler: Readonly<{
+    kind: "UpdateHandler";
+}>;
+export declare function extractCommonParams(kwargs: Record<string, unknown>): CommonParams;
+export declare const extract_common_params: typeof extractCommonParams;

package/dist/openai-completion.d.ts

@@ -0,0 +1,324 @@
+import { ConfiguredLLM, LocalFileUploader, type BaseLLMOptions, type LLMCallOptions, type LLMMessageInput, type LLMResponse } from "./llm.js";
+import type { LLMMessage, Tool } from "./types.js";
+export declare const WebSearchResult: Readonly<{
+    kind: "WebSearchResult";
+}>;
+export type WebSearchResult = {
+    id?: string | null;
+    status?: string | null;
+    type: string;
+};
+export declare const FileSearchResultItem: Readonly<{
+    kind: "FileSearchResultItem";
+}>;
+export type FileSearchResultItem = {
+    file_id?: string | null;
+    fileId?: string | null;
+    filename?: string | null;
+    text?: string | null;
+    score?: number | null;
+    attributes?: Record<string, string | number | boolean> | null;
+};
+export declare const FileSearchResult: Readonly<{
+    kind: "FileSearchResult";
+}>;
+export type FileSearchResult = {
+    id?: string | null;
+    status?: string | null;
+    type: string;
+    queries?: string[];
+    results?: FileSearchResultItem[];
+};
+export declare const CodeInterpreterLogResult: Readonly<{
+    kind: "CodeInterpreterLogResult";
+}>;
+export type CodeInterpreterLogResult = {
+    type: string;
+    logs: string;
+};
+export declare const CodeInterpreterFileResult: Readonly<{
+    kind: "CodeInterpreterFileResult";
+}>;
+export type CodeInterpreterFileResult = {
+    type: string;
+    files: Array<Record<string, unknown>>;
+};
+export declare const CodeInterpreterResult: Readonly<{
+    kind: "CodeInterpreterResult";
+}>;
+export type CodeInterpreterResult = {
+    id?: string | null;
+    status?: string | null;
+    type: string;
+    code?: string | null;
+    container_id?: string | null;
+    containerId?: string | null;
+    results?: Array<CodeInterpreterLogResult | CodeInterpreterFileResult>;
+};
+export declare const ComputerUseResult: Readonly<{
+    kind: "ComputerUseResult";
+}>;
+export type ComputerUseResult = {
+    id?: string | null;
+    status?: string | null;
+    type: string;
+    call_id?: string | null;
+    callId?: string | null;
+    action?: Record<string, unknown>;
+    pending_safety_checks?: Array<Record<string, unknown>>;
+    pendingSafetyChecks?: Array<Record<string, unknown>>;
+};
+export declare const ReasoningSummary: Readonly<{
+    kind: "ReasoningSummary";
+}>;
+export type ReasoningSummary = {
+    id?: string | null;
+    status?: string | null;
+    type: string;
+    summary?: Array<Record<string, unknown>>;
+    encrypted_content?: string | null;
+    encryptedContent?: string | null;
+};
+export type ResponsesAPIResultOptions = {
+    text?: string;
+    web_search_results?: WebSearchResult[];
+    webSearchResults?: WebSearchResult[];
+    file_search_results?: FileSearchResult[];
+    fileSearchResults?: FileSearchResult[];
+    code_interpreter_results?: CodeInterpreterResult[];
+    codeInterpreterResults?: CodeInterpreterResult[];
+    computer_use_results?: ComputerUseResult[];
+    computerUseResults?: ComputerUseResult[];
+    reasoning_summaries?: ReasoningSummary[];
+    reasoningSummaries?: ReasoningSummary[];
+    function_calls?: Array<Record<string, unknown>>;
+    functionCalls?: Array<Record<string, unknown>>;
+    response_id?: string | null;
+    responseId?: string | null;
+};
+export declare class ResponsesAPIResult {
+    text: string;
+    web_search_results: WebSearchResult[];
+    webSearchResults: WebSearchResult[];
+    file_search_results: FileSearchResult[];
+    fileSearchResults: FileSearchResult[];
+    code_interpreter_results: CodeInterpreterResult[];
+    codeInterpreterResults: CodeInterpreterResult[];
+    computer_use_results: ComputerUseResult[];
+    computerUseResults: ComputerUseResult[];
+    reasoning_summaries: ReasoningSummary[];
+    reasoningSummaries: ReasoningSummary[];
+    function_calls: Array<Record<string, unknown>>;
+    functionCalls: Array<Record<string, unknown>>;
+    response_id: string | null;
+    responseId: string | null;
+    constructor(options?: ResponsesAPIResultOptions);
+    hasToolOutputs(): boolean;
+    has_tool_outputs(): boolean;
+    hasReasoning(): boolean;
+    has_reasoning(): boolean;
+}
+export type OpenAICompletionOptions = BaseLLMOptions & {
+    organization?: string | null;
+    project?: string | null;
+    timeout?: number | null;
+    max_retries?: number;
+    maxRetries?: number;
+    default_headers?: Record<string, string> | null;
+    defaultHeaders?: Record<string, string> | null;
+    default_query?: Record<string, unknown> | null;
+    defaultQuery?: Record<string, unknown> | null;
+    client_params?: Record<string, unknown> | null;
+    clientParams?: Record<string, unknown> | null;
+    top_p?: number | null;
+    topP?: number | null;
+    frequency_penalty?: number | null;
+    frequencyPenalty?: number | null;
+    presence_penalty?: number | null;
+    presencePenalty?: number | null;
+    max_tokens?: number | null;
+    maxTokens?: number | null;
+    max_completion_tokens?: number | null;
+    maxCompletionTokens?: number | null;
+    seed?: number | null;
+    stream?: boolean;
+    response_format?: unknown;
+    responseFormat?: unknown;
+    logprobs?: boolean | null;
+    top_logprobs?: number | null;
+    topLogprobs?: number | null;
+    reasoning_effort?: string | null;
+    reasoningEffort?: string | null;
+    interceptor?: unknown;
+    api?: "completions" | "responses";
+    instructions?: string | null;
+    store?: boolean | null;
+    previous_response_id?: string | null;
+    previousResponseId?: string | null;
+    include?: string[] | null;
+    builtin_tools?: string[] | null;
+    builtinTools?: string[] | null;
+    parse_tool_outputs?: boolean;
+    parseToolOutputs?: boolean;
+    auto_chain?: boolean;
+    autoChain?: boolean;
+    auto_chain_reasoning?: boolean;
+    autoChainReasoning?: boolean;
+    api_base?: string | null;
+    apiBase?: string | null;
+};
+export declare class OpenAICompletion extends ConfiguredLLM {
+    static readonly BUILTIN_TOOL_TYPES: Readonly<Record<string, string>>;
+    readonly organization: string | null;
+    readonly project: string | null;
+    readonly maxRetries: number;
+    readonly max_retries: number;
+    readonly defaultHeaders: Record<string, string> | null;
+    readonly default_headers: Record<string, string> | null;
+    readonly defaultQuery: Record<string, unknown> | null;
+    readonly default_query: Record<string, unknown> | null;
+    readonly clientParams: Record<string, unknown> | null;
+    readonly client_params: Record<string, unknown> | null;
+    readonly topP: number | null;
+    readonly top_p: number | null;
+    readonly frequencyPenalty: number | null;
+    readonly frequency_penalty: number | null;
+    readonly presencePenalty: number | null;
+    readonly presence_penalty: number | null;
+    readonly seed: number | null;
+    readonly stream: boolean;
+    readonly topLogprobs: number | null;
+    readonly top_logprobs: number | null;
+    readonly reasoningEffort: string | null;
+    readonly reasoning_effort: string | null;
+    readonly interceptor: unknown;
+    readonly api: "completions" | "responses";
+    readonly instructions: string | null;
+    readonly store: boolean | null;
+    readonly previousResponseId: string | null;
+    readonly previous_response_id: string | null;
+    readonly include: string[] | null;
+    readonly builtinTools: string[] | null;
+    readonly builtin_tools: string[] | null;
+    readonly parseToolOutputs: boolean;
+    readonly parse_tool_outputs: boolean;
+    readonly autoChain: boolean;
+    readonly auto_chain: boolean;
+    readonly autoChainReasoning: boolean;
+    readonly auto_chain_reasoning: boolean;
+    readonly isO1Model: boolean;
+    readonly is_o1_model: boolean;
+    readonly isGpt4Model: boolean;
+    readonly is_gpt4_model: boolean;
+    private responseChainId;
+    private reasoningChainItems;
+    constructor(options?: OpenAICompletionOptions);
+    call(messages: readonly LLMMessage[], options?: LLMCallOptions): Promise<LLMResponse>;
+    acall(messages: LLMMessageInput, options?: LLMCallOptions): Promise<LLMResponse>;
+    prepareCompletionParams(messages: readonly LLMMessage[], tools?: readonly Tool[] | null): Record<string, unknown>;
+    _prepare_completion_params(messages: readonly LLMMessage[], tools?: readonly Tool[] | null): Record<string, unknown>;
+    prepareResponsesParams(messages: readonly LLMMessage[], tools?: readonly Tool[] | null, responseModel?: unknown): Record<string, unknown>;
+    _prepare_responses_params(messages: readonly LLMMessage[], tools?: readonly Tool[] | null, responseModel?: unknown): Record<string, unknown>;
+    convertToolsForInterference(tools: readonly Tool[]): Record<string, unknown>[];
+    _convert_tools_for_interference(tools: readonly Tool[]): Record<string, unknown>[];
+    convertToolsForResponses(tools: readonly Tool[]): Record<string, unknown>[];
+    _convert_tools_for_responses(tools: readonly Tool[]): Record<string, unknown>[];
+    getClientParams(env?: NodeJS.ProcessEnv): Record<string, unknown>;
+    _get_client_params(env?: NodeJS.ProcessEnv): Record<string, unknown>;
+    extractOpenAITokenUsage(response: unknown): Record<string, number>;
+    _extract_openai_token_usage(response: unknown): Record<string, number>;
+    static extractOpenAITokenUsage(response: unknown): Record<string, number>;
+    static extract_openai_token_usage(response: unknown): Record<string, number>;
+    extractResponsesTokenUsage(response: unknown): Record<string, number>;
+    _extract_responses_token_usage(response: unknown): Record<string, number>;
+    extractFunctionCallsFromResponse(response: unknown): Record<string, unknown>[];
+    _extract_function_calls_from_response(response: unknown): Record<string, unknown>[];
+    extractReasoningItems(response: unknown): unknown[];
+    _extract_reasoning_items(response: unknown): unknown[];
+    extractBuiltinToolOutputs(response: unknown): ResponsesAPIResult;
+    _extract_builtin_tool_outputs(response: unknown): ResponsesAPIResult;
+    accumulateResponsesStreamEvents(events: readonly unknown[]): {
+        text: string;
+        response_id: string | null;
+        function_calls: Record<string, unknown>[];
+        usage: Record<string, number> | null;
+        final_response: unknown;
+        reasoning_items: unknown[];
+    };
+    _accumulate_responses_stream_events(events: readonly unknown[]): {
+        text: string;
+        response_id: string | null;
+        function_calls: Record<string, unknown>[];
+        usage: Record<string, number> | null;
+        final_response: unknown;
+        reasoning_items: unknown[];
+    };
+    supportsFunctionCalling(): boolean;
+    supports_function_calling(): boolean;
+    supportsStopWords(): boolean;
+    supports_stop_words(): boolean;
+    supportsMultimodal(): boolean;
+    supports_multimodal(): boolean;
+    getFileUploader(): LocalFileUploader;
+    get_file_uploader(): LocalFileUploader;
+    getContextWindowSize(): number;
+    get_context_window_size(): number;
+    get lastResponseId(): string | null;
+    get last_response_id(): string | null;
+    get lastReasoningItems(): readonly unknown[] | null;
+    get last_reasoning_items(): readonly unknown[] | null;
+    resetChain(): void;
+    reset_chain(): void;
+    resetReasoningChain(): void;
+    reset_reasoning_chain(): void;
+    toConfigDict(): Record<string, unknown>;
+    to_config_dict(): Record<string, unknown>;
+}
+export type ProviderConfigOptions = {
+    base_url?: string;
+    baseUrl?: string;
+    api_key_env?: string;
+    apiKeyEnv?: string;
+    base_url_env?: string | null;
+    baseUrlEnv?: string | null;
+    default_headers?: Record<string, string>;
+    defaultHeaders?: Record<string, string>;
+    api_key_required?: boolean;
+    apiKeyRequired?: boolean;
+    default_api_key?: string | null;
+    defaultApiKey?: string | null;
+};
+export declare class ProviderConfig {
+    readonly base_url: string;
+    readonly baseUrl: string;
+    readonly api_key_env: string;
+    readonly apiKeyEnv: string;
+    readonly base_url_env: string | null;
+    readonly baseUrlEnv: string | null;
+    readonly default_headers: Record<string, string>;
+    readonly defaultHeaders: Record<string, string>;
+    readonly api_key_required: boolean;
+    readonly apiKeyRequired: boolean;
+    readonly default_api_key: string | null;
+    readonly defaultApiKey: string | null;
+    constructor(options: ProviderConfigOptions);
+}
+export declare const OPENAI_COMPATIBLE_PROVIDERS: Readonly<Record<string, ProviderConfig>>;
+export declare class OpenAICompatibleCompletion extends OpenAICompletion {
+    constructor(options?: OpenAICompletionOptions & {
+        provider?: string | null;
+    });
+    static _resolveProviderConfig<TOptions extends OpenAICompletionOptions & {
+        provider?: string | null;
+    }>(data: TOptions): TOptions;
+    static _resolve_provider_config<TOptions extends OpenAICompletionOptions & {
+        provider?: string | null;
+    }>(data: TOptions): TOptions;
+    supports_function_calling(): boolean;
+    static resolveApiKey(apiKey: string | null, config: ProviderConfig, provider: string): string | null;
+    static _resolve_api_key(apiKey: string | null, config: ProviderConfig, provider: string): string | null;
+    static resolveBaseUrl(baseUrl: string | null, config: ProviderConfig, provider: string): string;
+    static _resolve_base_url(baseUrl: string | null, config: ProviderConfig, provider: string): string;
+    static resolveHeaders(headers: Record<string, string> | null, config: ProviderConfig): Record<string, string> | null;
+    static _resolve_headers(headers: Record<string, string> | null, config: ProviderConfig): Record<string, string> | null;
+}

package/dist/outputs.d.ts

@@ -0,0 +1,69 @@
+import { OutputFormat } from "./types.js";
+import { type UsageMetrics } from "./llm.js";
+export type TaskOutputOptions = {
+    description: string;
+    name?: string | null;
+    expectedOutput?: string | null;
+    expected_output?: string | null;
+    raw?: string;
+    jsonDict?: Record<string, unknown> | null;
+    json_dict?: Record<string, unknown> | null;
+    pydantic?: unknown;
+    agent: string;
+    outputFormat?: OutputFormat;
+    output_format?: OutputFormat;
+    messages?: readonly unknown[];
+};
+export declare class TaskOutput {
+    readonly description: string;
+    readonly name: string | null;
+    readonly expectedOutput: string | null;
+    readonly expected_output: string | null;
+    summary: string;
+    readonly raw: string;
+    readonly jsonDict: Record<string, unknown> | null;
+    readonly json_dict: Record<string, unknown> | null;
+    readonly pydantic: unknown;
+    readonly agent: string;
+    readonly outputFormat: OutputFormat;
+    readonly output_format: OutputFormat;
+    readonly messages: readonly unknown[];
+    constructor(options: TaskOutputOptions);
+    set_summary(): this;
+    get json(): string | null;
+    toDict(): Record<string, unknown>;
+    to_dict(): Record<string, unknown>;
+    modelDump(): Record<string, unknown>;
+    model_dump(): Record<string, unknown>;
+    toJSON(): Record<string, unknown>;
+    toString(): string;
+    __str__(): string;
+}
+export type CrewOutputOptions = {
+    raw?: string;
+    pydantic?: unknown;
+    jsonDict?: Record<string, unknown> | null;
+    json_dict?: Record<string, unknown> | null;
+    tasksOutput?: readonly TaskOutput[];
+    tasks_output?: readonly TaskOutput[];
+    tokenUsage?: UsageMetrics;
+    token_usage?: UsageMetrics;
+};
+export declare class CrewOutput {
+    readonly raw: string;
+    readonly pydantic: unknown;
+    readonly jsonDict: Record<string, unknown> | null;
+    readonly json_dict: Record<string, unknown> | null;
+    readonly tasksOutput: readonly TaskOutput[];
+    readonly tasks_output: readonly TaskOutput[];
+    readonly tokenUsage: UsageMetrics;
+    readonly token_usage: UsageMetrics;
+    constructor(options?: CrewOutputOptions);
+    get json(): string | null;
+    toDict(): Record<string, unknown>;
+    to_dict(): Record<string, unknown>;
+    get(key: string): unknown;
+    __getitem__(key: string): unknown;
+    toString(): string;
+    __str__(): string;
+}

package/dist/planning.d.ts

@@ -0,0 +1,60 @@
+import { Agent } from "./agent.js";
+import { Task } from "./task.js";
+import type { LLM } from "./types.js";
+export type PlanPerTaskOptions = {
+    taskNumber?: number;
+    task_number?: number;
+    task: string;
+    plan: string;
+};
+export type PlanPerTask = {
+    taskNumber: number;
+    task_number: number;
+    task: string;
+    plan: string;
+};
+export declare const PlanPerTask: {
+    new (options: PlanPerTaskOptions): {
+        readonly taskNumber: number;
+        readonly task_number: number;
+        readonly task: string;
+        readonly plan: string;
+    };
+};
+export type PlannerTaskOutput = {
+    listOfPlansPerTask: readonly PlanPerTask[];
+    list_of_plans_per_task: readonly PlanPerTask[];
+};
+export declare const PlannerTaskPydanticOutput: {
+    new (options: {
+        listOfPlansPerTask?: readonly (PlanPerTask | PlanPerTaskOptions)[];
+        list_of_plans_per_task?: readonly (PlanPerTask | PlanPerTaskOptions)[];
+    }): {
+        readonly listOfPlansPerTask: readonly PlanPerTask[];
+        readonly list_of_plans_per_task: readonly PlanPerTask[];
+    };
+};
+export type PlannerTaskPydanticOutput = InstanceType<typeof PlannerTaskPydanticOutput>;
+export type CrewPlannerOptions = {
+    tasks: readonly Task[];
+    planningAgentLlm?: LLM | string | null;
+    planning_agent_llm?: LLM | string | null;
+};
+export declare class CrewPlanner {
+    readonly tasks: readonly Task[];
+    readonly planningAgentLlm: LLM | string | null;
+    readonly planning_agent_llm: LLM | string | null;
+    private planningAgent;
+    constructor(options: CrewPlannerOptions);
+    constructor(tasks: readonly Task[], planningAgentLlm?: LLM | string | null);
+    handleCrewPlanning(): Promise<PlannerTaskOutput>;
+    _handle_crew_planning(): Promise<PlannerTaskOutput>;
+    getUsageMetrics(): import("./llm.js").UsageMetrics | undefined;
+    createPlanningAgent(): Agent;
+    _create_planning_agent(): Agent;
+    static _create_planner_task(planningAgent: Agent, tasksSummary: string): Task;
+    static _get_agent_knowledge(task: Task): string[];
+    createTasksSummary(): string;
+    _create_tasks_summary(): string;
+}
+export declare function parsePlannerTaskOutput(raw: string): PlannerTaskOutput;