@llumiverse/drivers 1.2.0 → 1.4.0-dev.20260629.090753Z

package/src/shared/claude-thinking.ts

@@ -1,9 +1,5 @@
-import type { OutputConfig, ThinkingConfigParam } from "@anthropic-ai/sdk/resources/messages.js";
-import {
-    hasSamplingParameterRestriction,
-    isClaudeVersionGTE,
-    supportsAdaptiveThinking,
-} from "@llumiverse/core";
+import type { OutputConfig, ThinkingConfigParam } from '@anthropic-ai/sdk/resources/messages.js';
+import { hasSamplingParameterRestriction, isClaudeVersionGTE, supportsAdaptiveThinking } from '@llumiverse/core';
 
 /**
  * Common Claude model options relevant to thinking/effort configuration.
@@ -59,25 +55,23 @@ export function resolveClaudeThinking(model: string, options?: ClaudeThinkingInp
         // Explicit budget — use extended thinking regardless of adaptive support.
         // On adaptive models this uses the deprecated path, but user input takes priority.
         thinking = {
-            type: "enabled" as const,
+            type: 'enabled' as const,
             budget_tokens: budgetTokens,
         };
     } else if (supportsAdaptive) {
         // Adaptive models: enable when effort is set, omit otherwise (thinking is OFF by default).
         // display controls whether thinking blocks are returned; defaults to omitted.
         thinking = adaptiveEnabled
-            ? { type: "adaptive" as const, display: options?.include_thoughts ? "summarized" : "omitted" }
+            ? { type: 'adaptive' as const, display: options?.include_thoughts ? 'summarized' : 'omitted' }
             : undefined;
     } else {
         // Older thinking models (3.7, 4.5): no adaptive support, thinking is always disabled
         // unless an explicit budget is provided (handled above).
-        thinking = { type: "disabled" as const };
+        thinking = { type: 'disabled' as const };
     }
 
     // Output config for effort parameter (Opus 4.5+, Sonnet 4.6+, all 4.7+)
-    const outputConfig: OutputConfig | undefined = options?.effort
-        ? { effort: options.effort }
-        : undefined;
+    const outputConfig: OutputConfig | undefined = options?.effort ? { effort: options.effort } : undefined;
 
     return {
         thinking,

package/src/shared/debug-prompt.ts

@@ -0,0 +1,28 @@
+export const BINARY_TRUNCATED_MARKER = '...[truncated binary]...';
+
+const BINARY_DEBUG_EDGE_CHARS = 10;
+
+export function truncateBinaryForDebug(value: string): string {
+    if (value.length <= BINARY_DEBUG_EDGE_CHARS * 2 + BINARY_TRUNCATED_MARKER.length) {
+        return value;
+    }
+    return `${value.slice(0, BINARY_DEBUG_EDGE_CHARS)}${BINARY_TRUNCATED_MARKER}${value.slice(-BINARY_DEBUG_EDGE_CHARS)}`;
+}
+
+export function truncateDataUrlForDebug(value: string): string {
+    const base64Marker = ';base64,';
+    const markerIndex = value.indexOf(base64Marker);
+    if (!value.startsWith('data:') || markerIndex === -1) {
+        return value;
+    }
+    const payloadStart = markerIndex + base64Marker.length;
+    return value.slice(0, payloadStart) + truncateBinaryForDebug(value.slice(payloadStart));
+}
+
+export function uint8ArrayToBase64ForDebug(bytes: Uint8Array): string {
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}

package/src/test-driver/TestErrorCompletionStream.ts

@@ -1,17 +1,16 @@
-import { CompletionStream, ExecutionOptions, ExecutionResponse, PromptSegment } from "@llumiverse/core";
-import { sleep, throwError } from "./utils.js";
+import type { CompletionStream, ExecutionOptions, ExecutionResponse, PromptSegment } from '@llumiverse/core';
+import { sleep, throwError } from './utils.js';
 
 export class TestErrorCompletionStream implements CompletionStream<PromptSegment[]> {
-
     completion: ExecutionResponse<PromptSegment[]> | undefined;
 
-    constructor(public segments: PromptSegment[],
-        public options: ExecutionOptions) {
-    }
+    constructor(
+        public segments: PromptSegment[],
+        public options: ExecutionOptions,
+    ) {}
     async *[Symbol.asyncIterator]() {
-        yield "Started TestError. Next we will thrown an error.\n";
-        sleep(1000);
-        throwError("Testing stream completion error.", this.segments);
+        yield 'Started TestError. Next we will thrown an error.\n';
+        await sleep(1000);
+        throwError('Testing stream completion error.', this.segments);
     }
 }
-

package/src/test-driver/TestValidationErrorCompletionStream.ts

@@ -1,20 +1,19 @@
-import { CompletionStream, ExecutionOptions, ExecutionResponse, PromptSegment } from "@llumiverse/core";
-import { createValidationErrorCompletion, sleep } from "./utils.js";
-
+import type { CompletionStream, ExecutionOptions, ExecutionResponse, PromptSegment } from '@llumiverse/core';
+import { createValidationErrorCompletion, sleep } from './utils.js';
 
 export class TestValidationErrorCompletionStream implements CompletionStream<PromptSegment[]> {
-
     completion: ExecutionResponse<PromptSegment[]> | undefined;
 
-    constructor(public segments: PromptSegment[],
-        public options: ExecutionOptions) {
-    }
+    constructor(
+        public segments: PromptSegment[],
+        public options: ExecutionOptions,
+    ) {}
     async *[Symbol.asyncIterator]() {
-        yield "Started TestValidationError.\n";
+        yield 'Started TestValidationError.\n';
         await sleep(1000);
-        yield "chunk1\n";
+        yield 'chunk1\n';
         await sleep(1000);
-        yield "chunk2\n";
+        yield 'chunk2\n';
         await sleep(1000);
         this.completion = createValidationErrorCompletion(this.segments);
     }

package/src/test-driver/index.ts

@@ -1,39 +1,50 @@
-import { AIModel, AIModelStatus, CompletionStream, Driver, EmbeddingsResult, ExecutionOptions, ExecutionResponse, ModelType, PromptSegment, TrainingJob } from "@llumiverse/core";
-import { TestErrorCompletionStream } from "./TestErrorCompletionStream.js";
-import { TestValidationErrorCompletionStream } from "./TestValidationErrorCompletionStream.js";
-import { createValidationErrorCompletion, sleep, throwError } from "./utils.js";
+import {
+    type AIModel,
+    AIModelStatus,
+    type CompletionStream,
+    type Driver,
+    type EmbeddingsResult,
+    type ExecutionOptions,
+    type ExecutionResponse,
+    ModelType,
+    type PromptSegment,
+    type TrainingJob,
+} from '@llumiverse/core';
+import { TestErrorCompletionStream } from './TestErrorCompletionStream.js';
+import { TestValidationErrorCompletionStream } from './TestValidationErrorCompletionStream.js';
+import { createValidationErrorCompletion, sleep, throwError } from './utils.js';
 
-export * from "./TestErrorCompletionStream.js";
-export * from "./TestValidationErrorCompletionStream.js";
+export * from './TestErrorCompletionStream.js';
+export * from './TestValidationErrorCompletionStream.js';
 
 export enum TestDriverModels {
-    executionError = "execution-error",
-    validationError = "validation-error",
+    executionError = 'execution-error',
+    validationError = 'validation-error',
 }
 
 export class TestDriver implements Driver<PromptSegment[]> {
-    provider = "test";
+    provider = 'test';
 
     createTrainingPrompt(): Promise<string> {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
 
     startTraining(): Promise<TrainingJob> {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
 
     cancelTraining(): Promise<TrainingJob> {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
 
     getTrainingJob(_jobId: string): Promise<TrainingJob> {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
 
     async createPrompt(segments: PromptSegment[], _opts: ExecutionOptions): Promise<PromptSegment[]> {
         return segments;
     }
-    
+
     execute(segments: PromptSegment[], options: ExecutionOptions): Promise<ExecutionResponse<PromptSegment[]>> {
         switch (options.model) {
             case TestDriverModels.executionError:
@@ -41,7 +52,7 @@ export class TestDriver implements Driver<PromptSegment[]> {
             case TestDriverModels.validationError:
                 return this.executeValidationError(segments, options);
             default:
-                throwError("[test driver] Unknown model: " + options.model, segments)
+                throwError(`[test driver] Unknown model: ${options.model}`, segments);
         }
     }
     async stream(segments: PromptSegment[], options: ExecutionOptions): Promise<CompletionStream<PromptSegment[]>> {
@@ -51,7 +62,7 @@ export class TestDriver implements Driver<PromptSegment[]> {
             case TestDriverModels.validationError:
                 return new TestValidationErrorCompletionStream(segments, options);
             default:
-                throwError("[test driver] Unknown model: " + options.model, segments)
+                throwError(`[test driver] Unknown model: ${options.model}`, segments);
         }
     }
 
@@ -63,40 +74,45 @@ export class TestDriver implements Driver<PromptSegment[]> {
         return [
             {
                 id: TestDriverModels.executionError,
-                name: "Execution Error",
+                name: 'Execution Error',
                 type: ModelType.Test,
                 provider: this.provider,
                 status: AIModelStatus.Available,
-                description: "Test execution errors",
+                description: 'Test execution errors',
                 tags: [],
             },
             {
                 id: TestDriverModels.validationError,
-                name: "Validation Error",
+                name: 'Validation Error',
                 type: ModelType.Test,
                 provider: this.provider,
                 status: AIModelStatus.Available,
-                description: "Test validation errors",
+                description: 'Test validation errors',
                 tags: [],
             },
-        ]
+        ];
     }
     validateConnection(): Promise<boolean> {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
     generateEmbeddings(): Promise<EmbeddingsResult> {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
 
     // ============== execution error ==================
-    async executeError(segments: PromptSegment[], _options: ExecutionOptions): Promise<ExecutionResponse<PromptSegment[]>> {
+    async executeError(
+        segments: PromptSegment[],
+        _options: ExecutionOptions,
+    ): Promise<ExecutionResponse<PromptSegment[]>> {
         await sleep(1000);
-        throwError("Testing stream completion error.", segments);
+        throwError('Testing stream completion error.', segments);
     }
     // ============== validation error ==================
-    async executeValidationError(segments: PromptSegment[], _options: ExecutionOptions): Promise<ExecutionResponse<PromptSegment[]>> {
+    async executeValidationError(
+        segments: PromptSegment[],
+        _options: ExecutionOptions,
+    ): Promise<ExecutionResponse<PromptSegment[]>> {
         await sleep(3000);
         return createValidationErrorCompletion(segments);
     }
-
 }

package/src/test-driver/utils.ts

@@ -1,19 +1,19 @@
-import { ExecutionResponse, PromptSegment } from "@llumiverse/core";
+import type { ExecutionResponse, PromptSegment } from '@llumiverse/core';
 
 export function throwError(message: string, prompt: PromptSegment[]): never {
-    const err = new Error(message);
-    (err as any).prompt = prompt;
+    const err = new Error(message) as Error & { prompt?: PromptSegment[] };
+    err.prompt = prompt;
     throw err;
 }
 
 export function createValidationErrorCompletion(segments: PromptSegment[]) {
     return {
-        result: [{ type: "text", value: "An invalid result" }],
+        result: [{ type: 'text', value: 'An invalid result' }],
         prompt: segments,
         execution_time: 3000,
         error: {
-            code: "validation_error",
-            message: "Result cannot be validated!",
+            code: 'validation_error',
+            message: 'Result cannot be validated!',
         },
         token_usage: {
             result: 10,
@@ -24,5 +24,5 @@ export function createValidationErrorCompletion(segments: PromptSegment[]) {
 }
 
 export function sleep(ms: number) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/togetherai/index.test.ts

@@ -0,0 +1,32 @@
+import { ModelType, Providers } from '@llumiverse/core';
+import { describe, expect, it, vi } from 'vitest';
+import { TogetherAIDriver } from './index.js';
+
+describe('TogetherAIDriver', () => {
+    it('maps Together array-shaped model catalog responses', async () => {
+        const driver = new TogetherAIDriver({ apiKey: 'test-key' });
+        const get = vi.fn(async () => [
+            {
+                id: 'Qwen/Qwen3.5-9B',
+                display_name: 'Qwen3.5 9B',
+                organization: 'Qwen',
+                type: 'chat',
+            },
+        ]);
+        driver.service = { get } as unknown as TogetherAIDriver['service'];
+
+        const models = await driver.listModels();
+
+        expect(get).toHaveBeenCalledWith('/models');
+        expect(models).toEqual([
+            expect.objectContaining({
+                id: 'Qwen/Qwen3.5-9B',
+                name: 'Qwen3.5 9B',
+                owner: 'Qwen',
+                provider: Providers.togetherai,
+                type: ModelType.Chat,
+                tool_support: true,
+            }),
+        ]);
+    });
+});

package/src/togetherai/index.ts

@@ -1,142 +1,78 @@
-import { AbstractDriver, AIModel, Completion, CompletionChunkObject, DriverOptions, EmbeddingsResult, ExecutionOptions, TextFallbackOptions } from "@llumiverse/core";
-import { transformSSEStream } from "@llumiverse/core/async";
-import { FetchClient } from "@vertesia/api-fetch-client";
-import { TextCompletion, TogetherModelInfo } from "./interfaces.js";
-
-interface TogetherAIDriverOptions extends DriverOptions {
+import {
+    type AIModel,
+    type DriverOptions,
+    getModelCapabilities,
+    ModelType,
+    modelModalitiesToArray,
+    Providers,
+} from '@llumiverse/core';
+import OpenAI from 'openai';
+import { BaseOpenAIDriver } from '../openai/index.js';
+
+export interface TogetherAIDriverOptions extends DriverOptions {
     apiKey: string;
+    endpoint?: string;
 }
 
-export class TogetherAIDriver extends AbstractDriver<TogetherAIDriverOptions, string> {
-    static PROVIDER = "togetherai";
-    provider = TogetherAIDriver.PROVIDER;
-    apiKey: string;
-    fetchClient: FetchClient;
-
-    constructor(options: TogetherAIDriverOptions) {
-        super(options);
-        this.apiKey = options.apiKey;
-        this.fetchClient = new FetchClient('https://api.together.xyz').withHeaders({
-            authorization: `Bearer ${this.apiKey}`
-        });
-    }
-
-    getResponseFormat = (options: ExecutionOptions): { type: string; schema: any } | undefined => {
-        return options.result_schema ?
-            {
-                type: "json_object",
-                schema: options.result_schema
-            } : undefined;
-    }
-
-    async requestTextCompletion(prompt: string, options: ExecutionOptions): Promise<Completion> {
-        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
-        }
-        options.model_options = options.model_options as TextFallbackOptions;
+interface TogetherModel {
+    id: string;
+    display_name?: string;
+    organization?: string;
+    type?: string;
+}
 
-        const stop_seq = options.model_options?.stop_sequence ?? [];
+export class TogetherAIDriver extends BaseOpenAIDriver {
+    static readonly PROVIDER = Providers.togetherai;
+    readonly provider = Providers.togetherai;
+    service: OpenAI;
 
-        const res = await this.fetchClient.post('/v1/completions', {
-            payload: {
-                model: options.model,
-                prompt: prompt,
-                response_format: this.getResponseFormat(options),
-                max_tokens: options.model_options?.max_tokens,
-                temperature: options.model_options?.temperature,
-                top_p: options.model_options?.top_p,
-                top_k: options.model_options?.top_k,
-                //logprobs: options.top_logprobs,       //Logprobs output currently not supported
-                frequency_penalty: options.model_options?.frequency_penalty,
-                presence_penalty: options.model_options?.presence_penalty,
-                stop: [
-                    "</s>",
-                    "[/INST]",
-                    ...stop_seq,
-                ],
-            }
-        }) as TextCompletion;
-        const choice = res.choices[0];
-        const text = choice.text ?? '';
-        const usage = res.usage || {};
-        return {
-            result: [{ type: "text", value: text }],
-            token_usage: {
-                prompt: usage.prompt_tokens,
-                result: usage.completion_tokens,
-                total: usage.total_tokens,
-            },
-            finish_reason: choice.finish_reason,                //Uses expected "stop" , "length" format
-            original_response: options.include_original_response ? res : undefined,
-        }
-    }
+    constructor(opts: TogetherAIDriverOptions) {
+        super(opts);
 
-    async requestTextCompletionStream(prompt: string, options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
-        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+        if (!opts.apiKey) {
+            throw new Error('apiKey is required');
         }
-        options.model_options = options.model_options as TextFallbackOptions;
-
-        const stop_seq = options.model_options?.stop_sequence ?? [];
-        const stream = await this.fetchClient.post('/v1/completions', {
-            payload: {
-                model: options.model,
-                prompt: prompt,
-                max_tokens: options.model_options?.max_tokens,
-                temperature: options.model_options?.temperature,
-                response_format: this.getResponseFormat(options),
-                top_p: options.model_options?.top_p,
-                top_k: options.model_options?.top_k,
-                //logprobs: options.top_logprobs,       //Logprobs output currently not supported
-                frequency_penalty: options.model_options?.frequency_penalty,
-                presence_penalty: options.model_options?.presence_penalty,
-                stream: true,
-                stop: [
-                    "</s>",
-                    "[/INST]",
-                    ...stop_seq,
-                ],
-            },
-            reader: 'sse'
-        })
 
-        return transformSSEStream(stream, (data: string) => {
-            const json = JSON.parse(data);
-            return {
-                result: [{ type: "text", value: json.choices[0]?.text ?? '' }],
-                finish_reason: json.choices[0]?.finish_reason,          //Uses expected "stop" , "length" format
-                token_usage: {
-                    prompt: json.usage?.prompt_tokens,
-                    result: json.usage?.completion_tokens,
-                    total: json.usage?.prompt_tokens + json.usage?.completion_tokens,
-                }
-            };
+        this.service = new OpenAI({
+            apiKey: opts.apiKey,
+            baseURL: opts.endpoint ?? 'https://api.together.ai/v1',
+            fetch: this.getDriverFetch(),
         });
-
     }
 
-    async listModels(): Promise<AIModel<string>[]> {
-        const models: TogetherModelInfo[] = await this.fetchClient.get("/models/info");
-        //        logObject('#### LIST MODELS RESULT IS', models[0]);
-
-        const aiModels = models.map(m => {
-            return {
-                id: m.name,
-                name: m.display_name,
-                description: m.description,
-                provider: this.provider,
-            }
-        });
-
-        return aiModels;
-
+    async listModels(): Promise<AIModel[]> {
+        const result = await this.service.get<TogetherModel[]>('/models');
+        return result
+            .map((model) => {
+                const modelCapability = getModelCapabilities(model.id, this.provider);
+                return {
+                    id: model.id,
+                    name: model.display_name ?? model.id,
+                    provider: this.provider,
+                    owner: model.organization,
+                    type: togetherModelType(model.type),
+                    can_stream: true,
+                    is_multimodal: modelCapability.input.image === true,
+                    input_modalities: modelModalitiesToArray(modelCapability.input),
+                    output_modalities: modelModalitiesToArray(modelCapability.output),
+                    tool_support: modelCapability.tool_support,
+                } satisfies AIModel<string>;
+            })
+            .sort((a, b) => a.id.localeCompare(b.id));
     }
+}
 
-    validateConnection(): Promise<boolean> {
-        throw new Error("Method not implemented.");
-    }
-    generateEmbeddings(): Promise<EmbeddingsResult> {
-        throw new Error("Method not implemented.");
+function togetherModelType(type?: string): ModelType {
+    switch (type) {
+        case 'chat':
+            return ModelType.Chat;
+        case 'code':
+            return ModelType.Code;
+        case 'image':
+            return ModelType.Image;
+        case 'embedding':
+            return ModelType.Embedding;
+        default:
+            return ModelType.Text;
     }
-
-}
+}

package/src/togetherai/interfaces.ts

@@ -1,5 +1,5 @@
 interface ModelInstanceConfig {
-    appearsIn: any[];
+    appearsIn: unknown[];
     order: number;
 }
 
@@ -90,15 +90,15 @@ export interface TogetherModelInfo {
 export interface TextCompletion {
     id: string;
     choices: {
-        text: string,
-        finish_reason: string, // stop | length ?
+        text: string;
+        finish_reason: string; // stop | length ?
     }[];
     usage: {
         prompt_tokens: number;
         completion_tokens: number;
         total_tokens: number;
-    }
+    };
     created: number;
     model: string;
     object: string;
-}
+}

package/src/vertexai/debug.ts

@@ -1,6 +1,6 @@
-import util from 'util';
+import util from 'node:util';
 
-export function logObject(prefix: string, obj: any) {
+export function logObject(prefix: string, obj: unknown) {
     const fullObj = util.inspect(obj, { showHidden: false, depth: null, colors: true });
-    console.log(prefix, fullObj)
+    console.log(prefix, fullObj);
 }