@crewai-ts/core 0.1.1 → 0.1.3

package/dist/execution-utils.d.ts

@@ -0,0 +1,85 @@
+import { type InputFiles } from "./input-files.js";
+import { CrewOutput } from "./outputs.js";
+import { FlowStreamingOutput, CrewStreamingOutput, type StreamingState, type TaskInfo } from "./streaming.js";
+import type { Tool } from "./types.js";
+export declare function handleReasoning(agent: Record<string, unknown>, task: Record<string, unknown>): void;
+export declare const handle_reasoning: typeof handleReasoning;
+export declare function buildTaskPromptWithSchema(task: Record<string, unknown>, taskPrompt: string): string;
+export declare const build_task_prompt_with_schema: typeof buildTaskPromptWithSchema;
+export declare function formatTaskWithContext(taskPrompt: string, context?: string | null): string;
+export declare const format_task_with_context: typeof formatTaskWithContext;
+export declare function getKnowledgeConfig(agent: Record<string, unknown>): Record<string, unknown>;
+export declare const get_knowledge_config: typeof getKnowledgeConfig;
+export declare function handleKnowledgeRetrieval(agent: Record<string, unknown>, _task: unknown, taskPrompt: string, knowledgeConfig: Record<string, unknown>, queryFunc: (queries: readonly string[], config?: Record<string, unknown>) => unknown, crewQueryFunc: (queries: readonly string[], config?: Record<string, unknown>) => unknown): string;
+export declare const handle_knowledge_retrieval: typeof handleKnowledgeRetrieval;
+export declare const ahandle_knowledge_retrieval: (...args: Parameters<typeof handleKnowledgeRetrieval>) => Promise<string>;
+export declare function applyTrainingData(agent: Record<string, unknown>, taskPrompt: string): string;
+export declare const apply_training_data: typeof applyTrainingData;
+export declare function processToolResults(agent: {
+    toolsResults?: readonly Record<string, unknown>[];
+    tools_results?: readonly Record<string, unknown>[];
+}, result: unknown): unknown;
+export declare const process_tool_results: typeof processToolResults;
+export declare function saveLastMessages(agent: Record<string, unknown>): void;
+export declare const save_last_messages: typeof saveLastMessages;
+export declare function validateMaxExecutionTime(agent: {
+    maxExecutionTime?: number | null;
+    max_execution_time?: number | null;
+    startTime?: Date | null;
+    start_time?: Date | null;
+}): void;
+export declare const validate_max_execution_time: typeof validateMaxExecutionTime;
+export declare function prepareTools(agent: {
+    tools?: readonly Tool[];
+}, task?: {
+    tools?: readonly Tool[];
+} | null): readonly Tool[];
+export declare const prepare_tools: typeof prepareTools;
+export declare function enableAgentStreaming(agents: Iterable<Record<string, unknown>>): void;
+export declare const enable_agent_streaming: typeof enableAgentStreaming;
+export declare function _resolve_crew_skills(crew: {
+    skills?: unknown;
+}): unknown[] | null;
+export declare function _extract_files_from_inputs(inputs: Record<string, unknown>): Record<string, unknown>;
+export declare class TaskExecutionData {
+    readonly agent: unknown;
+    readonly tools: readonly unknown[];
+    readonly shouldSkip: boolean;
+    readonly should_skip: boolean;
+    constructor(agent?: unknown, tools?: readonly unknown[], shouldSkip?: boolean);
+}
+export declare function setupAgents(crew: Record<string, unknown>, agents: Iterable<Record<string, unknown>>, embedder?: unknown, functionCallingLlm?: unknown, stepCallback?: unknown): void;
+export declare const setup_agents: typeof setupAgents;
+export declare function prepareTaskExecution(crew: Record<string, unknown>, task: Record<string, unknown>, taskIndex: number, startIndex: number | null, taskOutputs: unknown[], lastSyncOutput?: unknown): [TaskExecutionData, unknown[], unknown];
+export declare const prepare_task_execution: typeof prepareTaskExecution;
+export declare function checkConditionalSkip(crew: Record<string, unknown>, task: Record<string, unknown>, taskOutputs: readonly unknown[], taskIndex?: number, wasReplayed?: boolean): unknown;
+export declare const check_conditional_skip: typeof checkConditionalSkip;
+export declare function prepareKickoff(crew: Record<string, unknown>, inputs?: Record<string, unknown> | null, inputFiles?: InputFiles | null): Record<string, unknown> | null;
+export declare const prepare_kickoff: typeof prepareKickoff;
+export declare function runForEachAsync<TInput, TResult>(items: readonly TInput[], runner: (item: TInput, index: number) => Promise<TResult>): Promise<TResult[]>;
+export declare function runForEachAsync<TCrew extends Record<string, unknown>, TInput extends Record<string, unknown>, TResult>(crew: TCrew, inputs: readonly TInput[], kickoffFn: (crew: TCrew, input: TInput) => Promise<TResult>): Promise<TResult[] | CrewStreamingOutput>;
+export declare const run_for_each_async: typeof runForEachAsync;
+export declare function run_all_crews<TCrew extends Record<string, unknown>, TInput extends Record<string, unknown>, TResult>(crew: TCrew, inputs: readonly TInput[], kickoff_fn: (crew: TCrew, input: TInput) => Promise<TResult>): Promise<TResult[] | CrewStreamingOutput>;
+export declare function consume_stream(stream_output: CrewStreamingOutput): Promise<CrewOutput>;
+export declare function set_results_wrapper(streaming_output: CrewStreamingOutput): (result: CrewOutput | readonly CrewOutput[]) => void;
+export declare class StreamingContext {
+    readonly resultHolder: unknown[];
+    readonly result_holder: unknown[];
+    readonly currentTaskInfo: TaskInfo;
+    readonly current_task_info: TaskInfo;
+    readonly state: StreamingState;
+    readonly outputHolder: Array<CrewStreamingOutput | FlowStreamingOutput>;
+    readonly output_holder: Array<CrewStreamingOutput | FlowStreamingOutput>;
+    readonly output: CrewStreamingOutput | FlowStreamingOutput | null;
+    constructor(useAsync?: boolean, output?: CrewStreamingOutput | FlowStreamingOutput | null);
+}
+export declare class ForEachStreamingContext {
+    readonly resultHolder: unknown[][];
+    readonly result_holder: unknown[][];
+    readonly currentTaskInfo: TaskInfo;
+    readonly current_task_info: TaskInfo;
+    readonly state: StreamingState;
+    readonly outputHolder: Array<CrewStreamingOutput | FlowStreamingOutput>;
+    readonly output_holder: Array<CrewStreamingOutput | FlowStreamingOutput>;
+    constructor();
+}

