@crewai-ts/core 0.1.1 → 0.1.3

package/dist/state.d.ts

@@ -0,0 +1,204 @@
+import { crewaiEventBus, BaseEvent, type EventType } from "./events.js";
+export type CheckpointEventType = EventType | "lite_agent_execution_started" | "lite_agent_execution_completed" | "lite_agent_execution_error";
+export declare const CheckpointEventType: Readonly<{
+    kind: "CheckpointEventType";
+}>;
+export type CheckpointTrigger = CheckpointEventType | "*";
+export declare const _event_type_map: Record<string, typeof BaseEvent>;
+export declare function buildEventTypeMap(): Record<string, typeof BaseEvent>;
+export declare const _build_event_type_map: typeof buildEventTypeMap;
+export declare function resolveEvent(value: unknown): BaseEvent;
+export declare const _resolve_event: typeof resolveEvent;
+export declare function _ensure_handlers_registered(): void;
+export declare function _resolve_from_agent(agent: unknown): CheckpointConfig | null;
+export declare function _find_checkpoint(source: unknown): CheckpointConfig | null;
+export declare function _do_checkpoint(state: RuntimeState, cfg: CheckpointConfig, event?: BaseEvent | null): void;
+export declare function _should_checkpoint(source: unknown, event: BaseEvent): CheckpointConfig | null;
+export declare function _on_any_event(source: unknown, event: BaseEvent, state?: unknown): void;
+export declare function _register_all_handlers(event_bus: typeof crewaiEventBus): void;
+export type EdgeType = "parent" | "child" | "trigger" | "triggered_by" | "next" | "previous" | "started" | "completed_by";
+export declare const EdgeType: readonly ["parent", "child", "trigger", "triggered_by", "next", "previous", "started", "completed_by"];
+export declare class EventNode {
+    readonly event: BaseEvent;
+    readonly edges: Record<string, string[]>;
+    constructor(options: {
+        event: BaseEvent | Record<string, unknown>;
+        edges?: Record<string, readonly string[]>;
+    });
+    addEdge(edgeType: EdgeType, targetId: string): void;
+    add_edge(edgeType: EdgeType, targetId: string): void;
+    neighbors(edgeType: EdgeType): string[];
+    toJSON(): Record<string, unknown>;
+    modelDump(): Record<string, unknown>;
+    model_dump(): Record<string, unknown>;
+}
+export declare class EventRecord {
+    nodes: Record<string, EventNode>;
+    constructor(options?: {
+        nodes?: Record<string, EventNode | {
+            event: BaseEvent | Record<string, unknown>;
+            edges?: Record<string, readonly string[]>;
+        }>;
+    });
+    add(event: BaseEvent): EventNode;
+    get(eventId: string): EventNode | null;
+    descendants(eventId: string): EventNode[];
+    roots(): EventNode[];
+    allNodes(): EventNode[];
+    all_nodes(): EventNode[];
+    clear(): void;
+    has(eventId: string): boolean;
+    __contains__(eventId: string): boolean;
+    get size(): number;
+    __len__(): number;
+    toJSON(): Record<string, unknown>;
+    modelDump(): Record<string, unknown>;
+    model_dump(): Record<string, unknown>;
+    modelDumpJson(): string;
+    model_dump_json(): string;
+    static modelValidateJson(value: string): EventRecord;
+    static model_validate_json(value: string): EventRecord;
+}
+export type RuntimeStateOptions = {
+    root?: readonly unknown[];
+    entities?: readonly unknown[];
+    provider?: BaseProvider;
+    eventRecord?: EventRecord;
+    event_record?: EventRecord;
+    checkpointId?: string | null;
+    checkpoint_id?: string | null;
+    parentId?: string | null;
+    parent_id?: string | null;
+    branch?: string;
+    crewaiVersion?: string;
+    crewai_version?: string;
+};
+export declare function _sync_checkpoint_fields(entity: object): void;
+export declare function _backfill_memory_kind(value: unknown): void;
+export declare function _backfill_source_type(source: unknown): void;
+export declare function _backfill_sources_on(container: unknown): void;
+export declare function _backfill_discriminators(entity: unknown): void;
+export declare function _prepare_entities(root: readonly object[]): void;
+export declare class RuntimeState {
+    root: unknown[];
+    private provider;
+    private readonly runtimeEventRecord;
+    checkpointId: string | null;
+    checkpoint_id: string | null;
+    parentId: string | null;
+    parent_id: string | null;
+    branch: string;
+    constructor(options?: RuntimeStateOptions);
+    get eventRecord(): EventRecord;
+    get event_record(): EventRecord;
+    get providerType(): string;
+    setProvider(provider: BaseProvider): void;
+    set_provider(provider: BaseProvider): void;
+    checkpoint(location: string): string;
+    acheckpoint(location: string): Promise<string>;
+    fork(branch?: string): string;
+    toJSON(): Record<string, unknown>;
+    _serialize(): Record<string, unknown>;
+    toJSONText(): string;
+    to_json(): string;
+    static fromJSONText(raw: string, provider?: BaseProvider): RuntimeState;
+    static _deserialize(data: unknown, provider?: BaseProvider): RuntimeState;
+    static from_json(raw: string, provider?: BaseProvider): RuntimeState;
+    static fromCheckpoint(config: CheckpointConfig, provider?: BaseProvider): Promise<RuntimeState>;
+    static from_checkpoint(config: CheckpointConfig, provider?: BaseProvider): Promise<RuntimeState>;
+    static afromCheckpoint(config: CheckpointConfig, provider?: BaseProvider): Promise<RuntimeState>;
+    static afrom_checkpoint(config: CheckpointConfig, provider?: BaseProvider): Promise<RuntimeState>;
+    private chainLineage;
+    _chain_lineage(provider: BaseProvider, location: string): void;
+    private beginCheckpoint;
+    _begin_checkpoint(location: string): [string, string | null, string, number];
+    private emitCheckpointCompleted;
+    _emit_checkpoint_completed(result: string, providerName: string, branchSnapshot: string, parentIdSnapshot: string | null, startedAt: number): void;
+    private emitCheckpointFailed;
+    _emit_checkpoint_failed(location: string, providerName: string, branchSnapshot: string, parentIdSnapshot: string | null, error: unknown): void;
+}
+export type CheckpointProviderOptions = {
+    parentId?: string | null;
+    parent_id?: string | null;
+    branch?: string;
+};
+export declare abstract class BaseProvider {
+    abstract readonly providerType: string;
+    abstract readonly provider_type: string;
+    abstract checkpoint(data: string, location: string, options?: CheckpointProviderOptions): string | Promise<string>;
+    abstract acheckpoint(data: string, location: string, options?: CheckpointProviderOptions): Promise<string>;
+    abstract prune(location: string, maxKeep: number, options?: {
+        branch?: string;
+    }): number | Promise<number>;
+    abstract extractId(location: string): string;
+    abstract extract_id(location: string): string;
+    abstract fromCheckpoint(location: string): string | Promise<string>;
+    abstract from_checkpoint(location: string): string | Promise<string>;
+    abstract afromCheckpoint(location: string): Promise<string>;
+    abstract afrom_checkpoint(location: string): Promise<string>;
+}
+export declare class JsonProvider implements BaseProvider {
+    readonly providerType = "json";
+    readonly provider_type = "json";
+    checkpoint(data: string, location: string, options?: CheckpointProviderOptions): string;
+    acheckpoint(data: string, location: string, options?: CheckpointProviderOptions): Promise<string>;
+    prune(location: string, maxKeep: number, options?: {
+        branch?: string;
+    }): number;
+    extractId(location: string): string;
+    extract_id(location: string): string;
+    fromCheckpoint(location: string): string;
+    from_checkpoint(location: string): string;
+    afromCheckpoint(location: string): Promise<string>;
+    afrom_checkpoint(location: string): Promise<string>;
+}
+export declare class SqliteProvider implements BaseProvider {
+    readonly providerType = "sqlite";
+    readonly provider_type = "sqlite";
+    checkpoint(data: string, location: string, options?: CheckpointProviderOptions): string;
+    acheckpoint(data: string, location: string, options?: CheckpointProviderOptions): Promise<string>;
+    prune(location: string, maxKeep: number, options?: {
+        branch?: string;
+    }): number;
+    extractId(location: string): string;
+    extract_id(location: string): string;
+    fromCheckpoint(location: string): string;
+    from_checkpoint(location: string): string;
+    afromCheckpoint(location: string): Promise<string>;
+    afrom_checkpoint(location: string): Promise<string>;
+}
+export type CheckpointConfigOptions = {
+    location?: string;
+    onEvents?: readonly CheckpointTrigger[];
+    on_events?: readonly CheckpointTrigger[];
+    provider?: BaseProvider;
+    maxCheckpoints?: number | null;
+    max_checkpoints?: number | null;
+    restoreFrom?: string | null;
+    restore_from?: string | null;
+};
+export declare class CheckpointConfig {
+    location: string;
+    onEvents: readonly CheckpointTrigger[];
+    on_events: readonly CheckpointTrigger[];
+    provider: BaseProvider;
+    maxCheckpoints: number | null;
+    max_checkpoints: number | null;
+    restoreFrom: string | null;
+    restore_from: string | null;
+    constructor(options?: CheckpointConfigOptions);
+    _register_handlers(): this;
+    get triggerAll(): boolean;
+    get trigger_all(): boolean;
+    get triggerEvents(): ReadonlySet<CheckpointTrigger>;
+    get trigger_events(): ReadonlySet<CheckpointTrigger>;
+}
+export type CheckpointOption = CheckpointConfig | CheckpointConfigOptions | boolean | null | undefined;
+export declare function coerceCheckpointConfig(value: CheckpointOption): CheckpointConfig | false | null;
+export declare const _coerce_checkpoint: typeof coerceCheckpointConfig;
+export declare function apply_checkpoint(instance: unknown, from_checkpoint: CheckpointConfig | null): unknown;
+export declare function detectProvider(path: string): BaseProvider;
+export declare const detect_provider: typeof detectProvider;
+export declare function _build_path(directory: string, branch?: string, parent_id?: string | null): string;
+export declare function _safe_branch(base: string, branch: string): void;
+export declare function _make_id(): [string, string];

