@llumiverse/drivers 0.9.2 → 0.11.0

package/lib/types/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./bedrock/index.js";
+export * from "./huggingface_ie.js";
+export * from "./mistral/index.js";
+export * from "./openai.js";
+export * from "./replicate.js";
+export * from "./test/index.js";
+export * from "./togetherai/index.js";
+export * from "./vertexai/index.js";

package/lib/types/src/mistral/index.d.ts

@@ -0,0 +1,23 @@
+import { AIModel, AbstractDriver, Completion, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, PromptSegment } from "@llumiverse/core";
+import { OpenAITextMessage } from "@llumiverse/core/formatters";
+import { FetchClient } from "api-fetch-client";
+import { ResponseFormat } from "./types.js";
+interface MistralAIDriverOptions extends DriverOptions {
+    apiKey: string;
+    endpoint_url?: string;
+}
+export declare class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, OpenAITextMessage[]> {
+    provider: string;
+    apiKey: string;
+    client: FetchClient;
+    endpointUrl?: string;
+    constructor(options: MistralAIDriverOptions);
+    getResponseFormat: (_options: ExecutionOptions) => ResponseFormat | undefined;
+    protected formatPrompt(segments: PromptSegment[], opts: ExecutionOptions): OpenAITextMessage[];
+    requestCompletion(messages: OpenAITextMessage[], options: ExecutionOptions): Promise<Completion<any>>;
+    requestCompletionStream(messages: OpenAITextMessage[], options: ExecutionOptions): Promise<AsyncIterable<string>>;
+    listModels(): Promise<AIModel<string>[]>;
+    validateConnection(): Promise<boolean>;
+    generateEmbeddings({ content, model }: EmbeddingsOptions): Promise<EmbeddingsResult>;
+}
+export {};

package/lib/types/src/mistral/types.d.ts

@@ -0,0 +1,130 @@
+export interface ModelPermission {
+    id: string;
+    object: 'model_permission';
+    created: number;
+    allow_create_engine: boolean;
+    allow_sampling: boolean;
+    allow_logprobs: boolean;
+    allow_search_indices: boolean;
+    allow_view: boolean;
+    allow_fine_tuning: boolean;
+    organization: string;
+    group: string | null;
+    is_blocking: boolean;
+}
+export interface Model {
+    id: string;
+    object: 'model';
+    created: number;
+    owned_by: string;
+    root: string | null;
+    parent: string | null;
+    permission: ModelPermission[];
+}
+export interface ListModelsResponse {
+    object: 'list';
+    data: Model[];
+}
+export interface Function {
+    name: string;
+    description: string;
+    parameters: object;
+}
+export declare enum ToolType {
+    function = "function"
+}
+export interface FunctionCall {
+    name: string;
+    arguments: string;
+}
+export interface ToolCalls {
+    id: 'null';
+    type: ToolType;
+    function: FunctionCall;
+}
+export declare enum ResponseFormats {
+    text = "text",
+    json_object = "json_object"
+}
+export declare enum ToolChoice {
+    auto = "auto",
+    any = "any",
+    none = "none"
+}
+export interface ResponseFormat {
+    type: ResponseFormats;
+}
+export interface TokenUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+export interface ChatCompletionResponseChoice {
+    index: number;
+    message: {
+        role: string;
+        content: string;
+    };
+    finish_reason: string;
+}
+export interface ChatCompletionResponseChunkChoice {
+    index: number;
+    delta: {
+        role?: string;
+        content?: string;
+        tool_calls?: ToolCalls[];
+    };
+    finish_reason: string;
+}
+export interface ChatCompletionResponse {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    model: string;
+    choices: ChatCompletionResponseChoice[];
+    usage: TokenUsage;
+}
+export interface ChatCompletionResponseChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: ChatCompletionResponseChunkChoice[];
+}
+export interface Embedding {
+    id: string;
+    object: 'embedding';
+    embedding: number[];
+}
+export interface EmbeddingResponse {
+    id: string;
+    object: 'list';
+    data: Embedding[];
+    model: string;
+    usage: TokenUsage;
+}
+export interface CompletionRequestParams {
+    model: string;
+    messages: Array<{
+        role: string;
+        name?: string;
+        content: string | string[];
+        tool_calls?: ToolCalls[];
+    }>;
+    tools?: Array<{
+        type: string;
+        function: Function;
+    }>;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    randomSeed?: number;
+    stream?: boolean;
+    /**
+     * @deprecated use safePrompt instead
+     */
+    safeMode?: boolean;
+    safePrompt?: boolean;
+    toolChoice?: ToolChoice;
+    responseFormat?: ResponseFormat;
+}

