@trymirai/uzu 0.3.0 → 0.4.0

package/src/interactors/chatModelInteractor.ts

@@ -1,126 +0,0 @@
-import { AsyncBatchSize } from '../bridging/asyncBatchSize';
-import { Config } from '../bridging/config';
-import { ContextLength } from '../bridging/contextLength';
-import { ContextMode } from '../bridging/contextMode';
-import { DownloadProgressUpdate } from '../bridging/downloadProgressUpdate';
-import { DownloadPhase } from '../bridging/downloadState';
-import { Message } from '../bridging/message';
-import { Model } from '../bridging/model';
-import { ModelKind } from '../bridging/modelKind';
-import { Output } from '../bridging/output';
-import { PrefillStepSize } from '../bridging/prefillStepSize';
-import { Preset } from '../bridging/preset';
-import { RunConfig } from '../bridging/runConfig';
-import { SamplingSeed } from '../bridging/samplingSeed';
-import { ChatModelsInteractor } from './chatModelsInteractor';
-import { ChatSessionInteractor } from './chatSessionInteractor';
-import { DownloadInteractor } from './downloadInteractor';
-import { Interactor, InteractorEntity } from './interactor';
-
-export class ChatModelInteractor implements Interactor<Model> {
-    readonly modelsInteractor: ChatModelsInteractor;
-    readonly entity: InteractorEntity<Model>;
-    readonly config: Config;
-
-    constructor(modelsInteractor: ChatModelsInteractor, model: InteractorEntity<Model>, config: Config) {
-        this.modelsInteractor = modelsInteractor;
-        this.entity = model;
-        this.config = config;
-    }
-
-    async finalize(): Promise<Model> {
-        return await this.entity;
-    }
-
-    /* Downloading */
-
-    downloading(): DownloadInteractor {
-        const handlePromise = (async () => {
-            const model = await this.finalize();
-            const engine = await this.modelsInteractor.engineInteractor.finalize();
-            const handle = engine.downloadHandle(model.repoId);
-            return handle;
-        })();
-        return new DownloadInteractor(this, handlePromise);
-    }
-
-    download(callback?: (progressUpdate: DownloadProgressUpdate) => void): ChatModelInteractor {
-        const modelPromise = (async () => {
-            const downloadInteractor = this.downloading();
-            const handle = await downloadInteractor.finalize();
-            const state = await handle.state();
-            switch (state.phase) {
-                case DownloadPhase.Downloaded:
-                    break;
-                default:
-                    await downloadInteractor
-                        .resume()
-                        .onProgressUpdate(callback ?? (() => {}))
-                        .finalize();
-                    break;
-            }
-            return this.finalize();
-        })();
-        return new ChatModelInteractor(this.modelsInteractor, modelPromise, this.config);
-    }
-
-    /* Config */
-
-    preset(preset: Preset): ChatModelInteractor {
-        const config = this.config.withPreset(preset);
-        return new ChatModelInteractor(this.modelsInteractor, this.entity, config);
-    }
-
-    contextMode(contextMode: ContextMode): ChatModelInteractor {
-        const config = this.config.withContextMode(contextMode);
-        return new ChatModelInteractor(this.modelsInteractor, this.entity, config);
-    }
-
-    contextLength(contextLength: ContextLength): ChatModelInteractor {
-        const config = this.config.withContextLength(contextLength);
-        return new ChatModelInteractor(this.modelsInteractor, this.entity, config);
-    }
-
-    prefillStepSize(prefillStepSize: PrefillStepSize): ChatModelInteractor {
-        const config = this.config.withPrefillStepSize(prefillStepSize);
-        return new ChatModelInteractor(this.modelsInteractor, this.entity, config);
-    }
-
-    samplingSeed(samplingSeed: SamplingSeed): ChatModelInteractor {
-        const config = this.config.withSamplingSeed(samplingSeed);
-        return new ChatModelInteractor(this.modelsInteractor, this.entity, config);
-    }
-
-    asyncBatchSize(asyncBatchSize: AsyncBatchSize): ChatModelInteractor {
-        const config = this.config.withAsyncBatchSize(asyncBatchSize);
-        return new ChatModelInteractor(this.modelsInteractor, this.entity, config);
-    }
-
-    /* Session */
-
-    session(): ChatSessionInteractor {
-        const sessionPromise = (async () => {
-            const engine = await this.modelsInteractor.engineInteractor.finalize();
-
-            let model = await this.finalize();
-            if (model.kind === ModelKind.Local) {
-                model = await this.download().finalize();
-            }
-
-            const session = engine.chatSession(model, this.config);
-            return session;
-        })();
-        return new ChatSessionInteractor(this, sessionPromise, RunConfig.default());
-    }
-
-    async reply(text: string, progress: (partialOutput: Output) => boolean = () => true): Promise<Output> {
-        return await this.session().reply(text, progress);
-    }
-
-    async replyToMessages(
-        messages: Message[],
-        progress: (partialOutput: Output) => boolean = () => true,
-    ): Promise<Output> {
-        return await this.session().replyToMessages(messages, progress);
-    }
-}

