@trymirai/uzu 0.3.1 → 0.4.0

package/src/bridging/classificationStats.ts

@@ -1,45 +0,0 @@
-import { ClassificationStats as NapiClassificationStats } from '../napi/uzu';
-
-export class ClassificationStats {
-    readonly preprocessingDuration: number;
-    readonly forwardPassDuration: number;
-    readonly postprocessingDuration: number;
-    readonly totalDuration: number;
-    readonly tokensCount: number;
-    readonly tokensPerSecond: number;
-    readonly predictedLabel: string;
-    readonly confidence: number;
-
-    constructor(
-        preprocessingDuration: number,
-        forwardPassDuration: number,
-        postprocessingDuration: number,
-        totalDuration: number,
-        tokensCount: number,
-        tokensPerSecond: number,
-        predictedLabel: string,
-        confidence: number,
-    ) {
-        this.preprocessingDuration = preprocessingDuration;
-        this.forwardPassDuration = forwardPassDuration;
-        this.postprocessingDuration = postprocessingDuration;
-        this.totalDuration = totalDuration;
-        this.tokensCount = tokensCount;
-        this.tokensPerSecond = tokensPerSecond;
-        this.predictedLabel = predictedLabel;
-        this.confidence = confidence;
-    }
-
-    static fromNapi(napiEntity: NapiClassificationStats): ClassificationStats {
-        return new ClassificationStats(
-            napiEntity.preprocessingDuration,
-            napiEntity.forwardPassDuration,
-            napiEntity.postprocessingDuration,
-            napiEntity.totalDuration,
-            napiEntity.tokensCount,
-            napiEntity.tokensPerSecond,
-            napiEntity.predictedLabel,
-            napiEntity.confidence,
-        );
-    }
-}

package/src/bridging/config.ts

@@ -1,122 +0,0 @@
-import { Config as NapiConfig } from '../napi/uzu';
-import { AsyncBatchSize } from './asyncBatchSize';
-import { ContextLength } from './contextLength';
-import { ContextMode } from './contextMode';
-import { ToNapi } from './napi';
-import { PrefillStepSize } from './prefillStepSize';
-import { Preset } from './preset';
-import { SamplingSeed } from './samplingSeed';
-
-export class Config implements ToNapi<NapiConfig> {
-    readonly preset: Preset;
-    readonly contextMode: ContextMode;
-    readonly contextLength: ContextLength;
-    readonly prefillStepSize: PrefillStepSize;
-    readonly samplingSeed: SamplingSeed;
-    readonly asyncBatchSize: AsyncBatchSize;
-
-    constructor(
-        preset: Preset,
-        contextMode: ContextMode,
-        contextLength: ContextLength,
-        prefillStepSize: PrefillStepSize,
-        samplingSeed: SamplingSeed,
-        asyncBatchSize: AsyncBatchSize,
-    ) {
-        this.preset = preset;
-        this.contextMode = contextMode;
-        this.contextLength = contextLength;
-        this.prefillStepSize = prefillStepSize;
-        this.samplingSeed = samplingSeed;
-        this.asyncBatchSize = asyncBatchSize;
-    }
-
-    static default(): Config {
-        return new Config(
-            Preset.general(),
-            ContextMode.none(),
-            ContextLength.default(),
-            PrefillStepSize.default(),
-            SamplingSeed.default(),
-            AsyncBatchSize.default(),
-        );
-    }
-
-    withPreset(preset: Preset): Config {
-        return new Config(
-            preset,
-            this.contextMode,
-            this.contextLength,
-            this.prefillStepSize,
-            this.samplingSeed,
-            this.asyncBatchSize,
-        );
-    }
-
-    withContextMode(contextMode: ContextMode): Config {
-        return new Config(
-            this.preset,
-            contextMode,
-            this.contextLength,
-            this.prefillStepSize,
-            this.samplingSeed,
-            this.asyncBatchSize,
-        );
-    }
-
-    withContextLength(contextLength: ContextLength): Config {
-        return new Config(
-            this.preset,
-            this.contextMode,
-            contextLength,
-            this.prefillStepSize,
-            this.samplingSeed,
-            this.asyncBatchSize,
-        );
-    }
-
-    withPrefillStepSize(prefillStepSize: PrefillStepSize): Config {
-        return new Config(
-            this.preset,
-            this.contextMode,
-            this.contextLength,
-            prefillStepSize,
-            this.samplingSeed,
-            this.asyncBatchSize,
-        );
-    }
-
-    withSamplingSeed(samplingSeed: SamplingSeed): Config {
-        return new Config(
-            this.preset,
-            this.contextMode,
-            this.contextLength,
-            this.prefillStepSize,
-            samplingSeed,
-            this.asyncBatchSize,
-        );
-    }
-
-    withAsyncBatchSize(asyncBatchSize: AsyncBatchSize): Config {
-        return new Config(
-            this.preset,
-            this.contextMode,
-            this.contextLength,
-            this.prefillStepSize,
-            this.samplingSeed,
-            asyncBatchSize,
-        );
-    }
-
-    toNapi(): NapiConfig {
-        const napiConfig: NapiConfig = {
-            preset: this.preset.toNapi(),
-            contextMode: this.contextMode.toNapi(),
-            contextLength: this.contextLength.toNapi(),
-            prefillStepSize: this.prefillStepSize.toNapi(),
-            samplingSeed: this.samplingSeed.toNapi(),
-            asyncBatchSize: this.asyncBatchSize.toNapi(),
-        };
-        return napiConfig;
-    }
-}

