@crewai-ts/core 0.1.1 → 0.1.3

package/dist/flow.d.ts

@@ -0,0 +1,927 @@
+import { Crew, type KickoffOptions } from "./crew.js";
+import { type FlowPersistence } from "./flow-persistence.js";
+import { type InputFiles } from "./input-files.js";
+import { ConsoleInputProvider } from "./input-provider.js";
+import { type LLM } from "./llm.js";
+import type { CrewOutput } from "./outputs.js";
+import { CheckpointConfig, type CheckpointOption } from "./state.js";
+import type { InputValues, MaybePromise } from "./types.js";
+import { Memory, MemoryScope, MemorySlice, type MemoryMatch, type MemoryRecord } from "./memory.js";
+import { FlowDefinition } from "./flow-definition.js";
+import { type ConversationEventVisibility, RouterConfig } from "./experimental-conversational.js";
+import type { LLMMessage } from "./types.js";
+export declare const AND_CONDITION = "AND";
+export declare const OR_CONDITION = "OR";
+export type InputProvider = import("./input-provider.js").InputProvider;
+export type InputResponse = import("./input-provider.js").InputResponse;
+export type FlowCondition = {
+    type: "OR" | "AND";
+    conditions: readonly FlowConditionInput[];
+};
+export declare const FlowCondition: Readonly<{
+    kind: "FlowCondition";
+}>;
+export declare const FlowConditionType: Readonly<{
+    OR: "OR";
+    AND: "AND";
+}>;
+export declare const SimpleFlowCondition: Readonly<{
+    kind: "SimpleFlowCondition";
+}>;
+export declare const FlowConditions: Readonly<{
+    kind: "FlowConditions";
+}>;
+export declare const P: Readonly<{
+    kind: "ParamSpec";
+}>;
+export declare const R: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const F: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const T: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const FlowState: Readonly<{
+    kind: "FlowState";
+}>;
+export declare const FlowMethodName: StringConstructor;
+export declare const FlowRouteName: StringConstructor;
+export declare const PendingListenerKey: StringConstructor;
+export declare const FlowMethodCallable: FunctionConstructor;
+export declare const FlowMethodData: Readonly<{
+    kind: "FlowMethodData";
+}>;
+export declare const CompletedMethodData: Readonly<{
+    kind: "CompletedMethodData";
+}>;
+export declare const ExecutionMethodData: Readonly<{
+    kind: "ExecutionMethodData";
+}>;
+export declare const FlowData: Readonly<{
+    kind: "FlowData";
+}>;
+export declare const InputHistoryEntry: Readonly<{
+    kind: "InputHistoryEntry";
+}>;
+export declare const FlowExecutionData: Readonly<{
+    kind: "FlowExecutionData";
+}>;
+export declare const FlowStructure: Readonly<{
+    kind: "FlowStructure";
+}>;
+export declare const InputProvider: Readonly<{
+    kind: "InputProvider";
+}>;
+export declare const InputResponse: Readonly<{
+    kind: "InputResponse";
+}>;
+export declare const HumanFeedbackProvider: Readonly<{
+    kind: "HumanFeedbackProvider";
+}>;
+export declare const HumanFeedbackResult: Readonly<{
+    kind: "HumanFeedbackResult";
+}>;
+export declare const HumanFeedbackConfig: Readonly<{
+    kind: "HumanFeedbackConfig";
+}>;
+export declare const HumanFeedbackMethod: Readonly<{
+    kind: "HumanFeedbackMethod";
+}>;
+export declare const PreReviewResult: Readonly<{
+    kind: "PreReviewResult";
+}>;
+export declare const DistilledLessons: Readonly<{
+    kind: "DistilledLessons";
+}>;
+export declare const FlowMeta: Readonly<{
+    kind: "FlowMeta";
+}>;
+export declare const MethodInfo: Readonly<{
+    kind: "MethodInfo";
+}>;
+export declare const EdgeInfo: Readonly<{
+    kind: "EdgeInfo";
+}>;
+export declare const StateFieldInfo: Readonly<{
+    kind: "StateFieldInfo";
+}>;
+export declare const StateSchemaInfo: Readonly<{
+    kind: "StateSchemaInfo";
+}>;
+export declare const FlowStructureInfo: Readonly<{
+    kind: "FlowStructureInfo";
+}>;
+export declare const flow_config: import("./input-provider.js").FlowConfig;
+export declare const _INITIAL_STATE_CLASS_MARKER = "__crewai_pydantic_class_schema__";
+export type ConsoleProviderOptions = {
+    verbose?: boolean;
+    input?: (prompt: string) => MaybePromise<string | null>;
+};
+export declare class ConsoleProvider extends ConsoleInputProvider implements HumanFeedbackProvider {
+    readonly verbose: boolean;
+    private readonly inputFn;
+    constructor(options?: boolean | ConsoleProviderOptions);
+    requestInput(message: string, flow?: Flow<object>, metadata?: Record<string, unknown> | null): Promise<string>;
+    request_input(message: string, flow: Flow<object>, metadata?: Record<string, unknown> | null): Promise<string>;
+    requestFeedback(context: PendingFeedbackContext, flow: Flow<object>): Promise<string>;
+    request_feedback(context: PendingFeedbackContext, flow: Flow<object>): Promise<string>;
+}
+export declare function _resolve_persistence(value: unknown): unknown;
+export declare function _serialize_persistence(value: unknown): Record<string, unknown> | null;
+export declare function _validate_input_provider(value: unknown): Promise<unknown>;
+export declare function _serialize_input_provider(value: unknown): string | null;
+export declare function _serialize_initial_state(value: unknown): unknown;
+export declare function _deserialize_initial_state(value: unknown): unknown;
+export type FlowConditionInput = string | FlowCondition | ((...args: never[]) => unknown);
+export type FlowTrigger = FlowConditionInput;
+export declare const FlowTrigger: Readonly<{
+    kind: "FlowTrigger";
+}>;
+export type FlowMethodKind = "start" | "listen" | "router";
+export type FlowMethodEntry = {
+    name: string | symbol;
+    kind: FlowMethodKind;
+    condition: FlowCondition | null;
+    emit?: readonly string[] | null;
+};
+export type FlowOptions<TState extends object = Record<string, unknown>> = {
+    initialState?: TState | (() => TState);
+    name?: string | null;
+    maxMethodCalls?: number;
+    inputProvider?: InputProvider | null;
+    persistence?: FlowPersistence | null;
+    stream?: boolean;
+    checkpoint?: CheckpointOption;
+    memory?: Memory | MemoryScope | MemorySlice | null;
+};
+export declare class LockedDictProxy<TValue extends Record<string, unknown> = Record<string, unknown>> {
+    readonly value: TValue;
+    constructor(value?: TValue);
+    get(key: string, defaultValue?: unknown): unknown;
+    __getitem__(key: string): unknown;
+    set(key: string, value: unknown): this;
+    __setitem__(key: string, value: unknown): void;
+    delete(key: string): boolean;
+    __delitem__(key: string): void;
+    has(key: string): boolean;
+    __contains__(key: string): boolean;
+    update(values: Record<string, unknown>): this;
+    clear(): void;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<unknown>;
+    entries(): IterableIterator<[string, unknown]>;
+    items(): IterableIterator<[string, unknown]>;
+    pop(key: string, defaultValue?: unknown): unknown;
+    setdefault(key: string, defaultValue: unknown): unknown;
+    copy(): TValue;
+    [Symbol.iterator](): IterableIterator<[string, unknown]>;
+    __iter__(): IterableIterator<string>;
+    __len__(): number;
+    __repr__(): string;
+    toString(): string;
+    __bool__(): boolean;
+    __or__(other: Record<string, unknown>): Record<string, unknown>;
+    __ror__(other: Record<string, unknown>): Record<string, unknown>;
+    __ior__(other: Record<string, unknown>): this;
+    __reversed__(): IterableIterator<string>;
+    __eq__(other: unknown): boolean;
+    __ne__(other: unknown): boolean;
+    toJSON(): TValue;
+}
+export declare class LockedListProxy<TValue = unknown> {
+    [index: number]: TValue;
+    readonly value: TValue[];
+    constructor(value?: readonly TValue[]);
+    get length(): number;
+    at(index: number): TValue | undefined;
+    __getitem__(index: number): TValue | undefined;
+    __setitem__(index: number, item: TValue): void;
+    __delitem__(index: number): void;
+    push(...items: TValue[]): number;
+    append(item: TValue): void;
+    pop(index?: number): TValue | undefined;
+    extend(items: Iterable<TValue>): void;
+    insert(index: number, item: TValue): void;
+    remove(item: TValue): void;
+    splice(start: number, deleteCount?: number, ...items: TValue[]): TValue[];
+    includes(item: TValue): boolean;
+    __contains__(item: TValue): boolean;
+    indexOf(item: TValue): number;
+    index(item: TValue, start?: number, stop?: number): number;
+    count(item: TValue): number;
+    sort(options?: {
+        key?: ((value: TValue) => unknown) | null;
+        reverse?: boolean;
+    }): void;
+    reverse(): void;
+    copy(): TValue[];
+    clear(): void;
+    [Symbol.iterator](): IterableIterator<TValue>;
+    __iter__(): IterableIterator<TValue>;
+    __len__(): number;
+    __repr__(): string;
+    toString(): string;
+    __bool__(): boolean;
+    __add__(other: readonly TValue[]): TValue[];
+    __radd__(other: readonly TValue[]): TValue[];
+    __iadd__(other: Iterable<TValue>): this;
+    __mul__(count: number): TValue[];
+    __rmul__(count: number): TValue[];
+    __imul__(count: number): this;
+    __reversed__(): IterableIterator<TValue>;
+    __eq__(other: unknown): boolean;
+    __ne__(other: unknown): boolean;
+    toJSON(): TValue[];
+}
+export declare class StateProxy<TState extends object = Record<string, unknown>> {
+    readonly state: TState;
+    constructor(state: TState);
+    get(key: keyof TState): TState[keyof TState];
+    __getitem__(key: keyof TState): TState[keyof TState];
+    set<K extends keyof TState>(key: K, value: TState[K]): this;
+    __setitem__<K extends keyof TState>(key: K, value: TState[K]): void;
+    delete(key: keyof TState): boolean;
+    __delitem__(key: keyof TState): void;
+    has(key: keyof TState): boolean;
+    __contains__(key: keyof TState): boolean;
+    list<TItem = unknown>(key: keyof TState): LockedListProxy<TItem>;
+    dict<TRecord extends Record<string, unknown> = Record<string, unknown>>(key: keyof TState): LockedDictProxy<TRecord>;
+    toJSON(): TState;
+    modelDump(): TState;
+    model_dump(): TState;
+    _unwrap(): TState;
+    __repr__(): string;
+    toString(): string;
+}
+export type FlowAskOptions = {
+    /** Timeout in seconds. */
+    timeout?: number | null;
+    metadata?: Record<string, unknown> | null;
+};
+export type FlowInputHistoryEntry = {
+    message: string;
+    response: string | null;
+    methodName: string | null;
+    method_name?: string | null;
+    timestamp: Date;
+    metadata: Record<string, unknown> | null;
+    responseMetadata: Record<string, unknown> | null;
+    response_metadata?: Record<string, unknown> | null;
+};
+export type HumanFeedbackContext = {
+    flowName: string;
+    flow_name?: string;
+    methodName: string;
+    method_name?: string;
+    output: unknown;
+    methodOutput?: unknown;
+    method_output?: unknown;
+    message: string;
+    emit: readonly string[] | null;
+    defaultOutcome: string | null;
+    default_outcome?: string | null;
+    metadata: Record<string, unknown>;
+    llm?: string | Record<string, unknown> | null;
+};
+export type PendingFeedbackContext = HumanFeedbackContext & {
+    flowId: string | null;
+    flow_id?: string | null;
+    flowClass: string;
+    flow_class?: string;
+    requestedAt: Date;
+    requested_at?: Date;
+};
+export type PendingFeedbackContextOptions = Partial<HumanFeedbackContext> & {
+    flowId?: string | null;
+    flow_id?: string | null;
+    flowClass?: string;
+    flow_class?: string;
+    requestedAt?: Date | string | null;
+    requested_at?: Date | string | null;
+};
+export declare const PendingFeedbackContext: {
+    new (options: PendingFeedbackContextOptions): {
+        readonly flowName: string;
+        readonly flow_name: string;
+        readonly flowId: string | null;
+        readonly flow_id: string | null;
+        readonly flowClass: string;
+        readonly flow_class: string;
+        readonly methodName: string;
+        readonly method_name: string;
+        readonly output: unknown;
+        readonly methodOutput: unknown;
+        readonly method_output: unknown;
+        readonly message: string;
+        readonly emit: readonly string[] | null;
+        readonly defaultOutcome: string | null;
+        readonly default_outcome: string | null;
+        readonly metadata: Record<string, unknown>;
+        readonly llm: string | Record<string, unknown> | null;
+        readonly requestedAt: Date;
+        readonly requested_at: Date;
+        to_dict(): Record<string, unknown>;
+        toDict(): Record<string, unknown>;
+        toJSON(): Record<string, unknown>;
+    };
+    from_dict(data: Record<string, unknown>): {
+        readonly flowName: string;
+        readonly flow_name: string;
+        readonly flowId: string | null;
+        readonly flow_id: string | null;
+        readonly flowClass: string;
+        readonly flow_class: string;
+        readonly methodName: string;
+        readonly method_name: string;
+        readonly output: unknown;
+        readonly methodOutput: unknown;
+        readonly method_output: unknown;
+        readonly message: string;
+        readonly emit: readonly string[] | null;
+        readonly defaultOutcome: string | null;
+        readonly default_outcome: string | null;
+        readonly metadata: Record<string, unknown>;
+        readonly llm: string | Record<string, unknown> | null;
+        readonly requestedAt: Date;
+        readonly requested_at: Date;
+        to_dict(): Record<string, unknown>;
+        toDict(): Record<string, unknown>;
+        toJSON(): Record<string, unknown>;
+    };
+    fromDict(data: Record<string, unknown>): {
+        readonly flowName: string;
+        readonly flow_name: string;
+        readonly flowId: string | null;
+        readonly flow_id: string | null;
+        readonly flowClass: string;
+        readonly flow_class: string;
+        readonly methodName: string;
+        readonly method_name: string;
+        readonly output: unknown;
+        readonly methodOutput: unknown;
+        readonly method_output: unknown;
+        readonly message: string;
+        readonly emit: readonly string[] | null;
+        readonly defaultOutcome: string | null;
+        readonly default_outcome: string | null;
+        readonly metadata: Record<string, unknown>;
+        readonly llm: string | Record<string, unknown> | null;
+        readonly requestedAt: Date;
+        readonly requested_at: Date;
+        to_dict(): Record<string, unknown>;
+        toDict(): Record<string, unknown>;
+        toJSON(): Record<string, unknown>;
+    };
+};
+export type HumanFeedbackProvider = {
+    requestFeedback?: (context: PendingFeedbackContext, flow: Flow<object>) => MaybePromise<string | null>;
+    request_feedback?: (context: PendingFeedbackContext, flow: Flow<object>) => MaybePromise<string | null>;
+};
+export type HumanFeedbackResult = {
+    output: unknown;
+    feedback: string;
+    outcome: string | null;
+    timestamp: Date;
+    methodName: string;
+    metadata: Record<string, unknown>;
+};
+declare const HUMAN_FEEDBACK_ROUTING_RESULT: unique symbol;
+type HumanFeedbackRoutingResult = {
+    readonly [HUMAN_FEEDBACK_ROUTING_RESULT]: true;
+    readonly methodOutput: unknown;
+    readonly routerOutput: string;
+};
+export type HumanFeedbackConfig = {
+    message: string;
+    emit?: readonly string[] | null;
+    llm?: string | Record<string, unknown> | LLM | null;
+    defaultOutcome?: string | null;
+    default_outcome?: string | null;
+    metadata?: Record<string, unknown> | null;
+    provider?: HumanFeedbackProvider | null;
+    learn?: boolean;
+    learnSource?: string;
+    learn_source?: string;
+    learnStrict?: boolean;
+    learn_strict?: boolean;
+};
+export declare class HumanFeedbackPending extends Error {
+    readonly context: PendingFeedbackContext;
+    readonly callbackInfo: Record<string, unknown>;
+    constructor(options: {
+        context: PendingFeedbackContext;
+        callbackInfo?: Record<string, unknown> | null;
+        message?: string | null;
+    });
+}
+export type FlowKickoffOptions = {
+    inputs?: InputValues;
+    inputFiles?: InputFiles;
+    input_files?: InputFiles;
+    fromCheckpoint?: CheckpointConfig | null;
+    from_checkpoint?: CheckpointConfig | null;
+    restoreFromStateId?: string | null;
+    restore_from_state_id?: string | null;
+    userMessage?: string | Record<string, unknown> | null;
+    user_message?: string | Record<string, unknown> | null;
+    sessionId?: string | null;
+    session_id?: string | null;
+    intents?: readonly string[] | null;
+    intentLlm?: string | LLM | null;
+    intent_llm?: string | LLM | null;
+};
+export type FlowExecutionTraceEntry = {
+    methodName: string;
+    kind: FlowMethodKind;
+    input: unknown;
+    output: unknown;
+    routerPath: string | null;
+};
+export type FlowExecutionMethodData = {
+    flowMethod: {
+        name: string;
+        type: FlowMethodKind;
+    };
+    input: unknown;
+    output: unknown;
+    routerPath: string | null;
+    finalState: Record<string, unknown> | null;
+    order: number;
+};
+export type FlowCompletedMethodData = {
+    flowMethod: {
+        name: string;
+        type: FlowMethodKind;
+    };
+    output: unknown;
+};
+export type FlowExecutionData = {
+    id: string | null;
+    flow: FlowStructure;
+    inputs: InputValues;
+    completedMethods: readonly FlowCompletedMethodData[];
+    executionMethods: readonly FlowExecutionMethodData[];
+    finalState: Record<string, unknown>;
+};
+export type FlowStructureMethod = {
+    name: string;
+    type: FlowMethodKind | "start_router";
+    triggerMethods: readonly string[];
+    conditionType: FlowCondition["type"] | null;
+    routerPaths: readonly string[];
+    hasHumanFeedback: boolean;
+};
+export type FlowStructureEdge = {
+    from: string;
+    to: string;
+    type: "listen" | "route";
+    conditionType: FlowCondition["type"] | null;
+    condition: string | null;
+};
+export type FlowStructure = {
+    name: string;
+    methods: readonly FlowStructureMethod[];
+    edges: readonly FlowStructureEdge[];
+    startMethods: readonly string[];
+    routerMethods: readonly string[];
+};
+export type OpenAPISchema = Record<string, unknown>;
+export type FlowMethodSignature = {
+    operationId: string;
+    parameters: Record<string, OpenAPISchema>;
+    returns: OpenAPISchema;
+    summary?: string;
+    description?: string;
+};
+export type FlowNodeMetadata = {
+    type: FlowMethodKind | "start_router";
+    is_router?: boolean;
+    router_paths?: readonly string[];
+    router_events?: readonly string[];
+    condition_type?: FlowCondition["type"] | "IF" | null;
+    trigger_condition_type?: FlowCondition["type"] | null;
+    trigger_methods?: readonly string[];
+    trigger_condition?: FlowCondition;
+    method_signature?: FlowMethodSignature;
+    source_code?: string;
+    class_name?: string;
+    class_signature?: string;
+};
+export type FlowChatOptions = {
+    session_id?: string | null;
+    sessionId?: string | null;
+    prompt?: string;
+    assistant_prefix?: string;
+    assistantPrefix?: string;
+    exit_commands?: readonly string[];
+    exitCommands?: readonly string[];
+    input_fn?: (prompt: string) => MaybePromise<string>;
+    inputFn?: (prompt: string) => MaybePromise<string>;
+    output_fn?: (message: string) => void;
+    outputFn?: (message: string) => void;
+    skip_empty?: boolean;
+    skipEmpty?: boolean;
+    defer_trace_finalization?: boolean;
+    deferTraceFinalization?: boolean;
+    handle_turn_options?: Omit<FlowKickoffOptions, "userMessage" | "user_message">;
+    handleTurnOptions?: Omit<FlowKickoffOptions, "userMessage" | "user_message">;
+};
+export type FlowVisualizationEdge = {
+    source: string;
+    target: string;
+    condition_type: FlowCondition["type"] | null;
+    is_router_path: boolean;
+    is_router_event?: boolean;
+    router_path_label?: string;
+    router_event?: string;
+};
+export type FlowVisualizationStructure = {
+    nodes: Record<string, FlowNodeMetadata>;
+    edges: readonly FlowVisualizationEdge[];
+    start_methods: readonly string[];
+    router_methods: readonly string[];
+};
+export type FlowSerializedMethodInfo = {
+    name: string;
+    type: FlowMethodKind | "start_router";
+    trigger_methods: readonly string[];
+    condition_type: FlowCondition["type"] | null;
+    router_paths: readonly string[];
+    router_events: readonly string[];
+    has_human_feedback: boolean;
+    has_crew: boolean;
+};
+export type FlowSerializedEdgeInfo = {
+    from_method: string;
+    to_method: string;
+    edge_type: "listen" | "route";
+    condition: string | null;
+};
+export type FlowSerializedStateFieldInfo = {
+    name: string;
+    type: string;
+    default?: unknown;
+};
+export type FlowSerializedStateSchemaInfo = {
+    fields: readonly FlowSerializedStateFieldInfo[];
+};
+export type FlowSerializedStructureInfo = {
+    name: string;
+    description: string | null;
+    methods: readonly FlowSerializedMethodInfo[];
+    edges: readonly FlowSerializedEdgeInfo[];
+    state_schema: FlowSerializedStateSchemaInfo | null;
+    inputs: readonly string[];
+};
+type AnyFlowMethod<This = unknown> = (this: This, ...args: unknown[]) => MaybePromise<unknown>;
+export declare class FlowMethod {
+    readonly _meth: (...args: unknown[]) => unknown;
+    readonly _instance: unknown;
+    readonly __name__: string;
+    constructor(method: (...args: unknown[]) => unknown, instance?: unknown);
+    call(...args: unknown[]): unknown;
+    __call__(...args: unknown[]): unknown;
+    unwrap(): (...args: unknown[]) => unknown;
+}
+export declare class StartMethod extends FlowMethod {
+    readonly __is_start_method__ = true;
+}
+export declare class ListenMethod extends FlowMethod {
+}
+export declare class RouterMethod extends FlowMethod {
+    readonly __is_router__ = true;
+}
+type FlowMetadataTarget = abstract new (...args: never[]) => object;
+export declare class Flow<TState extends object = Record<string, unknown>> {
+    static _flow_definition?: FlowDefinition | null;
+    static builtin_routes: readonly string[];
+    static builtinRoutes: readonly string[];
+    static internal_routes: readonly string[];
+    static internalRoutes: readonly string[];
+    static builtin_route_descriptions: Readonly<Record<string, string>>;
+    static builtinRouteDescriptions: Readonly<Record<string, string>>;
+    static flowDefinition(this: FlowMetadataTarget & {
+        _flow_definition?: FlowDefinition | null;
+    }): FlowDefinition;
+    static flow_definition(this: FlowMetadataTarget & {
+        _flow_definition?: FlowDefinition | null;
+    }): FlowDefinition;
+    readonly entityType = "flow";
+    readonly entity_type = "flow";
+    readonly name: string | null;
+    readonly maxMethodCalls: number;
+    inputProvider: InputProvider | null;
+    input_provider: InputProvider | null;
+    persistence: FlowPersistence | null;
+    stream: boolean;
+    checkpoint: CheckpointConfig | false | null;
+    memory: Memory | MemoryScope | MemorySlice | null;
+    state: TState;
+    private currentInputFiles;
+    private readonly runtimeMethodOutputs;
+    private readonly runtimeCompletedMethods;
+    private readonly runtimeMethodExecutionCounts;
+    private readonly runtimeExecutionTrace;
+    private readonly runtimeInputHistory;
+    readonly humanFeedbackHistory: HumanFeedbackResult[];
+    lastHumanFeedback: HumanFeedbackResult | null;
+    private pendingFeedbackContext;
+    private lastInputs;
+    private currentMethodName;
+    private currentFlowRequestId;
+    private checkpointRestoreActive;
+    private flowPostInitDone;
+    private readonly firedOrListeners;
+    private racingGroupsCache;
+    private readonly autoMemoryDisabled;
+    private deferredFlowFinished;
+    constructor(options?: FlowOptions<TState>);
+    model_post_init(_context?: unknown): void;
+    modelPostInit(context?: unknown): void;
+    _flowPostInit(): void;
+    _flow_post_init(): void;
+    _copyState(): TState;
+    _copy_state(): TState;
+    _initializeState(inputs: Record<string, unknown>): void;
+    _initialize_state(inputs: Record<string, unknown>): void;
+    _restoreState(state: Record<string, unknown>): void;
+    _restore_state(state: Record<string, unknown>): void;
+    _updateStateField(key: string, value: unknown): void;
+    _update_state_field(key: string, value: unknown): void;
+    _applyStateUpdates(updates: Record<string, unknown>): void;
+    _apply_state_updates(updates: Record<string, unknown>): void;
+    _createInitialState(): TState;
+    _create_initial_state(): TState;
+    get conversationMessages(): LLMMessage[];
+    get conversation_messages(): LLMMessage[];
+    appendMessage(role: LLMMessage["role"], content: string, extra?: Record<string, unknown>): void;
+    append_message(role: LLMMessage["role"], content: string, extra?: Record<string, unknown>): void;
+    appendAssistantMessage(content: string, extra?: Record<string, unknown>): void;
+    append_assistant_message(content: string, extra?: Record<string, unknown>): void;
+    appendAgentResult(agentName: string, result: unknown, options?: {
+        visibility?: ConversationEventVisibility;
+        metadata?: Record<string, unknown>;
+    }): void;
+    append_agent_result(agentName: string, result: unknown, options?: {
+        visibility?: ConversationEventVisibility;
+        metadata?: Record<string, unknown>;
+    }): void;
+    _buildRouteCatalog(routerConfig?: RouterConfig | null): Record<string, string>;
+    _build_route_catalog(routerConfig?: RouterConfig | null): Record<string, string>;
+    _buildRouterMessages(routerConfig: RouterConfig, context: Record<string, unknown>): LLMMessage[];
+    _build_router_messages(routerConfig: RouterConfig, context: Record<string, unknown>): LLMMessage[];
+    buildRouterContext(): Record<string, unknown>;
+    build_router_context(): Record<string, unknown>;
+    buildAgentContext(agentName: string): LLMMessage[];
+    build_agent_context(agentName: string): LLMMessage[];
+    conversationStart(): string | null;
+    conversation_start(): string | null;
+    classifyIntent(text: string, outcomes: readonly string[], options?: {
+        llm?: string | LLM | null;
+        context?: readonly LLMMessage[] | null;
+    }): string;
+    classify_intent(text: string, outcomes: readonly string[], options?: {
+        llm?: string | LLM | null;
+        context?: readonly LLMMessage[] | null;
+    }): string;
+    routeTurn(context: Record<string, unknown>): string | null;
+    route_turn(context: Record<string, unknown>): string | null;
+    routeConversation(): string;
+    route_conversation(): string;
+    _routeWithConfig(routerConfig: RouterConfig, context: Record<string, unknown>): string | null;
+    _route_with_config(routerConfig: RouterConfig, context: Record<string, unknown>): string | null;
+    _routerResponseFormat(routerConfig: RouterConfig): unknown;
+    _router_response_format(routerConfig: RouterConfig): unknown;
+    converseTurn(): string;
+    converse_turn(): string;
+    answerFromHistoryTurn(): string | null;
+    answer_from_history_turn(): string | null;
+    endConversation(): string;
+    end_conversation(): string;
+    finalizeSessionTraces(): void;
+    finalize_session_traces(): void;
+    _shouldDeferTraceFinalization(): boolean;
+    _should_defer_trace_finalization(): boolean;
+    _effectiveRoutes(routerConfig?: RouterConfig | null): string[];
+    _effective_routes(routerConfig?: RouterConfig | null): string[];
+    private validRouteLabels;
+    private routeDescriptionForHandler;
+    private builtinRouteNames;
+    private defaultRouterLlm;
+    private defaultConversationLlm;
+    private resolveConversationalSystemPrompt;
+    private resolveAnswerFromHistoryPrompt;
+    private routerResponseFormat;
+    private shouldDeferConversationalTraceFinalization;
+    private canAnswerFromHistory;
+    handleTurn(message: string | Record<string, unknown>, options?: Omit<FlowKickoffOptions, "userMessage" | "user_message">): Promise<unknown>;
+    handle_turn(message: string | Record<string, unknown>, options?: Omit<FlowKickoffOptions, "userMessage" | "user_message">): Promise<unknown>;
+    chat(options?: FlowChatOptions): Promise<void>;
+    _replayRecordedEvents(): Promise<void>;
+    _replay_recorded_events(): Promise<void>;
+    _executeStartMethod(startMethodName: string): Promise<void>;
+    _execute_start_method(startMethodName: string): Promise<void>;
+    _injectTriggerPayloadForStartMethod<TMethod extends (...args: unknown[]) => MaybePromise<unknown>>(originalMethod: TMethod): TMethod;
+    _inject_trigger_payload_for_start_method<TMethod extends (...args: unknown[]) => MaybePromise<unknown>>(originalMethod: TMethod): TMethod;
+    _executeMethod(methodName: string, method: (...args: unknown[]) => MaybePromise<unknown>, ...args: unknown[]): Promise<[unknown, string | null]>;
+    _execute_method(methodName: string, method: (...args: unknown[]) => MaybePromise<unknown>, ...args: unknown[]): Promise<[unknown, string | null]>;
+    _copyAndSerializeState(): Record<string, unknown>;
+    _copy_and_serialize_state(): Record<string, unknown>;
+    _executeListeners(triggerMethod: string, result: unknown, triggeringEventId?: string | null): Promise<void>;
+    _execute_listeners(triggerMethod: string, result: unknown, triggeringEventId?: string | null): Promise<void>;
+    _evaluateCondition(condition: string | FlowCondition, triggerMethod: string, listenerName: string): boolean;
+    _evaluate_condition(condition: string | FlowCondition, triggerMethod: string, listenerName: string): boolean;
+    _findTriggeredMethods(triggerMethod: string, routerOnly: boolean): string[];
+    _find_triggered_methods(triggerMethod: string, routerOnly: boolean): string[];
+    _checkpointStateForAsk(): MaybePromise<void>;
+    _checkpoint_state_for_ask(): Promise<void>;
+    _collapseToOutcome(feedback: string, outcomes: readonly string[]): string;
+    _collapse_to_outcome(feedback: string, outcomes: readonly string[]): string;
+    _logFlowEvent(message: string, color?: string, level?: "info" | "warning"): void;
+    _log_flow_event(message: string, color?: string, level?: "info" | "warning"): void;
+    _markOrListenerFired(listenerName: string): boolean;
+    _mark_or_listener_fired(listenerName: string): boolean;
+    _clearOrListeners(): void;
+    _clear_or_listeners(): void;
+    _discardOrListener(listenerName: string): void;
+    _discard_or_listener(listenerName: string): void;
+    _rearmOrListenersForTrigger(trigger: FlowConditionInput, rearmable?: Set<string> | null): void;
+    _rearm_or_listeners_for_trigger(trigger: FlowConditionInput, rearmable?: Set<string> | null): void;
+    _buildRacingGroups(): Map<ReadonlySet<string>, string>;
+    _build_racing_groups(): Map<ReadonlySet<string>, string>;
+    _getRacingGroupForListeners(listenerNames: readonly string[]): [ReadonlySet<string>, string] | null;
+    _get_racing_group_for_listeners(listenerNames: readonly string[]): [ReadonlySet<string>, string] | null;
+    _executeSingleListener(name: string, result: unknown, triggeringEventId?: string | null): Promise<unknown>;
+    _execute_single_listener(name: string, result: unknown, triggeringEventId?: string | null): Promise<unknown>;
+    _executeRacingListeners(racingListeners: Iterable<string>, otherListeners: readonly string[], result: unknown, triggeringEventId?: string | null): Promise<void>;
+    _execute_racing_listeners(racingListeners: Iterable<string>, otherListeners: readonly string[], result: unknown, triggeringEventId?: string | null): Promise<void>;
+    private flowPostInit;
+    private applyStateUpdates;
+    kickoff(optionsOrInputs?: FlowKickoffOptions | InputValues | null, inputFiles?: InputFiles | null, fromCheckpoint?: CheckpointConfig | null, restoreFromStateId?: string | null): Promise<unknown>;
+    kickoffAsync(optionsOrInputs?: FlowKickoffOptions | InputValues | null, inputFiles?: InputFiles | null, fromCheckpoint?: CheckpointConfig | null, restoreFromStateId?: string | null): Promise<unknown>;
+    recall(query: string, options?: Parameters<Memory["recall"]>[1]): MemoryMatch[];
+    remember(content: string | readonly string[], options?: Parameters<Memory["remember"]>[1]): MemoryRecord | MemoryRecord[] | null;
+    extractMemories(content: string): readonly string[];
+    extract_memories(content: string): readonly string[];
+    plot(filename?: string, show?: boolean): string;
+    static showTracingDisabledMessage(): void;
+    static _show_tracing_disabled_message(): void;
+    akickoff(optionsOrInputs?: FlowKickoffOptions | InputValues | null, inputFiles?: InputFiles | null, fromCheckpoint?: CheckpointConfig | null, restoreFromStateId?: string | null): Promise<unknown>;
+    kickoff_async(optionsOrInputs?: FlowKickoffOptions | InputValues | null, inputFiles?: InputFiles | null, fromCheckpoint?: CheckpointConfig | null, restoreFromStateId?: string | null): Promise<unknown>;
+    resume(feedback?: string): Promise<unknown>;
+    resumeAsync(feedback?: string): Promise<unknown>;
+    resume_async(feedback?: string): Promise<unknown>;
+    aresume(feedback?: string): Promise<unknown>;
+    get pendingFeedback(): PendingFeedbackContext | null;
+    get pending_feedback(): PendingFeedbackContext | null;
+    static fromPending<TFlow extends Flow<object>>(this: new () => TFlow, flowId: string, persistence?: FlowPersistence | null): Promise<TFlow>;
+    static from_pending<TFlow extends Flow<object>>(this: new () => TFlow, flowId: string, persistence?: FlowPersistence | null): Promise<TFlow>;
+    static fromState<TFlow extends Flow<object>>(this: new () => TFlow, flowId: string, persistence: FlowPersistence): Promise<TFlow>;
+    static from_state<TFlow extends Flow<object>>(this: new () => TFlow, flowId: string, persistence: FlowPersistence): Promise<TFlow>;
+    static fromCheckpoint<TFlow extends Flow<object>>(this: new () => TFlow, config: CheckpointConfig): Promise<TFlow>;
+    static from_checkpoint<TFlow extends Flow<object>>(this: new () => TFlow, config: CheckpointConfig): Promise<TFlow>;
+    static fork<TFlow extends Flow<object>>(this: new () => TFlow, config: CheckpointConfig, branch?: string | null): Promise<TFlow>;
+    get inputFiles(): InputFiles;
+    get methodOutputs(): readonly unknown[];
+    get method_outputs(): readonly unknown[];
+    get flow_id(): string;
+    get completedMethods(): ReadonlySet<string>;
+    get methodExecutionCounts(): ReadonlyMap<string, number>;
+    get executionTrace(): readonly FlowExecutionTraceEntry[];
+    get inputHistory(): readonly FlowInputHistoryEntry[];
+    get input_history(): readonly FlowInputHistoryEntry[];
+    get _input_history(): readonly FlowInputHistoryEntry[];
+    toExecutionData(): FlowExecutionData;
+    reload(executionData: FlowExecutionData): void;
+    toJSON(): Record<string, unknown>;
+    kickoffCrew(crew: Crew, options?: KickoffOptions): Promise<CrewOutput>;
+    ask(message: string, options?: FlowAskOptions): MaybePromise<string | null>;
+    private requestInputFromProvider;
+    private requestInputAfterCheckpoint;
+    private resolveInputProvider;
+    _resolveInputProvider(): InputProvider;
+    _resolve_input_provider(): InputProvider;
+    requestHumanFeedback(methodName: string, methodOutput: unknown, config: HumanFeedbackConfig, options?: {
+        preserveMethodOutput?: boolean;
+    }): Promise<HumanFeedbackResult | HumanFeedbackRoutingResult | string>;
+    _requestHumanFeedback(message: string, output: unknown, metadata?: Record<string, unknown> | null, emit?: readonly string[] | null): Promise<string>;
+    _request_human_feedback(message: string, output: unknown, metadata?: Record<string, unknown> | null, emit?: readonly string[] | null): Promise<string>;
+    get humanFeedback(): HumanFeedbackResult | null;
+    private callFlowMethod;
+    private resetRuntimeState;
+    private restoreFromCheckpointEntity;
+    _restoreFromCheckpoint(checkpoint?: Partial<FlowCheckpointEntity> | null): void;
+    _restore_from_checkpoint(checkpoint?: Partial<FlowCheckpointEntity> | null): void;
+    private continueFromHumanFeedback;
+    private savePendingFeedback;
+    private withStreamDisabled;
+    private saveState;
+    private recordHumanFeedbackResult;
+    private resolveAsyncInput;
+    private recordInput;
+    stateSnapshot(): Record<string, unknown>;
+    private flowName;
+    private shouldSkipAutoMemory;
+    private flowPersistenceId;
+    private isStartMethod;
+    private isRouterOutput;
+    private collectHumanFeedback;
+}
+export declare class _FlowGeneric<TState extends object = Record<string, unknown>> extends Flow<TState> {
+}
+export declare class StateWithId {
+    id: string;
+    constructor(id?: string);
+}
+export declare class FeedbackOutcome {
+    readonly outcome: string;
+    constructor(outcome: string);
+}
+export declare function _run_flow<TState extends object>(flow: Flow<TState>, options?: FlowKickoffOptions | InputValues | null): Promise<unknown>;
+export declare function run_flow<TState extends object>(flow: Flow<TState>, options?: FlowKickoffOptions | InputValues | null): Promise<unknown>;
+export declare function prepare_kwargs(...args: unknown[]): [unknown[], Record<string, unknown>];
+export declare function enhanced_method<TArgs extends unknown[], TResult>(method: (...args: TArgs) => TResult): (...args: TArgs) => TResult;
+export declare function start<This extends object>(value: AnyFlowMethod<This>, context: ClassMethodDecoratorContext<This, AnyFlowMethod<This>>): AnyFlowMethod<This>;
+export declare function start(condition?: FlowConditionInput): MethodDecoratorFactory;
+export declare function listen(condition: FlowConditionInput): MethodDecoratorFactory;
+export declare function router(condition: FlowConditionInput, options?: {
+    emit?: readonly string[] | null;
+}): MethodDecoratorFactory;
+export declare function humanFeedback(configOrMessage: HumanFeedbackConfig | string): MethodDecoratorFactory;
+export declare const human_feedback: typeof humanFeedback;
+export declare function or_(...conditions: FlowConditionInput[]): FlowCondition;
+export declare function and_(...conditions: FlowConditionInput[]): FlowCondition;
+export declare function getFlowMetadata(instanceOrConstructor: object | FlowMetadataTarget): readonly FlowMethodEntry[];
+export declare function getHumanFeedbackMetadata(instanceOrConstructor: object | FlowMetadataTarget): ReadonlyMap<string, HumanFeedbackConfig>;
+export declare function buildFlowDefinition(instanceOrConstructor: object | FlowMetadataTarget, namespace?: Record<string, unknown> | null): FlowDefinition;
+export declare const build_flow_definition: typeof buildFlowDefinition;
+export type FlowRegistryListenerCondition = readonly [FlowCondition["type"], readonly string[]] | FlowCondition;
+export type ExtractedFlowDefinitionRegistries = [
+    startMethods: string[],
+    listeners: Record<string, FlowRegistryListenerCondition>,
+    routers: Set<string>,
+    routerEmit: Record<string, readonly string[]>
+];
+export declare function extractFlowDefinition(namespace: Record<string, unknown>): ExtractedFlowDefinitionRegistries;
+export declare const extract_flow_definition: typeof extractFlowDefinition;
+export declare function getFlowStructure(instanceOrConstructor: object | FlowMetadataTarget): FlowStructure;
+export declare const get_flow_structure: typeof getFlowStructure;
+export declare function visualizeFlowStructure(structure: FlowVisualizationStructure, filename?: string, show?: boolean): string;
+export declare const visualize_flow_structure: typeof visualizeFlowStructure;
+export declare function typeToOpenAPISchema(typeHint: unknown): OpenAPISchema;
+export declare const type_to_openapi_schema: typeof typeToOpenAPISchema;
+export declare function extractMethodSignature(method: unknown, methodName: string): FlowMethodSignature;
+export declare const extract_method_signature: typeof extractMethodSignature;
+export declare function getPossibleReturnConstants(method: unknown): readonly string[] | null;
+export declare const get_possible_return_constants: typeof getPossibleReturnConstants;
+export declare function buildFlowStructure(instanceOrConstructor: object | FlowMetadataTarget): FlowVisualizationStructure;
+export declare const build_flow_structure: typeof buildFlowStructure;
+export declare function flowStructure(instanceOrConstructor: object | FlowMetadataTarget): FlowSerializedStructureInfo;
+export declare function flow_structure(instanceOrConstructor: object | FlowMetadataTarget): FlowSerializedStructureInfo;
+export declare function calculateExecutionPaths(structure: FlowVisualizationStructure): number;
+export declare const calculate_execution_paths: typeof calculateExecutionPaths;
+export declare function calculateNodeLevels(instanceOrConstructor: object | FlowMetadataTarget | FlowVisualizationStructure): Record<string, number>;
+export declare const calculate_node_levels: typeof calculateNodeLevels;
+export declare function countOutgoingEdges(instanceOrConstructor: object | FlowMetadataTarget | FlowVisualizationStructure): Record<string, number>;
+export declare const count_outgoing_edges: typeof countOutgoingEdges;
+export declare function buildAncestorDict(instanceOrConstructor: object | FlowMetadataTarget | FlowVisualizationStructure): Record<string, ReadonlySet<string>>;
+export declare const build_ancestor_dict: typeof buildAncestorDict;
+export declare function isAncestor(node: string, ancestorCandidate: string, ancestors: Readonly<Record<string, ReadonlySet<string>>>): boolean;
+export declare const is_ancestor: typeof isAncestor;
+export declare function dfsAncestors(node: string, ancestors: Record<string, Set<string>>, visited: Set<string>, flow: unknown): void;
+export declare const dfs_ancestors: typeof dfsAncestors;
+export declare function buildParentChildrenDict(instanceOrConstructor: object | FlowMetadataTarget | FlowVisualizationStructure): Record<string, readonly string[]>;
+export declare const build_parent_children_dict: typeof buildParentChildrenDict;
+export declare function getChildIndex(parent: string, child: string, parentChildren: Readonly<Record<string, readonly string[]>>): number;
+export declare const get_child_index: typeof getChildIndex;
+export declare function processRouterPaths(flow: unknown, current: string, currentLevel: number, levels: Record<string, number>, queue: {
+    push?: (value: string) => unknown;
+    append?: (value: string) => unknown;
+}): void;
+export declare const process_router_paths: typeof processRouterPaths;
+export declare function isFlowMethodName(value: unknown): value is string;
+export declare const is_flow_method_name: typeof isFlowMethodName;
+export declare function isFlowMethodCallable(value: unknown): value is (...args: unknown[]) => unknown;
+export declare const is_flow_method_callable: typeof isFlowMethodCallable;
+export declare function isFlowConditionDict(value: unknown): value is FlowCondition;
+export declare const is_flow_condition_dict: typeof isFlowConditionDict;
+export declare function isFlowConditionList(value: unknown): value is FlowConditionInput[];
+export declare const is_flow_condition_list: typeof isFlowConditionList;
+export declare function isSimpleFlowCondition(value: unknown): value is [string, string[]];
+export declare const is_simple_flow_condition: typeof isSimpleFlowCondition;
+export declare function isFlowMethod(value: unknown): boolean;
+export declare const is_flow_method: typeof isFlowMethod;
+export type FlowMethodDecorator = <This extends object>(value: AnyFlowMethod<This>, context: ClassMethodDecoratorContext<This, AnyFlowMethod<This>>) => AnyFlowMethod<This>;
+export declare const FlowMethodDecorator: Readonly<{
+    kind: "FlowMethodDecorator";
+}>;
+type MethodDecoratorFactory = FlowMethodDecorator;
+type FlowCheckpointEntity = {
+    checkpoint_completed_methods: string[];
+    checkpoint_method_outputs: unknown[];
+    checkpoint_method_counts: Record<string, number>;
+    checkpoint_state: Record<string, unknown>;
+};
+export {};