package/lib/types/src/openai.d.ts

@@ -0,0 +1,30 @@
+import { AIModel, AbstractDriver, BuiltinProviders, Completion, DataSource, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, ModelType, TrainingJob, TrainingOptions, TrainingPromptOptions } from "@llumiverse/core";
+import OpenAI from "openai";
+export interface OpenAIDriverOptions extends DriverOptions {
+    apiKey: string;
+}
+export declare class OpenAIDriver extends AbstractDriver<OpenAIDriverOptions, OpenAI.Chat.Completions.ChatCompletionMessageParam[]> {
+    inputContentTypes: string[];
+    generatedContentTypes: string[];
+    service: OpenAI;
+    provider: BuiltinProviders;
+    constructor(opts: OpenAIDriverOptions);
+    extractDataFromResponse(options: ExecutionOptions, result: OpenAI.Chat.Completions.ChatCompletion): Completion;
+    requestCompletionStream(prompt: OpenAI.Chat.Completions.ChatCompletionMessageParam[], options: ExecutionOptions): Promise<any>;
+    requestCompletion(prompt: OpenAI.Chat.Completions.ChatCompletionMessageParam[], options: ExecutionOptions): Promise<any>;
+    createTrainingPrompt(options: TrainingPromptOptions): string;
+    startTraining(dataset: DataSource, options: TrainingOptions): Promise<TrainingJob>;
+    cancelTraining(jobId: string): Promise<TrainingJob>;
+    getTrainingJob(jobId: string): Promise<TrainingJob>;
+    validateConnection(): Promise<boolean>;
+    listTrainableModels(): Promise<AIModel<string>[]>;
+    listModels(): Promise<AIModel[]>;
+    _listModels(filter?: (m: OpenAI.Models.Model) => boolean): Promise<{
+        id: string;
+        name: string;
+        provider: BuiltinProviders;
+        owner: string;
+        type: ModelType;
+    }[]>;
+    generateEmbeddings({ content, model }: EmbeddingsOptions): Promise<EmbeddingsResult>;
+}

package/lib/types/src/replicate.d.ts

