@crewai-ts/core 0.1.1 → 0.1.3

package/dist/input-files.d.ts

@@ -0,0 +1,24 @@
+import type { Tool } from "./types.js";
+export type InputFileLike = {
+    read(): Uint8Array | Buffer | string;
+    content_type?: string | null;
+    contentType?: string | null;
+    filename?: string | null;
+};
+export type StructuredInputFile = {
+    path?: string;
+    content?: string;
+    filename?: string;
+    contentType?: string;
+};
+export type InputFile = string | InputFileLike | StructuredInputFile;
+export type InputFiles = Record<string, InputFile>;
+export type ExtractedInputFiles = {
+    inputs: Record<string, unknown>;
+    inputFiles: InputFiles;
+};
+export declare function renderInputFiles(inputFiles: InputFiles): string | null;
+export declare function createReadFileTool(inputFiles: InputFiles): Tool;
+export declare function withReadFileTool(tools: readonly Tool[], inputFiles: InputFiles | undefined): readonly Tool[];
+export declare function extractInputFilesFromInputs(inputs: Record<string, unknown>): ExtractedInputFiles;
+export declare function isStructuredInputFile(value: unknown): value is Exclude<InputFile, string>;

package/dist/input-provider.d.ts

@@ -0,0 +1,22 @@
+import type { Flow, HumanFeedbackProvider } from "./flow.js";
+import type { MaybePromise } from "./types.js";
+export type InputResponse = {
+    text: string | null;
+    metadata?: Record<string, unknown> | null;
+};
+export type InputProvider = {
+    requestInput?(message: string, flow: Flow<object>, metadata?: Record<string, unknown> | null): MaybePromise<string | InputResponse | null>;
+    request_input?(message: string, flow: Flow<object>, metadata?: Record<string, unknown> | null): MaybePromise<string | InputResponse | null>;
+};
+export type FlowConfig = {
+    inputProvider: InputProvider | null;
+    hitlProvider: HumanFeedbackProvider | null;
+};
+export declare const FlowConfig: Readonly<{
+    kind: "FlowConfig";
+}>;
+export declare const flowConfig: FlowConfig;
+export declare class ConsoleInputProvider implements InputProvider {
+    requestInput(message: string): Promise<string>;
+}
+export declare function isInputResponse(value: unknown): value is InputResponse;

package/dist/knowledge.d.ts

