@crewai-ts/core 0.1.2 → 0.1.5

package/dist/flow-definition.d.ts

@@ -0,0 +1,195 @@
+export type FlowDefinitionCondition = string | Record<string, unknown>;
+export declare const FlowDefinitionCondition: Readonly<{
+    kind: "FlowDefinitionCondition";
+}>;
+export type FlowDefinitionDiagnosticOptions = {
+    code: string;
+    message: string;
+    severity?: "warning" | "error";
+    path?: string | null;
+};
+export declare class FlowDefinitionDiagnostic {
+    readonly code: string;
+    readonly message: string;
+    readonly severity: "warning" | "error";
+    readonly path: string | null;
+    constructor(options: FlowDefinitionDiagnosticOptions);
+    toDict(excludeNone?: boolean): Record<string, unknown>;
+    to_dict(options?: {
+        exclude_none?: boolean;
+    }): Record<string, unknown>;
+}
+export type FlowStateDefinitionOptions = {
+    type?: "dict" | "pydantic" | "unknown";
+    ref?: string | null;
+    default?: unknown;
+};
+export declare class FlowStateDefinition {
+    readonly type: "dict" | "pydantic" | "unknown";
+    readonly ref: string | null;
+    readonly default: unknown;
+    constructor(options?: FlowStateDefinitionOptions);
+    toDict(excludeNone?: boolean): Record<string, unknown>;
+    to_dict(options?: {
+        exclude_none?: boolean;
+    }): Record<string, unknown>;
+}
+export type FlowConfigDefinitionOptions = {
+    tracing?: boolean | null;
+    stream?: boolean;
+    memory?: unknown;
+    inputProvider?: unknown;
+    input_provider?: unknown;
+    suppressFlowEvents?: boolean;
+    suppress_flow_events?: boolean;
+    maxMethodCalls?: number;
+    max_method_calls?: number;
+};
+export declare class FlowConfigDefinition {
+    readonly tracing: boolean | null;
+    readonly stream: boolean;
+    readonly memory: unknown;
+    readonly inputProvider: unknown;
+    readonly input_provider: unknown;
+    readonly suppressFlowEvents: boolean;
+    readonly suppress_flow_events: boolean;
+    readonly maxMethodCalls: number;
+    readonly max_method_calls: number;
+    constructor(options?: FlowConfigDefinitionOptions);
+    toDict(excludeNone?: boolean): Record<string, unknown>;
+    to_dict(options?: {
+        exclude_none?: boolean;
+    }): Record<string, unknown>;
+}
+export type FlowPersistenceDefinitionOptions = {
+    enabled?: boolean;
+    verbose?: boolean;
+    persistence?: unknown;
+};
+export declare class FlowPersistenceDefinition {
+    readonly enabled: boolean;
+    readonly verbose: boolean;
+    readonly persistence: unknown;
+    constructor(options?: FlowPersistenceDefinitionOptions);
+    toDict(excludeNone?: boolean): Record<string, unknown>;
+    to_dict(options?: {
+        exclude_none?: boolean;
+    }): Record<string, unknown>;
+}
+export type FlowHumanFeedbackDefinitionOptions = {
+    message: string;
+    emit?: readonly string[] | null;
+    llm?: unknown;
+    defaultOutcome?: string | null;
+    default_outcome?: string | null;
+    metadata?: Record<string, unknown> | null;
+    provider?: unknown;
+    learn?: boolean;
+    learnSource?: string;
+    learn_source?: string;
+    learnStrict?: boolean;
+    learn_strict?: boolean;
+};
+export declare class FlowHumanFeedbackDefinition {
+    readonly message: string;
+    readonly emit: readonly string[] | null;
+    readonly llm: unknown;
+    readonly defaultOutcome: string | null;
+    readonly default_outcome: string | null;
+    readonly metadata: Record<string, unknown> | null;
+    readonly provider: unknown;
+    readonly learn: boolean;
+    readonly learnSource: string;
+    readonly learn_source: string;
+    readonly learnStrict: boolean;
+    readonly learn_strict: boolean;
+    constructor(options: FlowHumanFeedbackDefinitionOptions);
+    toDict(excludeNone?: boolean): Record<string, unknown>;
+    to_dict(options?: {
+        exclude_none?: boolean;
+    }): Record<string, unknown>;
+}
+export type FlowMethodDefinitionOptions = {
+    start?: boolean | FlowDefinitionCondition | null;
+    listen?: FlowDefinitionCondition | null;
+    router?: boolean;
+    emit?: readonly string[] | null;
+    humanFeedback?: FlowHumanFeedbackDefinition | FlowHumanFeedbackDefinitionOptions | null;
+    human_feedback?: FlowHumanFeedbackDefinition | FlowHumanFeedbackDefinitionOptions | null;
+    persist?: FlowPersistenceDefinition | FlowPersistenceDefinitionOptions | null;
+};
+export declare class FlowMethodDefinition {
+    readonly start: boolean | FlowDefinitionCondition | null;
+    readonly listen: FlowDefinitionCondition | null;
+    readonly router: boolean;
+    readonly emit: readonly string[] | null;
+    readonly humanFeedback: FlowHumanFeedbackDefinition | null;
+    readonly human_feedback: FlowHumanFeedbackDefinition | null;
+    readonly persist: FlowPersistenceDefinition | null;
+    constructor(options?: FlowMethodDefinitionOptions);
+    get isStart(): boolean;
+    get is_start(): boolean;
+    toDict(excludeNone?: boolean): Record<string, unknown>;
+    to_dict(options?: {
+        exclude_none?: boolean;
+    }): Record<string, unknown>;
+}
+export type FlowDefinitionOptions = {
+    schema?: string;
+    schema_?: string;
+    name: string;
+    description?: string | null;
+    state?: FlowStateDefinition | FlowStateDefinitionOptions | null;
+    config?: FlowConfigDefinition | FlowConfigDefinitionOptions;
+    persist?: FlowPersistenceDefinition | FlowPersistenceDefinitionOptions | null;
+    methods?: Record<string, FlowMethodDefinition | FlowMethodDefinitionOptions>;
+    diagnostics?: readonly (FlowDefinitionDiagnostic | FlowDefinitionDiagnosticOptions)[];
+};
+export declare class FlowDefinition {
+    readonly schema_: string;
+    readonly name: string;
+    readonly description: string | null;
+    readonly state: FlowStateDefinition | null;
+    readonly config: FlowConfigDefinition;
+    readonly persist: FlowPersistenceDefinition | null;
+    readonly methods: Record<string, FlowMethodDefinition>;
+    diagnostics: FlowDefinitionDiagnostic[];
+    constructor(options: FlowDefinitionOptions);
+    toDict(options?: {
+        excludeNone?: boolean;
+        exclude_none?: boolean;
+    }): Record<string, unknown>;
+    to_dict(options?: {
+        exclude_none?: boolean;
+    }): Record<string, unknown>;
+    toJson(options?: {
+        indent?: number | null;
+        excludeNone?: boolean;
+        exclude_none?: boolean;
+    }): string;
+    to_json(options?: {
+        indent?: number | null;
+        exclude_none?: boolean;
+    }): string;
+    toYaml(options?: {
+        excludeNone?: boolean;
+        exclude_none?: boolean;
+    }): string;
+    to_yaml(options?: {
+        exclude_none?: boolean;
+    }): string;
+    static fromDict(data: Record<string, unknown>): FlowDefinition;
+    static from_dict(data: Record<string, unknown>): FlowDefinition;
+    static fromJson(data: string): FlowDefinition;
+    static from_json(data: string): FlowDefinition;
+    static fromYaml(data: string): FlowDefinition;
+    static from_yaml(data: string): FlowDefinition;
+    static jsonSchema(): Record<string, unknown>;
+    static json_schema(): Record<string, unknown>;
+    validateContract(): FlowDefinitionDiagnostic[];
+    validate_contract(): FlowDefinitionDiagnostic[];
+    withDiagnostics(): this;
+    with_diagnostics(): this;
+    logDiagnostics(): void;
+    log_diagnostics(): void;
+}