package/src/bridging/contextLength.ts

@@ -1,29 +0,0 @@
-import { ContextLength as NapiContextLength } from '../napi/uzu';
-import { ToNapi } from './napi';
-
-export class ContextLength implements ToNapi<NapiContextLength> {
-    private readonly napiContextLength: NapiContextLength;
-
-    private constructor(napiContextLength: NapiContextLength) {
-        this.napiContextLength = napiContextLength;
-    }
-
-    static default(): ContextLength {
-        const napiContextLength: NapiContextLength = { type: 'Default' };
-        return new ContextLength(napiContextLength);
-    }
-
-    static maximal(): ContextLength {
-        const napiContextLength: NapiContextLength = { type: 'Maximal' };
-        return new ContextLength(napiContextLength);
-    }
-
-    static custom(length: number): ContextLength {
-        const napiContextLength: NapiContextLength = { type: 'Custom', length };
-        return new ContextLength(napiContextLength);
-    }
-
-    toNapi(): NapiContextLength {
-        return this.napiContextLength;
-    }
-}

package/src/bridging/contextMode.ts

@@ -1,31 +0,0 @@
-import { ContextMode as NapiContextMode, Input as NapiInput } from '../napi/uzu';
-import { Input } from './input';
-import { ToNapi } from './napi';
-
-export class ContextMode implements ToNapi<NapiContextMode> {
-    private readonly napiContextMode: NapiContextMode;
-
-    private constructor(napiContextMode: NapiContextMode) {
-        this.napiContextMode = napiContextMode;
-    }
-
-    static none(): ContextMode {
-        const napiContextMode: NapiContextMode = { type: 'None' };
-        return new ContextMode(napiContextMode);
-    }
-
-    static static(input: Input): ContextMode {
-        let napiInput: NapiInput = input.toNapi();
-        let napiContextMode: NapiContextMode = { type: 'Static', input: napiInput };
-        return new ContextMode(napiContextMode);
-    }
-
-    static dynamic(): ContextMode {
-        const napiContextMode: NapiContextMode = { type: 'Dynamic' };
-        return new ContextMode(napiContextMode);
-    }
-
-    toNapi(): NapiContextMode {
-        return this.napiContextMode;
-    }
-}

package/src/bridging/downloadHandle.ts

