@llumiverse/core 0.22.0 → 0.23.0-dev-20251118

package/src/CompletionStream.ts

@@ -3,39 +3,36 @@ import { AbstractDriver } from "./Driver.js";
 
 export class DefaultCompletionStream<PromptT = any> implements CompletionStream<PromptT> {
 
-    chunks: string[];
+    chunks: number; // Counter for number of chunks instead of storing strings
     completion: ExecutionResponse<PromptT> | undefined;
 
     constructor(public driver: AbstractDriver<DriverOptions, PromptT>,
         public prompt: PromptT,
         public options: ExecutionOptions) {
-        this.chunks = [];
+        this.chunks = 0;
     }
 
     async *[Symbol.asyncIterator]() {
         // reset state
         this.completion = undefined;
-        if (this.chunks.length > 0) {
-            this.chunks = [];
-        }
-        const chunks = this.chunks;
+        this.chunks = 0;
+        const accumulatedResults: any[] = []; // Accumulate CompletionResult[] from chunks
 
         this.driver.logger.debug(
             `[${this.driver.provider}] Streaming Execution of ${this.options.model} with prompt`,
         );
 
         const start = Date.now();
-        let stream;
         let finish_reason: string | undefined = undefined;
         let promptTokens: number = 0;
         let resultTokens: number | undefined = undefined;
 
         try {
-            stream = await this.driver.requestTextCompletionStream(this.prompt, this.options);
+            const stream = await this.driver.requestTextCompletionStream(this.prompt, this.options);
             for await (const chunk of stream) {
                 if (chunk) {
                     if (typeof chunk === 'string') {
-                        chunks.push(chunk);
+                        this.chunks++;
                         yield chunk;
                     } else {
                         if (chunk.finish_reason) {                           //Do not replace non-null values with null values
@@ -48,9 +45,65 @@ export class DefaultCompletionStream<PromptT = any> implements CompletionStream<
                             promptTokens = Math.max(promptTokens, chunk.token_usage.prompt ?? 0);
                             resultTokens = Math.max(resultTokens ?? 0, chunk.token_usage.result ?? 0);
                         }
-                        if (chunk.result) {
-                            chunks.push(chunk.result);
-                            yield chunk.result;
+                        if (Array.isArray(chunk.result) && chunk.result.length > 0) {
+                            // Process each result in the chunk, combining consecutive text/JSON
+                            for (const result of chunk.result) {
+                                // Check if we can combine with the last accumulated result
+                                const lastResult = accumulatedResults[accumulatedResults.length - 1];
+
+                                if (lastResult &&
+                                    ((lastResult.type === 'text' && result.type === 'text') ||
+                                        (lastResult.type === 'json' && result.type === 'json'))) {
+                                    // Combine consecutive text or JSON results
+                                    if (result.type === 'text') {
+                                        lastResult.value += result.value;
+                                    } else if (result.type === 'json') {
+                                        // For JSON, combine the parsed objects directly
+                                        try {
+                                            const lastParsed = lastResult.value;
+                                            const currentParsed = result.value;
+                                            if (lastParsed !== null && typeof lastParsed === 'object' &&
+                                                currentParsed !== null && typeof currentParsed === 'object') {
+                                                const combined = { ...lastParsed, ...currentParsed };
+                                                lastResult.value = combined;
+                                            } else {
+                                                // If not objects, convert to string and concatenate
+                                                const lastStr = typeof lastParsed === 'string' ? lastParsed : JSON.stringify(lastParsed);
+                                                const currentStr = typeof currentParsed === 'string' ? currentParsed : JSON.stringify(currentParsed);
+                                                lastResult.value = lastStr + currentStr;
+                                            }
+                                        } catch {
+                                            // If anything fails, just concatenate string representations
+                                            lastResult.value = String(lastResult.value) + String(result.value);
+                                        }
+                                    }
+                                } else {
+                                    // Add as new result
+                                    accumulatedResults.push(result);
+                                }
+                            }
+
+                            // Convert CompletionResult[] to string for streaming
+                            // Only yield if we have results to show
+                            const resultText = chunk.result.map(r => {
+                                switch (r.type) {
+                                    case 'text':
+                                        return r.value;
+                                    case 'json':
+                                        return JSON.stringify(r.value);
+                                    case 'image':
+                                        // Show truncated image placeholder for streaming
+                                        const truncatedValue = typeof r.value === 'string' ? r.value.slice(0, 10) : String(r.value).slice(0, 10);
+                                        return `\n[Image: ${truncatedValue}...]\n`;
+                                    default:
+                                        return String((r as any).value || '');
+                                }
+                            }).join('');
+
+                            if (resultText) {
+                                this.chunks++;
+                                yield resultText;
+                            }
                         }
                     }
                 }
@@ -60,24 +113,24 @@ export class DefaultCompletionStream<PromptT = any> implements CompletionStream<
             throw error;
         }
 
-        const content = chunks.join('');
-
         // Return undefined for the ExecutionTokenUsage object if there is nothing to fill it with.
-        // Allows for checking for truthyness on token_usage, rather than it's internals. For testing and downstream usage.
-        let tokens: ExecutionTokenUsage | undefined = resultTokens ?
+        // Allows for checking for truthy-ness on token_usage, rather than it's internals. For testing and downstream usage.
+        const tokens: ExecutionTokenUsage | undefined = resultTokens ?
             { prompt: promptTokens, result: resultTokens, total: resultTokens + promptTokens, } : undefined
 
         this.completion = {
-            result: content,
+            result: accumulatedResults, // Return the accumulated CompletionResult[] instead of text
             prompt: this.prompt,
             execution_time: Date.now() - start,
             token_usage: tokens,
             finish_reason: finish_reason,
-            chunks: chunks.length,
+            chunks: this.chunks,
         }
 
         try {
-            this.driver.validateResult(this.completion, this.options);
+            if (this.completion) {
+                this.driver.validateResult(this.completion, this.options);
+            }
         } catch (error: any) {
             error.prompt = this.prompt;
             throw error;
@@ -103,9 +156,23 @@ export class FallbackCompletionStream<PromptT = any> implements CompletionStream
         );
         try {
             const completion = await this.driver._execute(this.prompt, this.options);
-            const content = typeof completion.result === 'string' ? completion.result : JSON.stringify(completion.result);
+            // For fallback streaming, yield the text content but keep the original completion
+            const content = completion.result.map(r => {
+                switch (r.type) {
+                    case 'text':
+                        return r.value;
+                    case 'json':
+                        return JSON.stringify(r.value);
+                    case 'image':
+                        // Show truncated image placeholder for streaming
+                        const truncatedValue = typeof r.value === 'string' ? r.value.slice(0, 10) : String(r.value).slice(0, 10);
+                        return `[Image: ${truncatedValue}...]`;
+                    default:
+                        return String((r as any).value || '');
+                }
+            }).join('');
             yield content;
-            this.completion = completion;
+            this.completion = completion; // Return the original completion with untouched CompletionResult[]
         } catch (error: any) {
             error.prompt = this.prompt;
             throw error;

package/src/Driver.ts

@@ -9,7 +9,7 @@ import { formatTextPrompt } from "./formatters/index.js";
 import {
     AIModel,
     Completion,
-    CompletionChunk,
+    CompletionChunkObject,
     CompletionStream,
     DataSource,
     DriverOptions,
@@ -17,7 +17,6 @@ import {
     EmbeddingsResult,
     ExecutionOptions,
     ExecutionResponse,
-    ImageGeneration,
     Logger,
     Modalities,
     ModelSearchPayload,
@@ -29,19 +28,35 @@ import {
 } from "@llumiverse/common";
 import { validateResult } from "./validation.js";
 
+// Helper to create logger methods that support both message-only and object-first signatures
+function createConsoleLoggerMethod(consoleMethod: (...args: unknown[]) => void): Logger['info'] {
+    return ((objOrMsg: any, msgOrNever?: any, ...args: (string | number | boolean)[]) => {
+        if (typeof objOrMsg === 'string') {
+            // Message-only: logger.info("message", ...args)
+            consoleMethod(objOrMsg, msgOrNever, ...args);
+        } else if (msgOrNever !== undefined) {
+            // Object-first: logger.info({ obj }, "message", ...args)
+            consoleMethod(msgOrNever, objOrMsg, ...args);
+        } else {
+            // Object-only: logger.info({ obj })
+            consoleMethod(objOrMsg, ...args);
+        }
+    }) as Logger['info'];
+}
+
 const ConsoleLogger: Logger = {
-    debug: console.debug,
-    info: console.info,
-    warn: console.warn,
-    error: console.error,
+    debug: createConsoleLoggerMethod(console.debug.bind(console)),
+    info: createConsoleLoggerMethod(console.info.bind(console)),
+    warn: createConsoleLoggerMethod(console.warn.bind(console)),
+    error: createConsoleLoggerMethod(console.error.bind(console)),
 }
 
 const noop = () => void 0;
 const NoopLogger: Logger = {
-    debug: noop,
-    info: noop,
-    warn: noop,
-    error: noop,
+    debug: noop as Logger['debug'],
+    info: noop as Logger['info'],
+    warn: noop as Logger['warn'],
+    error: noop as Logger['error'],
 }
 
 export function createLogger(logger: Logger | "console" | undefined) {
@@ -131,7 +146,8 @@ export abstract class AbstractDriver<OptionsT extends DriverOptions = DriverOpti
             try {
                 result.result = validateResult(result.result, options.result_schema);
             } catch (error: any) {
-                this.logger?.error({ err: error, data: result.result }, `[${this.provider}] [${options.model}] ${error.code ? '[' + error.code + '] ' : ''}Result validation error: ${error.message}`);
+                const errorMessage = `[${this.provider}] [${options.model}] ${error.code ? '[' + error.code + '] ' : ''}Result validation error: ${error.message}`;
+                this.logger.error({ err: error, data: result.result }, errorMessage);
                 result.error = {
                     code: error.code || error.name,
                     message: error.message,
@@ -225,9 +241,9 @@ export abstract class AbstractDriver<OptionsT extends DriverOptions = DriverOpti
 
     abstract requestTextCompletion(prompt: PromptT, options: ExecutionOptions): Promise<Completion>;
 
-    abstract requestTextCompletionStream(prompt: PromptT, options: ExecutionOptions): Promise<AsyncIterable<CompletionChunk>>;
+    abstract requestTextCompletionStream(prompt: PromptT, options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>>;
 
-    async requestImageGeneration(_prompt: PromptT, _options: ExecutionOptions): Promise<Completion<ImageGeneration>> {
+    async requestImageGeneration(_prompt: PromptT, _options: ExecutionOptions): Promise<Completion> {
         throw new Error("Image generation not implemented.");
         //Cannot be made abstract, as abstract methods are required in the derived class
     }

package/src/async.ts

@@ -1,5 +1,5 @@
 import type { ServerSentEvent } from "@vertesia/api-fetch-client"
-import { CompletionChunk } from "@llumiverse/common";
+import { CompletionChunkObject } from "@llumiverse/common";
 
 export async function* asyncMap<T, R>(asyncIterable: AsyncIterable<T>, callback: (value: T, index: number) => R) {
     let i = 0;
@@ -18,9 +18,9 @@ export function oneAsyncIterator<T>(value: T): AsyncIterable<T> {
 /**
  * Given a ReadableStream of server sent events, tran
  */
-export function transformSSEStream(stream: ReadableStream<ServerSentEvent>, transform: (data: string) => CompletionChunk): ReadableStream<CompletionChunk> & AsyncIterable<CompletionChunk> {
+export function transformSSEStream(stream: ReadableStream<ServerSentEvent>, transform: (data: string) => CompletionChunkObject): ReadableStream<CompletionChunkObject> & AsyncIterable<CompletionChunkObject> {
     // on node and bun the ReadableStream is an async iterable
-    return stream.pipeThrough(new TransformStream<ServerSentEvent, CompletionChunk>({
+    return stream.pipeThrough(new TransformStream<ServerSentEvent, CompletionChunkObject>({
         transform(event: ServerSentEvent, controller) {
             if (event.type === 'event' && event.data && event.data !== '[DONE]') {
                 try {
@@ -32,7 +32,7 @@ export function transformSSEStream(stream: ReadableStream<ServerSentEvent>, tran
                 }
             }
         }
-    })) as ReadableStream<CompletionChunk> & AsyncIterable<CompletionChunk>;
+    })) satisfies ReadableStream<CompletionChunkObject> & AsyncIterable<CompletionChunkObject>;
 }
 
 export class EventStream<T, ReturnT = any> implements AsyncIterable<T> {

package/src/json.ts

@@ -1,181 +1,16 @@
 import { JSONValue } from "@llumiverse/common";
+import { jsonrepair } from 'jsonrepair';
 
 function extractJsonFromText(text: string): string {
     const start = text.indexOf("{");
     const end = text.lastIndexOf("}");
-    text = text.substring(start, end + 1);
-    return text.replace(/\\n/g, "");
+    return text.substring(start, end + 1);
 }
 
 export function extractAndParseJSON(text: string): JSONValue {
     return parseJSON(extractJsonFromText(text));
 }
 
-const RX_DQUOTE = /^"([^"\\]|\\.)*"/us;
-const RX_SQUOTE = /^'([^'\\]|\\.)*'/us;
-const RX_NUMBER = /^-?\d+(\.\d+)?/;
-const RX_BOOLEAN = /^true|false/;
-const RX_NULL = /^null/;
-const RX_KEY = /^[$_a-zA-Z][$_a-zA-Z0-9]*/;
-const RX_PUNCTUATION = /^\s*([\[\]{}:,])\s*/;
-
-function fixText(value: string) {
-    return value.replaceAll('\n', '\\n').replaceAll('\r', '\\r');
-}
-
-function decodeSingleQuotedString(value: string) {
-    return JSON.parse('"' + value.slice(1, -1).replaceAll(/(?<!\\)"/g, '\\"') + '"');
-}
-
-export class JsonParser {
-    pos: number = 0;
-
-    constructor(public text: string) { }
-
-    skip(n: number) {
-        this.text = this.text.substring(n);
-        this.pos += n;
-    }
-
-    tryReadPunctuation() {
-        const m = RX_PUNCTUATION.exec(this.text);
-        if (m) {
-            this.skip(m[0].length);
-            return m[1];
-        }
-    }
-
-    readKey() {
-        const first = this.text.charCodeAt(0);
-        if (first === 34) { // "
-            const m = RX_DQUOTE.exec(this.text);
-            if (m) {
-                this.skip(m[0].length);
-                return JSON.parse(m[0]);
-            }
-        } else if (first === 39) { // '
-            const m = RX_SQUOTE.exec(this.text);
-            if (m) {
-                this.skip(m[0].length);
-                return decodeSingleQuotedString(m[0]);
-            }
-        } else {
-            const m = RX_KEY.exec(this.text);
-            if (m) {
-                this.skip(m[0].length);
-                return m[0];
-            }
-        }
-        throw new Error('Expected a key at position ' + this.pos + ' but found ' + this.text);
-    }
-
-    readScalar() {
-        const first = this.text.charCodeAt(0);
-        if (first === 34) { // "
-            const m = RX_DQUOTE.exec(this.text);
-            if (m) {
-                this.skip(m[0].length);
-                return JSON.parse(fixText(m[0]));
-            }
-        } else if (first === 39) { // '
-            const m = RX_SQUOTE.exec(this.text);
-            if (m) {
-                this.skip(m[0].length);
-                return decodeSingleQuotedString(fixText(m[0]));
-            }
-        } else {
-            let m = RX_NUMBER.exec(this.text);
-            if (m) {
-                this.skip(m[0].length);
-                return parseFloat(m[0]);
-            }
-            m = RX_BOOLEAN.exec(this.text);
-            if (m) {
-                this.skip(m[0].length);
-                return m[0] === 'true';
-            }
-            m = RX_NULL.exec(this.text);
-            if (m) {
-                this.skip(m[0].length);
-                return null;
-            }
-        }
-        throw new Error('Expected a value at position ' + this.pos + ' but found ' + this.text);
-    }
-
-    readObject() {
-        let key: string | undefined;
-        const obj: any = {};
-        while (true) {
-            if (!key) { // read key
-                const p = this.tryReadPunctuation();
-                if (p === '}') {
-                    return obj;
-                } else if (p === ',') {
-                    continue;
-                } else if (p) {
-                    throw new Error('Expected a key at position ' + this.pos + ' but found ' + this.text);
-                }
-                key = this.readKey();
-                if (!key) {
-                    throw new Error('Expected a key at position ' + this.pos + ' but found ' + this.text);
-                }
-                if (this.tryReadPunctuation() !== ':') {
-                    throw new Error('Expected a colon at position ' + this.pos + ' but found ' + this.text);
-                };
-            } else { // read value
-                const value = this.readValue();
-                if (value === undefined) {
-                    throw new Error('Expected a value at position ' + this.pos + ' but found ' + this.text);
-                }
-                obj[key] = value;
-                key = undefined;
-            }
-        }
-    }
-
-    readArray() {
-        const ar: any[] = [];
-        while (true) {
-            const p = this.tryReadPunctuation();
-            if (p === ',') {
-                continue;
-            } else if (p === ']') {
-                return ar;
-            } else if (p === '[') {
-                ar.push(this.readArray());
-            } else if (p === '{') {
-                ar.push(this.readObject());
-            } else if (!p) {
-                ar.push(this.readScalar());
-            } else {
-                throw new Error('Expected a value at position ' + this.pos + ' but found ' + this.text);
-            }
-        }
-    }
-
-    readValue() {
-        const p = this.tryReadPunctuation();
-        if (p === '{') {
-            return this.readObject();
-        } else if (p === '[') {
-            return this.readArray();
-        } else if (!p) {
-            return this.readScalar();
-        }
-    }
-
-    static parse(text: string) {
-        const parser = new JsonParser(text);
-        const r = parser.readValue();
-        if (r === undefined) {
-            throw new Error('Not a valid JSON');
-        }
-        return r;
-    }
-}
-
-
 export function parseJSON(text: string): JSONValue {
     text = text.trim();
     try {
@@ -183,7 +18,7 @@ export function parseJSON(text: string): JSONValue {
     } catch (err: any) {
         // use a relaxed parser
         try {
-            return JsonParser.parse(text);
+            return JSON.parse(jsonrepair(text));
         } catch (err2: any) { // throw the original error
             throw err;
         }

package/src/stream.ts

@@ -1,22 +1,30 @@
 
 export async function readStreamAsBase64(stream: ReadableStream): Promise<string> {
-    return (await _readStreamAsBuffer(stream)).toString('base64');
+    const uint8Array = await readStreamAsUint8Array(stream);
+    return Buffer.from(uint8Array).toString('base64');
 }
 
 export async function readStreamAsString(stream: ReadableStream): Promise<string> {
-    return (await _readStreamAsBuffer(stream)).toString();
+    const uint8Array = await readStreamAsUint8Array(stream);
+    return Buffer.from(uint8Array).toString();
 }
 
 export async function readStreamAsUint8Array(stream: ReadableStream): Promise<Uint8Array> {
-    // We return a Uint8Array for strict type checking, even though the buffer extends Uint8Array.
-    const buffer = await _readStreamAsBuffer(stream);
-    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-}
-
-async function _readStreamAsBuffer(stream: ReadableStream): Promise<Buffer> {
-    const out: Buffer[] = [];
+    const chunks: Uint8Array[] = [];
+    let totalLength = 0;
+    
     for await (const chunk of stream) {
-        out.push(Buffer.from(chunk));
+        const uint8Chunk = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+        chunks.push(uint8Chunk);
+        totalLength += uint8Chunk.length;
+    }
+    
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.length;
     }
-    return Buffer.concat(out);
+    
+    return combined;
 }

package/src/validation.ts

@@ -1,8 +1,8 @@
+import { CompletionResult, ResultValidationError } from "@llumiverse/common";
 import { Ajv } from 'ajv';
 import addFormats from 'ajv-formats';
 import { extractAndParseJSON } from "./json.js";
 import { resolveField } from './resolver.js';
-import { ResultValidationError } from "@llumiverse/common";
 
 
 const ajv = new Ajv({
@@ -28,17 +28,40 @@ export class ValidationError extends Error implements ResultValidationError {
     }
 }
 
-export function validateResult(data: any, schema: Object) {
-    let json;
+function parseCompletionAsJson(data: CompletionResult[]) {
+    let lastError: ValidationError | undefined;
+    for (const part of data) {
+        if (part.type === "text") {
+            const text = part.value.trim();
+            try {
+                return extractAndParseJSON(text);
+            } catch (error: any) {
+                lastError = new ValidationError("json_error", error.message);
+            }
+        }
+    }
+    if (!lastError) {
+        lastError = new ValidationError("json_error", "No JSON compatible response found in completion result");
+    }
+    throw lastError;
+}
+
 
-    if (typeof data === "string") {
-        try {
-            json = extractAndParseJSON(data);
-        } catch (error: any) {
-            throw new ValidationError("json_error", error.message)
+export function validateResult(data: CompletionResult[], schema: Object): CompletionResult[] {
+    let json;
+    if (Array.isArray(data)) {
+        const jsonResults = data.filter(r => r.type === "json");
+        if (jsonResults.length > 0) {
+            json = jsonResults[0].value;
+        } else {
+            try {
+                json = parseCompletionAsJson(data);
+            } catch (error: any) {
+                throw new ValidationError("json_error", error.message)
+            }
         }
     } else {
-        json = data;
+        throw new Error("Data to validate must be an array")
     }
 
     const validate = ajv.compile(schema);
@@ -71,5 +94,5 @@ export function validateResult(data: any, schema: Object) {
         }
     }
 
-    return json;
+    return [{ type: "json", value: json }];
 }