@@ -0,0 +1,353 @@
+import { type EmbedderConfig, type RagClient, type SearchResult } from "./rag.js";
+export type KnowledgeSearchResult = {
+    content: string;
+    score: number;
+    source: string | null;
+    metadata: Record<string, unknown>;
+};
+export type KnowledgeQueryOptions = {
+    resultsLimit?: number;
+    results_limit?: number;
+    scoreThreshold?: number | null;
+    score_threshold?: number | null;
+};
+export declare const DEFAULT_KNOWLEDGE_SCORE_THRESHOLD = 0.6;
+export type KnowledgeSource = {
+    readonly sourceType?: string;
+    readonly metadata?: Record<string, unknown>;
+    storage?: BaseKnowledgeStorage | null;
+    chunks(): readonly string[];
+    add?(): void;
+    aadd?(): Promise<void>;
+    get_embeddings?(): readonly unknown[];
+    validate_content?(): unknown;
+};
+export type StringKnowledgeSourceOptions = {
+    content: string;
+    chunkSize?: number;
+    chunkOverlap?: number;
+    metadata?: Record<string, unknown>;
+    storage?: BaseKnowledgeStorage | null;
+    collectionName?: string | null;
+    collection_name?: string | null;
+};
+export type FileKnowledgeSourceOptions = {
+    filePaths?: string | readonly string[];
+    file_path?: string | readonly string[];
+    file_paths?: string | readonly string[];
+    chunkSize?: number;
+    chunkOverlap?: number;
+    metadata?: Record<string, unknown>;
+    storage?: BaseKnowledgeStorage | null;
+    collectionName?: string | null;
+    collection_name?: string | null;
+};
+export type BaseKnowledgeSourceOptions = {
+    chunkSize?: number;
+    chunk_size?: number;
+    chunkOverlap?: number;
+    chunk_overlap?: number;
+    chunks?: readonly string[];
+    chunkEmbeddings?: readonly unknown[];
+    chunk_embeddings?: readonly unknown[];
+    metadata?: Record<string, unknown>;
+    storage?: BaseKnowledgeStorage | null;
+    collectionName?: string | null;
+    collection_name?: string | null;
+};
+export type PDFTextExtractor = (filePath: string, bytes: Buffer) => string;
+export type PDFKnowledgeSourceOptions = FileKnowledgeSourceOptions & {
+    extractor?: PDFTextExtractor;
+};
+export type ExcelSheetData = readonly (readonly unknown[])[];
+export type ExcelWorkbookData = Record<string, ExcelSheetData>;
+export type ExcelTextExtractor = (filePath: string, bytes: Buffer) => ExcelWorkbookData | string;
+export type ExcelKnowledgeSourceOptions = FileKnowledgeSourceOptions & {
+    extractor?: ExcelTextExtractor;
+};
+export type DoclingConversionResult = unknown;
+export type DoclingDocumentConverter = {
+    convert_all?: (paths: readonly string[]) => Iterable<DoclingConversionResult>;
+    convertAll?: (paths: readonly string[]) => Iterable<DoclingConversionResult>;
+} | ((paths: readonly string[]) => Iterable<DoclingConversionResult>);
+export type DoclingChunk = {
+    text?: string | number | boolean | bigint | null | undefined;
+} | string;
+export type DoclingChunker = {
+    chunk?: (document: unknown) => Iterable<DoclingChunk>;
+} | ((document: unknown) => Iterable<DoclingChunk>);
+export type CrewDoclingSourceOptions = FileKnowledgeSourceOptions & {
+    documentConverter?: DoclingDocumentConverter | null;
+    document_converter?: DoclingDocumentConverter | null;
+    chunker?: DoclingChunker | null;
+};
+export declare class BaseKnowledgeSource {
+    readonly chunkSize: number;
+    readonly chunk_size: number;
+    readonly chunkOverlap: number;
+    readonly chunk_overlap: number;
+    readonly metadata: Record<string, unknown>;
+    readonly collectionName: string | null;
+    readonly collection_name: string | null;
+    storage: BaseKnowledgeStorage | null;
+    chunks: string[];
+    private chunkEmbeddingsValue;
+    constructor(options?: BaseKnowledgeSourceOptions);
+    get chunkEmbeddings(): unknown[];
+    set chunkEmbeddings(value: readonly unknown[]);
+    get chunk_embeddings(): unknown[];
+    set chunk_embeddings(value: readonly unknown[]);
+    validateContent(): unknown;
+    validate_content(): unknown;
+    add(): void;
+    aadd(): Promise<void>;
+    getEmbeddings(): readonly unknown[];
+    get_embeddings(): readonly unknown[];
+    chunkText(text: string): string[];
+    _chunk_text(text: string): string[];
+    saveDocuments(): void;
+    _save_documents(): void;
+    asaveDocuments(): Promise<void>;
+    _asave_documents(): Promise<void>;
+}
+export type KnowledgeOptions = {
+    sources?: readonly KnowledgeSource[];
+    collectionName?: string | null;
+    collection_name?: string | null;
+    storage?: BaseKnowledgeStorage | null;
+    embedder?: EmbedderConfig | null;
+};
+export type KnowledgeStorageOptions = {
+    collectionName?: string | null;
+    collection_name?: string | null;
+    client?: RagClient | null;
+    embedder?: EmbedderConfig | null;
+};
+export declare class StringKnowledgeSource implements KnowledgeSource {
+    readonly sourceType = "string";
+    readonly source_type = "string";
+    readonly content: string;
+    readonly chunkSize: number;
+    readonly chunkOverlap: number;
+    readonly metadata: Record<string, unknown>;
+    readonly collectionName: string | null;
+    readonly collection_name: string | null;
+    storage: BaseKnowledgeStorage | null;
+    constructor(options: StringKnowledgeSourceOptions | string);
+    model_post_init(_context?: unknown): void;
+    validateContent(): void;
+    validate_content(): void;
+    chunks(): readonly string[];
+    _chunk_text(text: string): string[];
+    add(): void;
+    aadd(): Promise<void>;
+    getEmbeddings(): readonly unknown[];
+    get_embeddings(): readonly unknown[];
+    saveDocuments(documents?: readonly string[]): void;
+    _save_documents(): void;
+    asaveDocuments(documents?: readonly string[]): Promise<void>;
+    _asave_documents(): Promise<void>;
+}
+declare abstract class BaseTextKnowledgeSource implements KnowledgeSource {
+    abstract readonly sourceType: string;
+    readonly chunkSize: number;
+    readonly chunkOverlap: number;
+    readonly metadata: Record<string, unknown>;
+    readonly collectionName: string | null;
+    readonly collection_name: string | null;
+    storage: BaseKnowledgeStorage | null;
+    protected constructor(options: Pick<FileKnowledgeSourceOptions, "chunkSize" | "chunkOverlap" | "metadata" | "storage" | "collectionName" | "collection_name">);
+    chunks(): readonly string[];
+    _chunk_text(text: string): string[];
+    validateContent(): void;
+    validate_content(): void;
+    add(): void;
+    aadd(): Promise<void>;
+    getEmbeddings(): readonly unknown[];
+    get_embeddings(): readonly unknown[];
+    protected abstract loadText(): string;
+    saveDocuments(documents?: readonly string[]): void;
+    _save_documents(): void;
+    asaveDocuments(documents?: readonly string[]): Promise<void>;
+    _asave_documents(): Promise<void>;
+}
+export declare abstract class BaseFileKnowledgeSource extends BaseTextKnowledgeSource {
+    readonly filePath: string | readonly string[] | null;
+    readonly file_path: string | readonly string[] | null;
+    readonly filePaths: readonly string[];
+    readonly file_paths: readonly string[];
+    safeFilePaths: string[];
+    safe_file_paths: string[];
+    content: Record<string, string>;
+    protected constructor(options: FileKnowledgeSourceOptions | string | readonly string[]);
+    model_post_init(_context?: unknown): void;
+    validateFilePath(value: string | readonly string[] | null, info?: {
+        field_name?: string;
+        data?: Record<string, unknown>;
+    }): string | readonly string[] | null;
+    validate_file_path(value: string | readonly string[] | null, info?: {
+        field_name?: string;
+        data?: Record<string, unknown>;
+    }): string | readonly string[] | null;
+    validateContent(): void;
+    validate_content(): void;
+    abstract loadContent(): Record<string, string>;
+    load_content(): Record<string, string>;
+    _load_content(): unknown;
+    convertToPath(filePath: string): string;
+    convert_to_path(filePath: string): string;
+    protected loadText(): string;
+    protected processFilePaths(): string[];
+    _process_file_paths(): string[];
+}
+export declare class TextFileKnowledgeSource extends BaseFileKnowledgeSource {
+    readonly sourceType = "text_file";
+    readonly source_type = "text_file";
+    constructor(options: FileKnowledgeSourceOptions | string | readonly string[]);
+    loadContent(): Record<string, string>;
+}
+export declare class JSONKnowledgeSource extends BaseFileKnowledgeSource {
+    readonly sourceType = "json";
+    readonly source_type = "json";
+    constructor(options: FileKnowledgeSourceOptions | string | readonly string[]);
+    loadContent(): Record<string, string>;
+    _json_to_text(data: unknown, level?: number): string;
+}
+export declare class CSVKnowledgeSource extends BaseFileKnowledgeSource {
+    readonly sourceType = "csv";
+    readonly source_type = "csv";
+    constructor(options: FileKnowledgeSourceOptions | string | readonly string[]);
+    loadContent(): Record<string, string>;
+}
+export declare class PDFKnowledgeSource extends BaseFileKnowledgeSource {
+    readonly sourceType = "pdf";
+    readonly source_type = "pdf";
+    private readonly extractor;
+    constructor(options: PDFKnowledgeSourceOptions | string | readonly string[]);
+    loadContent(): Record<string, string>;
+    _import_pdfplumber(): never;
+    _chunk_text(text: string): string[];
+    add(): void;
+    aadd(): Promise<void>;
+    private loadContentAsync;
+}
+export declare class ExcelKnowledgeSource extends BaseFileKnowledgeSource {
+    readonly sourceType = "excel";
+    readonly source_type = "excel";
+    private readonly extractor;
+    constructor(options: ExcelKnowledgeSourceOptions | string | readonly string[]);
+    loadContent(): Record<string, string>;
+    _import_dependencies(): {
+        readWorkbook: typeof parseXlsxWorkbook;
+    };
+}
+export declare class CrewDoclingSource extends BaseFileKnowledgeSource {
+    readonly sourceType = "docling";
+    readonly source_type = "docling";
+    private readonly documentConverter;
+    private readonly chunker;
+    private doclingDocuments;
+    constructor(options: CrewDoclingSourceOptions | string | readonly string[]);
+    model_post_init(_context?: unknown): void;
+    validateContent(): string[];
+    validate_content(): string[];
+    loadContent(): Record<string, string>;
+    load_content(): Record<string, string>;
+    _load_content(): unknown[];
+    add(): void;
+    aadd(): Promise<void>;
+    _convert_source_to_docling_documents(): unknown[];
+    _chunk_doc(document: unknown): Iterable<string>;
+    _save_documents(): void;
+    _asave_documents(): Promise<void>;
+    _validate_url(url: string): boolean;
+    private convertSourceToDoclingDocuments;
+    private chunkDoc;
+    private saveDoclingDocuments;
+    private asaveDoclingDocuments;
+}
+export declare class SourceHelper {
+    static readonly SUPPORTED_FILE_TYPES: readonly [".csv", ".pdf", ".json", ".txt", ".xlsx", ".xls"];
+    static readonly _FILE_TYPE_MAP: {
+        readonly ".csv": typeof CSVKnowledgeSource;
+        readonly ".pdf": typeof PDFKnowledgeSource;
+        readonly ".json": typeof JSONKnowledgeSource;
+        readonly ".txt": typeof TextFileKnowledgeSource;
+        readonly ".xlsx": typeof ExcelKnowledgeSource;
+        readonly ".xls": typeof ExcelKnowledgeSource;
+    };
+    readonly supportedFileTypes: readonly [".csv", ".pdf", ".json", ".txt", ".xlsx", ".xls"];
+    readonly _fileTypeMap: {
+        readonly ".csv": typeof CSVKnowledgeSource;
+        readonly ".pdf": typeof PDFKnowledgeSource;
+        readonly ".json": typeof JSONKnowledgeSource;
+        readonly ".txt": typeof TextFileKnowledgeSource;
+        readonly ".xlsx": typeof ExcelKnowledgeSource;
+        readonly ".xls": typeof ExcelKnowledgeSource;
+    };
+    readonly _file_type_map: {
+        readonly ".csv": typeof CSVKnowledgeSource;
+        readonly ".pdf": typeof PDFKnowledgeSource;
+        readonly ".json": typeof JSONKnowledgeSource;
+        readonly ".txt": typeof TextFileKnowledgeSource;
+        readonly ".xlsx": typeof ExcelKnowledgeSource;
+        readonly ".xls": typeof ExcelKnowledgeSource;
+    };
+    isSupportedFile(filePath: string): boolean;
+    getSource(filePath: string, metadata?: Record<string, unknown> | null): KnowledgeSource;
+    static isSupportedFile(filePath: string): boolean;
+    static is_supported_file(filePath: string): boolean;
+    static getSource(filePath: string, metadata?: Record<string, unknown> | null): KnowledgeSource;
+    static get_source(filePath: string, metadata?: Record<string, unknown> | null): KnowledgeSource;
+}
+export declare class Knowledge {
+    readonly sources: readonly KnowledgeSource[];
+    readonly collectionName: string | null;
+    readonly collection_name: string | null;
+    readonly storage: BaseKnowledgeStorage | null;
+    private entries;
+    constructor(options?: KnowledgeOptions);
+    addSources(sources?: readonly KnowledgeSource[]): void;
+    add_sources(sources?: readonly KnowledgeSource[]): void;
+    aaddSources(sources?: readonly KnowledgeSource[]): Promise<void>;
+    aadd_sources(sources?: readonly KnowledgeSource[]): Promise<void>;
+    add(content: string, options?: {
+        source?: string | null;
+        metadata?: Record<string, unknown> | null;
+    }): void;
+    query(query: string | readonly string[], options?: KnowledgeQueryOptions): KnowledgeSearchResult[];
+    aquery(query: string | readonly string[], options?: KnowledgeQueryOptions): Promise<KnowledgeSearchResult[]>;
+    reset(): void;
+    areset(): Promise<void>;
+    private documentsFromSources;
+}
+export declare abstract class BaseKnowledgeStorage {
+    abstract search(query: readonly string[], limit?: number, metadataFilter?: Record<string, unknown> | null, scoreThreshold?: number): SearchResult[];
+    abstract asearch(query: readonly string[], limit?: number, metadataFilter?: Record<string, unknown> | null, scoreThreshold?: number): Promise<SearchResult[]>;
+    abstract save(documents: readonly string[]): void;
+    abstract asave(documents: readonly string[]): Promise<void>;
+    abstract reset(): void;
+    abstract areset(): Promise<void>;
+}
+export declare class KnowledgeStorage extends BaseKnowledgeStorage {
+    readonly collectionName: string | null;
+    readonly collection_name: string | null;
+    readonly embedder: EmbedderConfig | null;
+    private client;
+    constructor(options?: KnowledgeStorageOptions);
+    _init_client(): this;
+    search(query: readonly string[], limit?: number, metadataFilter?: Record<string, unknown> | null, scoreThreshold?: number): SearchResult[];
+    asearch(query: readonly string[], limit?: number, metadataFilter?: Record<string, unknown> | null, scoreThreshold?: number): Promise<SearchResult[]>;
+    save(documents: readonly string[]): void;
+    asave(documents: readonly string[]): Promise<void>;
+    reset(): void;
+    areset(): Promise<void>;
+    _get_client(): RagClient;
+    get _client(): RagClient | null;
+    set _client(client: RagClient | null);
+    ragCollectionName(): string;
+    rag_collection_name(): string;
+}
+export declare function extractKnowledgeContext(results: readonly unknown[]): string;
+declare function parseXlsxWorkbook(bytes: Buffer): ExcelWorkbookData;
+export {};

