@llumiverse/drivers/lib/esm/src/test/index.js

LLM driver implementations. Currently supported are: openai, huggingface, bedrock, replicate.

import { AIModelStatus, ModelType } 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 var TestDriverModels;
(function (TestDriverModels) {
    TestDriverModels["executionError"] = "execution-error";
    TestDriverModels["validationError"] = "validation-error";
})(TestDriverModels || (TestDriverModels = {}));
export class TestDriver {
    provider = "test";
    createTrainingPrompt() {
        throw new Error("Method not implemented.");
    }
    startTraining() {
        throw new Error("Method not implemented.");
    }
    cancelTraining() {
        throw new Error("Method not implemented.");
    }
    getTrainingJob(_jobId) {
        throw new Error("Method not implemented.");
    }
    async createPrompt(segments, _opts) {
        return segments;
    }
    execute(segments, options) {
        switch (options.model) {
            case TestDriverModels.executionError:
                return this.executeError(segments, options);
            case TestDriverModels.validationError:
                return this.executeValidationError(segments, options);
            default:
                throwError("[test driver] Unknown model: " + options.model, segments);
        }
    }
    async stream(segments, options) {
        switch (options.model) {
            case TestDriverModels.executionError:
                return new TestErrorCompletionStream(segments, options);
            case TestDriverModels.validationError:
                return new TestValidationErrorCompletionStream(segments, options);
            default:
                throwError("[test driver] Unknown model: " + options.model, segments);
        }
    }
    async listTrainableModels() {
        return [];
    }
    async listModels() {
        return [
            {
                id: TestDriverModels.executionError,
                name: "Execution Error",
                type: ModelType.Test,
                provider: this.provider,
                status: AIModelStatus.Available,
                description: "Test execution errors",
                tags: [],
            },
            {
                id: TestDriverModels.validationError,
                name: "Validation Error",
                type: ModelType.Test,
                provider: this.provider,
                status: AIModelStatus.Available,
                description: "Test validation errors",
                tags: [],
            },
        ];
    }
    validateConnection() {
        throw new Error("Method not implemented.");
    }
    generateEmbeddings() {
        throw new Error("Method not implemented.");
    }
    // ============== execution error ==================
    async executeError(segments, _options) {
        await sleep(1000);
        throwError("Testing stream completion error.", segments);
    }
    // ============== validation error ==================
    async executeValidationError(segments, _options) {
        await sleep(3000);
        return createValidationErrorCompletion(segments);
    }
}
//# sourceMappingURL=index.js.map