@@ -0,0 +1,47 @@
+import { AIModel, AbstractDriver, BuiltinProviders, Completion, DataSource, DriverOptions, EmbeddingsResult, ExecutionOptions, ModelSearchPayload, TrainingJob, TrainingOptions } from "@llumiverse/core";
+import Replicate, { Prediction } from "replicate";
+export interface ReplicateDriverOptions extends DriverOptions {
+    apiKey: string;
+}
+export declare class ReplicateDriver extends AbstractDriver<DriverOptions, string> {
+    provider: BuiltinProviders;
+    service: Replicate;
+    static parseModelId(modelId: string): {
+        owner: string;
+        model: string;
+        version: string;
+    };
+    constructor(options: ReplicateDriverOptions);
+    extractDataFromResponse(prompt: string, response: Prediction): Completion;
+    requestCompletionStream(prompt: string, options: ExecutionOptions): Promise<AsyncIterable<string>>;
+    requestCompletion(prompt: string, options: ExecutionOptions): Promise<{
+        result: any;
+        token_usage: {
+            result: any;
+            prompt: number;
+            total: any;
+        };
+    }>;
+    startTraining(dataset: DataSource, options: TrainingOptions): Promise<TrainingJob>;
+    /**
+     * This method is not returning a consistent TrainingJob like the one returned by startTraining
+     * Instead of returning the full model name `owner/model:version` it returns only the version `version
+     * @param jobId
+     * @returns
+     */
+    cancelTraining(jobId: string): Promise<TrainingJob>;
+    /**
+     * This method is not returning a consistent TrainingJob like the one returned by startTraining
+     * Instead of returning the full model name `owner/model:version` it returns only the version `version
+     * @param jobId
+     * @returns
+     */
+    getTrainingJob(jobId: string): Promise<TrainingJob>;
+    validateConnection(): Promise<boolean>;
+    _listTrainableModels(): Promise<AIModel[]>;
+    listTrainableModels(): Promise<AIModel[]>;
+    listModels(params?: ModelSearchPayload): Promise<AIModel[]>;
+    listModelVersions(owner: string, model: string): Promise<AIModel[]>;
+    searchModels(params: ModelSearchPayload): Promise<AIModel[]>;
+    generateEmbeddings(): Promise<EmbeddingsResult>;
+}

package/lib/types/src/test/TestErrorCompletionStream.d.ts

@@ -0,0 +1,8 @@
+import { CompletionStream, ExecutionOptions, ExecutionResponse, PromptSegment } from "@llumiverse/core";
+export declare class TestErrorCompletionStream implements CompletionStream<PromptSegment[]> {
+    segments: PromptSegment[];
+    options: ExecutionOptions;
+    completion: ExecutionResponse<PromptSegment[]> | undefined;
+    constructor(segments: PromptSegment[], options: ExecutionOptions);
+    [Symbol.asyncIterator](): AsyncGenerator<string, void, unknown>;
+}

package/lib/types/src/test/TestValidationErrorCompletionStream.d.ts

@@ -0,0 +1,8 @@
+import { CompletionStream, ExecutionOptions, ExecutionResponse, PromptSegment } from "@llumiverse/core";
+export declare class TestValidationErrorCompletionStream implements CompletionStream<PromptSegment[]> {
+    segments: PromptSegment[];
+    options: ExecutionOptions;
+    completion: ExecutionResponse<PromptSegment[]> | undefined;
+    constructor(segments: PromptSegment[], options: ExecutionOptions);
+    [Symbol.asyncIterator](): AsyncGenerator<"Started TestValidationError.\n" | "chunk1\n" | "chunk2\n", void, unknown>;
+}

package/lib/types/src/test/index.d.ts

@@ -0,0 +1,23 @@
+import { AIModel, CompletionStream, Driver, EmbeddingsResult, ExecutionOptions, ExecutionResponse, PromptOptions, PromptSegment, TrainingJob } from "@llumiverse/core";
+export * from "./TestErrorCompletionStream.js";
+export * from "./TestValidationErrorCompletionStream.js";
+export declare enum TestDriverModels {
+    executionError = "execution-error",
+    validationError = "validation-error"
+}
+export declare class TestDriver implements Driver<PromptSegment[]> {
+    provider: string;
+    createTrainingPrompt(): string;
+    startTraining(): Promise<TrainingJob>;
+    cancelTraining(): Promise<TrainingJob>;
+    getTrainingJob(_jobId: string): Promise<TrainingJob>;
+    createPrompt(segments: PromptSegment[], _opts: PromptOptions): PromptSegment[];
+    execute(segments: PromptSegment[], options: ExecutionOptions): Promise<ExecutionResponse<PromptSegment[]>>;
+    stream(segments: PromptSegment[], options: ExecutionOptions): Promise<CompletionStream<PromptSegment[]>>;
+    listTrainableModels(): Promise<AIModel<string>[]>;
+    listModels(): Promise<AIModel<string>[]>;
+    validateConnection(): Promise<boolean>;
+    generateEmbeddings(): Promise<EmbeddingsResult>;
+    executeError(segments: PromptSegment[], _options: ExecutionOptions): Promise<ExecutionResponse<PromptSegment[]>>;
+    executeValidationError(segments: PromptSegment[], _options: ExecutionOptions): Promise<ExecutionResponse<PromptSegment[]>>;
+}

