@fine-dev/fine-js/dist/module/ai.d.ts

Javascript client for Fine BaaS

import { Fetch } from "./types";
export type AIConfig = {
    baseUrl: string;
    fetch: Fetch;
};
export type AIThreadData = {
    id: string;
    object: "thread";
    createdAt: number;
    metadata: Record<string, unknown>;
};
export type AIMessageContent = {
    type: "text";
    text: string;
} | {
    type: "image";
    imageUrl: string;
};
export type AIMessageAttachment = {
    data: string;
    name: string;
};
export type AIMessageData = {
    id: string;
    threadId: string;
    status: "in_progress" | "completed" | "incomplete";
    content: AIMessageContent;
    role: "assistant" | "user";
    assistantId?: string | null;
    createdAt: number;
    completedAt?: number | null;
    metadata: Record<string, unknown>;
    attachments?: AIMessageAttachment[];
};
type MessageRunResult = {
    runId: string;
    status: "completed";
    object: "thread.run";
    threadId: string;
    assistantId: string;
    messageId: string;
    content: string;
} | {
    runId: string;
    status: "failed";
    error: string;
} | {
    error: string;
};
type ListOrSingle<T> = T | T[];
export default class FineAIClient {
    private config;
    constructor({ baseUrl, headers, fetch: customFetch }: {
        baseUrl: string;
        fetch?: Fetch;
        headers?: HeadersInit;
    });
    get threads(): Promise<FineAIThread[]>;
    thread(threadId: string): FineAIThread;
    message(assistantId: string, content: ListOrSingle<string | AIMessageContent>): FineAIMessage;
}
declare class FineAIThread {
    id: string;
    private config;
    private threadData?;
    constructor(id: string, config: AIConfig, threadData?: AIThreadData | undefined);
    get data(): AIThreadData | Promise<AIThreadData>;
    get messages(): Promise<AIMessageData>;
    update(metadata: Record<string, unknown>): Promise<AIThreadData>;
    delete(): Promise<undefined>;
    message(assistantId: string, content: ListOrSingle<string | AIMessageContent>): FineAIMessage;
    private makeThreadRequest;
}
type AIStreamEvent = {
    type: "runStarted";
    runId: string;
    threadId: string;
    messageId: string;
} | {
    type: "runError";
    runId: string;
    error: string;
} | {
    type: "contentChunk";
    chunk: string;
} | {
    type: "runCompleted";
    runId: string;
    fullResponse: string;
};
type StreamCallback = (event: AIStreamEvent) => void;
declare class FineAIMessage {
    private config;
    private assistantId;
    private threadId?;
    private content;
    private metadata;
    private attachments;
    constructor(config: AIConfig, assistantId: string, content: ListOrSingle<string | AIMessageContent>, threadId?: string | undefined);
    setMetadata(metadata: Record<string, unknown>): this;
    attach(files: File | File[]): this;
    send(): Promise<MessageRunResult>;
    stream(callback: StreamCallback): Promise<ReadableStreamDefaultReader<Uint8Array<ArrayBufferLike>>>;
    private prepareBody;
    private readStream;
}
export {};
//# sourceMappingURL=ai.d.ts.map