@crewai-ts/core 0.1.2 → 0.1.3

package/dist/files.d.ts

@@ -0,0 +1,554 @@
+export type FileMode = "strict" | "auto" | "warn" | "chunk";
+export type FileReadable = {
+    read(size?: number): Uint8Array | Buffer | string;
+    seek?(position: number): void;
+    tell?(): number;
+    close?(): void;
+    name?: string;
+};
+export type FileSourceInput = string | Uint8Array | Buffer | FileSource | FileReadable;
+export type FileInput = AudioFile | File | ImageFile | PDFFile | TextFile | VideoFile;
+export type FileProvider = string;
+export declare abstract class ResolvedFile {
+    readonly contentType: string;
+    readonly content_type: string;
+    protected constructor(contentType: string);
+}
+export declare class InlineBase64 extends ResolvedFile {
+    readonly data: string;
+    constructor(options: {
+        contentType?: string;
+        content_type?: string;
+        data: string;
+    });
+}
+export declare class InlineBytes extends ResolvedFile {
+    readonly data: Uint8Array;
+    constructor(options: {
+        contentType?: string;
+        content_type?: string;
+        data: Uint8Array | Buffer | string;
+    });
+}
+export declare class FileReference extends ResolvedFile {
+    readonly fileId: string;
+    readonly file_id: string;
+    readonly provider: string;
+    readonly expiresAt: Date | null;
+    readonly expires_at: Date | null;
+    readonly fileUri: string | null;
+    readonly file_uri: string | null;
+    constructor(options: {
+        contentType?: string;
+        content_type?: string;
+        fileId?: string;
+        file_id?: string;
+        provider: string;
+        expiresAt?: Date | null;
+        expires_at?: Date | null;
+        fileUri?: string | null;
+        file_uri?: string | null;
+    });
+}
+export declare class UrlReference extends ResolvedFile {
+    readonly url: string;
+    constructor(options: {
+        contentType?: string;
+        content_type?: string;
+        url: string;
+    });
+}
+export type ResolvedFileType = InlineBase64 | InlineBytes | FileReference | UrlReference;
+export declare enum FileHandling {
+    STRICT = "strict",
+    AUTO = "auto",
+    WARN = "warn",
+    CHUNK = "chunk"
+}
+export declare class FileValidationError extends Error {
+    readonly fileName: string | null;
+    readonly file_name: string | null;
+    constructor(message: string, options?: {
+        fileName?: string | null;
+        file_name?: string | null;
+    });
+}
+export declare class FileTooLargeError extends FileValidationError {
+    readonly actualSize: number | null;
+    readonly actual_size: number | null;
+    readonly maxSize: number | null;
+    readonly max_size: number | null;
+    constructor(message: string, options?: {
+        fileName?: string | null;
+        file_name?: string | null;
+        actualSize?: number | null;
+        actual_size?: number | null;
+        maxSize?: number | null;
+        max_size?: number | null;
+    });
+}
+export declare class UnsupportedFileTypeError extends FileValidationError {
+    readonly contentType: string | null;
+    readonly content_type: string | null;
+    constructor(message: string, options?: {
+        fileName?: string | null;
+        file_name?: string | null;
+        contentType?: string | null;
+        content_type?: string | null;
+    });
+}
+export declare class FileProcessingError extends FileValidationError {
+    constructor(message: string, options?: {
+        fileName?: string | null;
+        file_name?: string | null;
+    });
+}
+export declare class ProcessingDependencyError extends FileProcessingError {
+    readonly dependency: string | null;
+    readonly installCommand: string | null;
+    readonly install_command: string | null;
+    constructor(message: string, options?: {
+        dependency?: string | null;
+        installCommand?: string | null;
+        install_command?: string | null;
+    });
+}
+export declare class ImageConstraints {
+    readonly maxSizeBytes: number;
+    readonly max_size_bytes: number;
+    readonly maxWidth: number | null;
+    readonly max_width: number | null;
+    readonly maxHeight: number | null;
+    readonly max_height: number | null;
+    readonly maxImagesPerRequest: number | null;
+    readonly max_images_per_request: number | null;
+    readonly supportedFormats: readonly string[];
+    readonly supported_formats: readonly string[];
+    constructor(options: {
+        maxSizeBytes?: number;
+        max_size_bytes?: number;
+        maxWidth?: number | null;
+        max_width?: number | null;
+        maxHeight?: number | null;
+        max_height?: number | null;
+        maxImagesPerRequest?: number | null;
+        max_images_per_request?: number | null;
+        supportedFormats?: readonly string[];
+        supported_formats?: readonly string[];
+    });
+}
+export declare class PDFConstraints {
+    readonly maxSizeBytes: number;
+    readonly max_size_bytes: number;
+    readonly maxPages: number | null;
+    readonly max_pages: number | null;
+    constructor(options: {
+        maxSizeBytes?: number;
+        max_size_bytes?: number;
+        maxPages?: number | null;
+        max_pages?: number | null;
+    });
+}
+export declare class AudioConstraints {
+    readonly maxSizeBytes: number;
+    readonly max_size_bytes: number;
+    readonly maxDurationSeconds: number | null;
+    readonly max_duration_seconds: number | null;
+    readonly supportedFormats: readonly string[];
+    readonly supported_formats: readonly string[];
+    constructor(options: {
+        maxSizeBytes?: number;
+        max_size_bytes?: number;
+        maxDurationSeconds?: number | null;
+        max_duration_seconds?: number | null;
+        supportedFormats?: readonly string[];
+        supported_formats?: readonly string[];
+    });
+}
+export declare class VideoConstraints {
+    readonly maxSizeBytes: number;
+    readonly max_size_bytes: number;
+    readonly maxDurationSeconds: number | null;
+    readonly max_duration_seconds: number | null;
+    readonly supportedFormats: readonly string[];
+    readonly supported_formats: readonly string[];
+    constructor(options: {
+        maxSizeBytes?: number;
+        max_size_bytes?: number;
+        maxDurationSeconds?: number | null;
+        max_duration_seconds?: number | null;
+        supportedFormats?: readonly string[];
+        supported_formats?: readonly string[];
+    });
+}
+export declare class TextConstraints {
+    readonly maxSizeBytes: number;
+    readonly max_size_bytes: number;
+    readonly supportedFormats: readonly string[];
+    readonly supported_formats: readonly string[];
+    constructor(options: {
+        maxSizeBytes?: number;
+        max_size_bytes?: number;
+        supportedFormats?: readonly string[];
+        supported_formats?: readonly string[];
+    });
+}
+export declare class ProviderConstraints {
+    readonly name: string;
+    readonly image: ImageConstraints | null;
+    readonly pdf: PDFConstraints | null;
+    readonly audio: AudioConstraints | null;
+    readonly video: VideoConstraints | null;
+    readonly text: TextConstraints | null;
+    readonly generalMaxSizeBytes: number | null;
+    readonly general_max_size_bytes: number | null;
+    readonly supportsFileUpload: boolean;
+    readonly supports_file_upload: boolean;
+    readonly fileUploadThresholdBytes: number | null;
+    readonly file_upload_threshold_bytes: number | null;
+    readonly supportsUrlReferences: boolean;
+    readonly supports_url_references: boolean;
+    constructor(options: {
+        name: string;
+        image?: ImageConstraints | null;
+        pdf?: PDFConstraints | null;
+        audio?: AudioConstraints | null;
+        video?: VideoConstraints | null;
+        text?: TextConstraints | null;
+        generalMaxSizeBytes?: number | null;
+        general_max_size_bytes?: number | null;
+        supportsFileUpload?: boolean;
+        supports_file_upload?: boolean;
+        fileUploadThresholdBytes?: number | null;
+        file_upload_threshold_bytes?: number | null;
+        supportsUrlReferences?: boolean;
+        supports_url_references?: boolean;
+    });
+}
+export declare const ANTHROPIC_CONSTRAINTS: ProviderConstraints;
+export declare const OPENAI_RESPONSES_CONSTRAINTS: ProviderConstraints;
+export declare const OPENAI_CONSTRAINTS: ProviderConstraints;
+export declare const GEMINI_CONSTRAINTS: ProviderConstraints;
+export declare const BEDROCK_CONSTRAINTS: ProviderConstraints;
+export declare const AZURE_CONSTRAINTS: ProviderConstraints;
+export declare function getConstraintsForProvider(provider: string | ProviderConstraints): ProviderConstraints | null;
+export declare const get_constraints_for_provider: typeof getConstraintsForProvider;
+export declare function usesOpenAIResponsesApi(provider: string, api?: string | null): boolean;
+export declare const uses_openai_responses_api: typeof usesOpenAIResponsesApi;
+export declare function getSupportedContentTypes(provider: string, api?: string | null): string[];
+export declare const get_supported_content_types: typeof getSupportedContentTypes;
+export declare function validateImage(file: ImageFile, constraints: ImageConstraints, options?: {
+    raiseOnError?: boolean;
+    raise_on_error?: boolean;
+}): string[];
+export declare const validate_image: typeof validateImage;
+export declare function validatePDF(file: PDFFile, constraints: PDFConstraints, options?: {
+    raiseOnError?: boolean;
+    raise_on_error?: boolean;
+}): string[];
+export declare const validate_pdf: typeof validatePDF;
+export declare function validateAudio(file: AudioFile, constraints: AudioConstraints, options?: {
+    raiseOnError?: boolean;
+    raise_on_error?: boolean;
+    durationSeconds?: number | null;
+    duration_seconds?: number | null;
+}): string[];
+export declare const validate_audio: typeof validateAudio;
+export declare function validateVideo(file: VideoFile, constraints: VideoConstraints, options?: {
+    raiseOnError?: boolean;
+    raise_on_error?: boolean;
+    durationSeconds?: number | null;
+    duration_seconds?: number | null;
+}): string[];
+export declare const validate_video: typeof validateVideo;
+export declare function validateText(file: TextFile, constraints: ProviderConstraints, options?: {
+    raiseOnError?: boolean;
+    raise_on_error?: boolean;
+}): string[];
+export declare const validate_text: typeof validateText;
+export declare function validateFile(file: FileInput, constraints: ProviderConstraints, options?: {
+    raiseOnError?: boolean;
+    raise_on_error?: boolean;
+}): string[];
+export declare const validate_file: typeof validateFile;
+export declare class FileProcessor {
+    readonly constraints: ProviderConstraints | null;
+    constructor(options?: {
+        constraints?: ProviderConstraints | string | null;
+    } | ProviderConstraints | string | null);
+    validate(file: FileInput): string[];
+    process(file: FileInput): FileInput | FileInput[];
+    processFiles(files: Record<string, FileInput>): Record<string, FileInput>;
+    process_files(files: Record<string, FileInput>): Record<string, FileInput>;
+    aprocessFiles(files: Record<string, FileInput>): Promise<Record<string, FileInput>>;
+    aprocess_files(files: Record<string, FileInput>): Promise<Record<string, FileInput>>;
+    private fileMode;
+    private chunkProcess;
+}
+export declare function chunkText(file: TextFile, maxChars: number, options?: {
+    overlapChars?: number;
+    overlap_chars?: number;
+    splitOnNewlines?: boolean;
+    split_on_newlines?: boolean;
+}): TextFile[];
+export declare const chunk_text: typeof chunkText;
+export declare function chunkPDF(_file: PDFFile, _maxPages: number): PDFFile[];
+export declare const chunk_pdf: typeof chunkPDF;
+export declare function resizeImage(_file: ImageFile, _maxWidth: number, _maxHeight: number): ImageFile;
+export declare const resize_image: typeof resizeImage;
+export declare function optimizeImage(_file: ImageFile, _targetSizeBytes: number): ImageFile;
+export declare const optimize_image: typeof optimizeImage;
+export declare class CachedUpload {
+    readonly fileId: string;
+    readonly file_id: string;
+    readonly provider: string;
+    readonly fileUri: string | null;
+    readonly file_uri: string | null;
+    readonly contentType: string;
+    readonly content_type: string;
+    readonly uploadedAt: Date;
+    readonly uploaded_at: Date;
+    readonly expiresAt: Date | null;
+    readonly expires_at: Date | null;
+    constructor(options: {
+        fileId?: string;
+        file_id?: string;
+        provider: string;
+        fileUri?: string | null;
+        file_uri?: string | null;
+        contentType?: string;
+        content_type?: string;
+        uploadedAt?: Date;
+        uploaded_at?: Date;
+        expiresAt?: Date | null;
+        expires_at?: Date | null;
+    });
+    isExpired(now?: Date): boolean;
+    is_expired(now?: Date): boolean;
+}
+export declare class UploadCache {
+    readonly ttl: number;
+    readonly namespace: string;
+    readonly maxEntries: number | null;
+    readonly max_entries: number | null;
+    private readonly entries;
+    private readonly providerKeys;
+    private readonly accessOrder;
+    constructor(options?: {
+        ttl?: number;
+        namespace?: string;
+        cacheType?: string;
+        cache_type?: string;
+        maxEntries?: number | null;
+        max_entries?: number | null;
+    });
+    get size(): number;
+    get length(): number;
+    get(file: FileInput, provider: FileProvider): CachedUpload | null;
+    get_by_hash(fileHash: string, provider: FileProvider): CachedUpload | null;
+    getByHash(fileHash: string, provider: FileProvider): CachedUpload | null;
+    aget(file: FileInput, provider: FileProvider): Promise<CachedUpload | null>;
+    aget_by_hash(fileHash: string, provider: FileProvider): Promise<CachedUpload | null>;
+    agetByHash(fileHash: string, provider: FileProvider): Promise<CachedUpload | null>;
+    set(file: FileInput, provider: FileProvider, fileIdOrOptions: string | {
+        fileId?: string;
+        file_id?: string;
+        fileUri?: string | null;
+        file_uri?: string | null;
+        expiresAt?: Date | null;
+        expires_at?: Date | null;
+    }, fileUri?: string | null, expiresAt?: Date | null): CachedUpload;
+    set_by_hash(fileHash: string, contentType: string, provider: FileProvider, fileId: string, fileUri?: string | null, expiresAt?: Date | null): CachedUpload;
+    setByHash(fileHash: string, contentType: string, provider: FileProvider, fileId: string, fileUri?: string | null, expiresAt?: Date | null): CachedUpload;
+    aset(file: FileInput, provider: FileProvider, fileId: string, fileUri?: string | null, expiresAt?: Date | null): Promise<CachedUpload>;
+    aset_by_hash(fileHash: string, contentType: string, provider: FileProvider, fileId: string, fileUri?: string | null, expiresAt?: Date | null): Promise<CachedUpload>;
+    asetByHash(fileHash: string, contentType: string, provider: FileProvider, fileId: string, fileUri?: string | null, expiresAt?: Date | null): Promise<CachedUpload>;
+    remove(file: FileInput, provider: FileProvider): boolean;
+    aremove(file: FileInput, provider: FileProvider): Promise<boolean>;
+    removeByFileId(fileId: string, provider: FileProvider): boolean;
+    remove_by_file_id(fileId: string, provider: FileProvider): boolean;
+    aremove_by_file_id(fileId: string, provider: FileProvider): Promise<boolean>;
+    clearExpired(): number;
+    clear_expired(): number;
+    aclear_expired(): Promise<number>;
+    clear(): number;
+    aclear(): Promise<number>;
+    getAllForProvider(provider: FileProvider): CachedUpload[];
+    get_all_for_provider(provider: FileProvider): CachedUpload[];
+    aget_all_for_provider(provider: FileProvider): Promise<CachedUpload[]>;
+    getProviders(): Set<string>;
+    get_providers(): Set<string>;
+    private getCachedByKey;
+    private trackKey;
+    private untrackKey;
+    private evictIfNeeded;
+}
+export declare function getUploadCache(options?: {
+    ttl?: number;
+    namespace?: string;
+    cacheType?: string;
+    cache_type?: string;
+    maxEntries?: number | null;
+    max_entries?: number | null;
+}): UploadCache;
+export declare const get_upload_cache: typeof getUploadCache;
+export declare function resetUploadCache(): void;
+export declare const reset_upload_cache: typeof resetUploadCache;
+export declare abstract class FileSource {
+    abstract readonly filename: string | null;
+    abstract readonly contentType: string;
+    get content_type(): string;
+    abstract read(): Uint8Array;
+    aread(): Promise<Uint8Array>;
+    readChunks(chunkSize?: number): IterableIterator<Uint8Array>;
+    read_chunks(chunkSize?: number): IterableIterator<Uint8Array>;
+}
+type FileUrlFetchResult = {
+    content: Uint8Array | Buffer | string;
+    contentType?: string | null;
+};
+type FileUrlFetcher = (url: string) => FileUrlFetchResult | Promise<FileUrlFetchResult>;
+export declare class FilePath extends FileSource {
+    readonly path: string;
+    readonly maxSizeBytes: number;
+    readonly max_size_bytes: number;
+    readonly contentType: string;
+    private content;
+    constructor(options: {
+        path: string;
+        maxSizeBytes?: number;
+        max_size_bytes?: number;
+    });
+    get filename(): string;
+    read(): Uint8Array;
+}
+export declare class FileBytes extends FileSource {
+    readonly data: Uint8Array;
+    readonly filename: string | null;
+    readonly contentType: string;
+    constructor(options: {
+        data: Uint8Array | Buffer | string;
+        filename?: string | null;
+    });
+    read(): Uint8Array;
+}
+export declare class FileStream extends FileSource {
+    readonly stream: FileReadable;
+    filename: string | null;
+    readonly contentType: string;
+    private content;
+    constructor(options: {
+        stream: FileReadable;
+        filename?: string | null;
+    });
+    read(): Uint8Array;
+    close(): void;
+}
+export declare class FileUrl extends FileSource {
+    readonly url: string;
+    readonly filename: string | null;
+    private detectedContentType;
+    private content;
+    private readonly fetcher;
+    constructor(options: {
+        url: string;
+        filename?: string | null;
+        fetcher?: FileUrlFetcher | null;
+    });
+    get contentType(): string;
+    read(): Uint8Array;
+    aread(): Promise<Uint8Array>;
+    private applyFetchedContent;
+}
+export declare abstract class BaseFile {
+    readonly source: FileSource;
+    readonly mode: FileMode;
+    constructor(options: {
+        source: FileSourceInput;
+        mode?: FileMode;
+    } | FileSourceInput);
+    get filename(): string | null;
+    get contentType(): string;
+    get content_type(): string;
+    read(): Uint8Array;
+    aread(): Promise<Uint8Array>;
+    readText(encoding?: BufferEncoding): string;
+    read_text(encoding?: BufferEncoding): string;
+    keys(): string[];
+    getItem(key: string): this;
+    __getitem__(key: string): this;
+    protected unpackKey(): string;
+}
+export declare class ImageFile extends BaseFile {
+}
+export declare class PDFFile extends BaseFile {
+}
+export declare class TextFile extends BaseFile {
+}
+export declare class AudioFile extends BaseFile {
+}
+export declare class VideoFile extends BaseFile {
+}
+export declare class File extends BaseFile {
+}
+export declare function detectContentType(data: Uint8Array | Buffer | string, filename?: string | null): string;
+export declare const detect_content_type: typeof detectContentType;
+export declare function wrapFileSource(source: FileSource): FileInput;
+export declare const wrap_file_source: typeof wrapFileSource;
+export declare function normalizeInputFiles(inputFiles: readonly (FileSourceInput | FileInput)[]): Record<string, FileInput>;
+export declare const normalize_input_files: typeof normalizeInputFiles;
+export declare class FileResolverConfig {
+    readonly preferUpload: boolean;
+    readonly prefer_upload: boolean;
+    readonly uploadThresholdBytes: number | null;
+    readonly upload_threshold_bytes: number | null;
+    readonly useBytesForBedrock: boolean;
+    readonly use_bytes_for_bedrock: boolean;
+    constructor(options?: {
+        preferUpload?: boolean;
+        prefer_upload?: boolean;
+        uploadThresholdBytes?: number | null;
+        upload_threshold_bytes?: number | null;
+        useBytesForBedrock?: boolean;
+        use_bytes_for_bedrock?: boolean;
+    });
+}
+export declare class FileResolver {
+    readonly config: FileResolverConfig;
+    readonly uploadCache: UploadCache | null;
+    readonly upload_cache: UploadCache | null;
+    constructor(options?: {
+        config?: FileResolverConfig | ConstructorParameters<typeof FileResolverConfig>[0];
+        uploadCache?: UploadCache | null;
+        upload_cache?: UploadCache | null;
+    });
+    resolve(file: FileInput, provider: FileProvider): ResolvedFileType;
+    aresolve(file: FileInput, provider: FileProvider): Promise<ResolvedFileType>;
+    resolveFiles(files: Record<string, FileInput>, provider: FileProvider): Record<string, ResolvedFileType>;
+    resolve_files(files: Record<string, FileInput>, provider: FileProvider): Record<string, ResolvedFileType>;
+    aresolveFiles(files: Record<string, FileInput>, provider: FileProvider, maxConcurrency?: number): Promise<Record<string, ResolvedFileType>>;
+    aresolve_files(files: Record<string, FileInput>, provider: FileProvider, max_concurrency?: number): Promise<Record<string, ResolvedFileType>>;
+    getCachedUploads(provider: FileProvider): CachedUpload[];
+    get_cached_uploads(provider: FileProvider): CachedUpload[];
+    clearCache(): void;
+    clear_cache(): void;
+    private resolveCachedUpload;
+    private shouldUseUpload;
+}
+export type CreateResolverOptions = ConstructorParameters<typeof FileResolverConfig>[0] & {
+    provider?: FileProvider | null;
+    enableCache?: boolean;
+    enable_cache?: boolean;
+};
+export declare function createResolver(options?: FileResolverConfig | CreateResolverOptions): FileResolver;
+export declare const create_resolver: typeof createResolver;
+export type MultimodalContentApi = "completions" | "responses";
+export declare function formatMultimodalContent(files: Record<string, FileInput>, provider: string, options?: {
+    api?: MultimodalContentApi;
+    text?: string | null;
+} | MultimodalContentApi): Record<string, unknown>[];
+export declare function format_multimodal_content(files: Record<string, FileInput>, provider: string, options?: {
+    api?: MultimodalContentApi;
+    text?: string | null;
+} | MultimodalContentApi): Record<string, unknown>[];
+export {};