package/dist/experimental-conversational.d.ts

@@ -0,0 +1,181 @@
+import type { LLMMessage } from "./types.js";
+export type ConversationMessageRole = "user" | "assistant" | "system" | "tool";
+export declare const ConversationMessageRole: Readonly<{
+    kind: "ConversationMessageRole";
+}>;
+export type ConversationEventVisibility = "private" | "public";
+export declare const ConversationEventVisibility: Readonly<{
+    kind: "ConversationEventVisibility";
+}>;
+export type RouterConfigOptions = {
+    prompt?: string | null;
+    responseFormat?: unknown;
+    response_format?: unknown;
+    llm?: unknown;
+    routes?: readonly string[] | null;
+    routeDescriptions?: Record<string, string> | null;
+    route_descriptions?: Record<string, string> | null;
+    defaultIntent?: string | null;
+    default_intent?: string | null;
+    fallbackIntent?: string | null;
+    fallback_intent?: string | null;
+    intentField?: string;
+    intent_field?: string;
+};
+export declare class RouterConfig {
+    readonly prompt: string | null;
+    readonly responseFormat: unknown;
+    readonly response_format: unknown;
+    readonly llm: unknown;
+    readonly routes: readonly string[] | null;
+    readonly routeDescriptions: Record<string, string> | null;
+    readonly route_descriptions: Record<string, string> | null;
+    readonly defaultIntent: string | null;
+    readonly default_intent: string | null;
+    readonly fallbackIntent: string | null;
+    readonly fallback_intent: string | null;
+    readonly intentField: string;
+    readonly intent_field: string;
+    constructor(options?: RouterConfigOptions);
+}
+export type ConversationConfigOptions = {
+    systemPrompt?: string | null;
+    system_prompt?: string | null;
+    llm?: unknown;
+    router?: RouterConfig | RouterConfigOptions | null;
+    answerFromHistoryPrompt?: string | null;
+    answer_from_history_prompt?: string | null;
+    defaultIntents?: readonly string[] | null;
+    default_intents?: readonly string[] | null;
+    intentLlm?: unknown;
+    intent_llm?: unknown;
+    answerFromHistoryLlm?: unknown;
+    answer_from_history_llm?: unknown;
+    visibleAgentOutputs?: readonly string[] | "all" | null;
+    visible_agent_outputs?: readonly string[] | "all" | null;
+    deferTraceFinalization?: boolean;
+    defer_trace_finalization?: boolean;
+};
+export declare class ConversationConfig {
+    readonly systemPrompt: string | null;
+    readonly system_prompt: string | null;
+    readonly llm: unknown;
+    readonly router: RouterConfig | null;
+    readonly answerFromHistoryPrompt: string | null;
+    readonly answer_from_history_prompt: string | null;
+    readonly defaultIntents: readonly string[] | null;
+    readonly default_intents: readonly string[] | null;
+    readonly intentLlm: unknown;
+    readonly intent_llm: unknown;
+    readonly answerFromHistoryLlm: unknown;
+    readonly answer_from_history_llm: unknown;
+    readonly visibleAgentOutputs: readonly string[] | "all" | null;
+    readonly visible_agent_outputs: readonly string[] | "all" | null;
+    readonly deferTraceFinalization: boolean;
+    readonly defer_trace_finalization: boolean;
+    constructor(options?: ConversationConfigOptions);
+    __call__<T extends object>(flowClass: T): T;
+}
+export type ConversationMessageOptions = {
+    role: ConversationMessageRole;
+    content: string | readonly Record<string, unknown>[] | null;
+    name?: string | null;
+    tool_call_id?: string | null;
+    toolCallId?: string | null;
+    tool_calls?: readonly Record<string, unknown>[] | null;
+    toolCalls?: readonly Record<string, unknown>[] | null;
+    files?: Record<string, unknown> | null;
+    metadata?: Record<string, unknown>;
+};
+export declare class ConversationMessage {
+    readonly role: ConversationMessageRole;
+    readonly content: string | readonly Record<string, unknown>[] | null;
+    readonly name: string | null;
+    readonly tool_call_id: string | null;
+    readonly toolCallId: string | null;
+    readonly tool_calls: readonly Record<string, unknown>[] | null;
+    readonly toolCalls: readonly Record<string, unknown>[] | null;
+    readonly files: Record<string, unknown> | null;
+    readonly metadata: Record<string, unknown>;
+    constructor(options: ConversationMessageOptions);
+    modelDump(options?: {
+        exclude_none?: boolean;
+        excludeNone?: boolean;
+    }): Record<string, unknown>;
+    model_dump(options?: {
+        exclude_none?: boolean;
+        excludeNone?: boolean;
+    }): Record<string, unknown>;
+}
+export type AgentMessageOptions = {
+    role?: string;
+    content: unknown;
+    metadata?: Record<string, unknown>;
+};
+export declare class AgentMessage {
+    readonly role: string;
+    readonly content: unknown;
+    readonly metadata: Record<string, unknown>;
+    constructor(options: AgentMessageOptions);
+    model_dump(options?: {
+        exclude_none?: boolean;
+        excludeNone?: boolean;
+    }): Record<string, unknown>;
+}
+export type ConversationEventOptions = {
+    type: string;
+    payload?: Record<string, unknown>;
+    agent_name?: string | null;
+    agentName?: string | null;
+    visibility?: ConversationEventVisibility;
+};
+export declare class ConversationEvent {
+    readonly type: string;
+    readonly payload: Record<string, unknown>;
+    readonly agent_name: string | null;
+    readonly agentName: string | null;
+    readonly visibility: ConversationEventVisibility;
+    constructor(options: ConversationEventOptions);
+    model_dump(options?: {
+        exclude_none?: boolean;
+        excludeNone?: boolean;
+    }): Record<string, unknown>;
+}
+export type ConversationStateOptions = {
+    id?: string;
+    messages?: readonly (ConversationMessage | ConversationMessageOptions)[];
+    current_user_message?: string | null;
+    currentUserMessage?: string | null;
+    last_user_message?: string | null;
+    lastUserMessage?: string | null;
+    last_intent?: string | null;
+    lastIntent?: string | null;
+    ended?: boolean;
+    events?: readonly (ConversationEvent | ConversationEventOptions)[];
+    agent_threads?: Record<string, readonly (AgentMessage | AgentMessageOptions)[]>;
+    agentThreads?: Record<string, readonly (AgentMessage | AgentMessageOptions)[]>;
+    session_ready?: boolean;
+    sessionReady?: boolean;
+};
+export declare class ConversationState {
+    readonly id: string;
+    messages: ConversationMessage[];
+    current_user_message: string | null;
+    currentUserMessage: string | null;
+    last_user_message: string | null;
+    lastUserMessage: string | null;
+    last_intent: string | null;
+    lastIntent: string | null;
+    ended: boolean;
+    events: ConversationEvent[];
+    agent_threads: Record<string, AgentMessage[]>;
+    agentThreads: Record<string, AgentMessage[]>;
+    session_ready: boolean;
+    sessionReady: boolean;
+    constructor(options?: ConversationStateOptions);
+    isReady(): boolean;
+    is_ready(): boolean;
+}
+export declare function messageToLlmDict(message: unknown): LLMMessage;
+export declare const message_to_llm_dict: typeof messageToLlmDict;
+export declare function _conversational_only<T extends (...args: never[]) => unknown>(func: T): T;