package/dist/step-execution-context.d.ts

@@ -0,0 +1,36 @@
+export declare class StepExecutionContext {
+    readonly taskDescription: string;
+    readonly task_description: string;
+    readonly taskGoal: string;
+    readonly task_goal: string;
+    readonly dependencyResults: Readonly<Record<number, string>>;
+    readonly dependency_results: Readonly<Record<number, string>>;
+    constructor(options: {
+        taskDescription?: string;
+        task_description?: string;
+        taskGoal?: string;
+        task_goal?: string;
+        dependencyResults?: Readonly<Record<number, string>>;
+        dependency_results?: Readonly<Record<number, string>>;
+    });
+    getDependencyResult(stepNumber: number): string | null;
+    get_dependency_result(stepNumber: number): string | null;
+}
+export declare class StepResult {
+    readonly success: boolean;
+    readonly result: string;
+    readonly error: string | null;
+    readonly toolCallsMade: readonly string[];
+    readonly tool_calls_made: readonly string[];
+    readonly executionTime: number;
+    readonly execution_time: number;
+    constructor(options: {
+        success: boolean;
+        result: string;
+        error?: string | null;
+        toolCallsMade?: readonly string[];
+        tool_calls_made?: readonly string[];
+        executionTime?: number;
+        execution_time?: number;
+    });
+}

