@crewai-ts/core 0.1.2 → 0.1.5

package/dist/index.js

@@ -31009,33 +31009,37 @@ var GeminiCompletion = class _GeminiCompletion extends ConfiguredLLM {
     delete generationConfigBody.safety_settings;
     const model = this.model.replace(/^(?:gemini|google)\//, "");
     const baseUrl = this.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta";
-    const requestInit = {
+    const buildRequestInit = (currentContents) => ({
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        contents,
+        contents: currentContents,
         ...Object.keys(generationConfigBody).length > 0 ? { generationConfig: generationConfigBody } : {},
         ..."system_instruction" in requestBody ? { system_instruction: requestBody.system_instruction } : {},
         ..."tools" in requestBody ? { tools: requestBody.tools } : {},
         ..."safety_settings" in requestBody ? { safety_settings: requestBody.safety_settings } : {}
-      })
-    };
-    if (options?.signal) {
-      requestInit.signal = options.signal;
-    }
-    return fetch(
-      `${baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(apiKey)}`,
-      requestInit
-    ).then(async (response) => {
+      }),
+      ...options?.signal ? { signal: options.signal } : {}
+    });
+    const generateContent = async (currentContents) => {
+      const response = await fetch(
+        `${baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(apiKey)}`,
+        buildRequestInit(currentContents)
+      );
       const body = await response.json();
       if (!response.ok) {
         const error = readObject2(readObject2(body).error);
         throw new Error(scalarToString(error.message) ?? `Gemini request failed with HTTP ${response.status.toString()}.`);
       }
+      return body;
+    };
+    return generateContent(contents).then(async (body) => {
       return await this.processResponseWithTools(
         body,
         contents,
-        options?.availableFunctions ?? options?.available_functions ?? null
+        options?.availableFunctions ?? options?.available_functions ?? null,
+        generateContent,
+        geminiMaxToolRounds(options)
       );
     });
   }
