@crewai-ts/core 0.1.1 → 0.1.3

package/dist/formatter.d.ts

@@ -0,0 +1,7 @@
+import type { Task } from "./task.js";
+import type { TaskOutput } from "./outputs.js";
+export declare const DIVIDERS = "\n\n----------\n\n";
+export declare function aggregateRawOutputsFromTaskOutputs(taskOutputs: readonly TaskOutput[]): string;
+export declare const aggregate_raw_outputs_from_task_outputs: typeof aggregateRawOutputsFromTaskOutputs;
+export declare function aggregateRawOutputsFromTasks(tasks: readonly Task[] | null | undefined): string;
+export declare const aggregate_raw_outputs_from_tasks: typeof aggregateRawOutputsFromTasks;

package/dist/guardrail.d.ts

@@ -0,0 +1,95 @@
+import type { LiteAgentOutput } from "./lite-agent-output.js";
+import type { TaskOutput } from "./outputs.js";
+import { type LLM } from "./llm.js";
+export type GuardrailCallable = (output: TaskOutput | LiteAgentOutput) => readonly [boolean, unknown];
+export declare const GuardrailCallable: FunctionConstructor;
+export type GuardrailType = GuardrailCallable | string;
+export declare const GuardrailType: Readonly<{
+    kind: "GuardrailType";
+}>;
+export type GuardrailsType = readonly GuardrailType[] | GuardrailType;
+export declare const GuardrailsType: Readonly<{
+    kind: "GuardrailsType";
+}>;
+export type AsyncGuardrailCallable = (output: TaskOutput | LiteAgentOutput) => Promise<readonly [boolean, unknown]>;
+export declare function _is_coroutine<T>(obj: T | PromiseLike<T>): obj is PromiseLike<T>;
+export declare function _run_coroutine_sync<T>(coro: PromiseLike<T>): Promise<T>;
+export declare class GuardrailResult {
+    readonly success: boolean;
+    readonly result: unknown;
+    readonly error: unknown;
+    constructor(options: {
+        success: boolean;
+        result?: unknown;
+        error?: unknown;
+    });
+    static fromTuple(result: readonly [boolean, unknown]): GuardrailResult;
+    static from_tuple(result: readonly [boolean, unknown]): GuardrailResult;
+    static validateResultErrorExclusivity(value: unknown, info?: {
+        data?: Record<string, unknown>;
+    }): unknown;
+    static validate_result_error_exclusivity(value: unknown, info?: {
+        data?: Record<string, unknown>;
+    }): unknown;
+}
+export declare function serializeGuardrailForJson(value: unknown, fieldName?: string): string | null;
+export declare const serialize_guardrail_for_json: typeof serializeGuardrailForJson;
+export declare function serializeGuardrailsForJson(value: unknown, fieldName?: string): readonly string[] | string | null;
+export declare const serialize_guardrails_for_json: typeof serializeGuardrailsForJson;
+export declare function processGuardrail(output: TaskOutput | LiteAgentOutput, guardrail: GuardrailCallable | null | undefined, options?: {
+    retryCount?: number;
+    retry_count?: number;
+    fromAgent?: unknown;
+    from_agent?: unknown;
+    fromTask?: unknown;
+    from_task?: unknown;
+    eventSource?: unknown;
+    event_source?: unknown;
+}): GuardrailResult;
+export declare const process_guardrail: typeof processGuardrail;
+export type LLMGuardrailOptions = {
+    description: string;
+    llm: LLM;
+};
+export declare class LLMGuardrailResult {
+    readonly valid: boolean;
+    readonly feedback: string | null;
+    constructor(options: {
+        valid: boolean;
+        feedback?: string | null;
+    });
+}
+export declare class LLMGuardrail {
+    readonly description: string;
+    readonly llm: LLM;
+    constructor(options: LLMGuardrailOptions);
+    constructor(description: string, llm: LLM);
+    validateOutput(taskOutput: TaskOutput | LiteAgentOutput): Promise<LLMGuardrailResult>;
+    _validate_output(taskOutput: TaskOutput | LiteAgentOutput): Promise<LLMGuardrailResult>;
+    call(taskOutput: TaskOutput | LiteAgentOutput): Promise<readonly [boolean, unknown]>;
+    __call__(taskOutput: TaskOutput | LiteAgentOutput): Promise<readonly [boolean, unknown]>;
+    asGuardrail(): AsyncGuardrailCallable;
+}
+export type HallucinationGuardrailOptions = {
+    llm: LLM;
+    context?: string | null;
+    threshold?: number | null;
+    toolResponse?: string;
+    tool_response?: string;
+};
+export type HallucinationGuardrailHook = (guardrail: HallucinationGuardrail, taskOutput: TaskOutput | LiteAgentOutput) => readonly [boolean, unknown];
+export declare function setHallucinationGuardrailHook(hook: HallucinationGuardrailHook | null): void;
+export declare const set_hallucination_guardrail_hook: typeof setHallucinationGuardrailHook;
+export declare class HallucinationGuardrail {
+    readonly context: string | null;
+    readonly llm: LLM;
+    readonly threshold: number | null;
+    readonly toolResponse: string;
+    readonly tool_response: string;
+    constructor(options: HallucinationGuardrailOptions);
+    constructor(llm: LLM, context?: string | null, threshold?: number | null, toolResponse?: string);
+    get description(): string;
+    call(taskOutput: TaskOutput | LiteAgentOutput): readonly [boolean, unknown];
+    __call__(taskOutput: TaskOutput | LiteAgentOutput): readonly [boolean, unknown];
+    asGuardrail(): GuardrailCallable;
+}