package/lib/types/src/test/utils.d.ts

@@ -0,0 +1,4 @@
+import { ExecutionResponse, PromptSegment } from "@llumiverse/core";
+export declare function throwError(message: string, prompt: PromptSegment[]): never;
+export declare function createValidationErrorCompletion(segments: PromptSegment[]): ExecutionResponse<PromptSegment[]>;
+export declare function sleep(ms: number): Promise<unknown>;

package/lib/types/src/togetherai/index.d.ts

@@ -0,0 +1,21 @@
+import { AIModel, AbstractDriver, Completion, DriverOptions, EmbeddingsResult, ExecutionOptions } from "@llumiverse/core";
+import { FetchClient } from "api-fetch-client";
+interface TogetherAIDriverOptions extends DriverOptions {
+    apiKey: string;
+}
+export declare class TogetherAIDriver extends AbstractDriver<TogetherAIDriverOptions, string> {
+    provider: string;
+    apiKey: string;
+    fetchClient: FetchClient;
+    constructor(options: TogetherAIDriverOptions);
+    getResponseFormat: (options: ExecutionOptions) => {
+        type: string;
+        schema: import("json-schema").JSONSchema4;
+    } | undefined;
+    requestCompletion(prompt: string, options: ExecutionOptions): Promise<Completion<any>>;
+    requestCompletionStream(prompt: string, options: ExecutionOptions): Promise<AsyncIterable<string>>;
+    listModels(): Promise<AIModel<string>[]>;
+    validateConnection(): Promise<boolean>;
+    generateEmbeddings(): Promise<EmbeddingsResult>;
+}
+export {};

package/lib/types/src/togetherai/interfaces.d.ts

@@ -0,0 +1,80 @@
+interface ModelInstanceConfig {
+    appearsIn: any[];
+    order: number;
+}
+interface Config {
+    stop: string[];
+    prompt_format: string;
+    chat_template: string;
+}
+interface Pricing {
+    input: number;
+    output: number;
+    hourly: number;
+}
+interface Instance {
+    avzone: string;
+    cluster: string;
+}
+interface Ask {
+    [key: string]: number;
+}
+interface Gpu {
+    [key: string]: number;
+}
+interface Price {
+    base: number;
+    finetune: number;
+    hourly: number;
+    input: number;
+    output: number;
+}
+interface Stat {
+    avzone: string;
+    cluster: string;
+    capacity: number;
+    qps: number;
+    throughput_in: number;
+    throughput_out: number;
+    error_rate: number;
+    retry_rate: number;
+}
+interface Depth {
+    num_asks: number;
+    num_bids: number;
+    num_running: number;
+    asks: Ask;
+    asks_updated: string;
+    gpus: Gpu;
+    qps: number;
+    permit_required: boolean;
+    price: Price;
+    throughput_in: number;
+    throughput_out: number;
+    stats: Stat[];
+}
+export interface TogetherModelInfo {
+    modelInstanceConfig: ModelInstanceConfig;
+    _id: string;
+    name: string;
+    display_name: string;
+    display_type: string;
+    description: string;
+    license: string;
+    creator_organization: string;
+    hardware_label: string;
+    num_parameters: number;
+    show_in_playground: boolean;
+    isFeaturedModel: boolean;
+    context_length: number;
+    config: Config;
+    pricing: Pricing;
+    created_at: string;
+    update_at: string;
+    instances: Instance[];
+    access: string;
+    link: string;
+    descriptionLink: string;
+    depth: Depth;
+}
+export {};