@@ -1,41 +0,0 @@
-import { ModelDownloadHandle as NapiModelDownloadHandle } from '../napi/uzu';
-import { DownloadProgressUpdate } from './downloadProgressUpdate';
-import { DownloadState } from './downloadState';
-
-export class DownloadHandle {
-    private readonly napiDownloadHandle: NapiModelDownloadHandle;
-
-    constructor(napiDownloadHandle: NapiModelDownloadHandle) {
-        this.napiDownloadHandle = napiDownloadHandle;
-    }
-
-    identifier(): string {
-        return this.napiDownloadHandle.identifier();
-    }
-
-    async state(): Promise<DownloadState> {
-        const napiDownloadState = await this.napiDownloadHandle.state();
-        return DownloadState.fromNapi(napiDownloadState);
-    }
-
-    async download(): Promise<void> {
-        await this.napiDownloadHandle.download();
-    }
-
-    async pause(): Promise<void> {
-        await this.napiDownloadHandle.pause();
-    }
-
-    async delete(): Promise<void> {
-        await this.napiDownloadHandle.delete();
-    }
-
-    progressUpdate(): AsyncIterable<DownloadProgressUpdate> {
-        const source = this.napiDownloadHandle.progress();
-        return (async function* () {
-            for await (const update of source) {
-                yield DownloadProgressUpdate.fromNapi(update);
-            }
-        })();
-    }
-}

package/src/bridging/downloadProgressUpdate.ts

@@ -1,21 +0,0 @@
-import { ProgressUpdate as NapiProgressUpdate } from '../napi/uzu';
-
-export class DownloadProgressUpdate {
-    readonly completedBytes: number;
-    readonly totalBytes: number | null;
-    readonly progress: number;
-
-    private constructor(completedBytes: number, totalBytes: number | null, progress: number) {
-        this.completedBytes = completedBytes;
-        this.totalBytes = totalBytes;
-        this.progress = progress;
-    }
-
-    static fromNapi(napiDownloadProgress: NapiProgressUpdate): DownloadProgressUpdate {
-        return new DownloadProgressUpdate(
-            napiDownloadProgress.completedBytes,
-            napiDownloadProgress.totalBytes ?? null,
-            napiDownloadProgress.progress,
-        );
-    }
-}

package/src/bridging/downloadState.ts

@@ -1,62 +0,0 @@
-import { EngineError, EngineErrorCode } from '../error';
-import {
-    ModelDownloadPhase as NapiModelDownloadPhase,
-    ModelDownloadState as NapiModelDownloadState,
-} from '../napi/uzu';
-
-export enum DownloadPhase {
-    NotDownloaded = 'NotDownloaded',
-    Downloading = 'Downloading',
-    Paused = 'Paused',
-    Downloaded = 'Downloaded',
-    Locked = 'Locked',
-    Error = 'Error',
-}
-
-export class DownloadState {
-    readonly totalKbytes: number;
-    readonly downloadedKbytes: number;
-    readonly phase: DownloadPhase;
-    readonly error: string | null;
-
-    private constructor(
-        totalKbytes: number,
-        downloadedKbytes: number,
-        phase: DownloadPhase,
-        error: string | null,
-    ) {
-        this.totalKbytes = totalKbytes;
-        this.downloadedKbytes = downloadedKbytes;
-        this.phase = phase;
-        this.error = error;
-    }
-
-    private static napiPhaseToDownloadPhase(napiPhase: NapiModelDownloadPhase): DownloadPhase {
-        switch (napiPhase) {
-            case 0:
-                return DownloadPhase.NotDownloaded;
-            case 1:
-                return DownloadPhase.Downloading;
-            case 2:
-                return DownloadPhase.Paused;
-            case 3:
-                return DownloadPhase.Downloaded;
-            case 4:
-                return DownloadPhase.Locked;
-            case 5:
-                return DownloadPhase.Error;
-            default:
-                throw new EngineError(EngineErrorCode.UnexpectedDownloadPhase);
-        }
-    }
-
-    static fromNapi(napiDownloadState: NapiModelDownloadState): DownloadState {
-        const phase = DownloadState.napiPhaseToDownloadPhase(napiDownloadState.phase);
-        return new DownloadState(
-            napiDownloadState.totalKbytes,
-            napiDownloadState.downloadedKbytes,
-            phase,
-            napiDownloadState.error ?? null,
-        );
-    }
-}

