@convo-lang/convo-lang/src/lib/HttpConvoCompletionService.d.ts

The language of AI

import { CancelToken, HttpClientRequestOptions, Scope, ScopeRegistration } from "@iyio/common";
import type { ZodType } from "zod";
import { ConvoRagSearch, ConvoRagSearchResult, ConvoRagService } from "./convo-rag-types.js";
import { ConvoCompletionCtx, ConvoCompletionMessage, ConvoCompletionService, ConvoCompletionServiceFeatureSupport, ConvoEmbeddingsGenerationRequest, ConvoEmbeddingsGenerationResult, ConvoEmbeddingsGenerationSupportRequest, ConvoEmbeddingsService, ConvoModelInfo, ConvoTranscriptionRequest, ConvoTranscriptionResult, ConvoTranscriptionService, ConvoTranscriptionSupportRequest, ConvoTtsRequest, ConvoTtsResult, ConvoTtsService, FlatConvoConversationBase } from "./convo-types.js";
import type { ConvoDb, ConvoDbCommand, ConvoDbCommandResult, ConvoNode, ConvoNodeEdge, ConvoNodeEdgeQuery, ConvoNodeEdgeQueryResult, ConvoNodeEdgeUpdate, ConvoNodeEmbedding, ConvoNodeEmbeddingQuery, ConvoNodeEmbeddingQueryResult, ConvoNodeEmbeddingUpdate, ConvoNodeKeySelection, ConvoNodePermissionType, ConvoNodeQuery, ConvoNodeQueryResult, ConvoNodeStreamItem, ConvoNodeUpdate, DeleteConvoNodeEdgeOptions, DeleteConvoNodeEmbeddingOptions, DeleteConvoNodeOptions, InsertConvoNodeEdgeOptions, InsertConvoNodeEmbeddingOptions, InsertConvoNodeOptions, UpdateConvoNodeEdgeOptions, UpdateConvoNodeEmbeddingOptions, UpdateConvoNodeOptions } from "./db/convo-db-types.js";
import { ConvoDbAuthManager } from "./db/ConvoDbAuthManager.js";
import { PromiseResultType, PromiseResultTypeVoid } from "./result-type.js";
export declare const defaultConvoHttpEndpointPrefix = "/convo-lang";
export declare const defaultConvoHttpApiEndpointPrefix: string;
export declare const httpConvoCompletionEndpointParam: import("@iyio/common").ParamTypeDef<string>;
export declare const getHttpConvoCompletionServiceForEndpoint: (endpoint: string) => HttpConvoCompletionService;
export declare const convoHttpRelayModule: (scope: ScopeRegistration) => void;
export interface HttpConvoCompletionServiceOptions {
    /**
     * Endpoint to relay messages to. If an array is provided load balancing will be preformed
     * by evenly distributing request between each URL.
     */
    endpoint: string | string[];
    /**
     * Allows http request options to be customize
     */
    getRequestOptions?: () => HttpClientRequestOptions | Promise<HttpClientRequestOptions>;
    /**
     * Name of the database the ConvoDb functions use.
     * @default 'default'
     */
    dbName?: string;
}
/**
 * Forwards messages to an convo-lang api endpoint or pool of convo-lang api endpoints.
 *
 * ## Endpoint structure
 *
 * ### POST /completion (flat:FlatConvoConversationBase) => ConvoCompletionMessage[]
 * Completes a posted flat conversation and returns the completed messages.
 *
 * ### POST /convo (convo:string) => string
 * Completes a convo conversation as a string and returns the completed messages as a string
 *
 * ### GET /models ()=>ConvoModelInfo[]
 * Returns all models known to the server
 */