package/lib/types/src/vertexai/debug.d.ts

@@ -0,0 +1 @@
+export declare function logObject(prefix: string, obj: any): void;

package/lib/types/src/vertexai/embeddings/embeddings-text.d.ts

@@ -0,0 +1,9 @@
+import { EmbeddingsResult } from '@llumiverse/core';
+import { VertexAIDriver } from '../index.js';
+export interface TextEmbeddingsOptions {
+    model?: string;
+    task_type?: "RETRIEVAL_QUERY" | "RETRIEVAL_DOCUMENT" | "SEMANTIC_SIMILARITY" | "CLASSIFICATION" | "CLUSTERING";
+    title?: string;
+    content: string;
+}
+export declare function getEmbeddingsForText(driver: VertexAIDriver, options: TextEmbeddingsOptions): Promise<EmbeddingsResult>;

package/lib/types/src/vertexai/index.d.ts

@@ -0,0 +1,21 @@
+import { GenerateContentRequest, VertexAI } from "@google-cloud/vertexai";
+import { AIModel, AbstractDriver, BuiltinProviders, Completion, DriverOptions, EmbeddingsResult, ExecutionOptions, ModelSearchPayload, PromptOptions, PromptSegment } from "@llumiverse/core";
+import { FetchClient } from "api-fetch-client";
+import { TextEmbeddingsOptions } from "./embeddings/embeddings-text.js";
+export interface VertexAIDriverOptions extends DriverOptions {
+    project: string;
+    region: string;
+}
+export declare class VertexAIDriver extends AbstractDriver<VertexAIDriverOptions, GenerateContentRequest> {
+    provider: BuiltinProviders;
+    vertexai: VertexAI;
+    fetchClient: FetchClient;
+    constructor(options: VertexAIDriverOptions);
+    protected canStream(options: ExecutionOptions): Promise<boolean>;
+    createPrompt(segments: PromptSegment[], options: PromptOptions): GenerateContentRequest;
+    requestCompletion(prompt: GenerateContentRequest, options: ExecutionOptions): Promise<Completion<any>>;
+    requestCompletionStream(prompt: GenerateContentRequest, options: ExecutionOptions): Promise<AsyncIterable<string>>;
+    listModels(_params?: ModelSearchPayload): Promise<AIModel<string>[]>;
+    validateConnection(): Promise<boolean>;
+    generateEmbeddings(options: TextEmbeddingsOptions): Promise<EmbeddingsResult>;
+}

package/lib/types/src/vertexai/models/codey-chat.d.ts

@@ -0,0 +1,50 @@
+import { AIModel, PromptOptions, PromptSegment } from "@llumiverse/core";
+import { VertexAIDriver } from "../index.js";
+import { AbstractPalmModelDefinition, NonStreamingPromptBase, PalmResponseMetadata, StreamingPromptBase } from "./palm-model-base.js";
+export interface CodeyChatMessage {
+    author: string;
+    content: string;
+}
+export type CodeyChatPrompt = NonStreamingPromptBase<{
+    context?: string;
+    messages: CodeyChatMessage[];
+}>;
+export type CodeyChatStreamingPrompt = StreamingPromptBase<{
+    messages: {
+        listVal: {
+            structVal: {
+                author: {
+                    stringVal: string;
+                };
+                content: {
+                    stringVal: string;
+                };
+            };
+        }[];
+    };
+}>;
+interface CodeyChatResponsePrediction {
+    candidates: CodeyChatMessage[];
+    safetyAttributes: {
+        scores: number[];
+        blocked: boolean;
+        categories: string[];
+        errors: number[];
+    };
+    citationMetadata: {
+        citations: any[];
+    };
+    logprobs: any;
+}
+export interface CodeyChatResponse {
+    predictions: CodeyChatResponsePrediction[];
+    metadata: PalmResponseMetadata;
+}
+export declare class CodeyChatDefinition extends AbstractPalmModelDefinition<CodeyChatPrompt, CodeyChatStreamingPrompt> {
+    versions: string[];
+    model: AIModel;
+    createNonStreamingPrompt(_driver: VertexAIDriver, segments: PromptSegment[], opts: PromptOptions): CodeyChatPrompt;
+    extractContentFromResponse(response: CodeyChatResponse): string;
+    extractContentFromResponseChunk(chunk: any): string;
+}
+export {};

