@crewai-ts/core 0.1.1 → 0.1.3

package/dist/task.d.ts

@@ -0,0 +1,305 @@
+import { Agent } from "./agent.js";
+import type { Knowledge } from "./knowledge.js";
+import { type HumanInputProvider } from "./human-input.js";
+import { TaskOutput } from "./outputs.js";
+import type { Memory, MemoryScope } from "./memory.js";
+import { type Fingerprint, type SecurityConfig } from "./security.js";
+import { interpolateOnly } from "./string-utils.js";
+import { OutputFormat, type AgentStepCallback, type InputValues, type LLM, type MaybePromise, type TaskCallback, type Tool } from "./types.js";
+import type { InputFile, InputFiles } from "./input-files.js";
+import { type JsonSchema } from "./schema-utils.js";
+export type GuardrailResult = readonly [boolean, unknown] | {
+    success: boolean;
+    result: unknown;
+};
+export type Guardrail = (output: TaskOutput) => GuardrailResult | Promise<GuardrailResult>;
+export type TaskGuardrail = Guardrail | string;
+export type ConditionalTaskCondition = (output: TaskOutput) => MaybePromise<boolean>;
+export type TaskOutputConverter = (raw: string) => MaybePromise<unknown>;
+export type DeserializedModelClass = TaskOutputConverter & {
+    readonly schema: Record<string, unknown>;
+};
+export type TaskInputFile = InputFile;
+export type TaskInputFiles = InputFiles;
+export type TaskExecutionOptions = {
+    stepCallbacks?: readonly AgentStepCallback[];
+    humanInputProvider?: HumanInputProvider | null;
+    taskCallback?: TaskCallback | null;
+    context?: string | null;
+    triggerPayload?: unknown;
+    inputFiles?: TaskInputFiles;
+    functionCallingLlm?: LLM | string | null;
+    memory?: Memory | MemoryScope | null;
+    knowledge?: Knowledge | null;
+    useAsyncAgent?: boolean;
+};
+type ModelDumpOptions = {
+    mode?: string;
+    exclude?: ReadonlySet<string> | readonly string[] | Record<string, unknown>;
+};
+type ExportedTaskOutput = readonly [unknown, Record<string, unknown> | null];
+type TaskAsyncFuture = {
+    setResult?: (value: TaskOutput) => void;
+    set_result?: (value: TaskOutput) => void;
+    resolve?: (value: TaskOutput) => void;
+    setException?: (error: unknown) => void;
+    set_exception?: (error: unknown) => void;
+    reject?: (error: unknown) => void;
+};
+export type TaskExecutionFuture = Promise<TaskOutput> & {
+    result: () => Promise<TaskOutput>;
+    exception: () => Promise<unknown>;
+};
+export declare function get_supported_content_types(provider: string, api?: string | null): string[];
+export declare function is_auto_injected(content_type: string, supported_types: readonly string[]): boolean;
+export declare function get_agent_by_role<T extends {
+    role?: string;
+}>(agents: readonly T[], role: string): T | null;
+export declare function _serialize_model_class(value: unknown): JsonSchema | null;
+export declare function _deserialize_model_class(value: unknown): TaskOutputConverter | null;
+export type TaskOptions = {
+    id?: string;
+    fromCheckpoint?: boolean;
+    from_checkpoint?: boolean;
+    name?: string | null;
+    description?: string;
+    expectedOutput?: string;
+    expected_output?: string;
+    config?: Record<string, unknown> | null;
+    promptContext?: string | null;
+    prompt_context?: string | null;
+    agent?: Agent | null;
+    context?: readonly Task[] | null | undefined;
+    tools?: readonly Tool[];
+    callback?: TaskCallback | null;
+    callbacks?: readonly TaskCallback[];
+    outputJson?: boolean | null;
+    output_json?: boolean | null;
+    outputPydantic?: ((raw: string) => unknown) | null;
+    output_pydantic?: ((raw: string) => unknown) | null;
+    outputConverter?: TaskOutputConverter | null;
+    output_converter?: TaskOutputConverter | null;
+    converterCls?: TaskOutputConverter | null;
+    converter_cls?: TaskOutputConverter | null;
+    responseModel?: unknown;
+    response_model?: unknown;
+    outputFile?: string | null;
+    output_file?: string | null;
+    inputFiles?: TaskInputFiles;
+    input_files?: TaskInputFiles;
+    createDirectory?: boolean;
+    create_directory?: boolean;
+    asyncExecution?: boolean;
+    async_execution?: boolean;
+    humanInput?: boolean;
+    human_input?: boolean;
+    markdown?: boolean;
+    allowCrewaiTriggerContext?: boolean | null;
+    allow_crewai_trigger_context?: boolean | null;
+    guardrail?: TaskGuardrail | null;
+    guardrails?: TaskGuardrail | readonly TaskGuardrail[] | null;
+    guardrailMaxRetries?: number;
+    guardrail_max_retries?: number;
+    max_retries?: number | null;
+    retryCount?: number;
+    retry_count?: number;
+    usedTools?: number;
+    used_tools?: number;
+    toolsErrors?: number;
+    tools_errors?: number;
+    delegations?: number;
+    processedByAgents?: Iterable<string>;
+    processed_by_agents?: Iterable<string>;
+    startTime?: Date | string | null;
+    start_time?: Date | string | null;
+    endTime?: Date | string | null;
+    end_time?: Date | string | null;
+    output?: TaskOutput | null;
+    checkpointOriginalDescription?: string | null;
+    checkpoint_original_description?: string | null;
+    checkpointOriginalExpectedOutput?: string | null;
+    checkpoint_original_expected_output?: string | null;
+    checkpointOriginalOutputFile?: string | null;
+    checkpoint_original_output_file?: string | null;
+    securityConfig?: SecurityConfig | null;
+    security_config?: SecurityConfig | null;
+};
+export declare class Task {
+    readonly id: string;
+    readonly name: string | null;
+    description: string;
+    expectedOutput: string;
+    expected_output: string;
+    readonly config: Record<string, unknown> | null;
+    readonly agent: Agent | null;
+    readonly context: readonly Task[] | null | undefined;
+    readonly tools: readonly Tool[];
+    readonly callback: TaskCallback | null;
+    readonly callbacks: readonly TaskCallback[];
+    readonly outputJson: boolean | null;
+    readonly output_json: boolean | null;
+    readonly outputPydantic: ((raw: string) => unknown) | null;
+    readonly output_pydantic: ((raw: string) => unknown) | null;
+    readonly outputConverter: TaskOutputConverter | null;
+    readonly output_converter: TaskOutputConverter | null;
+    readonly converterCls: TaskOutputConverter | null;
+    readonly converter_cls: TaskOutputConverter | null;
+    readonly responseModel: unknown;
+    readonly response_model: unknown;
+    outputFile: string | null;
+    output_file: string | null;
+    readonly inputFiles: TaskInputFiles;
+    readonly input_files: TaskInputFiles;
+    readonly createDirectory: boolean;
+    readonly create_directory: boolean;
+    readonly asyncExecution: boolean;
+    readonly async_execution: boolean;
+    readonly humanInput: boolean;
+    readonly human_input: boolean;
+    readonly markdown: boolean;
+    allowCrewaiTriggerContext: boolean | null;
+    allow_crewai_trigger_context: boolean | null;
+    readonly guardrail: TaskGuardrail | null;
+    readonly guardrails: readonly TaskGuardrail[];
+    guardrailMaxRetries: number;
+    guardrail_max_retries: number;
+    readonly maxRetries: number | null;
+    readonly max_retries: number | null;
+    readonly securityConfig: SecurityConfig;
+    readonly security_config: SecurityConfig;
+    usedTools: number;
+    used_tools: number;
+    toolsErrors: number;
+    tools_errors: number;
+    delegations: number;
+    retryCount: number;
+    retry_count: number;
+    startTime: Date | null;
+    endTime: Date | null;
+    promptContext: string | null;
+    prompt_context: string | null;
+    readonly processedByAgents: Set<string>;
+    processed_by_agents: Set<string>;
+    output: TaskOutput | null;
+    checkpointOriginalDescription: string | null;
+    checkpoint_original_description: string | null;
+    checkpointOriginalExpectedOutput: string | null;
+    checkpoint_original_expected_output: string | null;
+    checkpointOriginalOutputFile: string | null;
+    checkpoint_original_output_file: string | null;
+    private executionPlan;
+    private resolvedGuardrail;
+    private resolvedGuardrails;
+    private readonly guardrailRetryCounts;
+    readonly _guardrail_retry_counts: Map<number, number>;
+    constructor(options: TaskOptions);
+    get fingerprint(): Fingerprint;
+    get key(): string;
+    get executionDuration(): number | null;
+    get start_time(): Date | null;
+    set start_time(value: Date | string | null);
+    get end_time(): Date | null;
+    set end_time(value: Date | string | null);
+    get execution_duration(): number | null;
+    validateGuardrailFunction(value?: Guardrail | string | null): Guardrail | string | null;
+    validate_guardrail_function(value?: Guardrail | string | null): Guardrail | string | null;
+    processModelConfig(values: Record<string, unknown>): Record<string, unknown>;
+    process_model_config(values: Record<string, unknown>): Record<string, unknown>;
+    modelDump(options?: ModelDumpOptions): Record<string, unknown>;
+    model_dump(options?: ModelDumpOptions): Record<string, unknown>;
+    validateRequiredFields(): this;
+    validate_required_fields(): this;
+    ensureGuardrailIsCallable(): this;
+    ensure_guardrail_is_callable(): this;
+    ensureGuardrailsIsListOfCallables(): this;
+    ensure_guardrails_is_list_of_callables(): this;
+    outputFileValidation(value: string | null): string | null;
+    output_file_validation(value: string | null): string | null;
+    static denyUserSetId(value: string | null | undefined, context?: {
+        fromCheckpoint?: boolean;
+        from_checkpoint?: boolean;
+    } | null): string | null | undefined;
+    static _deny_user_set_id(value: string | null | undefined, context?: {
+        fromCheckpoint?: boolean;
+        from_checkpoint?: boolean;
+    } | null): string | null | undefined;
+    static normalizeInputFiles<T extends TaskInputFiles | null | undefined>(value: T): T;
+    static _normalize_input_files<T extends TaskInputFiles | null | undefined>(value: T): T;
+    setAttributesBasedOnConfig(): this;
+    set_attributes_based_on_config(): this;
+    checkTools(): this;
+    check_tools(): this;
+    checkOutput(): this;
+    check_output(): this;
+    handleMaxRetriesDeprecation(): this;
+    handle_max_retries_deprecation(): this;
+    executeSync(agent?: Agent | null, context?: string | null, tools?: readonly Tool[]): Promise<TaskOutput>;
+    execute_sync(agent?: Agent | null, context?: string | null, tools?: readonly Tool[]): Promise<TaskOutput>;
+    executeAsync(agent?: Agent | null, context?: string | null, tools?: readonly Tool[]): TaskExecutionFuture;
+    execute_async(agent?: Agent | null, context?: string | null, tools?: readonly Tool[]): TaskExecutionFuture;
+    executeCore(agent?: Agent | null, context?: string | null, tools?: readonly Tool[] | null): Promise<TaskOutput>;
+    _execute_core(agent?: Agent | null, context?: string | null, tools?: readonly Tool[] | null): Promise<TaskOutput>;
+    aexecuteCore(agent?: Agent | null, context?: string | null, tools?: readonly Tool[] | null): Promise<TaskOutput>;
+    _aexecute_core(agent?: Agent | null, context?: string | null, tools?: readonly Tool[] | null): Promise<TaskOutput>;
+    executeTaskAsync(agent: Agent | null, context: string | null, tools: readonly Tool[] | null, future: TaskAsyncFuture): void;
+    _execute_task_async(agent: Agent | null, context: string | null, tools: readonly Tool[] | null, future: TaskAsyncFuture): void;
+    aexecuteSync(agent?: Agent | null, context?: string | null, tools?: readonly Tool[]): Promise<TaskOutput>;
+    aexecute_sync(agent?: Agent | null, context?: string | null, tools?: readonly Tool[]): Promise<TaskOutput>;
+    postAgentExecution(agent: Agent): void;
+    _post_agent_execution(agent: Agent): void;
+    prompt(): string;
+    interpolateInputsAndAddConversationHistory(inputs: InputValues, options?: {
+        strictMissing?: boolean;
+    }): void;
+    interpolate_inputs_and_add_conversation_history(inputs: InputValues): void;
+    incrementToolsErrors(): void;
+    increment_tools_errors(): void;
+    incrementDelegations(agentName?: string | null): void;
+    increment_delegations(agentName?: string | null): void;
+    storeInputFiles(): void;
+    _store_input_files(): void;
+    exportOutput(result: unknown): Promise<ExportedTaskOutput>;
+    _export_output(result: unknown): ExportedTaskOutput | Promise<ExportedTaskOutput>;
+    aexportOutput(result: unknown): Promise<ExportedTaskOutput>;
+    _aexport_output(result: unknown): Promise<ExportedTaskOutput>;
+    static unpackModelOutput(modelOutput: unknown): ExportedTaskOutput;
+    static _unpack_model_output(modelOutput: unknown): ExportedTaskOutput;
+    getOutputFormat(): OutputFormat;
+    _get_output_format(): OutputFormat;
+    saveFile(result: unknown): void;
+    _save_file(result: unknown): void;
+    toString(): string;
+    __repr__(): string;
+    invokeGuardrailFunction(taskOutput: TaskOutput, agent: Agent, tools: readonly Tool[], guardrail: Guardrail | null, guardrailIndex?: number | null): Promise<TaskOutput>;
+    _invoke_guardrail_function(task_output: TaskOutput, agent: Agent, tools: readonly Tool[], guardrail: Guardrail | null, guardrail_index?: number | null): Promise<TaskOutput>;
+    ainvokeGuardrailFunction(taskOutput: TaskOutput, agent: Agent, tools: readonly Tool[], guardrail: Guardrail | null, guardrailIndex?: number | null): Promise<TaskOutput>;
+    _ainvoke_guardrail_function(task_output: TaskOutput, agent: Agent, tools: readonly Tool[], guardrail: Guardrail | null, guardrail_index?: number | null): Promise<TaskOutput>;
+    copy(agents?: readonly Agent[], taskMapping?: Record<string, Task>): Task;
+    setExecutionPlan(plan: string | null): void;
+    clearExecutionPlan(): void;
+    execute(inputs?: InputValues, fallbackAgent?: Agent | null, overrideTools?: readonly Tool[], forceFallbackAgent?: boolean, stepCallbacksOrOptions?: readonly AgentStepCallback[] | TaskExecutionOptions): Promise<TaskOutput>;
+    private buildPrompt;
+    private descriptionWithTriggerPayload;
+    private renderContext;
+    private createOutput;
+    private effectiveGuardrailEntries;
+    private resolveGuardrail;
+    private runGuardrail;
+    private normalizeGuardrailOutput;
+    private handleHumanInput;
+    private executeAgentTask;
+    private createTrackingStepCallback;
+    private saveOutputFile;
+}
+export type ConditionalTaskOptions = TaskOptions & {
+    condition?: ConditionalTaskCondition | null;
+};
+export declare class ConditionalTask extends Task {
+    readonly condition: ConditionalTaskCondition | null;
+    constructor(options: ConditionalTaskOptions);
+    shouldExecute(context: TaskOutput): Promise<boolean>;
+    should_execute(context: TaskOutput): Promise<boolean>;
+    getSkippedTaskOutput(): TaskOutput;
+    get_skipped_task_output(): TaskOutput;
+}
+export { interpolateOnly };