@@ -31335,42 +31339,69 @@ ${textContent}` : textContent;
   static extract_structured_output_from_response(response) {
     return _GeminiCompletion.extractStructuredOutputFromResponse(response);
   }
-  async processResponseWithTools(response, contents = [], availableFunctions = null) {
-    void contents;
-    const candidates = readObject2(response).candidates;
-    if (!Array.isArray(candidates)) {
-      return _GeminiCompletion.extractTextFromResponse(response);
-    }
-    const first = readObject2(candidates[0]);
-    const rawParts = Array.isArray(readObject2(first.content).parts) ? readObject2(first.content).parts : [];
-    const functionCallParts = rawParts.filter((part) => Object.keys(readObject2(readObject2(part).functionCall ?? readObject2(part).function_call)).length > 0);
-    const nonStructuredParts = functionCallParts.filter((part) => {
-      const partRecord = readObject2(part);
-      const functionCall = readObject2(partRecord.functionCall ?? partRecord.function_call);
-      return (scalarToString(functionCall.name) ?? "") !== STRUCTURED_OUTPUT_TOOL_NAME;
-    });
-    if (nonStructuredParts.length > 0 && !availableFunctions) {
-      return nonStructuredParts;
-    }
-    if (nonStructuredParts.length > 0 && availableFunctions) {
+  async processResponseWithTools(response, contents = [], availableFunctions = null, generateContent = null, maxToolRounds = DEFAULT_GEMINI_MAX_TOOL_ROUNDS) {
+    let currentResponse = response;
+    let currentContents = [...contents];
+    for (let round = 0; round <= maxToolRounds; round += 1) {
+      const candidates = readObject2(currentResponse).candidates;
+      if (!Array.isArray(candidates)) {
+        return _GeminiCompletion.extractTextFromResponse(currentResponse);
+      }
+      const first = readObject2(candidates[0]);
+      const rawParts = Array.isArray(readObject2(first.content).parts) ? readObject2(first.content).parts : [];
+      const functionCallParts = rawParts.filter((part) => Object.keys(readObject2(readObject2(part).functionCall ?? readObject2(part).function_call)).length > 0);
+      const structuredOutput = _GeminiCompletion.extractStructuredOutputFromResponse(currentResponse);
+      const nonStructuredParts = functionCallParts.filter((part) => {
+        const partRecord = readObject2(part);
+        const functionCall = readObject2(partRecord.functionCall ?? partRecord.function_call);
+        return (scalarToString(functionCall.name) ?? "") !== STRUCTURED_OUTPUT_TOOL_NAME;
+      });
+      if (nonStructuredParts.length === 0) {
+        return structuredOutput ?? _GeminiCompletion.extractTextFromResponse(currentResponse);
+      }
+      if (!availableFunctions) {
+        return nonStructuredParts;
+      }
+      if (round >= maxToolRounds) {
+        throw new Error(`Gemini tool loop exceeded max tool rounds (${String(maxToolRounds)}).`);
+      }
+      const functionResponseParts = [];
+      let firstToolResult = null;
       for (const part of nonStructuredParts) {
         const partRecord = readObject2(part);
         const functionCall = readObject2(partRecord.functionCall ?? partRecord.function_call);
-        const functionName = scalarToString(functionCall.name);
+        const rawFunctionName = scalarToString(functionCall.name) ?? "";
+        const functionName = resolveGeminiFunctionName(rawFunctionName, availableFunctions);
         if (!functionName) {
-          continue;
+          throw new Error(`Gemini requested unknown function '${rawFunctionName}'.`);
         }
         const result = await this.handleToolExecution({
           functionName,
           functionArgs: readObject2(functionCall.args),
           availableFunctions
         });
-        if (result !== null) {
-          return result;
+        if (result === null) {
+          throw new Error(`Gemini failed to execute function '${rawFunctionName}'.`);
         }
+        firstToolResult ??= result;
+        functionResponseParts.push({
+          functionResponse: {
+            name: rawFunctionName,
+            response: { result }
+          }
+        });
       }
+      if (!generateContent) {
+        return firstToolResult;
+      }
+      currentContents = [
+        ...currentContents,
+        { role: "model", parts: rawParts },
+        { role: "user", parts: functionResponseParts }
+      ];
+      currentResponse = await generateContent(currentContents);
     }
-    return _GeminiCompletion.extractTextFromResponse(response);
+    throw new Error(`Gemini tool loop exceeded max tool rounds (${String(maxToolRounds)}).`);
   }
   async _process_response_with_tools(response, contents = [], availableFunctions = null) {
     return await this.processResponseWithTools(response, contents, availableFunctions);
@@ -32459,6 +32490,19 @@ function geminiVersion(model) {
   const match = /gemini-(\d+(?:\.\d+)?)/iu.exec(model.toLowerCase());
   return match ? Number.parseFloat(match[1] ?? "0") : 0;
 }
+var DEFAULT_GEMINI_MAX_TOOL_ROUNDS = 8;
+function geminiMaxToolRounds(options) {
+  const record = readObject2(options);
+  const configured = record.maxToolRounds ?? record.max_tool_rounds;
+  return typeof configured === "number" && Number.isInteger(configured) && configured > 0 ? configured : DEFAULT_GEMINI_MAX_TOOL_ROUNDS;
+}
+function resolveGeminiFunctionName(functionName, availableFunctions) {
+  if (functionName in availableFunctions) {
+    return functionName;
+  }
+  const sanitizedName = sanitizeToolName(functionName);
+  return sanitizedName in availableFunctions ? sanitizedName : null;
+}
 function geminiTextParts(content) {
   if (Array.isArray(content)) {
     return content.map((item) => {
@@ -35736,9 +35780,11 @@ ${todo.description}`);
     if (this.tools.length === 0) {
       return Object.keys(options).length > 0 ? options : void 0;
     }
-    const [tools] = setupNativeTools(this.tools);
+    const [tools, availableFunctions] = setupNativeTools(this.tools);
     if (tools.length > 0) {
       options.tools = tools;
+      options.availableFunctions = availableFunctions;
+      options.available_functions = availableFunctions;
     }
     return Object.keys(options).length > 0 ? options : void 0;
   }

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;
+}