package/lib/types/src/vertexai/models/codey-text.d.ts

@@ -0,0 +1,38 @@
+import { AIModel, PromptOptions, PromptSegment } from "@llumiverse/core";
+import { VertexAIDriver } from "../index.js";
+import { AbstractPalmModelDefinition, NonStreamingPromptBase, PalmResponseMetadata, StreamingPromptBase } from "./palm-model-base.js";
+export type CodeyTextPrompt = NonStreamingPromptBase<{
+    prefix: string;
+}>;
+export type CodeyTextStreamingPrompt = StreamingPromptBase<{
+    prefix: {
+        stringVal: string;
+    };
+}>;
+interface CodeyTextResponsePrediction {
+    content: string;
+    safetyAttributes: {
+        scores: number[];
+        safetyRatings: {
+            severity: string;
+            probabilityScore: number;
+            severityScore: number;
+            category: string;
+        }[];
+    };
+    citationMetadata: {
+        citations: any[];
+    };
+}
+export interface CodeyTextResponse {
+    predictions: CodeyTextResponsePrediction[];
+    metadata: PalmResponseMetadata;
+}
+export declare class CodeyTextDefinition extends AbstractPalmModelDefinition<CodeyTextPrompt, CodeyTextStreamingPrompt> {
+    versions: string[];
+    model: AIModel;
+    createNonStreamingPrompt(_driver: VertexAIDriver, segments: PromptSegment[], opts: PromptOptions): CodeyTextPrompt;
+    extractContentFromResponse(response: CodeyTextResponse): string;
+    extractContentFromResponseChunk(chunk: any): string;
+}
+export {};

package/lib/types/src/vertexai/models/gemini.d.ts

@@ -0,0 +1,10 @@
+import { GenerateContentRequest } from "@google-cloud/vertexai";
+import { AIModel, Completion, ExecutionOptions, PromptOptions, PromptSegment } from "@llumiverse/core";
+import { VertexAIDriver } from "../index.js";
+import { ModelDefinition } from "../models.js";
+export declare class GeminiModelDefinition implements ModelDefinition<GenerateContentRequest> {
+    model: AIModel;
+    createPrompt(_driver: VertexAIDriver, segments: PromptSegment[], options: PromptOptions): GenerateContentRequest;
+    requestCompletion(driver: VertexAIDriver, prompt: GenerateContentRequest, options: ExecutionOptions): Promise<Completion>;
+    requestCompletionStream(driver: VertexAIDriver, prompt: GenerateContentRequest, options: ExecutionOptions): Promise<AsyncIterable<string>>;
+}

package/lib/types/src/vertexai/models/palm-model-base.d.ts