package/dist/streaming.d.ts

@@ -0,0 +1,153 @@
+import { type BaseEvent } from "./events.js";
+import { CrewOutput } from "./outputs.js";
+export declare enum StreamChunkType {
+    TEXT = "text",
+    TOOL_CALL = "tool_call"
+}
+export type ToolCallChunk = {
+    toolId?: string | null;
+    tool_id?: string | null;
+    toolName?: string | null;
+    tool_name?: string | null;
+    arguments: string;
+    index?: number;
+};
+export declare const ToolCallChunk: Readonly<{
+    kind: "ToolCallChunk";
+}>;
+export type StreamChunkOptions = {
+    content: string;
+    chunkType?: StreamChunkType;
+    chunk_type?: StreamChunkType;
+    taskIndex?: number;
+    task_index?: number;
+    taskName?: string;
+    task_name?: string;
+    taskId?: string;
+    task_id?: string;
+    agentRole?: string;
+    agent_role?: string;
+    agentId?: string;
+    agent_id?: string;
+    toolCall?: ToolCallChunk | null;
+    tool_call?: ToolCallChunk | null;
+};
+export declare class StreamChunk {
+    readonly content: string;
+    readonly chunkType: StreamChunkType;
+    readonly chunk_type: StreamChunkType;
+    readonly taskIndex: number;
+    readonly task_index: number;
+    readonly taskName: string;
+    readonly task_name: string;
+    readonly taskId: string;
+    readonly task_id: string;
+    readonly agentRole: string;
+    readonly agent_role: string;
+    readonly agentId: string;
+    readonly agent_id: string;
+    readonly toolCall: ToolCallChunk | null;
+    readonly tool_call: ToolCallChunk | null;
+    constructor(options: StreamChunkOptions);
+    toString(): string;
+    __str__(): string;
+}
+export declare abstract class StreamingOutputBase<TResult> implements AsyncIterable<StreamChunk> {
+    private readonly run;
+    protected resultValue: TResult | null;
+    protected hasResult: boolean;
+    protected completed: boolean;
+    protected cancelled: boolean;
+    protected error: unknown;
+    protected readonly collectedChunks: StreamChunk[];
+    private iteratorStarted;
+    constructor(run: () => Promise<TResult>);
+    get result(): TResult;
+    get isCompleted(): boolean;
+    get is_completed(): boolean;
+    get isCancelled(): boolean;
+    get is_cancelled(): boolean;
+    get chunks(): readonly StreamChunk[];
+    getFullText(): string;
+    get_full_text(): string;
+    setResult(result: TResult): void;
+    _set_result(result: TResult): void;
+    close(): void;
+    aclose(): Promise<void>;
+    __aenter__(): Promise<this>;
+    __aexit__(..._excInfo: unknown[]): Promise<void>;
+    [Symbol.iterator](): Iterator<StreamChunk>;
+    __iter__(): IterableIterator<StreamChunk>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<StreamChunk>;
+    __aiter__(): AsyncIterableIterator<StreamChunk>;
+    _async_iterate(): AsyncIterableIterator<StreamChunk>;
+    protected abstract chunksFromResult(result: TResult): readonly StreamChunk[];
+}
+export declare class CrewStreamingOutput extends StreamingOutputBase<CrewOutput> {
+    private resultValues;
+    get results(): readonly CrewOutput[];
+    setResults(results: readonly CrewOutput[]): void;
+    _set_results(results: readonly CrewOutput[]): void;
+    protected chunksFromResult(result: CrewOutput): readonly StreamChunk[];
+}
+export declare class FlowStreamingOutput extends StreamingOutputBase<unknown> {
+    protected chunksFromResult(result: unknown): readonly StreamChunk[];
+}
+export declare const TaskInfo: Readonly<{
+    kind: "TaskInfo";
+}>;
+export type TaskInfo = {
+    index: number;
+    name: string;
+    id: string;
+    agent_role: string;
+    agent_id: string;
+};
+type QueueItem = StreamChunk | null | Error;
+type StreamHandler = (source: unknown, event: BaseEvent) => void;
+declare class ChunkQueue {
+    private readonly items;
+    private readonly waiters;
+    put(item: QueueItem): void;
+    get(): QueueItem | undefined;
+    wait(): Promise<QueueItem>;
+}
+export declare class StreamingState {
+    readonly current_task_info: TaskInfo;
+    readonly currentTaskInfo: TaskInfo;
+    readonly result_holder: unknown[];
+    readonly resultHolder: unknown[];
+    readonly sync_queue: ChunkQueue;
+    readonly syncQueue: ChunkQueue;
+    readonly async_queue: ChunkQueue | null;
+    readonly asyncQueue: ChunkQueue | null;
+    readonly loop: null;
+    readonly handler: StreamHandler;
+    readonly stream_id: string | null;
+    readonly streamId: string | null;
+    constructor(options: {
+        currentTaskInfo: TaskInfo;
+        resultHolder: unknown[];
+        syncQueue: ChunkQueue;
+        asyncQueue?: ChunkQueue | null;
+        handler: StreamHandler;
+        streamId?: string | null;
+    });
+}
+export declare const logger: Readonly<{
+    debug: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}>;
+export declare function createStreamingState(currentTaskInfo: TaskInfo, resultHolder: unknown[], useAsync?: boolean): StreamingState;
+export declare const create_streaming_state: typeof createStreamingState;
+export declare function registerCleanup(streamingOutput: unknown, state: StreamingState): void;
+export declare const register_cleanup: typeof registerCleanup;
+export declare function signalEnd(state: StreamingState, isAsync?: boolean): void;
+export declare const signal_end: typeof signalEnd;
+export declare function signalError(state: StreamingState, error: Error, isAsync?: boolean): void;
+export declare const signal_error: typeof signalError;
+export declare function createChunkGenerator(state: StreamingState, runFunc: () => void, outputHolder?: unknown[]): Generator<StreamChunk>;
+export declare const create_chunk_generator: typeof createChunkGenerator;
+export declare function createAsyncChunkGenerator(state: StreamingState, runCoro: () => unknown, outputHolder?: unknown[]): AsyncGenerator<StreamChunk>;
+export declare const create_async_chunk_generator: typeof createAsyncChunkGenerator;
+export {};

