@crewai-ts/core 0.1.1 → 0.1.3

package/dist/context.d.ts

@@ -0,0 +1,157 @@
+export type MismatchBehavior = "warn" | "raise" | "silent";
+export declare const MismatchBehavior: Readonly<{
+    readonly WARN: "warn";
+    readonly RAISE: "raise";
+    readonly SILENT: "silent";
+}>;
+export type EventContextConfigOptions = {
+    maxStackDepth?: number;
+    mismatchBehavior?: MismatchBehavior;
+    emptyPopBehavior?: MismatchBehavior;
+};
+export declare class StackDepthExceededError extends Error {
+    constructor(message: string);
+}
+export declare class EventPairingError extends Error {
+    constructor(message: string);
+}
+export declare class EmptyStackError extends Error {
+    constructor(message: string);
+}
+export declare class EventContextConfig {
+    readonly maxStackDepth: number;
+    readonly mismatchBehavior: MismatchBehavior;
+    readonly emptyPopBehavior: MismatchBehavior;
+    constructor(options?: EventContextConfigOptions);
+}
+export type EventScopeEntry = readonly [eventId: string, eventType: string];
+export type ExecutionContextOptions = {
+    currentTaskId?: string | null;
+    flowRequestId?: string | null;
+    flowId?: string | null;
+    flowName?: string | null;
+    flowMethodName?: string;
+    eventIdStack?: readonly EventScopeEntry[];
+    lastEventId?: string | null;
+    triggeringEventId?: string | null;
+    emissionSequence?: number;
+    feedbackCallbackInfo?: Record<string, unknown> | null;
+    platformToken?: string | null;
+    eventContextConfig?: EventContextConfig | EventContextConfigOptions | null;
+};
+export declare class ExecutionContext {
+    currentTaskId: string | null;
+    flowRequestId: string | null;
+    flowId: string | null;
+    flowName: string | null;
+    flowMethodName: string;
+    eventIdStack: EventScopeEntry[];
+    lastEventId: string | null;
+    triggeringEventId: string | null;
+    emissionSequence: number;
+    feedbackCallbackInfo: Record<string, unknown> | null;
+    platformToken: string | null;
+    eventContextConfig: EventContextConfig | null;
+    constructor(options?: ExecutionContextOptions);
+    clone(): ExecutionContext;
+    toJSON(): Record<string, unknown>;
+}
+export declare function setEventRuntimeStateProvider(provider: (() => unknown) | null): void;
+export declare const SCOPE_STARTING_EVENTS: Set<string>;
+export declare const SCOPE_ENDING_EVENTS: Set<string>;
+export declare const VALID_EVENT_PAIRS: Readonly<Record<string, string>>;
+export declare function runWithExecutionContext<T>(ctx: ExecutionContext | ExecutionContextOptions, fn: () => T): T;
+export declare const run_with_execution_context: typeof runWithExecutionContext;
+export declare function captureExecutionContext(feedbackCallbackInfo?: Record<string, unknown> | null): ExecutionContext;
+export declare const capture_execution_context: typeof captureExecutionContext;
+export declare function applyExecutionContext(ctx: ExecutionContext): void;
+export declare const apply_execution_context: typeof applyExecutionContext;
+export declare function setPlatformIntegrationToken(integrationToken: string | null): void;
+export declare const set_platform_integration_token: typeof setPlatformIntegrationToken;
+export declare function getPlatformIntegrationToken(): string | null;
+export declare const get_platform_integration_token: typeof getPlatformIntegrationToken;
+export declare function withPlatformContext<T>(integrationToken: string, fn: () => T): T;
+export declare const platformContext: typeof withPlatformContext;
+export declare const platform_context: typeof withPlatformContext;
+export declare function setCurrentTaskId(taskId: string | null): string | null;
+export declare const set_current_task_id: typeof setCurrentTaskId;
+export declare function resetCurrentTaskId(token: string | null): void;
+export declare const reset_current_task_id: typeof resetCurrentTaskId;
+export declare function getCurrentTaskId(): string | null;
+export declare const get_current_task_id: typeof getCurrentTaskId;
+export declare function setCurrentFlowContext(options: {
+    flowRequestId?: string | null;
+    flowId?: string | null;
+    flowName?: string | null;
+    flowMethodName?: string;
+}): void;
+export declare const set_current_flow_context: typeof setCurrentFlowContext;
+export declare function getCurrentFlowRequestId(): string | null;
+export declare const get_current_flow_request_id: typeof getCurrentFlowRequestId;
+export declare function getCurrentFlowId(): string | null;
+export declare const get_current_flow_id: typeof getCurrentFlowId;
+export declare function getCurrentFlowName(): string | null;
+export declare const get_current_flow_name: typeof getCurrentFlowName;
+export declare function getCurrentFlowMethodName(): string;
+export declare const get_current_flow_method_name: typeof getCurrentFlowMethodName;
+export type FlowContextVariable<T> = {
+    get: () => T;
+    set: (value: T) => T;
+};
+export declare const currentFlowRequestId: FlowContextVariable<string | null>;
+export declare const current_flow_request_id: FlowContextVariable<string | null>;
+export declare const currentFlowId: FlowContextVariable<string | null>;
+export declare const current_flow_id: FlowContextVariable<string | null>;
+export declare const currentFlowName: FlowContextVariable<string | null>;
+export declare const current_flow_name: FlowContextVariable<string | null>;
+export declare const currentFlowMethodName: FlowContextVariable<string>;
+export declare const current_flow_method_name: FlowContextVariable<string>;
+export declare class FlowTrackable {
+    _requestId: string | null;
+    _request_id: string | null;
+    _flowId: string | null;
+    _flow_id: string | null;
+    constructor();
+    _set_flow_context(): this;
+}
+export declare function getCurrentParentId(): string | null;
+export declare const get_current_parent_id: typeof getCurrentParentId;
+export declare function getEnclosingParentId(): string | null;
+export declare const get_enclosing_parent_id: typeof getEnclosingParentId;
+export declare function getLastEventId(): string | null;
+export declare const get_last_event_id: typeof getLastEventId;
+export declare function setLastEventId(eventId: string | null): void;
+export declare const set_last_event_id: typeof setLastEventId;
+export declare function resetLastEventId(): void;
+export declare const reset_last_event_id: typeof resetLastEventId;
+export declare function getTriggeringEventId(): string | null;
+export declare const get_triggering_event_id: typeof getTriggeringEventId;
+export declare function setTriggeringEventId(eventId: string | null): void;
+export declare const set_triggering_event_id: typeof setTriggeringEventId;
+export declare function triggeredByScope<T>(eventId: string, fn: () => T): T;
+export declare const triggered_by_scope: typeof triggeredByScope;
+export declare function restoreEventScope(stack: readonly EventScopeEntry[]): void;
+export declare const restore_event_scope: typeof restoreEventScope;
+export declare function resume_task_scope(task_id: string): boolean;
+export declare function pushEventScope(eventId: string, eventType?: string): void;
+export declare const push_event_scope: typeof pushEventScope;
+export declare function popEventScope(): EventScopeEntry | null;
+export declare const pop_event_scope: typeof popEventScope;
+export declare function eventScope<T>(eventId: string, eventType: string, fn: () => T): T;
+export declare const event_scope: typeof eventScope;
+export declare function getNextEmissionSequence(): number;
+export declare const get_next_emission_sequence: typeof getNextEmissionSequence;
+export declare function getEmissionSequence(): number;
+export declare const get_emission_sequence: typeof getEmissionSequence;
+export declare function resetEmissionCounter(): void;
+export declare const reset_emission_counter: typeof resetEmissionCounter;
+export declare function setEmissionCounter(start: number): void;
+export declare const set_emission_counter: typeof setEmissionCounter;
+export declare function setEventContextConfig(config: EventContextConfig | EventContextConfigOptions | null): void;
+export declare const set_event_context_config: typeof setEventContextConfig;
+export declare function getEventContextConfig(): EventContextConfig;
+export declare const get_event_context_config: typeof getEventContextConfig;
+export declare function handleEmptyPop(eventTypeName: string): void;
+export declare const handle_empty_pop: typeof handleEmptyPop;
+export declare function handleMismatch(eventTypeName: string, poppedType: string, expectedStart: string): void;
+export declare const handle_mismatch: typeof handleMismatch;