@@ -0,0 +1,60 @@
+import { AIModel, Completion, ExecutionOptions, PromptOptions, PromptSegment } from "@llumiverse/core";
+import { VertexAIDriver } from "../index.js";
+import { ModelDefinition } from "../models.js";
+export interface PromptParamatersBase {
+    temperature?: number;
+    maxOutputTokens?: number;
+    topK?: number;
+    topP?: number;
+    groundingConfig?: string;
+    stopSequences?: string[];
+    candidateCount?: number;
+    logprobs?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    logitBias?: Record<string, number>;
+    seed?: number;
+    echo?: boolean;
+}
+export interface NonStreamingPromptBase<InstanceType = any> {
+    instances: InstanceType[];
+    parameters: PromptParamatersBase;
+}
+export interface StreamingPromptBase<InputType = any> {
+    inputs: {
+        structVal: InputType;
+    }[];
+    parameters: {
+        structVal: {
+            temperature?: {
+                floatval: number;
+            };
+            maxOutputTokens?: {
+                intVal: number;
+            };
+            [key: string]: Record<string, any> | undefined;
+        };
+    };
+}
+export interface PalmResponseMetadata {
+    tokenMetadata: {
+        outputTokenCount: {
+            totalBillableCharacters: number;
+            totalTokens: number;
+        };
+        inputTokenCount: {
+            totalBillableCharacters: number;
+            totalTokens: number;
+        };
+    };
+}
+export declare abstract class AbstractPalmModelDefinition<NonStreamingPromptT extends NonStreamingPromptBase, StreamingPromptT extends StreamingPromptBase> implements ModelDefinition<NonStreamingPromptT | StreamingPromptT> {
+    abstract model: AIModel;
+    abstract versions?: string[];
+    abstract createNonStreamingPrompt(driver: VertexAIDriver, segments: PromptSegment[], options: PromptOptions): NonStreamingPromptT;
+    abstract extractContentFromResponse(response: any): string;
+    abstract extractContentFromResponseChunk(chunk: any): string;
+    createPrompt(driver: VertexAIDriver, segments: PromptSegment[], options: PromptOptions): NonStreamingPromptT;
+    requestCompletion(driver: VertexAIDriver, prompt: NonStreamingPromptT | StreamingPromptT, options: ExecutionOptions): Promise<Completion<any>>;
+    requestCompletionStream(driver: VertexAIDriver, prompt: NonStreamingPromptT | StreamingPromptT, options: ExecutionOptions): Promise<AsyncIterable<string>>;
+}

package/lib/types/src/vertexai/models/palm2-chat.d.ts

@@ -0,0 +1,60 @@
+import { AIModel, PromptOptions, PromptSegment } from "@llumiverse/core";
+import { VertexAIDriver } from "../index.js";
+import { AbstractPalmModelDefinition, NonStreamingPromptBase, PalmResponseMetadata, StreamingPromptBase } from "./palm-model-base.js";
+export interface Palm2ChatMessage {
+    author: string;
+    content: string;
+}
+export type Palm2ChatPrompt = NonStreamingPromptBase<{
+    context?: string;
+    examples?: [
+        {
+            input: {
+                content: string;
+            };
+            output: {
+                content: string;
+            };
+        }
+    ];
+    messages: Palm2ChatMessage[];
+}>;
+export type Palm2ChatStreamingPrompt = StreamingPromptBase<{
+    messages: {
+        listVal: {
+            structVal: {
+                author: {
+                    stringVal: string;
+                };
+                content: {
+                    stringVal: string;
+                };
+            };
+        }[];
+    };
+}>;
+interface Palm2ChatResponsePrediction {
+    candidates: Palm2ChatMessage[];
+    safetyAttributes: {
+        scores: number[];
+        blocked: boolean;
+        categories: string[];
+        errors: number[];
+    };
+    citationMetadata: {
+        citations: any[];
+    };
+    logprobs: any;
+}
+export interface Palm2ChatResponse {
+    predictions: Palm2ChatResponsePrediction[];
+    metadata: PalmResponseMetadata;
+}
+export declare class Palm2ChatDefinition extends AbstractPalmModelDefinition<Palm2ChatPrompt, Palm2ChatStreamingPrompt> {
+    versions: string[];
+    model: AIModel;
+    createNonStreamingPrompt(_driver: VertexAIDriver, segments: PromptSegment[], opts: PromptOptions): Palm2ChatPrompt;
+    extractContentFromResponse(response: Palm2ChatResponse): string;
+    extractContentFromResponseChunk(chunk: any): string;
+}
+export {};