package/dist/flow-persistence.d.ts

@@ -0,0 +1,107 @@
+import type { PendingFeedbackContext } from "./flow.js";
+import type { DatabaseSync as DatabaseSyncType } from "node:sqlite";
+export type PendingFeedbackRecord = {
+    state: Record<string, unknown>;
+    context: PendingFeedbackContext;
+};
+export type FlowPersistence = {
+    persistenceType?: string;
+    persistence_type?: string;
+    saveState?(flowId: string, methodName: string, state: unknown): void | Promise<void>;
+    save_state?(flowId: string, methodName: string, state: unknown): void | Promise<void>;
+    loadState?(flowId: string): Promise<Record<string, unknown> | null>;
+    load_state?(flowId: string): Promise<Record<string, unknown> | null>;
+    savePendingFeedback(flowId: string, context: PendingFeedbackContext, state: unknown): Promise<void>;
+    save_pending_feedback(flowId: string, context: PendingFeedbackContext, state: unknown): Promise<void>;
+    loadPendingFeedback(flowId: string): Promise<PendingFeedbackRecord | null>;
+    load_pending_feedback(flowId: string): Promise<PendingFeedbackRecord | null>;
+    clearPendingFeedback(flowId: string): Promise<void>;
+    clear_pending_feedback(flowId: string): Promise<void>;
+};
+export declare const FlowPersistence: Readonly<{
+    kind: "FlowPersistence";
+}>;
+export declare const LOG_MESSAGES: Readonly<{
+    SAVE_SKIPPED: "Flow persistence skipped.";
+    LOAD_SKIPPED: "Flow persistence load skipped.";
+}>;
+type PersistableFlowInstance = {
+    state?: unknown;
+    name?: string | null;
+    constructor: {
+        name?: string;
+    };
+};
+type FlowClass = new (...args: any[]) => object;
+export type PersistDecoratorOptions = {
+    persistence?: FlowPersistence | null;
+    verbose?: boolean;
+};
+type ClassDecoratorFactory = <TClass extends FlowClass>(value: TClass, context: ClassDecoratorContext<TClass>) => TClass | undefined;
+type MethodDecoratorFactory = <This extends PersistableFlowInstance, Args extends unknown[], Return>(value: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => ((this: This, ...args: Args) => Return) | undefined;
+export type PersistDecoratorMetadata = {
+    enabled: true;
+    verbose: boolean;
+    persistence: FlowPersistence | null;
+};
+export declare class JsonFlowPersistence implements FlowPersistence {
+    readonly location: string;
+    readonly persistenceType = "JsonFlowPersistence";
+    readonly persistence_type = "JsonFlowPersistence";
+    constructor(location?: string);
+    saveState(flowId: string, methodName: string, state: Record<string, unknown>): Promise<void>;
+    save_state(flowId: string, methodName: string, state: Record<string, unknown>): Promise<void>;
+    loadState(flowId: string): Promise<Record<string, unknown> | null>;
+    load_state(flowId: string): Promise<Record<string, unknown> | null>;
+    savePendingFeedback(flowId: string, context: PendingFeedbackContext, state: Record<string, unknown>): Promise<void>;
+    save_pending_feedback(flowId: string, context: PendingFeedbackContext, state: Record<string, unknown>): Promise<void>;
+    loadPendingFeedback(flowId: string): Promise<PendingFeedbackRecord | null>;
+    load_pending_feedback(flowId: string): Promise<PendingFeedbackRecord | null>;
+    clearPendingFeedback(flowId: string): Promise<void>;
+    clear_pending_feedback(flowId: string): Promise<void>;
+    private ensureDirectory;
+    private statePath;
+    private pendingPath;
+}
+export declare class SQLiteFlowPersistence implements FlowPersistence {
+    readonly persistenceType = "SQLiteFlowPersistence";
+    readonly persistence_type = "SQLiteFlowPersistence";
+    readonly dbPath: string;
+    readonly db_path: string;
+    constructor(dbPath?: string | null);
+    initDb(): void;
+    init_db(): void;
+    _setup(): this;
+    saveState(flowId: string, methodName: string, state: unknown): Promise<void>;
+    save_state(flowId: string, methodName: string, state: unknown): Promise<void>;
+    loadState(flowId: string): Promise<Record<string, unknown> | null>;
+    load_state(flowId: string): Promise<Record<string, unknown> | null>;
+    savePendingFeedback(flowId: string, context: PendingFeedbackContext, state: unknown): Promise<void>;
+    save_pending_feedback(flowId: string, context: PendingFeedbackContext, state: unknown): Promise<void>;
+    loadPendingFeedback(flowId: string): Promise<PendingFeedbackRecord | null>;
+    load_pending_feedback(flowId: string): Promise<PendingFeedbackRecord | null>;
+    clearPendingFeedback(flowId: string): Promise<void>;
+    clear_pending_feedback(flowId: string): Promise<void>;
+    static _to_state_dict(stateData: unknown): Record<string, unknown>;
+    _to_state_dict(stateData: unknown): Record<string, unknown>;
+    _save_state_sql(db: DatabaseSyncType, flowId: string, methodName: string, state: unknown): void;
+    private withDb;
+}
+export declare function persistState(flowInstance: PersistableFlowInstance, methodName: string, persistenceInstance: FlowPersistence, verbose?: boolean): Promise<void>;
+export declare function persist(persistenceOrOptions?: FlowPersistence | PersistDecoratorOptions | null, verbose?: boolean): ClassDecoratorFactory & MethodDecoratorFactory;
+export declare const PersistenceDecorator: {
+    persistState: typeof persistState;
+};
+export declare const PersistDecorator: {
+    persistState: typeof persistState;
+};
+export declare const persist_state: typeof persistState;
+export declare function getPersistDecoratorMetadata(value: object): PersistDecoratorMetadata | null;
+export declare function getMethodPersistDecoratorMetadata(value: unknown): PersistDecoratorMetadata | null;
+export declare const SQLiteFlowPersistenceAlias: typeof SQLiteFlowPersistence;
+export declare const SqliteFlowPersistence: typeof SQLiteFlowPersistence;
+export declare const sqliteFlowPersistence: typeof SQLiteFlowPersistence;
+export declare const sqlite_flow_persistence: typeof SQLiteFlowPersistence;
+export declare function serializePendingFeedbackContext(context: PendingFeedbackContext): Record<string, unknown>;
+export declare function deserializePendingFeedbackContext(value: Record<string, unknown>): PendingFeedbackContext;
+export {};

package/dist/flow-visualization.d.ts

@@ -0,0 +1,77 @@
+export declare const CREWAI_ORANGE = "#FF5A50";
+export declare const DARK_GRAY = "#333333";
+export declare const WHITE = "#FFFFFF";
+export declare const GRAY = "#666666";
+export declare const BG_DARK = "#0d1117";
+export declare const BG_CARD = "#161b22";
+export declare const BORDER_SUBTLE = "#30363d";
+export declare const TEXT_PRIMARY = "#e6edf3";
+export declare const TEXT_SECONDARY = "#7d8590";
+export declare class CSSExtension {
+    readonly tags: Set<string>;
+    parse(parser: ExtensionParserLike): ExtensionParseResult;
+    renderCss(href: string): string;
+    _render_css(href: string): string;
+}
+export declare class JSExtension {
+    readonly tags: Set<string>;
+    parse(parser: ExtensionParserLike): ExtensionParseResult;
+    renderJs(src: string): string;
+    _render_js(src: string): string;
+}
+export type ExtensionParserLike = {
+    stream: Iterator<{
+        lineno?: number;
+    }> | Iterable<{
+        lineno?: number;
+    }> | readonly {
+        lineno?: number;
+    }[];
+    parse_expression: () => unknown;
+};
+export type ExtensionParseResult = {
+    lineno: number;
+    method: "_render_css" | "_render_js";
+    args: readonly string[];
+    html: string;
+};
+export type FlowVisualizationNodeMetadata = {
+    type?: string;
+    condition_type?: string | null;
+    conditionType?: string | null;
+    trigger_methods?: readonly string[];
+    triggerMethods?: readonly string[];
+    router_paths?: readonly string[];
+    routerPaths?: readonly string[];
+};
+export declare const NodeMetadata: Readonly<{
+    kind: "NodeMetadata";
+}>;
+export type FlowVisualizationEdge = {
+    source: string;
+    target: string;
+    condition_type?: string | null;
+    conditionType?: string | null;
+    is_router_path?: boolean;
+    isRouterPath?: boolean;
+    router_path_label?: string | null;
+    routerPathLabel?: string | null;
+};
+export declare const StructureEdge: Readonly<{
+    kind: "StructureEdge";
+}>;
+export type FlowStructureLike = {
+    nodes?: Record<string, FlowVisualizationNodeMetadata>;
+    edges?: readonly FlowVisualizationEdge[];
+    start_methods?: readonly string[];
+    startMethods?: readonly string[];
+};
+export type NodePosition = {
+    level: number;
+    x: number;
+    y: number;
+};
+export declare function calculateNodePositions(dag: FlowStructureLike): Record<string, NodePosition>;
+export declare const calculate_node_positions: typeof calculateNodePositions;
+export declare function renderInteractive(dag: FlowStructureLike, filename?: string, show?: boolean): string;
+export declare const render_interactive: typeof renderInteractive;