package/dist/converter.d.ts

@@ -0,0 +1,97 @@
+import type { LLMClient } from "./llm.js";
+import type { LLMMessage } from "./types.js";
+import { InternalInstructor } from "./utilities.js";
+export type StructuredModel<T = unknown> = ((value: unknown) => T) | {
+    modelValidate?: (value: unknown) => T;
+    model_validate?: (value: unknown) => T;
+    modelValidateJson?: (value: string) => T;
+    model_validate_json?: (value: string) => T;
+    modelDump?: (value: T) => Record<string, unknown>;
+    model_dump?: (value: T) => Record<string, unknown>;
+    schema?: unknown;
+    name?: string;
+};
+export type ConverterOptions<T = unknown> = {
+    llm: LLMClient;
+    text: string;
+    model: StructuredModel<T>;
+    instructions: string;
+    maxAttempts?: number;
+    max_attempts?: number;
+};
+export declare class CreateConverterKwargs<T = unknown> {
+    readonly agent: ConversionAgent;
+    readonly converterCls: typeof Converter<T>;
+    readonly converter_cls: typeof Converter<T>;
+    readonly llm: LLMClient;
+    readonly text: string;
+    readonly model: StructuredModel<T>;
+    readonly instructions: string;
+    constructor(options: {
+        agent: ConversionAgent;
+        converterCls?: typeof Converter<T>;
+        converter_cls?: typeof Converter<T>;
+        llm: LLMClient;
+        text: string;
+        model: StructuredModel<T>;
+        instructions: string;
+    });
+}
+export type ConversionAgent = {
+    llm?: LLMClient | null;
+    functionCallingLlm?: LLMClient | null;
+    function_calling_llm?: LLMClient | null;
+    verbose?: boolean;
+};
+export declare class ConverterError extends Error {
+    readonly message: string;
+    constructor(message: string);
+}
+export declare class Converter<T = unknown> {
+    readonly llm: LLMClient;
+    readonly text: string;
+    readonly model: StructuredModel<T>;
+    readonly instructions: string;
+    readonly maxAttempts: number;
+    readonly max_attempts: number;
+    constructor(options: ConverterOptions<T>);
+    buildMessages(): LLMMessage[];
+    _build_messages(): LLMMessage[];
+    toPydantic(currentAttempt?: number): Promise<T>;
+    to_pydantic(currentAttempt?: number): Promise<T>;
+    atoPydantic(currentAttempt?: number): Promise<T>;
+    ato_pydantic(currentAttempt?: number): Promise<T>;
+    toJson(currentAttempt?: number): Promise<string | ConverterError>;
+    to_json(currentAttempt?: number): Promise<string | ConverterError>;
+    atoJson(currentAttempt?: number): Promise<string | ConverterError>;
+    ato_json(currentAttempt?: number): Promise<string | ConverterError>;
+    _coerce_response_to_pydantic(response: unknown): T;
+    _create_instructor(): InternalInstructor;
+}
+export declare function validateModel<T>(result: string, model: StructuredModel<T>, isJsonOutput: boolean): T | Record<string, unknown>;
+export declare const validate_model: typeof validateModel;
+export declare function handlePartialJson<T>(result: string, model: StructuredModel<T>, isJsonOutput: boolean, agent?: ConversionAgent | null, converterClass?: typeof Converter<T> | null): T | Record<string, unknown> | string;
+export declare const handle_partial_json: typeof handlePartialJson;
+export declare function asyncHandlePartialJson<T>(result: string, model: StructuredModel<T>, isJsonOutput: boolean, agent?: ConversionAgent | null, converterClass?: typeof Converter<T> | null): Promise<T | Record<string, unknown> | string>;
+export declare const async_handle_partial_json: typeof asyncHandlePartialJson;
+export declare function convertToModel<T>(result: string | T, outputPydantic: StructuredModel<T> | null, outputJson: StructuredModel<T> | null, agent?: ConversionAgent | null, converterClass?: typeof Converter<T> | null): T | Record<string, unknown> | string;
+export declare const convert_to_model: typeof convertToModel;
+export declare function convertWithInstructions<T>(result: string, model: StructuredModel<T>, isJsonOutput: boolean, agent: ConversionAgent | null, converterClass?: typeof Converter<T>): T | Record<string, unknown> | string;
+export declare const convert_with_instructions: typeof convertWithInstructions;
+export declare const convertWithInstructionsSync: typeof convertWithInstructions;
+export declare const convert_with_instructions_sync: typeof convertWithInstructions;
+export declare function asyncConvertWithInstructions<T>(result: string, model: StructuredModel<T>, isJsonOutput: boolean, agent: ConversionAgent | null, converterClass?: typeof Converter<T>): Promise<T | Record<string, unknown> | string>;
+export declare const async_convert_with_instructions: typeof asyncConvertWithInstructions;
+type OutputConverterAgent<T> = {
+    getOutputConverter?: (...args: unknown[]) => Converter<T> | null;
+    get_output_converter?: (...args: unknown[]) => Converter<T> | null;
+};
+type ConverterClass<T> = new (...args: unknown[]) => Converter<T>;
+export declare function createConverter<T>(options: ConverterOptions<T>): Converter<T>;
+export declare function createConverter<T>(agent: OutputConverterAgent<T> | null, converterClass?: ConverterClass<T> | null, ...args: unknown[]): Converter<T>;
+export declare const create_converter: typeof createConverter;
+export declare function asyncConvertToModel<T>(result: string | T, outputPydantic: StructuredModel<T> | null, outputJson: StructuredModel<T> | null, agent?: ConversionAgent | null, converterClass?: typeof Converter<T> | null): Promise<T | Record<string, unknown> | string>;
+export declare const async_convert_to_model: typeof asyncConvertToModel;
+export declare function getConversionInstructions<T>(model: StructuredModel<T>, _llm?: unknown): string;
+export declare const get_conversion_instructions: typeof getConversionInstructions;
+export {};