package/dist/hooks.d.ts

@@ -0,0 +1,241 @@
+import type { LLMResponse } from "./llm.js";
+import type { LLM, LLMMessage, MaybePromise, Tool } from "./types.js";
+export declare class LLMCallHookContext {
+    readonly executor: unknown;
+    readonly agent: unknown;
+    readonly task: unknown;
+    readonly crew: unknown;
+    readonly llm: LLM | string | null | undefined;
+    readonly iterations: number;
+    readonly messages: LLMMessage[];
+    response: LLMResponse | null;
+    constructor(options?: {
+        executor?: unknown;
+        messages?: LLMMessage[];
+        llm?: LLM | string | null;
+        agent?: unknown;
+        task?: unknown;
+        crew?: unknown;
+        iterations?: number;
+        response?: LLMResponse | null;
+    });
+    requestHumanInput(prompt: string, defaultMessage?: string): string;
+    request_human_input(prompt: string, defaultMessage?: string): string;
+}
+export declare class ToolCallHookContext {
+    readonly toolName: string;
+    readonly tool_name: string;
+    readonly tool: Tool;
+    readonly agent: unknown;
+    readonly task: unknown;
+    readonly crew: unknown;
+    readonly toolInput: Record<string, unknown>;
+    readonly tool_input: Record<string, unknown>;
+    toolResult: unknown;
+    tool_result: unknown;
+    constructor(options: {
+        toolName?: string;
+        tool_name?: string;
+        toolInput?: Record<string, unknown>;
+        tool_input?: Record<string, unknown>;
+        tool: Tool;
+        agent?: unknown;
+        task?: unknown;
+        crew?: unknown;
+        toolResult?: unknown;
+        tool_result?: unknown;
+    });
+    requestHumanInput(prompt: string, defaultMessage?: string): string;
+    request_human_input(prompt: string, defaultMessage?: string): string;
+}
+export type BeforeLLMCallHook = (context: LLMCallHookContext) => MaybePromise<boolean | null | undefined>;
+export type AfterLLMCallHook = (context: LLMCallHookContext) => MaybePromise<string | null | undefined>;
+export type BeforeToolCallHook = (context: ToolCallHookContext) => MaybePromise<boolean | null | undefined>;
+export type AfterToolCallHook = (context: ToolCallHookContext) => MaybePromise<string | null | undefined>;
+export declare const ContextT: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const ReturnT: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const P: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const R: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const U: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const Hook: Readonly<{
+    kind: "Hook";
+}>;
+export declare const HTTPTransportKwargs: Readonly<{
+    kind: "HTTPTransportKwargs";
+}>;
+export type HTTPTransportKwargs = Record<string, unknown>;
+export declare abstract class BaseInterceptor<TOutbound = unknown, TInbound = unknown> {
+    abstract on_outbound(message: TOutbound): TOutbound;
+    abstract on_inbound(message: TInbound): TInbound;
+    static __get_pydantic_core_schema__(): {
+        type: "plain-validator";
+        validator: (value: unknown) => BaseInterceptor;
+        serialization: {
+            type: "identity";
+        };
+    };
+    static validateInterceptor(value: unknown): BaseInterceptor;
+    static validate_interceptor(value: unknown): BaseInterceptor;
+    aon_outbound(message: TOutbound): Promise<TOutbound>;
+    aon_inbound(message: TInbound): Promise<TInbound>;
+}
+export declare function _validate_interceptor(value: unknown): BaseInterceptor;
+export declare class AsyncHTTPTransport {
+    readonly interceptor: BaseInterceptor;
+    readonly kwargs: HTTPTransportKwargs;
+    constructor(interceptor: BaseInterceptor, kwargs?: HTTPTransportKwargs);
+    handle_async_request(request: unknown): Promise<unknown>;
+}
+export declare class HTTPTransport {
+    readonly interceptor: BaseInterceptor;
+    readonly kwargs: HTTPTransportKwargs;
+    constructor(interceptor: BaseInterceptor, kwargs?: HTTPTransportKwargs);
+    handle_request(request: unknown): unknown;
+}
+export declare const BeforeLLMCallHook: Readonly<{
+    kind: "BeforeLLMCallHook";
+}>;
+export declare const AfterLLMCallHook: Readonly<{
+    kind: "AfterLLMCallHook";
+}>;
+export declare const BeforeToolCallHook: Readonly<{
+    kind: "BeforeToolCallHook";
+}>;
+export declare const AfterToolCallHook: Readonly<{
+    kind: "AfterToolCallHook";
+}>;
+export declare const BeforeLLMCallHookType: Readonly<{
+    kind: "BeforeLLMCallHook";
+}>;
+export declare const AfterLLMCallHookType: Readonly<{
+    kind: "AfterLLMCallHook";
+}>;
+export declare const BeforeToolCallHookType: Readonly<{
+    kind: "BeforeToolCallHook";
+}>;
+export declare const AfterToolCallHookType: Readonly<{
+    kind: "AfterToolCallHook";
+}>;
+export declare const BeforeLLMCallHookCallable: Readonly<{
+    kind: "BeforeLLMCallHook";
+}>;
+export declare const AfterLLMCallHookCallable: Readonly<{
+    kind: "AfterLLMCallHook";
+}>;
+export declare const BeforeToolCallHookCallable: Readonly<{
+    kind: "BeforeToolCallHook";
+}>;
+export declare const AfterToolCallHookCallable: Readonly<{
+    kind: "AfterToolCallHook";
+}>;
+declare class HookMethod {
+    readonly _meth: (...args: unknown[]) => unknown;
+    readonly agents: readonly string[] | null;
+    readonly tools: readonly string[] | null;
+    constructor(method: (...args: unknown[]) => unknown, options?: {
+        agents?: readonly string[] | null;
+        tools?: readonly string[] | null;
+    });
+    call(...args: unknown[]): unknown;
+    __call__(...args: unknown[]): unknown;
+}
+export declare class BeforeLLMCallHookMethod extends HookMethod {
+    readonly is_before_llm_call_hook = true;
+    constructor(method: (...args: unknown[]) => unknown, agents?: readonly string[] | null);
+}
+export declare class AfterLLMCallHookMethod extends HookMethod {
+    readonly is_after_llm_call_hook = true;
+    constructor(method: (...args: unknown[]) => unknown, agents?: readonly string[] | null);
+}
+export declare class BeforeToolCallHookMethod extends HookMethod {
+    readonly is_before_tool_call_hook = true;
+    constructor(method: (...args: unknown[]) => unknown, tools?: readonly string[] | null, agents?: readonly string[] | null);
+}
+export declare class AfterToolCallHookMethod extends HookMethod {
+    readonly is_after_tool_call_hook = true;
+    constructor(method: (...args: unknown[]) => unknown, tools?: readonly string[] | null, agents?: readonly string[] | null);
+}
+export declare function registerBeforeLlmCallHook(hook: BeforeLLMCallHook): void;
+export declare const register_before_llm_call_hook: typeof registerBeforeLlmCallHook;
+export declare function registerAfterLlmCallHook(hook: AfterLLMCallHook): void;
+export declare const register_after_llm_call_hook: typeof registerAfterLlmCallHook;
+export declare function getBeforeLlmCallHooks(): BeforeLLMCallHook[];
+export declare const get_before_llm_call_hooks: typeof getBeforeLlmCallHooks;
+export declare function getAfterLlmCallHooks(): AfterLLMCallHook[];
+export declare const get_after_llm_call_hooks: typeof getAfterLlmCallHooks;
+export declare function unregisterBeforeLlmCallHook(hook: BeforeLLMCallHook): boolean;
+export declare const unregister_before_llm_call_hook: typeof unregisterBeforeLlmCallHook;
+export declare function unregisterAfterLlmCallHook(hook: AfterLLMCallHook): boolean;
+export declare const unregister_after_llm_call_hook: typeof unregisterAfterLlmCallHook;
+export declare function clearBeforeLlmCallHooks(): number;
+export declare const clear_before_llm_call_hooks: typeof clearBeforeLlmCallHooks;
+export declare function clearAfterLlmCallHooks(): number;
+export declare const clear_after_llm_call_hooks: typeof clearAfterLlmCallHooks;
+export declare function clearAllLlmCallHooks(): [number, number];
+export declare const clear_all_llm_call_hooks: typeof clearAllLlmCallHooks;
+export declare function registerBeforeToolCallHook(hook: BeforeToolCallHook): void;
+export declare const register_before_tool_call_hook: typeof registerBeforeToolCallHook;
+export declare function registerAfterToolCallHook(hook: AfterToolCallHook): void;
+export declare const register_after_tool_call_hook: typeof registerAfterToolCallHook;
+export declare function getBeforeToolCallHooks(): BeforeToolCallHook[];
+export declare const get_before_tool_call_hooks: typeof getBeforeToolCallHooks;
+export declare function getAfterToolCallHooks(): AfterToolCallHook[];
+export declare const get_after_tool_call_hooks: typeof getAfterToolCallHooks;
+export declare function unregisterBeforeToolCallHook(hook: BeforeToolCallHook): boolean;
+export declare const unregister_before_tool_call_hook: typeof unregisterBeforeToolCallHook;
+export declare function unregisterAfterToolCallHook(hook: AfterToolCallHook): boolean;
+export declare const unregister_after_tool_call_hook: typeof unregisterAfterToolCallHook;
+export declare function clearBeforeToolCallHooks(): number;
+export declare const clear_before_tool_call_hooks: typeof clearBeforeToolCallHooks;
+export declare function clearAfterToolCallHooks(): number;
+export declare const clear_after_tool_call_hooks: typeof clearAfterToolCallHooks;
+export declare function clearAllToolCallHooks(): [number, number];
+export declare const clear_all_tool_call_hooks: typeof clearAllToolCallHooks;
+export declare function clearAllGlobalHooks(): {
+    llm_hooks: [number, number];
+    tool_hooks: [number, number];
+    total: [number, number];
+};
+export declare const clear_all_global_hooks: typeof clearAllGlobalHooks;
+export type RegisteredCrewScopedHook = [
+    "before_llm_call" | "after_llm_call" | "before_tool_call" | "after_tool_call",
+    BeforeLLMCallHook | AfterLLMCallHook | BeforeToolCallHook | AfterToolCallHook
+];
+export declare function registerCrewScopedHooks(instance: object): RegisteredCrewScopedHook[];
+export declare function beforeLlmCall(hook: BeforeLLMCallHook, context?: ClassMethodDecoratorContext): BeforeLLMCallHook;
+export declare function beforeLlmCall(options: {
+    agents?: readonly string[];
+}): MethodDecorator;
+export declare const before_llm_call: typeof beforeLlmCall;
+export declare function afterLlmCall(hook: AfterLLMCallHook, context?: ClassMethodDecoratorContext): AfterLLMCallHook;
+export declare function afterLlmCall(options: {
+    agents?: readonly string[];
+}): MethodDecorator;
+export declare const after_llm_call: typeof afterLlmCall;
+export declare function beforeToolCall(hook: BeforeToolCallHook, context?: ClassMethodDecoratorContext): BeforeToolCallHook;
+export declare function beforeToolCall(options: {
+    tools?: readonly string[];
+    agents?: readonly string[];
+}): MethodDecorator;
+export declare const before_tool_call: typeof beforeToolCall;
+export declare function afterToolCall(hook: AfterToolCallHook, context?: ClassMethodDecoratorContext): AfterToolCallHook;
+export declare function afterToolCall(options: {
+    tools?: readonly string[];
+    agents?: readonly string[];
+}): MethodDecorator;
+export declare const after_tool_call: typeof afterToolCall;
+export declare function runBeforeLlmCallHooks(context: LLMCallHookContext): Promise<void>;
+export declare function runAfterLlmCallHooks(context: LLMCallHookContext): Promise<LLMResponse>;
+export declare function runBeforeToolCallHooks(context: ToolCallHookContext): Promise<void>;
+export declare function runAfterToolCallHooks(context: ToolCallHookContext): Promise<unknown>;
+export {};