package/dist/telemetry.d.ts

@@ -0,0 +1,91 @@
+export declare const CREWAI_TELEMETRY_BASE_URL = "https://telemetry.crewai.com:4319";
+export declare const CREWAI_TELEMETRY_SERVICE_NAME = "crewAI-telemetry";
+export type SpanLike = {
+    setAttribute?: (name: string, value: unknown) => void;
+    set_attribute?: (name: string, value: unknown) => void;
+    setStatus?: (status: unknown) => void;
+    end?: () => void;
+};
+export type AddAttributeFn = (span: SpanLike, name: string, value: unknown) => void;
+export declare class SafeOTLPSpanExporter {
+    readonly options: Record<string, unknown>;
+    constructor(options?: Record<string, unknown>);
+    export(spans: unknown): string;
+    shutdown(): Promise<void>;
+}
+export declare class RecordedSpan implements SpanLike {
+    readonly name: string;
+    readonly attributes: Record<string, unknown>;
+    status: unknown;
+    ended: boolean;
+    constructor(name: string);
+    setAttribute(name: string, value: unknown): void;
+    set_attribute(name: string, value: unknown): void;
+    setStatus(status: unknown): void;
+    end(): void;
+}
+export declare class Telemetry {
+    static instance: Telemetry | null;
+    static _instance: Telemetry | null;
+    ready: boolean;
+    traceSet: boolean;
+    trace_set: boolean;
+    readonly spans: RecordedSpan[];
+    constructor();
+    static getInstance(): Telemetry;
+    static get_instance(): Telemetry;
+    setTracer(): void;
+    set_tracer(): void;
+    flush(): Promise<void>;
+    _is_telemetry_disabled(): boolean;
+    _should_execute_telemetry(): boolean;
+    _safe_telemetry_operation<T>(operation: () => T): T | null;
+    _register_shutdown_handlers(): void;
+    _register_signal_handler(_signalName: unknown, _eventClass: unknown, _shutdown?: boolean): void;
+    _shutdown(): void;
+    _add_attribute(span: SpanLike | null | undefined, key: string, value: unknown): void;
+    getSpans(): RecordedSpan[];
+    get_spans(): RecordedSpan[];
+    clearSpans(): void;
+    clear_spans(): void;
+    crew_creation(crew: unknown, inputs?: Record<string, unknown> | null): void;
+    task_started(crew: unknown, task: unknown): RecordedSpan | null;
+    taskStarted(crew: unknown, task: unknown): RecordedSpan | null;
+    task_ended(span: SpanLike | null, task: unknown, crew: unknown): void;
+    taskEnded(span: SpanLike | null, task: unknown, crew: unknown): void;
+    tool_repeated_usage(llm: unknown, tool_name: string, attempts: number): void;
+    toolRepeatedUsage(llm: unknown, toolName: string, attempts: number): void;
+    tool_usage(llm: unknown, tool_name: string, attempts: number, agent?: unknown): void;
+    toolUsage(llm: unknown, toolName: string, attempts: number, agent?: unknown): void;
+    tool_usage_error(llm: unknown, agent?: unknown, tool_name?: string | null): void;
+    toolUsageError(llm: unknown, agent?: unknown, toolName?: string | null): void;
+    individual_test_result_span(crew: unknown, quality: number, exec_time: number, model_name: string): void;
+    test_execution_span(crew: unknown, iterations: number, inputs: Record<string, unknown> | null, model_name: string): void;
+    deploy_signup_error_span(): void;
+    start_deployment_span(uuid?: string | null): void;
+    create_crew_deployment_span(): void;
+    get_crew_logs_span(uuid: string | null, log_type?: string): void;
+    remove_crew_span(uuid?: string | null): void;
+    crew_execution_span(crew: unknown, inputs?: Record<string, unknown> | null): RecordedSpan | null;
+    end_crew(crew: unknown, final_string_output: string): void;
+    flow_creation_span(flow_name: string): void;
+    flow_plotting_span(flow_name: string, node_names: readonly string[]): void;
+    flow_execution_span(flow_name: string, node_names: readonly string[]): void;
+    env_context_span(tool: string): void;
+    human_feedback_span(event_type: string, has_routing: boolean, num_outcomes?: number, feedback_provided?: boolean | null, outcome?: string | null): void;
+    feature_usage_span(feature: string): void;
+    template_installed_span(template_name: string): void;
+    private startSpan;
+    private closedSpan;
+    private addTaskFingerprintDetails;
+}
+export declare function addAgentFingerprintToSpan(span: SpanLike, agent: unknown, addAttributeFn?: AddAttributeFn): void;
+export declare const add_agent_fingerprint_to_span: typeof addAgentFingerprintToSpan;
+export declare function addCrewAttributes(span: SpanLike, crew: unknown, addAttributeFn?: AddAttributeFn, includeFingerprint?: boolean): void;
+export declare const add_crew_attributes: typeof addCrewAttributes;
+export declare function addTaskAttributes(span: SpanLike, task: unknown, addAttributeFn?: AddAttributeFn, includeFingerprint?: boolean): void;
+export declare const add_task_attributes: typeof addTaskAttributes;
+export declare function addCrewAndTaskAttributes(span: SpanLike, crew: unknown, task: unknown, addAttributeFn?: AddAttributeFn, includeFingerprints?: boolean): void;
+export declare const add_crew_and_task_attributes: typeof addCrewAndTaskAttributes;
+export declare function closeSpan(span: SpanLike): void;
+export declare const close_span: typeof closeSpan;