package/dist/crew-chat.d.ts

@@ -0,0 +1,97 @@
+import type { Crew } from "./crew.js";
+import { type LLM, type LLMClient } from "./llm.js";
+import type { LLMMessage } from "./types.js";
+export declare const MIN_REQUIRED_CONVERSATIONAL_CREW_VERSION = "0.98.0";
+export declare const MIN_REQUIRED_VERSION = "0.98.0";
+export declare const DEFAULT_INPUT_DESCRIPTION = "Input value for the crew's tasks and agents.";
+export declare const DEFAULT_CREW_DESCRIPTION = "A CrewAI crew.";
+export type ChatInputFieldOptions = {
+    name: string;
+    description: string;
+};
+export declare class ChatInputField {
+    readonly name: string;
+    readonly description: string;
+    constructor(options: ChatInputFieldOptions);
+}
+export type ChatInputsOptions = {
+    crewName?: string;
+    crew_name?: string;
+    crewDescription?: string;
+    crew_description?: string;
+    inputs?: readonly (ChatInputField | ChatInputFieldOptions)[];
+};
+export declare class ChatInputs {
+    readonly crewName: string;
+    readonly crew_name: string;
+    readonly crewDescription: string;
+    readonly crew_description: string;
+    readonly inputs: readonly ChatInputField[];
+    constructor(options: ChatInputsOptions);
+}
+export type CrewChatToolSchema = {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: "object";
+            properties: Record<string, {
+                type: "string";
+                description: string;
+            }>;
+            required: string[];
+        };
+    };
+};
+export type GenerateCrewChatInputsOptions = {
+    generateDescriptions?: boolean;
+    generate_descriptions?: boolean;
+};
+export type CrewChatLoader = () => [Crew, string];
+export type ChatLoopOptions = {
+    getUserInput?: () => string | Promise<string>;
+    onAssistantMessage?: (message: string) => void;
+    onError?: (error: unknown) => void;
+    maxTurns?: number;
+};
+export declare function checkConversationalCrewsVersion(crewaiVersion: string, _pyprojectData?: Record<string, unknown>): boolean;
+export declare const check_conversational_crews_version: typeof checkConversationalCrewsVersion;
+export declare function buildSystemMessage(crewChatInputs: ChatInputs): string;
+export declare const build_system_message: typeof buildSystemMessage;
+export declare function generateCrewToolSchema(crewInputs: ChatInputs): CrewChatToolSchema;
+export declare const generate_crew_tool_schema: typeof generateCrewToolSchema;
+export declare function runCrewTool(crew: Crew, messages: readonly LLMMessage[], kwargs?: Record<string, unknown>): Promise<string>;
+export declare const run_crew_tool: typeof runCrewTool;
+export declare function run_crew_tool_with_messages(crew: Crew, messages: readonly LLMMessage[], kwargs?: Record<string, unknown>): Promise<string>;
+export declare function createToolFunction(crew: Crew, messages: readonly LLMMessage[]): (kwargs?: Record<string, unknown>) => Promise<string>;
+export declare const create_tool_function: typeof createToolFunction;
+export declare function flushInput(): void;
+export declare const flush_input: typeof flushInput;
+export declare function getUserInput(): Promise<string>;
+export declare const get_user_input: typeof getUserInput;
+export declare function handleUserInput(userInput: string, chatLlm: LLM | LLMClient, messages: LLMMessage[], crewToolSchema: CrewChatToolSchema | Record<string, unknown>, availableFunctions: Record<string, unknown>): Promise<void>;
+export declare const handle_user_input: typeof handleUserInput;
+export declare function chatLoop(chatLlm: LLM | LLMClient, messages: LLMMessage[], crewToolSchema: CrewChatToolSchema | Record<string, unknown>, availableFunctions: Record<string, unknown>, options?: ChatLoopOptions): Promise<void>;
+export declare const chat_loop: typeof chatLoop;
+export declare function showLoading(event?: {
+    isSet?: () => boolean;
+    is_set?: () => boolean;
+} | null): void;
+export declare const show_loading: typeof showLoading;
+export declare function initializeChatLlm(crew: Crew): LLM | LLMClient | null;
+export declare const initialize_chat_llm: typeof initializeChatLlm;
+export declare function setCrewChatLoader(loader: CrewChatLoader | null): void;
+export declare const set_crew_chat_loader: typeof setCrewChatLoader;
+export declare function loadCrewAndName(): [Crew, string];
+export declare const load_crew_and_name: typeof loadCrewAndName;
+export declare function runChat(): Promise<void>;
+export declare const run_chat: typeof runChat;
+export declare function generateCrewChatInputs(crew: Crew, crewName: string, chatLlm: LLM | LLMClient, options?: GenerateCrewChatInputsOptions): Promise<ChatInputs>;
+export declare const generate_crew_chat_inputs: typeof generateCrewChatInputs;
+export declare function fetchRequiredInputs(crew: Crew): Set<string>;
+export declare const fetch_required_inputs: typeof fetchRequiredInputs;
+export declare function generateInputDescriptionWithAi(inputName: string, crew: Crew, chatLlm: LLM | LLMClient): Promise<string>;
+export declare const generate_input_description_with_ai: typeof generateInputDescriptionWithAi;
+export declare function generateCrewDescriptionWithAi(crew: Crew, chatLlm: LLM | LLMClient): Promise<string>;
+export declare const generate_crew_description_with_ai: typeof generateCrewDescriptionWithAi;