package/src/interactors/chatModelsInteractor.ts

@@ -1,29 +0,0 @@
-import { Config } from '../bridging/config';
-import { Model } from '../bridging/model';
-import { EngineErrorCode, unwrapOrThrow } from '../error';
-import { ChatModelInteractor } from './chatModelInteractor';
-import { EngineInteractor } from './engineInteractor';
-import { Interactor, InteractorEntity } from './interactor';
-
-export class ChatModelsInteractor implements Interactor<Model[]> {
-    readonly engineInteractor: EngineInteractor;
-    readonly entity: InteractorEntity<Model[]>;
-
-    constructor(engineInteractor: EngineInteractor, models: InteractorEntity<Model[]>) {
-        this.engineInteractor = engineInteractor;
-        this.entity = models;
-    }
-
-    async finalize(): Promise<Model[]> {
-        return await this.entity;
-    }
-
-    get(repoId: string): ChatModelInteractor {
-        const modelPromise = (async () => {
-            const models = await this.finalize();
-            const model = models.find((model) => model.repoId === repoId);
-            return unwrapOrThrow(model, EngineErrorCode.ModelNotFound);
-        })();
-        return new ChatModelInteractor(this, modelPromise, Config.default());
-    }
-}

package/src/interactors/chatSessionInteractor.ts

@@ -1,80 +0,0 @@
-import { ChatSession } from '../bridging/chatSession';
-import { GrammarConfig } from '../bridging/grammarConfig';
-import { Input } from '../bridging/input';
-import { Message } from '../bridging/message';
-import { Output } from '../bridging/output';
-import { RunConfig } from '../bridging/runConfig';
-import { SamplingMethod } from '../bridging/samplingMethod';
-import { SamplingPolicy } from '../bridging/samplingPolicy';
-import { ChatModelInteractor } from './chatModelInteractor';
-import { Interactor, InteractorEntity } from './interactor';
-
-export class ChatSessionInteractor implements Interactor<ChatSession> {
-    readonly modelInteractor: ChatModelInteractor;
-    readonly entity: InteractorEntity<ChatSession>;
-    readonly config: RunConfig;
-
-    constructor(
-        modelInteractor: ChatModelInteractor,
-        session: InteractorEntity<ChatSession>,
-        config: RunConfig,
-    ) {
-        this.modelInteractor = modelInteractor;
-        this.entity = session;
-        this.config = config;
-    }
-
-    async finalize(): Promise<ChatSession> {
-        return await this.entity;
-    }
-
-    /* Config */
-
-    tokensLimit(tokensLimit: number): ChatSessionInteractor {
-        const config = this.config.withTokensLimit(tokensLimit);
-        return new ChatSessionInteractor(this.modelInteractor, this.entity, config);
-    }
-
-    enableThinking(enableThinking: boolean): ChatSessionInteractor {
-        const config = this.config.withEnableThinking(enableThinking);
-        return new ChatSessionInteractor(this.modelInteractor, this.entity, config);
-    }
-
-    samplingPolicy(samplingPolicy: SamplingPolicy): ChatSessionInteractor {
-        const config = this.config.withSamplingPolicy(samplingPolicy);
-        return new ChatSessionInteractor(this.modelInteractor, this.entity, config);
-    }
-
-    samplingMethod(samplingMethod: SamplingMethod): ChatSessionInteractor {
-        const config = this.config.withSamplingPolicy(SamplingPolicy.custom(samplingMethod));
-        return new ChatSessionInteractor(this.modelInteractor, this.entity, config);
-    }
-
-    grammarConfig(grammarConfig: GrammarConfig | null): ChatSessionInteractor {
-        const config = this.config.withGrammarConfig(grammarConfig);
-        return new ChatSessionInteractor(this.modelInteractor, this.entity, config);
-    }
-
-    /* Run */
-
-    async run(input: Input, progress: (partialOutput: Output) => boolean = () => true): Promise<Output> {
-        const outputPromise = (async () => {
-            const session = await this.finalize();
-            const output = session.run(input, this.config, progress);
-            return output;
-        })();
-        const output = await outputPromise;
-        return output;
-    }
-
-    async reply(text: string, progress: (partialOutput: Output) => boolean = () => true): Promise<Output> {
-        return await this.run(Input.text(text), progress);
-    }
-
-    async replyToMessages(
-        messages: Message[],
-        progress: (partialOutput: Output) => boolean = () => true,
-    ): Promise<Output> {
-        return await this.run(Input.messages(messages), progress);
-    }
-}