package/src/bridging/engine.ts

@@ -1,141 +0,0 @@
-import { EngineError, EngineErrorCode, unwrapOrThrow } from '../error';
-import { EngineInteractor } from '../interactors/engineInteractor';
-import { Engine as NapiEngine } from '../napi/uzu';
-import { readEnv } from '../utilities/env';
-import { ChatSession } from './chatSession';
-import { ClassificationSession } from './classificationSession';
-import { Config } from './config';
-import { DownloadHandle } from './downloadHandle';
-import { DownloadProgressUpdate } from './downloadProgressUpdate';
-import { DownloadPhase, DownloadState } from './downloadState';
-import { LicenseStatus, licenseStatusFromNapiLicenseStatus } from './licenseStatus';
-import { Model } from './model';
-import { ModelKind, modelKindToNapiModelKind } from './modelKind';
-import { TextToSpeechSession } from './textToSpeechSession';
-
-export class Engine {
-    private readonly napiEngine: NapiEngine;
-
-    private constructor(napiEngine: NapiEngine) {
-        this.napiEngine = napiEngine;
-    }
-
-    static async load(apiKey: string | undefined = undefined): Promise<Engine> {
-        const resolvedApiKey = unwrapOrThrow(
-            apiKey ?? readEnv('MIRAI_API_KEY'),
-            EngineErrorCode.APIKeyNotFound,
-        );
-
-        const napiEngine = new NapiEngine();
-
-        const napiLicenseStatus = await napiEngine.activate(resolvedApiKey);
-        const licenseStatus = licenseStatusFromNapiLicenseStatus(napiLicenseStatus);
-        switch (licenseStatus) {
-            case LicenseStatus.Activated:
-            case LicenseStatus.GracePeriodActive:
-                break;
-            default:
-                throw new EngineError(EngineErrorCode.LicenseNotActivated);
-        }
-
-        return new Engine(napiEngine);
-    }
-
-    static create(apiKey: string | undefined = undefined): EngineInteractor {
-        const enginePromise = (async () => {
-            return await Engine.load(apiKey);
-        })();
-        return new EngineInteractor(enginePromise);
-    }
-
-    getDownloadState(repoId: string): DownloadState {
-        let downloadState = this.napiEngine.getModelDownloadState(repoId);
-        return DownloadState.fromNapi(downloadState);
-    }
-
-    downloadHandle(repoId: string): DownloadHandle {
-        return new DownloadHandle(this.napiEngine.createModelDownloadHandle(repoId));
-    }
-
-    async downloadModel(
-        model: Model,
-        progress: (progressUpdate: DownloadProgressUpdate) => void = () => {},
-    ): Promise<DownloadState> {
-        switch (model.kind) {
-            case ModelKind.Local:
-                break;
-            case ModelKind.Cloud:
-                throw new EngineError(EngineErrorCode.UnexpectedModelKind);
-        }
-
-        const downloadHandle = this.downloadHandle(model.repoId);
-        const state = await downloadHandle.state();
-        switch (state.phase) {
-            case DownloadPhase.Downloaded:
-                break;
-            default:
-                await downloadHandle.download();
-                for await (const progressUpdate of downloadHandle.progressUpdate()) {
-                    progress(progressUpdate);
-                }
-                break;
-        }
-
-        const finalState = await downloadHandle.state();
-        return finalState;
-    }
-
-    async chatModels(kinds: ModelKind[] | null = null): Promise<Model[]> {
-        let kindsToFilter: ModelKind[] = kinds ?? [ModelKind.Local, ModelKind.Cloud];
-        let napiModelKinds = kindsToFilter.map(modelKindToNapiModelKind);
-        let napiChatModels = await this.napiEngine.getChatModels(napiModelKinds);
-        let results: Model[] = napiChatModels.map(Model.fromNapiModel);
-        return results;
-    }
-
-    async chatModel(repoId: string, kinds: ModelKind[] | null = null): Promise<Model> {
-        const chatModels = await this.chatModels(kinds);
-        const chatModel = chatModels.find((model) => model.repoId === repoId);
-        return unwrapOrThrow(chatModel, EngineErrorCode.ModelNotFound);
-    }
-
-    chatSession(model: Model, config: Config = Config.default()): ChatSession {
-        const napiModel = model.toNapi();
-        const napiConfig = config.toNapi();
-        return new ChatSession(this.napiEngine.createChatSession(napiModel, napiConfig));
-    }
-
-    async classificationModels(): Promise<Model[]> {
-        const napiClassificationModels = await this.napiEngine.getClassificationModels();
-        const results: Model[] = napiClassificationModels.map(Model.fromNapiModel);
-        return results;
-    }
-
-    async classificationModel(repoId: string): Promise<Model> {
-        const classificationModels = await this.classificationModels();
-        const classificationModel = classificationModels.find((model) => model.repoId === repoId);
-        return unwrapOrThrow(classificationModel, EngineErrorCode.ModelNotFound);
-    }
-
-    classificationSession(model: Model): ClassificationSession {
-        const napiModel = model.toNapi();
-        return new ClassificationSession(this.napiEngine.createClassificationSession(napiModel));
-    }
-
-    async textToSpeechModels(): Promise<Model[]> {
-        const napiTextToSpeechModels = await this.napiEngine.getTextToSpeechModels();
-        const results: Model[] = napiTextToSpeechModels.map(Model.fromNapiModel);
-        return results;
-    }
-
-    async textToSpeechModel(repoId: string): Promise<Model> {
-        const textToSpeechModels = await this.textToSpeechModels();
-        const textToSpeechModel = textToSpeechModels.find((model) => model.repoId === repoId);
-        return unwrapOrThrow(textToSpeechModel, EngineErrorCode.ModelNotFound);
-    }
-
-    textToSpeechSession(model: Model): TextToSpeechSession {
-        const napiModel = model.toNapi();
-        return new TextToSpeechSession(this.napiEngine.createTextToSpeechSession(napiModel));
-    }
-}