package/dist/file-handler.d.ts

@@ -0,0 +1,36 @@
+export type LogEntry = {
+    taskName?: string | null;
+    task_name?: string | null;
+    task?: string;
+    agent?: string;
+    status?: string;
+    output?: string;
+    input?: string;
+    message?: string;
+    level?: string;
+    crew?: string | null;
+    flow?: string | null;
+    tool?: string;
+    error?: string;
+    duration?: number;
+    metadata?: Record<string, unknown>;
+};
+export declare const LogEntry: Readonly<{
+    kind: "LogEntry";
+}>;
+export declare class FileHandler {
+    path: string;
+    _path: string;
+    constructor(filePath: boolean | string);
+    _initialize_path(filePath: boolean | string): void;
+    log(entry?: LogEntry): void;
+}
+export declare class PickleHandler {
+    readonly filePath: string;
+    readonly file_path: string;
+    constructor(fileName: string);
+    initializeFile(): void;
+    initialize_file(): void;
+    save(data: unknown): void;
+    load(): unknown;
+}

package/dist/file-store.d.ts

@@ -0,0 +1,37 @@
+export declare const DEFAULT_FILE_STORE_TTL = 3600;
+export type FileInput = unknown;
+export type FileInputMap = Record<string, FileInput>;
+export type FileStoreId = string | number | bigint | {
+    toString(): string;
+};
+export declare function astoreFiles(executionId: FileStoreId, files: FileInputMap, ttl?: number): Promise<void>;
+export declare const astore_files: typeof astoreFiles;
+export declare function agetFiles(executionId: FileStoreId): Promise<FileInputMap | null>;
+export declare const aget_files: typeof agetFiles;
+export declare function aclearFiles(executionId: FileStoreId): Promise<void>;
+export declare const aclear_files: typeof aclearFiles;
+export declare function astoreTaskFiles(taskId: FileStoreId, files: FileInputMap, ttl?: number): Promise<void>;
+export declare const astore_task_files: typeof astoreTaskFiles;
+export declare function agetTaskFiles(taskId: FileStoreId): Promise<FileInputMap | null>;
+export declare const aget_task_files: typeof agetTaskFiles;
+export declare function aclearTaskFiles(taskId: FileStoreId): Promise<void>;
+export declare const aclear_task_files: typeof aclearTaskFiles;
+export declare function agetAllFiles(crewId: FileStoreId, taskId?: FileStoreId | null): Promise<FileInputMap | null>;
+export declare const aget_all_files: typeof agetAllFiles;
+export declare function storeFiles(executionId: FileStoreId, files: FileInputMap, ttl?: number): void;
+export declare const store_files: typeof storeFiles;
+export declare function getFiles(executionId: FileStoreId): FileInputMap | null;
+export declare const get_files: typeof getFiles;
+export declare function clearFiles(executionId: FileStoreId): void;
+export declare const clear_files: typeof clearFiles;
+export declare function storeTaskFiles(taskId: FileStoreId, files: FileInputMap, ttl?: number): void;
+export declare const store_task_files: typeof storeTaskFiles;
+export declare function getTaskFiles(taskId: FileStoreId): FileInputMap | null;
+export declare const get_task_files: typeof getTaskFiles;
+export declare function clearTaskFiles(taskId: FileStoreId): void;
+export declare const clear_task_files: typeof clearTaskFiles;
+export declare function getAllFiles(crewId: FileStoreId, taskId?: FileStoreId | null): FileInputMap | null;
+export declare const get_all_files: typeof getAllFiles;
+export declare function clearFileStore(): void;
+export declare const clear_file_store: typeof clearFileStore;
+export declare function _run_sync<T>(task: Promise<T> | (() => T | Promise<T>)): Promise<T>;