package/src/interactors/downloadInteractor.ts

@@ -1,47 +0,0 @@
-import { DownloadHandle } from '../bridging/downloadHandle';
-import { DownloadProgressUpdate } from '../bridging/downloadProgressUpdate';
-import { ChatModelInteractor } from './chatModelInteractor';
-import { Interactor, InteractorEntity } from './interactor';
-
-export class DownloadInteractor implements Interactor<DownloadHandle> {
-    readonly modelInteractor: ChatModelInteractor;
-    readonly entity: InteractorEntity<DownloadHandle>;
-
-    constructor(modelInteractor: ChatModelInteractor, handle: InteractorEntity<DownloadHandle>) {
-        this.modelInteractor = modelInteractor;
-        this.entity = handle;
-    }
-
-    async finalize(): Promise<DownloadHandle> {
-        return await this.entity;
-    }
-
-    resume() {
-        return this.proxyHandleCall(async (handle) => await handle.download());
-    }
-
-    pause() {
-        return this.proxyHandleCall(async (handle) => await handle.pause());
-    }
-
-    delete() {
-        return this.proxyHandleCall(async (handle) => await handle.delete());
-    }
-
-    onProgressUpdate(callback: (progressUpdate: DownloadProgressUpdate) => void) {
-        return this.proxyHandleCall(async (handle) => {
-            for await (const update of handle.progressUpdate()) {
-                callback(update);
-            }
-        });
-    }
-
-    private proxyHandleCall(callback: (handle: DownloadHandle) => Promise<void>): DownloadInteractor {
-        const handlePromise = (async () => {
-            const handle = await this.finalize();
-            await callback(handle);
-            return handle;
-        })();
-        return new DownloadInteractor(this.modelInteractor, handlePromise);
-    }
-}

package/src/interactors/engineInteractor.ts

@@ -1,38 +0,0 @@
-import { Engine } from '../bridging/engine';
-import { ModelKind } from '../bridging/modelKind';
-import { ChatModelInteractor } from './chatModelInteractor';
-import { ChatModelsInteractor } from './chatModelsInteractor';
-import { Interactor, InteractorEntity } from './interactor';
-
-export class EngineInteractor implements Interactor<Engine> {
-    readonly entity: InteractorEntity<Engine>;
-    readonly modelKindFilter: ModelKind[] | null;
-
-    constructor(engine: InteractorEntity<Engine>, modelKindFilter: ModelKind[] | null = null) {
-        this.entity = engine;
-        this.modelKindFilter = modelKindFilter;
-    }
-
-    async finalize(): Promise<Engine> {
-        return await this.entity;
-    }
-
-    /* Models */
-
-    filterKinds(kinds: ModelKind[] | null): EngineInteractor {
-        return new EngineInteractor(this.entity, kinds);
-    }
-
-    chatModels(): ChatModelsInteractor {
-        const modelsPromise = (async () => {
-            const engine = await this.finalize();
-            return await engine.chatModels(this.modelKindFilter);
-        })();
-        return new ChatModelsInteractor(this, modelsPromise);
-    }
-
-    chatModel(repoId: string): ChatModelInteractor {
-        const models = this.chatModels();
-        return models.get(repoId);
-    }
-}

package/src/interactors/interactor.ts

@@ -1,7 +0,0 @@
-export type InteractorEntity<T> = T | Promise<T>;
-
-export interface Interactor<T> {
-    readonly entity: InteractorEntity<T>;
-
-    finalize(): Promise<T>;
-}

package/src/napi/uzu.d.ts