package/dist/human-input.d.ts

@@ -0,0 +1,74 @@
+import type { TaskOutput } from "./outputs.js";
+export type HumanInputRequest = {
+    taskName: string | null;
+    taskDescription: string;
+    expectedOutput: string;
+    output: TaskOutput;
+};
+export type HumanInputProvider = {
+    requestFeedback: (request: HumanInputRequest) => string | Promise<string>;
+    setupMessages?: (context: ExecutorContext) => boolean;
+    setup_messages?: (context: ExecutorContext) => boolean;
+    postSetupMessages?: (context: ExecutorContext) => void;
+    post_setup_messages?: (context: ExecutorContext) => void;
+    handleFeedback?: (formattedAnswer: unknown, context: ExecutorContext) => unknown;
+    handle_feedback?: (formatted_answer: unknown, context: ExecutorContext) => unknown;
+    handleFeedbackAsync?: (formattedAnswer: unknown, context: AsyncExecutorContext) => Promise<unknown>;
+    handle_feedback_async?: (formatted_answer: unknown, context: AsyncExecutorContext) => Promise<unknown>;
+};
+export type ExecutorContext = {
+    task?: unknown;
+    crew?: unknown;
+    messages: unknown[];
+    askForHumanInput?: boolean;
+    ask_for_human_input?: boolean;
+    llm?: unknown;
+    agent?: unknown;
+    _invokeLoop?: () => unknown;
+    _invoke_loop?: () => unknown;
+    _isTrainingMode?: () => boolean;
+    _is_training_mode?: () => boolean;
+    _handleCrewTrainingOutput?: (result: unknown, humanFeedback?: string | null) => void;
+    _handle_crew_training_output?: (result: unknown, human_feedback?: string | null) => void;
+    _formatFeedbackMessage?: (feedback: string) => unknown;
+    _format_feedback_message?: (feedback: string) => unknown;
+};
+export type AsyncExecutorContext = ExecutorContext & {
+    _ainvokeLoop?: () => Promise<unknown>;
+    _ainvoke_loop?: () => Promise<unknown>;
+};
+export declare const HumanInputProvider: Readonly<{
+    kind: "HumanInputProvider";
+}>;
+export declare const ExecutorContext: Readonly<{
+    kind: "ExecutorContext";
+}>;
+export declare const AsyncExecutorContext: Readonly<{
+    kind: "AsyncExecutorContext";
+}>;
+export declare class SyncHumanInputProvider implements HumanInputProvider {
+    requestFeedback(request: HumanInputRequest): string | Promise<string>;
+    setupMessages(_context: ExecutorContext): boolean;
+    setup_messages(context: ExecutorContext): boolean;
+    postSetupMessages(_context: ExecutorContext): void;
+    post_setup_messages(context: ExecutorContext): void;
+    handleFeedback(formattedAnswer: unknown, context: ExecutorContext): unknown;
+    handle_feedback(formatted_answer: unknown, context: ExecutorContext): unknown;
+    handleFeedbackAsync(formattedAnswer: unknown, context: AsyncExecutorContext): Promise<unknown>;
+    handle_feedback_async(formatted_answer: unknown, context: AsyncExecutorContext): Promise<unknown>;
+    static _get_output_string(answer: unknown): string;
+    static _handle_training_feedback(initialAnswer: unknown, feedback: string, context: ExecutorContext): unknown;
+    _handle_training_feedback(initialAnswer: unknown, feedback: string, context: ExecutorContext): unknown;
+    _handle_regular_feedback(currentAnswer: unknown, initialFeedback: string, context: ExecutorContext): unknown;
+    static _handle_training_feedback_async(initialAnswer: unknown, feedback: string, context: AsyncExecutorContext): Promise<unknown>;
+    _handle_training_feedback_async(initialAnswer: unknown, feedback: string, context: AsyncExecutorContext): Promise<unknown>;
+    _handle_regular_feedback_async(currentAnswer: unknown, initialFeedback: string, context: AsyncExecutorContext): Promise<unknown>;
+    _prompt_input(crew?: unknown): string;
+    _prompt_input_async(crew?: unknown): Promise<string>;
+}
+export declare function _async_readline(): Promise<string>;
+export declare function getHumanInputProvider(): HumanInputProvider;
+export declare function setHumanInputProvider(provider: HumanInputProvider | null): HumanInputProvider | null;
+export declare function get_provider(): HumanInputProvider;
+export declare function set_provider(provider: HumanInputProvider): HumanInputProvider | null;
+export declare function reset_provider(token: HumanInputProvider | null): void;

package/dist/i18n.d.ts

@@ -0,0 +1,26 @@
+export type PromptKind = "slices" | "errors" | "tools" | "reasoning" | "planning" | "hierarchical_manager_agent" | "memory";
+export type PromptLeaf = string | Record<string, string>;
+export type PromptCatalog = Record<string, Record<string, PromptLeaf>>;
+export declare class I18N {
+    readonly promptFile: string | null;
+    readonly prompt_file: string | null;
+    private prompts;
+    constructor(options?: {
+        promptFile?: string | null;
+        prompt_file?: string | null;
+        prompts?: PromptCatalog;
+    });
+    loadPrompts(): this;
+    load_prompts(): this;
+    slice(slice: string): string;
+    errors(error: string): string;
+    tools(tool: string): PromptLeaf;
+    memory(key: string): string;
+    retrieve(kind: PromptKind, key: string): PromptLeaf;
+    private retrieveString;
+}
+export declare function getI18N(promptFile?: string | null): I18N;
+export declare function clearI18NCache(): void;
+export declare const I18N_DEFAULT: I18N;
+export declare const get_i18n: typeof getI18N;
+export declare const clear_i18n_cache: typeof clearI18NCache;