package/dist/token-counter-callback.d.ts

@@ -0,0 +1,36 @@
+export type TokenProcessLike = {
+    sum_successful_requests?: (requests: number) => void;
+    sumSuccessfulRequests?: (requests: number) => void;
+    sum_prompt_tokens?: (tokens: number) => void;
+    sumPromptTokens?: (tokens: number) => void;
+    sum_completion_tokens?: (tokens: number) => void;
+    sumCompletionTokens?: (tokens: number) => void;
+    sum_cached_prompt_tokens?: (tokens: number) => void;
+    sumCachedPromptTokens?: (tokens: number) => void;
+};
+export type TokenUsageLike = {
+    prompt_tokens?: number;
+    promptTokens?: number;
+    completion_tokens?: number;
+    completionTokens?: number;
+    prompt_tokens_details?: {
+        cached_tokens?: number;
+        cachedTokens?: number;
+    } | null;
+    promptTokensDetails?: {
+        cached_tokens?: number;
+        cachedTokens?: number;
+    } | null;
+};
+export type TokenCalcHandlerOptions = {
+    tokenCostProcess?: TokenProcessLike | null;
+    token_cost_process?: TokenProcessLike | null;
+};
+export declare class TokenCalcHandler {
+    tokenCostProcess: TokenProcessLike | null;
+    token_cost_process: TokenProcessLike | null;
+    constructor(tokenCostProcess?: TokenProcessLike | TokenCalcHandlerOptions | null);
+    logSuccessEvent(_kwargs: Record<string, unknown>, responseObj: Record<string, unknown>, _startTime: number, _endTime: number): void;
+    log_success_event(kwargs: Record<string, unknown>, responseObj: Record<string, unknown>, startTime: number, endTime: number): void;
+    private recordUsage;
+}