@llumiverse/drivers 0.8.4 → 0.9.0

package/src/mistral/types.ts

@@ -0,0 +1,211 @@
+// Copied from https://github.com/mistralai/client-js/blob/main/src/client.d.ts
+// MistralAI Types
+
+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 enum ToolType {
+    function = 'function',
+}
+
+export interface FunctionCall {
+    name: string;
+    arguments: string;
+}
+
+export interface ToolCalls {
+    id: 'null';
+    type: ToolType;
+    function: FunctionCall;
+}
+
+export enum ResponseFormats {
+    text = 'text',
+    json_object = 'json_object',
+}
+
+export 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
+}
+
+// class MistralClient {
+//     constructor(apiKey?: string, endpoint?: string);
+
+//     private _request(
+//         method: string,
+//         path: string,
+//         request: unknown
+//     ): Promise<unknown>;
+
+//     private _makeChatCompletionRequest(
+//         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
+//     ): object;
+
+//     listModels(): Promise<ListModelsResponse>;
+
+//     chat(options: {
+//         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;
+//         /**
+//          * @deprecated use safePrompt instead
+//          */
+//         safeMode?: boolean;
+//         safePrompt?: boolean;
+//         toolChoice?: ToolChoice;
+//         responseFormat?: ResponseFormat;
+//     }): Promise<ChatCompletionResponse>;
+
+//     chatStream(options: {
+//         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;
+//         /**
+//          * @deprecated use safePrompt instead
+//          */
+//         safeMode?: boolean;
+//         safePrompt?: boolean;
+//         toolChoice?: ToolChoice;
+//         responseFormat?: ResponseFormat;
+//     }): AsyncGenerator<ChatCompletionResponseChunk, void, unknown>;
+
+//     embeddings(options: {
+//         model: string;
+//         input: string | string[];
+//     }): Promise<EmbeddingResponse>;
+// }

package/src/togetherai/index.ts

@@ -1,5 +1,6 @@
 import { AIModel, AbstractDriver, Completion, DriverOptions, ExecutionOptions, PromptFormats } from "@llumiverse/core";
-import { FetchClient, ServerSentEvent } from "api-fetch-client";
+import { transformSSEStream } from "@llumiverse/core/async";
+import { FetchClient } from "api-fetch-client";
 import { TogetherModelInfo } from "./interfaces.js";
 
 interface TogetherAIDriverOptions extends DriverOptions {
@@ -75,19 +76,10 @@ export class TogetherAIDriver extends AbstractDriver<TogetherAIDriverOptions, st
             reader: 'sse'
         })
 
-        return stream.pipeThrough(new TransformStream<ServerSentEvent, string>({
-            transform(event: ServerSentEvent, controller) {
-                if (event.type === 'event' && event.data && event.data !== '[DONE]') {
-                    try {
-                        const data = JSON.parse(event.data);
-                        controller.enqueue(data.choices[0]?.text ?? '');
-                    } catch (err) {
-                        // double check for the last event whicb is not a JSON - at this time togetherai returrns the string [DONE]
-                        // do nothing - happens if data is not a JSON - the last event data is the [DONE] string
-                    }
-                }
-            }
-        }));
+        return transformSSEStream(stream, (data: string) => {
+            const json = JSON.parse(data);
+            return json.choices[0]?.text ?? '';
+        });
 
     }
 

package/src/vertexai/models/palm-model-base.ts

@@ -1,9 +1,9 @@
 import { AIModel, Completion, ExecutionOptions, PromptOptions, PromptSegment } from "@llumiverse/core";
+import { transformSSEStream } from "@llumiverse/core/async";
 import { VertexAIDriver } from "../index.js";
 import { ModelDefinition } from "../models.js";
 import { PromptParamatersBase } from "../utils/prompts.js";
 import { generateStreamingPrompt } from "../utils/tensor.js";
-import { ServerSentEvent } from "api-fetch-client";
 
 export interface NonStreamingPromptBase<InstanceType = any> {
     instances: InstanceType[];
@@ -99,24 +99,13 @@ export abstract class AbstractPalmModelDefinition<NonStreamingPromptT extends No
             payload: newPrompt,
             reader: 'sse'
         });
-        return eventStrean.pipeThrough(new ChunkTransformStream(this));
 
-    }
-
-}
-
-class ChunkTransformStream<NonStreamingPromptT extends NonStreamingPromptBase, StreamingPromptT extends StreamingPromptBase> extends TransformStream {
-    constructor(def: AbstractPalmModelDefinition<NonStreamingPromptT, StreamingPromptT>) {
-        super({
-            transform(event: ServerSentEvent, controller: TransformStreamDefaultController) {
-                if (event.type === 'event' && event.data) {
-                    const data = JSON.parse(event.data);
-                    const stringChunk = def.extractContentFromResponseChunk(data);
-                    controller.enqueue(Array.isArray(stringChunk) ? stringChunk.join('') : stringChunk);
-                }
-            }
+        return transformSSEStream(eventStrean, (data: string) => {
+            const json = JSON.parse(data);
+            const stringChunk = this.extractContentFromResponseChunk(json);
+            return Array.isArray(stringChunk) ? stringChunk.join('') : stringChunk;
         })
     }
-}
 
+}