package/src/bridging/finishReason.ts

@@ -1,6 +0,0 @@
-export enum FinishReason {
-    Stop = 0,
-    Length = 1,
-    Cancelled = 2,
-    ContextLimitReached = 3,
-}

package/src/bridging/grammarConfig.ts

@@ -1,40 +0,0 @@
-import * as z from 'zod';
-import { GrammarConfig as NapiGrammarConfig } from '../napi/uzu';
-import { ToNapi } from './napi';
-
-export class GrammarConfig implements ToNapi<NapiGrammarConfig> {
-    private readonly napiGrammarConfig: NapiGrammarConfig;
-
-    private constructor(napiGrammarConfig: NapiGrammarConfig) {
-        this.napiGrammarConfig = napiGrammarConfig;
-    }
-
-    static jsonSchema(schema: string): GrammarConfig {
-        let a = z.object({
-            name: z.string(),
-            age: z.number(),
-        });
-        const napiGrammarConfig: NapiGrammarConfig = { type: 'JsonSchema', schema: schema };
-        return new GrammarConfig(napiGrammarConfig);
-    }
-
-    static regex(pattern: string): GrammarConfig {
-        const napiGrammarConfig: NapiGrammarConfig = { type: 'Regex', pattern: pattern };
-        return new GrammarConfig(napiGrammarConfig);
-    }
-
-    static builtinJson(): GrammarConfig {
-        const napiGrammarConfig: NapiGrammarConfig = { type: 'BuiltinJson' };
-        return new GrammarConfig(napiGrammarConfig);
-    }
-
-    static fromType(type: z.ZodType): GrammarConfig {
-        let schema = z.toJSONSchema(type);
-        let schemaString = JSON.stringify(schema);
-        return GrammarConfig.jsonSchema(schemaString);
-    }
-
-    toNapi(): NapiGrammarConfig {
-        return this.napiGrammarConfig;
-    }
-}

package/src/bridging/input.ts