export declare class HttpConvoCompletionService implements ConvoCompletionService<FlatConvoConversationBase, ConvoCompletionMessage[]>, ConvoRagService, ConvoTranscriptionService, ConvoTtsService, ConvoEmbeddingsService, ConvoDb {
    readonly serviceId = "http";
    readonly auth: ConvoDbAuthManager;
    static fromScope(scope: Scope, endpoint?: string | string[], getRequestOptions?: () => HttpClientRequestOptions | Promise<HttpClientRequestOptions>): HttpConvoCompletionService;
    readonly inputType = "FlatConvoConversation";
    readonly outputType = "ConvoCompletionMessageAry";
    private readonly endpoint;
    readonly dbName: string;
    private readonly getRequestOptions?;
    constructor({ endpoint, getRequestOptions, dbName, }: HttpConvoCompletionServiceOptions);
    initAsync(): PromiseResultTypeVoid;
    private _isDisposed;
    get isDisposed(): boolean;
    dispose(): void;
    canComplete(model: string | undefined, flat: FlatConvoConversationBase): boolean;
    private endpointIndex;
    private getEndpoint;
    getNodeByPathAsync(path: string, permissionFrom?: string): PromiseResultType<ConvoNode | undefined>;
    requireNodeByPathAsync(path: string, permissionFrom?: string): PromiseResultType<ConvoNode>;
    completeConvoAsync(flat: FlatConvoConversationBase, _: FlatConvoConversationBase, ctx: ConvoCompletionCtx<FlatConvoConversationBase, ConvoCompletionMessage[]>): Promise<ConvoCompletionMessage[]>;
    private supportMap;
    getSupportAsync(modelName: string): Promise<ConvoCompletionServiceFeatureSupport>;
    private _getSupportAsync;
    getModelsAsync(): Promise<ConvoModelInfo[] | undefined>;
    relayConvertConvoToInputAsync(flat: FlatConvoConversationBase, inputType?: string): Promise<FlatConvoConversationBase>;
    searchAsync(search: ConvoRagSearch): Promise<ConvoRagSearchResult>;
    private transcribeSupportCache;
    canTranscribe(request: ConvoTranscriptionSupportRequest): Promise<boolean>;
    private _canTranscribe;
    transcribeAsync(request: ConvoTranscriptionRequest): Promise<ConvoTranscriptionResult>;
    canConvertToSpeech(request: ConvoTtsRequest): Promise<boolean>;
    private _canConvertToSpeech;
    convertToSpeechAsync(request: ConvoTtsRequest): Promise<ConvoTtsResult>;
    private readonly embeddingsSupportCache;
    canGenerateEmbeddings(request: ConvoEmbeddingsGenerationSupportRequest): PromiseResultType<boolean>;
    private _canGenerateEmbeddings;
    generateEmbeddingsAsync(request: ConvoEmbeddingsGenerationRequest): PromiseResultType<ConvoEmbeddingsGenerationResult>;
    private requestAsync;
    streamNodesAsync<TKeys extends ConvoNodeKeySelection = undefined>(query: ConvoNodeQuery<TKeys>, cancel?: CancelToken): AsyncIterableIterator<ConvoNodeStreamItem<TKeys extends null | undefined ? keyof ConvoNode : TKeys extends "*" ? keyof ConvoNode : TKeys extends keyof ConvoNode ? TKeys : TKeys extends (infer U)[] ? "*" extends U ? keyof ConvoNode : Exclude<U, "*" | null | undefined> & keyof ConvoNode : keyof ConvoNode>>;
    executeCommandAsync<TKeys extends ConvoNodeKeySelection = '*'>(command: ConvoDbCommand<TKeys>): PromiseResultType<ConvoDbCommandResult<TKeys>>;
    executeCommandsAsync(commands: ConvoDbCommand<any>[]): PromiseResultType<ConvoDbCommandResult<any>[]>;
    queryNodesAsync<TKeys extends ConvoNodeKeySelection = undefined>(query: ConvoNodeQuery<TKeys>): PromiseResultType<ConvoNodeQueryResult<TKeys extends null | undefined ? keyof ConvoNode : TKeys extends "*" ? keyof ConvoNode : TKeys extends keyof ConvoNode ? TKeys : TKeys extends (infer U)[] ? "*" extends U ? keyof ConvoNode : Exclude<U, "*" | null | undefined> & keyof ConvoNode : keyof ConvoNode>>;
    private proxyDriverCallAsync;
    readonly _driver: {
        selectEdgesByPathsAsync: (...args: any[]) => Promise<any>;
        selectNodesByPathsAsync: (...args: any[]) => Promise<any>;
        selectNodePathsForPathAsync: (...args: any[]) => Promise<any>;
        selectNodePathsForConditionAsync: (...args: any[]) => Promise<any>;
        selectNodePathsForPermissionAsync: (...args: any[]) => Promise<any>;
        selectNodePathsForEmbeddingAsync: (...args: any[]) => Promise<any>;
        selectEdgeNodePathsForConditionAsync: (...args: any[]) => Promise<any>;
        insertNodeAsync: (...args: any[]) => Promise<any>;
        updateNodeAsync: (...args: any[]) => Promise<any>;
        deleteNodeAsync: (...args: any[]) => Promise<any>;
        insertEdgeAsync: (...args: any[]) => Promise<any>;
        updateEdgeAsync: (...args: any[]) => Promise<any>;
        deleteEdgeAsync: (...args: any[]) => Promise<any>;
        insertEmbeddingAsync: (...args: any[]) => Promise<any>;
        deleteEmbeddingAsync: (...args: any[]) => Promise<any>;
        updateEmbeddingAsync: (...args: any[]) => Promise<any>;
        queryEdgesAsync: (...args: any[]) => Promise<any>;
        queryEmbeddingsAsync: (...args: any[]) => Promise<any>;
        hasBlobAsync: (...args: any[]) => Promise<any>;
        openBlobAsync: (path: string) => PromiseResultType<ReadableStream>;
        writeBlobAsync: (path: string, blob: string | Blob | ReadableStream) => PromiseResultTypeVoid;
    };
    private _openBlobAsync;
    readBlobStringAsync(path: string, permissionFrom?: string): PromiseResultType<string | undefined>;
    private _writeBlobAsync;
    openBlobAsync(path: string, permissionFrom?: string): PromiseResultType<ReadableStream>;
    writeBlobAsync(path: string, blob: string | Blob | ReadableStream | null, permissionFrom?: string): PromiseResultTypeVoid;
    hasBlobAsync(path: string, permissionFrom?: string): PromiseResultType<boolean>;
    getNodesByPathAsync(path: string, permissionFrom?: string): PromiseResultType<ConvoNodeQueryResult<keyof ConvoNode>>;
    getNodePermissionAsync(fromPath: string, toPath: string): PromiseResultType<ConvoNodePermissionType>;
    checkNodePermissionAsync(fromPath: string, toPath: string, type: ConvoNodePermissionType, matchAny?: boolean): PromiseResultTypeVoid;
    insertNodeAsync(node: ConvoNode, options?: InsertConvoNodeOptions): PromiseResultType<ConvoNode>;
    updateNodeAsync(node: ConvoNodeUpdate, options?: UpdateConvoNodeOptions): PromiseResultTypeVoid;
    deleteNodeAsync(path: string, options?: DeleteConvoNodeOptions): PromiseResultTypeVoid;
    queryEdgesAsync(query: ConvoNodeEdgeQuery): PromiseResultType<ConvoNodeEdgeQueryResult>;
    getEdgeByIdAsync(id: string, permissionFrom?: string): PromiseResultType<ConvoNodeEdge>;
    insertEdgeAsync(edge: Omit<ConvoNodeEdge, 'id'>, options?: InsertConvoNodeEdgeOptions): PromiseResultType<ConvoNodeEdge>;
    updateEdgeAsync(update: ConvoNodeEdgeUpdate, options?: UpdateConvoNodeEdgeOptions): PromiseResultTypeVoid;
    deleteEdgeAsync(id: string, options?: DeleteConvoNodeEdgeOptions): PromiseResultTypeVoid;
    queryEmbeddingsAsync(query: ConvoNodeEmbeddingQuery): PromiseResultType<ConvoNodeEmbeddingQueryResult>;
    getEmbeddingByIdAsync(id: string, permissionFrom?: string): PromiseResultType<ConvoNodeEmbedding>;
    insertEmbeddingAsync(embedding: Omit<ConvoNodeEmbedding, 'id'>, options?: InsertConvoNodeEmbeddingOptions): PromiseResultType<ConvoNodeEmbedding>;
    updateEmbeddingAsync(update: ConvoNodeEmbeddingUpdate, options?: UpdateConvoNodeEmbeddingOptions): PromiseResultTypeVoid;
    deleteEmbeddingAsync(id: string, options?: DeleteConvoNodeEmbeddingOptions): PromiseResultTypeVoid;
    callFunctionAsync<T extends Record<string, any> = Record<string, any>>(path: string, args: Record<string, any>, permissionFrom?: string): PromiseResultType<T | undefined>;
    callFunctionWithSchemaAsync<TInput, TOutput>(inputSchema: ZodType<TInput>, outputSchema: ZodType<TOutput>, path: string, args: TInput, permissionFrom?: string): PromiseResultType<TOutput>;
    callFunctionReturnValueAsync<T extends Record<string, any> = Record<string, any>>(path: string, args: Record<string, any>, permissionFrom?: string): PromiseResultType<T>;
    callFunctionReturnNodeAsync(path: string, args: Record<string, any>, permissionFrom?: string): PromiseResultType<ConvoNode | undefined>;
}