package/dist/lite-agent-output.d.ts

@@ -0,0 +1,69 @@
+import type { UsageMetrics } from "./llm.js";
+import type { LLMMessage } from "./types.js";
+export type TodoExecutionResultOptions = {
+    stepNumber?: number;
+    step_number?: number;
+    description: string;
+    toolUsed?: string | null;
+    tool_used?: string | null;
+    status: string;
+    result?: string | null;
+    dependsOn?: readonly number[];
+    depends_on?: readonly number[];
+};
+export declare class TodoExecutionResult {
+    readonly stepNumber: number;
+    readonly step_number: number;
+    readonly description: string;
+    readonly toolUsed: string | null;
+    readonly tool_used: string | null;
+    readonly status: string;
+    readonly result: string | null;
+    readonly dependsOn: readonly number[];
+    readonly depends_on: readonly number[];
+    constructor(options: TodoExecutionResultOptions);
+}
+export type LiteAgentOutputOptions = {
+    raw?: string;
+    pydantic?: unknown;
+    agentRole?: string;
+    agent_role?: string;
+    usageMetrics?: UsageMetrics | null;
+    usage_metrics?: UsageMetrics | null;
+    messages?: readonly LLMMessage[];
+    plan?: string | null;
+    todos?: readonly (TodoExecutionResult | TodoExecutionResultOptions)[];
+    replanCount?: number;
+    replan_count?: number;
+    lastReplanReason?: string | null;
+    last_replan_reason?: string | null;
+};
+export declare class LiteAgentOutput {
+    readonly raw: string;
+    readonly pydantic: unknown;
+    readonly agentRole: string;
+    readonly agent_role: string;
+    readonly usageMetrics: UsageMetrics | null;
+    readonly usage_metrics: UsageMetrics | null;
+    readonly messages: readonly LLMMessage[];
+    readonly plan: string | null;
+    readonly todos: readonly TodoExecutionResult[];
+    readonly replanCount: number;
+    readonly replan_count: number;
+    readonly lastReplanReason: string | null;
+    readonly last_replan_reason: string | null;
+    constructor(options: LiteAgentOutputOptions);
+    static fromTodoItems(items: readonly TodoExecutionResultOptions[]): TodoExecutionResult[];
+    static from_todo_items(items: readonly TodoExecutionResultOptions[]): TodoExecutionResult[];
+    toDict(): Record<string, unknown>;
+    to_dict(): Record<string, unknown>;
+    get completedTodos(): readonly TodoExecutionResult[];
+    get completed_todos(): readonly TodoExecutionResult[];
+    get failedTodos(): readonly TodoExecutionResult[];
+    get failed_todos(): readonly TodoExecutionResult[];
+    get hadPlan(): boolean;
+    get had_plan(): boolean;
+    toString(): string;
+    __str__(): string;
+    __repr__(): string;
+}