@@ -1,29 +0,0 @@
-import { Input as NapiInput, Message as NapiMessage } from '../napi/uzu';
-import { Message } from './message';
-import { ToNapi } from './napi';
-
-export class Input implements ToNapi<NapiInput> {
-    private readonly napiInput: NapiInput;
-
-    private constructor(napiInput: NapiInput) {
-        this.napiInput = napiInput;
-    }
-
-    static text(text: string): Input {
-        const napiInput: NapiInput = { type: 'Text', text };
-        return new Input(napiInput);
-    }
-
-    static messages(messages: Message[]): Input {
-        const napiMessages: NapiMessage[] = messages.map((message) => message.toNapi());
-        const napiInput: NapiInput = {
-            type: 'Messages',
-            messages: napiMessages,
-        };
-        return new Input(napiInput);
-    }
-
-    toNapi(): NapiInput {
-        return this.napiInput;
-    }
-}

package/src/bridging/licenseStatus.ts

@@ -1,39 +0,0 @@
-import { EngineError, EngineErrorCode } from '../error';
-import { LicenseStatus as NapiLicenseStatus } from '../napi/uzu';
-
-export enum LicenseStatus {
-    NotActivated = 'NotActivated',
-    PaymentRequired = 'PaymentRequired',
-    GracePeriodActive = 'GracePeriodActive',
-    Activated = 'Activated',
-    NetworkError = 'NetworkError',
-    InvalidApiKey = 'InvalidApiKey',
-    SignatureMismatch = 'SignatureMismatch',
-    Timeout = 'Timeout',
-    HttpError = 'HttpError',
-}
-
-export function licenseStatusFromNapiLicenseStatus(napiLicenseStatus: NapiLicenseStatus): LicenseStatus {
-    switch (napiLicenseStatus.type) {
-        case 'NotActivated':
-            return LicenseStatus.NotActivated;
-        case 'PaymentRequired':
-            return LicenseStatus.PaymentRequired;
-        case 'GracePeriodActive':
-            return LicenseStatus.GracePeriodActive;
-        case 'Activated':
-            return LicenseStatus.Activated;
-        case 'NetworkError':
-            return LicenseStatus.NetworkError;
-        case 'InvalidApiKey':
-            return LicenseStatus.InvalidApiKey;
-        case 'SignatureMismatch':
-            return LicenseStatus.SignatureMismatch;
-        case 'Timeout':
-            return LicenseStatus.Timeout;
-        case 'HttpError':
-            return LicenseStatus.HttpError;
-        default:
-            throw new EngineError(EngineErrorCode.UnexpectedLicenseStatus);
-    }
-}

package/src/bridging/message.ts

@@ -1,50 +0,0 @@
-import { Message as NapiMessage, Role as NapiRole } from '../napi/uzu';
-import { ToNapi } from './napi';
-import { Role } from './role';
-
-export class Message implements ToNapi<NapiMessage> {
-    readonly role: Role;
-    readonly content: string;
-    readonly reasoningContent: string | null;
-
-    private constructor(role: Role, content: string, reasoningContent: string | null = null) {
-        this.role = role;
-        this.content = content;
-        this.reasoningContent = reasoningContent;
-    }
-
-    static system(content: string): Message {
-        return new Message(Role.System, content);
-    }
-
-    static user(content: string): Message {
-        return new Message(Role.User, content);
-    }
-
-    static assistant(content: string, reasoningContent: string | null = null): Message {
-        return new Message(Role.Assistant, content, reasoningContent);
-    }
-
-    private static roleToNapiRole(role: Role): NapiRole {
-        switch (role) {
-            case Role.System:
-                return 0;
-            case Role.User:
-                return 1;
-            case Role.Assistant:
-                return 2;
-        }
-    }
-
-    toNapi(): NapiMessage {
-        const napiRole: NapiRole = Message.roleToNapiRole(this.role);
-        const napiMessage: NapiMessage = {
-            role: napiRole,
-            content: this.content,
-        };
-        if (this.reasoningContent) {
-            napiMessage.reasoningContent = this.reasoningContent;
-        }
-        return napiMessage;
-    }
-}