package/dist/flow-conversation.d.ts

@@ -0,0 +1,90 @@
+import type { LLM } from "./llm.js";
+import type { LLMMessage } from "./types.js";
+export type ConversationalInputs = {
+    id?: string;
+    user_message?: string | Record<string, unknown>;
+    last_intent?: string;
+};
+export declare const ConversationalInputs: Readonly<{
+    kind: "ConversationalInputs";
+}>;
+export type ConversationalConfigOptions = {
+    defaultIntents?: readonly string[] | null;
+    default_intents?: readonly string[] | null;
+    intentLlm?: string | null;
+    intent_llm?: string | null;
+    interactivePrompt?: string;
+    interactive_prompt?: string;
+    interactiveTimeout?: number | null;
+    interactive_timeout?: number | null;
+    exitCommands?: readonly string[];
+    exit_commands?: readonly string[];
+    deferTraceFinalization?: boolean;
+    defer_trace_finalization?: boolean;
+};
+export declare class ConversationalConfig {
+    readonly defaultIntents: readonly string[] | null;
+    readonly default_intents: readonly string[] | null;
+    readonly intentLlm: string | null;
+    readonly intent_llm: string | null;
+    readonly interactivePrompt: string;
+    readonly interactive_prompt: string;
+    readonly interactiveTimeout: number | null;
+    readonly interactive_timeout: number | null;
+    readonly exitCommands: readonly string[];
+    readonly exit_commands: readonly string[];
+    readonly deferTraceFinalization: boolean;
+    readonly defer_trace_finalization: boolean;
+    constructor(options?: ConversationalConfigOptions);
+}
+export declare class ChatState {
+    id: string;
+    messages: LLMMessage[];
+    last_user_message: string | null;
+    lastUserMessage: string | null;
+    last_intent: string | null;
+    lastIntent: string | null;
+    session_ready: boolean;
+    sessionReady: boolean;
+    constructor(options?: {
+        id?: string;
+        messages?: readonly LLMMessage[];
+        last_user_message?: string | null;
+        lastUserMessage?: string | null;
+        last_intent?: string | null;
+        lastIntent?: string | null;
+        session_ready?: boolean;
+        sessionReady?: boolean;
+    });
+}
+export declare function normalizeKickoffInputs(inputs: Record<string, unknown> | null | undefined, options?: {
+    userMessage?: string | Record<string, unknown> | null;
+    user_message?: string | Record<string, unknown> | null;
+    sessionId?: string | null;
+    session_id?: string | null;
+}): Record<string, unknown> | null;
+export declare const normalize_kickoff_inputs: typeof normalizeKickoffInputs;
+export declare function getConversationMessages(flow: unknown): LLMMessage[];
+export declare const get_conversation_messages: typeof getConversationMessages;
+export declare function appendMessage(flow: unknown, role: LLMMessage["role"], content: string, extra?: Record<string, unknown>): void;
+export declare const append_message: typeof appendMessage;
+export declare function setStateField(flow: unknown, name: string, value: unknown): void;
+export declare const set_state_field: typeof setStateField;
+export declare function receiveUserMessage(flow: unknown, text: string, options?: {
+    outcomes?: readonly string[] | null;
+    llm?: string | LLM | null;
+}): string;
+export declare const receive_user_message: typeof receiveUserMessage;
+export declare function prepareConversationalTurn(flow: unknown, options?: {
+    userMessage?: string | Record<string, unknown> | null;
+    user_message?: string | Record<string, unknown> | null;
+    intents?: readonly string[] | null;
+    intentLlm?: string | LLM | null;
+    intent_llm?: string | LLM | null;
+    config?: ConversationalConfig | null;
+}): void;
+export declare const prepare_conversational_turn: typeof prepareConversationalTurn;
+export declare function inputHistoryToMessages(entries: readonly unknown[]): LLMMessage[];
+export declare const input_history_to_messages: typeof inputHistoryToMessages;
+export declare function getConversationalConfig(flow: unknown): ConversationalConfig | null;
+export declare const get_conversational_config: typeof getConversationalConfig;