package/dist/lite-agent.d.ts

@@ -0,0 +1,154 @@
+import { Agent, type CodeExecutionMode } from "./agent.js";
+import { type AfterLLMCallHook, type BeforeLLMCallHook } from "./hooks.js";
+import { type InputFiles } from "./input-files.js";
+import { type LLM, type LLMClient, type UsageMetrics } from "./llm.js";
+import { LiteAgentOutput } from "./lite-agent-output.js";
+import { Memory, type MemoryScope } from "./memory.js";
+import { AgentFinish } from "./agent-parser.js";
+import type { AgentStepCallback, LLMMessage, Tool } from "./types.js";
+export type LiteAgentGuardrailResult = readonly [boolean, unknown] | {
+    success: boolean;
+    result?: unknown;
+    error?: unknown;
+};
+export type LiteAgentGuardrail = (output: LiteAgentOutput) => LiteAgentGuardrailResult | Promise<LiteAgentGuardrailResult>;
+type ModelDumpOptions = {
+    mode?: string;
+    exclude?: ReadonlySet<string> | readonly string[] | Record<string, unknown>;
+};
+export type LiteAgentKickoffOptions = {
+    responseFormat?: unknown;
+    response_format?: unknown;
+    inputFiles?: InputFiles;
+    input_files?: InputFiles;
+};
+export type LiteAgentOptions = {
+    id?: string;
+    role: string;
+    goal: string;
+    backstory: string;
+    llm?: LLM | string | null;
+    tools?: readonly Tool[];
+    verbose?: boolean;
+    maxIterations?: number;
+    max_iterations?: number;
+    maxExecutionTime?: number | null;
+    max_execution_time?: number | null;
+    respectContextWindow?: boolean;
+    respect_context_window?: boolean;
+    useStopWords?: boolean;
+    use_stop_words?: boolean;
+    requestWithinRpmLimit?: (() => boolean) | null;
+    request_within_rpm_limit?: (() => boolean) | null;
+    responseFormat?: unknown;
+    response_format?: unknown;
+    guardrail?: LiteAgentGuardrail | null;
+    guardrailMaxRetries?: number;
+    guardrail_max_retries?: number;
+    memory?: Memory | MemoryScope | boolean | null;
+    stepCallback?: AgentStepCallback | null;
+    step_callback?: AgentStepCallback | null;
+    codeExecutionMode?: CodeExecutionMode;
+    code_execution_mode?: CodeExecutionMode;
+    a2a?: unknown;
+};
+export type LiteAgentKickoffInput = string | readonly LLMMessage[];
+export type LiteAgentKickoffFunction = (messages: LiteAgentKickoffInput, responseFormatOrOptions?: unknown, inputFiles?: InputFiles) => LiteAgentOutput | Promise<LiteAgentOutput>;
+export declare function _kickoff_with_a2a_support(agent: LiteAgent, original_kickoff: LiteAgentKickoffFunction, messages: LiteAgentKickoffInput, response_format?: unknown, input_files?: InputFiles | null, extension_registry?: import("./a2a.js").ExtensionRegistry): Promise<LiteAgentOutput>;
+export declare function task_to_kickoff_adapter(original_kickoff: LiteAgentKickoffFunction, messages: LiteAgentKickoffInput, response_format?: unknown, input_files?: InputFiles | null): (...args: unknown[]) => Promise<string>;
+export declare class LiteAgent {
+    readonly id: string;
+    readonly role: string;
+    readonly goal: string;
+    readonly backstory: string;
+    llm: LLM | LLMClient | string | null;
+    readonly tools: readonly Tool[];
+    readonly verbose: boolean;
+    readonly maxIterations: number;
+    readonly max_iterations: number;
+    readonly maxExecutionTime: number | null;
+    readonly max_execution_time: number | null;
+    readonly respectContextWindow: boolean;
+    readonly respect_context_window: boolean;
+    readonly useStopWords: boolean;
+    readonly use_stop_words: boolean;
+    readonly requestWithinRpmLimit: (() => boolean) | null;
+    readonly request_within_rpm_limit: (() => boolean) | null;
+    readonly responseFormat: unknown;
+    readonly response_format: unknown;
+    readonly guardrail: LiteAgentGuardrail | null;
+    readonly guardrailMaxRetries: number;
+    readonly guardrail_max_retries: number;
+    memory: Memory | MemoryScope | null;
+    readonly stepCallback: AgentStepCallback | null;
+    readonly codeExecutionMode: CodeExecutionMode;
+    readonly code_execution_mode: CodeExecutionMode;
+    readonly a2a: unknown;
+    readonly originalAgent: Agent | null;
+    readonly original_agent: Agent | null;
+    toolsResults: Record<string, unknown>[];
+    tools_results: Record<string, unknown>[];
+    private readonly _key;
+    private currentMessages;
+    private currentIterations;
+    private usageMetrics;
+    constructor(options: LiteAgentOptions);
+    get key(): string;
+    get messages(): readonly LLMMessage[];
+    get iterations(): number;
+    get _original_role(): string;
+    get beforeLlmCallHooks(): BeforeLLMCallHook[];
+    get before_llm_call_hooks(): BeforeLLMCallHook[];
+    get afterLlmCallHooks(): AfterLLMCallHook[];
+    get after_llm_call_hooks(): AfterLLMCallHook[];
+    setupLlm(): this;
+    setup_llm(): this;
+    parseTools(): this;
+    parse_tools(): this;
+    setupA2aSupport(): this;
+    setup_a2a_support(): this;
+    ensureGuardrailIsCallable(): this;
+    ensure_guardrail_is_callable(): this;
+    resolveMemory(): this;
+    resolve_memory(): this;
+    static validateGuardrailFunction(value: LiteAgentGuardrail | string | null | undefined): LiteAgentGuardrail | string | null | undefined;
+    static validate_guardrail_function(value: LiteAgentGuardrail | string | null | undefined): LiteAgentGuardrail | string | null | undefined;
+    modelDump(options?: ModelDumpOptions): Record<string, unknown>;
+    model_dump(options?: ModelDumpOptions): Record<string, unknown>;
+    kickoff(messages: LiteAgentKickoffInput, responseFormatOrOptions?: unknown, inputFiles?: InputFiles): Promise<LiteAgentOutput>;
+    kickoffAsync(messages: LiteAgentKickoffInput, responseFormatOrOptions?: unknown, inputFiles?: InputFiles): Promise<LiteAgentOutput>;
+    kickoff_async(messages: LiteAgentKickoffInput, responseFormatOrOptions?: unknown, inputFiles?: InputFiles): Promise<LiteAgentOutput>;
+    akickoff(messages: LiteAgentKickoffInput, responseFormatOrOptions?: unknown, inputFiles?: InputFiles): Promise<LiteAgentOutput>;
+    _invokeLoop(responseModel?: unknown): Promise<AgentFinish>;
+    _invoke_loop(response_model?: unknown): Promise<AgentFinish>;
+    _executeCore(agentInfo?: Record<string, unknown> | null): Promise<LiteAgentOutput>;
+    _execute_core(agent_info?: Record<string, unknown> | null): Promise<LiteAgentOutput>;
+    getUsageMetrics(): UsageMetrics;
+    get_usage_metrics(): UsageMetrics;
+    getTokenUsageSummary(): UsageMetrics;
+    get_token_usage_summary(): UsageMetrics;
+    resetUsageMetrics(): void;
+    reset_usage_metrics(): void;
+    _formatMessages(messages: LiteAgentKickoffInput, responseFormat?: unknown, inputFiles?: InputFiles): LLMMessage[];
+    _format_messages(messages: LiteAgentKickoffInput, response_format?: unknown, input_files?: InputFiles): LLMMessage[];
+    _getDefaultSystemPrompt(responseFormat?: unknown): string;
+    _get_default_system_prompt(response_format?: unknown): string;
+    _serializeResponseFormat(value: unknown): unknown;
+    _serialize_response_format(value: unknown): unknown;
+    _showLogs(formattedAnswer: unknown): void;
+    _show_logs(formatted_answer: unknown): void;
+    _getLastUserContent(): string;
+    _get_last_user_content(): string;
+    _appendMessage(message: LLMMessage): void;
+    _append_message(message: LLMMessage): void;
+    _injectMemoryContext(): void;
+    _inject_memory_context(): void;
+    _saveToMemory(outputText: string): void;
+    _save_to_memory(output_text: string): void;
+    private toolsWithMemoryTools;
+    private toAgent;
+    private agentInfo;
+    private captureStepCallback;
+    private applyGuardrail;
+}
+export {};