@@ -1,325 +0,0 @@
-/* auto-generated by NAPI-RS */
-/* eslint-disable */
-export declare class ChatSession {
-  run(input: Input, config: RunConfig, progress?: ((arg: Output) => boolean) | undefined | null): Output
-  reset(): void
-}
-
-export declare class ClassificationSession {
-  run(input: Input): ClassificationOutput
-}
-
-export declare class Engine {
-  activate(apiKey: string): Promise<LicenseStatus>
-  getChatModels(kinds: Array<ModelKind>): Promise<Array<Model>>
-  getTextToSpeechModels(): Promise<Array<Model>>
-  getClassificationModels(): Promise<Array<Model>>
-  getModelDownloadState(repoId: string): ModelDownloadState
-  createModelDownloadHandle(repoId: string): ModelDownloadHandle
-  benchmark(task: BenchmarksTask, prefillStepSize?: number | undefined | null): Promise<Array<BenchmarksResult>>
-  constructor()
-  createChatSession(model: Model, config: Config): ChatSession
-  createTextToSpeechSession(model: Model): TextToSpeechSession
-  createClassificationSession(model: Model): ClassificationSession
-  registerLicenseStatusHandler(callback?: ((arg: LicenseStatus) => void) | undefined | null): void
-  registerModelDownloadStateHandler(callback?: ((arg0: string, arg1: ModelDownloadState) => void) | undefined | null): void
-  registerModelsHandler(callback?: ((arg: Array<Model>) => void) | undefined | null): void
-}
-
-export declare class ModelDownloadHandle {
-  identifier(): string
-  download(): Promise<void>
-  pause(): Promise<void>
-  delete(): Promise<void>
-  state(): Promise<ModelDownloadState>
-  progress(): AsyncIterable<ProgressUpdate>
-}
-
-export declare class ProgressStream {
-
-}
-
-export declare class ProgressUpdate {
-  /** Bytes downloaded so far. */
-  completedBytes: number
-  /** Total bytes expected for the download; `None` while unknown. */
-  totalBytes?: number
-  /** Normalised progress between 0.0 and 1.0. */
-  progress: number
-}
-
-export declare class TextToSpeechSession {
-  run(input: Input, outputPath: string): void
-}
-
-export type AsyncBatchSize =
-  | { type: 'Default' }
-  | { type: 'Custom', size: number }
-
-export interface BenchmarksDevice {
-  osName?: string
-  cpuName?: string
-  memoryTotal: number
-}
-
-export interface BenchmarksResult {
-  task: BenchmarksTask
-  device: BenchmarksDevice
-  engineVersion: string
-  timestamp: number
-  precision?: DataType
-  memoryUsed?: number
-  tokensCountInput: number
-  tokensCountOutput: number
-  timeToFirstToken: number
-  promptTokensPerSecond: number
-  generateTokensPerSecond?: number
-  text: string
-}
-
-export interface BenchmarksTask {
-  identifier: string
-  repoId: string
-  numberOfRuns: number
-  tokensLimit: number
-  messages: Array<Message>
-  greedy: boolean
-}
-
-export interface ClassificationFeature {
-  name: string
-  values: Array<string>
-}
-
-export interface ClassificationLabel {
-  index: number
-  label: string
-  title: string
-  description: string
-  recommendedThreshold: number
-}
-
-export interface ClassificationOutput {
-  logits: Array<number>
-  probabilities: Record<string, number>
-  stats: ClassificationStats
-}
-
-export interface ClassificationStats {
-  preprocessingDuration: number
-  forwardPassDuration: number
-  postprocessingDuration: number
-  totalDuration: number
-  tokensCount: number
-  tokensPerSecond: number
-  predictedLabel: string
-  confidence: number
-}
-
-export interface Config {
-  preset: Preset
-  contextMode: ContextMode
-  contextLength: ContextLength
-  prefillStepSize: PrefillStepSize
-  samplingSeed: SamplingSeed
-  asyncBatchSize: AsyncBatchSize
-}
-
-export type ContextLength =
-  | { type: 'Default' }
-  | { type: 'Maximal' }
-  | { type: 'Custom', length: number }
-
-export type ContextMode =
-  | { type: 'None' }
-  | { type: 'Static', input: Input }
-  | { type: 'Dynamic' }
-
-export declare const enum DataType {
-  BFloat16 = 0,
-  Float16 = 1,
-  Float32 = 2,
-  Int4 = 3,
-  Int8 = 4
-}
-
-export declare const enum FinishReason {
-  Stop = 0,
-  Length = 1,
-  Cancelled = 2,
-  ContextLimitReached = 3
-}
-
-export type GrammarConfig =
-  | { type: 'JsonSchema', schema: string }
-  | { type: 'Regex', pattern: string }
-  | { type: 'BuiltinJson' }
-
-export type Input =
-  | { type: 'Text', text: string }
-  | { type: 'Messages', messages: Array<Message> }
-
-export type LicenseStatus =
-  | { type: 'NotActivated' }
-  | { type: 'PaymentRequired' }
-  | { type: 'GracePeriodActive' }
-  | { type: 'Activated' }
-  | { type: 'NetworkError' }
-  | { type: 'InvalidApiKey' }
-  | { type: 'SignatureMismatch' }
-  | { type: 'Timeout' }
-  | { type: 'HttpError', code: number }
-
-export interface Message {
-  role: Role
-  content: string
-  reasoningContent?: string
-}
-
-export interface Model {
-  readonly repoId: string
-  readonly type: ModelType
-  readonly kind: ModelKind
-  readonly name: string
-  readonly vendor: string
-  readonly quantization?: string
-  readonly outputParserRegex?: string
-  readonly classificationLabels: Array<ClassificationLabel>
-}
-
-export declare const enum ModelDownloadPhase {
-  NotDownloaded = 0,
-  Downloading = 1,
-  Paused = 2,
-  Downloaded = 3,
-  Locked = 4,
-  Error = 5
-}
-
-export interface ModelDownloadState {
-  /** Total size of all model files in kilobytes. */
-  readonly totalKbytes: number
-  /** Bytes already downloaded (meaningful in Downloading / Paused). */
-  readonly downloadedKbytes: number
-  /** Current phase of the download. */
-  readonly phase: ModelDownloadPhase
-  /** Stringified error when `phase == ModelDownloadPhase::Error`. */
-  readonly error?: string
-}
-
-export declare const enum ModelKind {
-  Local = 0,
-  Cloud = 1
-}
-
-export type ModelStorageError =
-  | { type: 'Io', message: string }
-  | { type: 'Network', message: string }
-  | { type: 'DownloadFailed', message: string }
-  | { type: 'Download', message: string }
-  | { type: 'InvalidPath', message: string }
-  | { type: 'ModelNotFound', identifier: string }
-  | { type: 'FileVerificationFailed', message: string }
-  | { type: 'Paused' }
-
-export declare const enum ModelType {
-  Chat = 0,
-  Classification = 1,
-  TTS = 2
-}
-
-export interface Output {
-  text: Text
-  stats: Stats
-  finishReason?: FinishReason
-}
-
-export interface ParsedText {
-  chainOfThought?: string
-  response?: string
-}
-
-export type PrefillStepSize =
-  | { type: 'Default' }
-  | { type: 'Maximal' }
-  | { type: 'Custom', length: number }
-
-export type Preset =
-  | { type: 'General' }
-  | { type: 'Classification', feature: ClassificationFeature }
-  | { type: 'Summarization' }
-  | { type: 'NGramSpeculator', useCase: string, numberOfSpeculatedTokens: number }
-  | { type: 'Chat' }
-
-export declare const enum Role {
-  System = 0,
-  User = 1,
-  Assistant = 2
-}
-
-export interface RunConfig {
-  tokensLimit: number
-  enableThinking: boolean
-  samplingPolicy: SamplingPolicy
-  grammarConfig?: GrammarConfig
-}
-
-export interface RunStats {
-  count: bigint
-  averageDuration: number
-}
-
-export type SamplingMethod =
-  | { type: 'Greedy' }
-  | { type: 'Stochastic', temperature?: number, topK?: number, topP?: number, minP?: number, processingOrder: SamplingProcessingOrder }
-
-export type SamplingPolicy =
-  | { type: 'Default' }
-  | { type: 'Custom', value: SamplingMethod }
-
-export declare const enum SamplingProcessingOrder {
-  TemperatureThenFilters = 0,
-  FiltersThenTemperature = 1
-}
-
-export type SamplingSeed =
-  | { type: 'Default' }
-  | { type: 'Custom', seed: number }
-
-export interface Stats {
-  prefillStats: StepStats
-  generateStats?: StepStats
-  totalStats: TotalStats
-}
-
-export interface StepStats {
-  duration: number
-  suffixLength: bigint
-  tokensCount: bigint
-  tokensPerSecond: number
-  processedTokensPerSecond: number
-  modelRun: RunStats
-  run?: RunStats
-  speculatorProposed: bigint
-  speculatorAccepted: bigint
-}
-
-export type StorageError =
-  | { type: 'ModelNotDownloaded' }
-  | { type: 'UnknownModel', repoId: string }
-  | { type: 'Storage', message: string }
-  | { type: 'MutexPoisoned', message: string }
-  | { type: 'LicenseNotActivated' }
-
-export interface Text {
-  original: string
-  parsed: ParsedText
-}
-
-export interface TotalStats {
-  duration: number
-  tokensCountInput: bigint
-  tokensCountOutput: bigint
-}
-
-export declare function version(): string