package/dist/string-utils.d.ts

@@ -0,0 +1,12 @@
+export type InterpolationValue = string | number | boolean | null | readonly InterpolationValue[] | {
+    readonly [key: string]: InterpolationValue;
+};
+export declare function sanitizeToolName(name: string, maxLength?: number): string;
+export declare const sanitize_tool_name: typeof sanitizeToolName;
+export declare function slugify(text: string, separator?: string): string;
+export declare function _duplicate_separator_pattern(separator: string): RegExp;
+export declare function interpolateOnly(inputString: string | null | undefined, inputs: Record<string, unknown>, options?: {
+    strictMissing?: boolean;
+}): string;
+export declare const interpolate_only: typeof interpolateOnly;
+export declare function _validate_type(value: unknown): void;

package/dist/task-output-storage.d.ts

@@ -0,0 +1,62 @@
+import type { Task } from "./task.js";
+export type StoredTaskOutput = {
+    description: string;
+    summary?: string;
+    raw: string;
+    pydantic: unknown;
+    jsonDict: Record<string, unknown> | null;
+    json_dict?: Record<string, unknown> | null;
+    outputFormat: string;
+    output_format?: string;
+    agent: string;
+    messages?: readonly unknown[];
+};
+export type TaskOutputStorageRecord = {
+    task_id: string;
+    expected_output: string;
+    output: StoredTaskOutput;
+    task_index: number;
+    inputs: Record<string, unknown>;
+    was_replayed: boolean;
+    timestamp: string;
+};
+export type TaskOutputStorageUpdate = Partial<Omit<TaskOutputStorageRecord, "task_index" | "timestamp">>;
+export interface KickoffTaskOutputsStorage {
+    add(task: Task, output: StoredTaskOutput, taskIndex: number, wasReplayed?: boolean, inputs?: Record<string, unknown>): void;
+    update(taskIndex: number, fields: TaskOutputStorageUpdate): void;
+    load(): TaskOutputStorageRecord[];
+    deleteAll(): void;
+}
+export declare class KickoffTaskOutputsSQLiteStorage implements KickoffTaskOutputsStorage {
+    readonly dbPath: string;
+    readonly db_path: string;
+    constructor(dbPath?: string | null);
+    add(task: Task, output: StoredTaskOutput, taskIndex: number, wasReplayed?: boolean, inputs?: Record<string, unknown>): void;
+    update(taskIndex: number, fields: TaskOutputStorageUpdate): void;
+    load(): TaskOutputStorageRecord[];
+    deleteAll(): void;
+    delete_all(): void;
+    private initializeDb;
+    _initialize_db(): void;
+    private withDb;
+}
+export declare class TaskOutputStorageHandler {
+    readonly storage: KickoffTaskOutputsStorage;
+    constructor(storage?: KickoffTaskOutputsStorage);
+    update(taskIndex: number, log: {
+        task: Task;
+        output: StoredTaskOutput;
+        task_index?: number;
+        taskIndex?: number;
+        inputs?: Record<string, unknown>;
+        was_replayed?: boolean;
+        wasReplayed?: boolean;
+    }): void;
+    add(task: Task, output: StoredTaskOutput, taskIndex: number, inputs?: Record<string, unknown>, wasReplayed?: boolean): void;
+    reset(): void;
+    load(): TaskOutputStorageRecord[] | null;
+}
+export declare function defaultTaskOutputStoragePath(): string;
+export declare const default_task_output_storage_path: typeof defaultTaskOutputStoragePath;
+export declare const KickoffTaskOutputsSqliteStorage: typeof KickoffTaskOutputsSQLiteStorage;
+export declare const TaskOutputStorageHandlerAlias: typeof TaskOutputStorageHandler;