@trymirai/uzu 0.1.21 → 0.1.22

package/src/interactors/engineInteractor.ts

@@ -0,0 +1,48 @@
+import { Engine } from '../bridging/engine';
+import { ModelKind, ModelType } from '../bridging/model';
+import { Interactor, InteractorEntity } from './interactor';
+import { ModelInteractor } from './modelInteractor';
+import { ModelsInteractor } from './modelsInteractor';
+
+export class EngineInteractor implements Interactor<Engine> {
+    readonly entity: InteractorEntity<Engine>;
+    readonly modelTypeFilter: ModelType[] | null;
+    readonly modelKindFilter: ModelKind[] | null;
+
+    constructor(
+        engine: InteractorEntity<Engine>,
+        modelTypeFilter: ModelType[] | null = null,
+        modelKindFilter: ModelKind[] | null = null,
+    ) {
+        this.entity = engine;
+        this.modelTypeFilter = modelTypeFilter;
+        this.modelKindFilter = modelKindFilter;
+    }
+
+    async finalize(): Promise<Engine> {
+        return await this.entity;
+    }
+
+    /* Models */
+
+    filterTypes(types: ModelType[] | null): EngineInteractor {
+        return new EngineInteractor(this.entity, types, this.modelKindFilter);
+    }
+
+    filterKinds(kinds: ModelKind[] | null): EngineInteractor {
+        return new EngineInteractor(this.entity, this.modelTypeFilter, kinds);
+    }
+
+    models(): ModelsInteractor {
+        const modelsPromise = (async () => {
+            const engine = await this.finalize();
+            return await engine.models(this.modelTypeFilter, this.modelKindFilter);
+        })();
+        return new ModelsInteractor(this, modelsPromise);
+    }
+
+    model(repoId: string): ModelInteractor {
+        const models = this.models();
+        return models.get(repoId);
+    }
+}

package/src/interactors/interactor.ts

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

package/src/interactors/modelInteractor.ts

@@ -0,0 +1,113 @@
+import { Config } from '../bridging/config';
+import { ContextLength } from '../bridging/contextLength';
+import { DownloadProgressUpdate } from '../bridging/downloadProgressUpdate';
+import { DownloadPhase } from '../bridging/downloadState';
+import { Message } from '../bridging/message';
+import { Model, ModelType } from '../bridging/model';
+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 { DownloadInteractor } from './downloadInteractor';
+import { Interactor, InteractorEntity } from './interactor';
+import { ModelsInteractor } from './modelsInteractor';
+import { SessionInteractor } from './sessionInteractor';
+
+export class ModelInteractor implements Interactor<Model> {
+    readonly modelsInteractor: ModelsInteractor;
+    readonly entity: InteractorEntity<Model>;
+    readonly config: Config;
+
+    constructor(modelsInteractor: ModelsInteractor, 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);
+            return handle;
+        })();
+        return new DownloadInteractor(this, handlePromise);
+    }
+
+    download(callback?: (progressUpdate: DownloadProgressUpdate) => void): ModelInteractor {
+        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 ModelInteractor(this.modelsInteractor, modelPromise, this.config);
+    }
+
+    /* Config */
+
+    preset(preset: Preset): ModelInteractor {
+        const config = this.config.withPreset(preset);
+        return new ModelInteractor(this.modelsInteractor, this.entity, config);
+    }
+
+    prefillStepSize(prefillStepSize: PrefillStepSize): ModelInteractor {
+        const config = this.config.withPrefillStepSize(prefillStepSize);
+        return new ModelInteractor(this.modelsInteractor, this.entity, config);
+    }
+
+    contextLength(contextLength: ContextLength): ModelInteractor {
+        const config = this.config.withContextLength(contextLength);
+        return new ModelInteractor(this.modelsInteractor, this.entity, config);
+    }
+
+    samplingSeed(samplingSeed: SamplingSeed): ModelInteractor {
+        const config = this.config.withSamplingSeed(samplingSeed);
+        return new ModelInteractor(this.modelsInteractor, this.entity, config);
+    }
+
+    /* Session */
+
+    session(): SessionInteractor {
+        const sessionPromise = (async () => {
+            const engine = await this.modelsInteractor.engineInteractor.finalize();
+
+            let model = await this.finalize();
+            if (model.type === ModelType.Local) {
+                model = await this.download().finalize();
+            }
+
+            const session = engine.session(model, this.config);
+            return session;
+        })();
+        return new SessionInteractor(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/modelsInteractor.ts

@@ -0,0 +1,29 @@
+import { Config } from '../bridging/config';
+import { Model } from '../bridging/model';
+import { EngineErrorCode, unwrapOrThrow } from '../error';
+import { EngineInteractor } from './engineInteractor';
+import { Interactor, InteractorEntity } from './interactor';
+import { ModelInteractor } from './modelInteractor';
+
+export class ModelsInteractor 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): ModelInteractor {
+        const modelPromise = (async () => {
+            const models = await this.finalize();
+            const model = models.find((model) => model.repoId === repoId);
+            return unwrapOrThrow(model, EngineErrorCode.ModelNotFound);
+        })();
+        return new ModelInteractor(this, modelPromise, Config.default());
+    }
+}

package/src/interactors/sessionInteractor.ts

@@ -0,0 +1,70 @@
+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 { Session } from '../bridging/session';
+import { Interactor, InteractorEntity } from './interactor';
+import { ModelInteractor } from './modelInteractor';
+
+export class SessionInteractor implements Interactor<Session> {
+    readonly modelInteractor: ModelInteractor;
+    readonly entity: InteractorEntity<Session>;
+    readonly config: RunConfig;
+
+    constructor(modelInteractor: ModelInteractor, session: InteractorEntity<Session>, config: RunConfig) {
+        this.modelInteractor = modelInteractor;
+        this.entity = session;
+        this.config = config;
+    }
+
+    async finalize(): Promise<Session> {
+        return await this.entity;
+    }
+
+    /* Config */
+
+    tokensLimit(tokensLimit: number): SessionInteractor {
+        const config = this.config.withTokensLimit(tokensLimit);
+        return new SessionInteractor(this.modelInteractor, this.entity, config);
+    }
+
+    enableThinking(enableThinking: boolean): SessionInteractor {
+        const config = this.config.withEnableThinking(enableThinking);
+        return new SessionInteractor(this.modelInteractor, this.entity, config);
+    }
+
+    samplingPolicy(samplingPolicy: SamplingPolicy): SessionInteractor {
+        const config = this.config.withSamplingPolicy(samplingPolicy);
+        return new SessionInteractor(this.modelInteractor, this.entity, config);
+    }
+
+    samplingMethod(samplingMethod: SamplingMethod): SessionInteractor {
+        const config = this.config.withSamplingPolicy(SamplingPolicy.custom(samplingMethod));
+        return new SessionInteractor(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/napi/uzu.d.ts

@@ -0,0 +1,230 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+/** Thin FFI wrapper around `ModelStorage`. */
+export declare class Engine {
+  getCloudModels(): Promise<Array<CloudModel>>
+  fetchCloudModels(): Promise<Array<CloudModel>>
+  /** Returns a `DownloadHandle` for the given model identifier. */
+  downloadHandle(identifier: string): ModelDownloadHandle
+  getLocalModels(): Array<LocalModel>
+  getState(identifier: string): ModelDownloadState
+  activate(apiKey: string): Promise<LicenseStatus>
+  downloadModel(identifier: string): Promise<void>
+  pauseModel(identifier: string): Promise<void>
+  deleteModel(identifier: string): Promise<void>
+  constructor()
+  createSession(modelId: ModelID, config: Config): Session
+}
+
+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 Session {
+  run(input: Input, config: RunConfig, progress?: (arg: Output) => boolean | undefined | null): Output
+}
+
+export interface ClassificationFeature {
+  name: string
+  values: Array<string>
+}
+
+export interface CloudModel {
+  readonly repoId: string
+  readonly name: string
+  readonly vendor: string
+}
+
+export interface Config {
+  preset: Preset
+  prefillStepSize: PrefillStepSize
+  contextLength: ContextLength
+  samplingSeed: SamplingSeed
+}
+
+export type ContextLength =
+  | { type: 'Default' }
+  | { type: 'Maximal' }
+  | { type: 'Custom', length: number }
+
+export declare const enum FinishReason {
+  Stop = 0,
+  Length = 1,
+  Cancelled = 2,
+  ContextLimitReached = 3
+}
+
+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 LocalModel {
+  /** Unique identifier of the model in the form `<vendor>-<name>-<precision>`. */
+  readonly identifier: string
+  /** Vendor/author of the model (e.g. "Alibaba", "Meta"). */
+  readonly vendor: string
+  /** Human-readable model name without vendor (e.g. "Qwen2.5-0.5B-Instruct"). */
+  readonly name: string
+  /** Precision of the model (e.g. "bfloat16", "float16"). */
+  readonly precision: string
+  /** Quantization type if the model is quantized (e.g. "uint4"). */
+  readonly quantization?: string
+  /** Optional regex to parse model output provided by the backend. */
+  readonly outputParserRegex?: string
+  /** Current download/installation state. */
+  readonly state: ModelDownloadState
+}
+
+export interface Message {
+  role: Role
+  content: string
+  reasoningContent?: string
+}
+
+export declare const enum ModelDownloadPhase {
+  NotDownloaded = 0,
+  Downloading = 1,
+  Paused = 2,
+  Downloaded = 3,
+  Error = 4
+}
+
+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 type ModelID =
+  | { type: 'Local', id: string }
+  | { type: 'Cloud', id: string }
+
+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 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' }
+
+export declare const enum Role {
+  System = 0,
+  User = 1,
+  Assistant = 2
+}
+
+export interface RunConfig {
+  tokensLimit: number
+  enableThinking: boolean
+  samplingPolicy: SamplingPolicy
+}
+
+export interface RunStats {
+  count: bigint
+  averageDuration: number
+}
+
+export type SamplingMethod =
+  | { type: 'Greedy' }
+  | { type: 'Temperature', temperature: number }
+  | { type: 'TopP', topP: number }
+
+export type SamplingPolicy =
+  | { type: 'Default' }
+  | { type: 'Custom', value: SamplingMethod }
+
+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
+  modelRun: RunStats
+  run?: RunStats
+}
+
+export type StorageError =
+  | { type: 'ModelNotDownloaded' }
+  | { type: 'UnknownModel', identifier: 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

package/src/napi/uzu.js

@@ -0,0 +1,95 @@
+// Auto-generated NAPI wrapper for uzu native module
+// Currently supports only Apple Silicon (arm64) on macOS
+// Other platforms may be added in future releases
+
+const { createRequire } = require('module');
+
+const require_ = createRequire(__filename);
+
+// Check for Apple Silicon support only
+if (process.platform !== 'darwin' || process.arch !== 'arm64') {
+  throw new Error(`This package only supports Apple Silicon (arm64) on macOS. Current platform: ${process.platform}-${process.arch}`);
+}
+
+let nativeBinding = null;
+
+try {
+  nativeBinding = require_('./uzu.node');
+} catch (e) {
+  throw new Error(`Failed to load native binding: ${e.message}`);
+}
+
+// Re-export all runtime exports
+const {
+  Engine,
+  ModelDownloadHandle,
+  ProgressStream,
+  ProgressUpdate,
+  Session,
+  FinishReason,
+  ModelDownloadPhase,
+  Role,
+  version,
+  ClassificationFeature,
+  CloudModel,
+  Config,
+  LocalModel,
+  Message,
+  ModelDownloadState,
+  Output,
+  ParsedText,
+  RunConfig,
+  RunStats,
+  Stats,
+  StepStats,
+  Text,
+  TotalStats,
+  ContextLength,
+  Input,
+  LicenseStatus,
+  ModelID,
+  ModelStorageError,
+  PrefillStepSize,
+  Preset,
+  SamplingMethod,
+  SamplingPolicy,
+  SamplingSeed,
+  StorageError
+} = nativeBinding;
+
+module.exports = {
+  Engine,
+  ModelDownloadHandle,
+  ProgressStream,
+  ProgressUpdate,
+  Session,
+  FinishReason,
+  ModelDownloadPhase,
+  Role,
+  version,
+  ClassificationFeature,
+  CloudModel,
+  Config,
+  LocalModel,
+  Message,
+  ModelDownloadState,
+  Output,
+  ParsedText,
+  RunConfig,
+  RunStats,
+  Stats,
+  StepStats,
+  Text,
+  TotalStats,
+  ContextLength,
+  Input,
+  LicenseStatus,
+  ModelID,
+  ModelStorageError,
+  PrefillStepSize,
+  Preset,
+  SamplingMethod,
+  SamplingPolicy,
+  SamplingSeed,
+  StorageError
+};

package/src/napi/uzu.mjs

@@ -0,0 +1,61 @@
+// Auto-generated NAPI wrapper for uzu native module
+// Currently supports only Apple Silicon (arm64) on macOS
+// Other platforms may be added in future releases
+
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+// Check for Apple Silicon support only
+if (process.platform !== 'darwin' || process.arch !== 'arm64') {
+  throw new Error(`This package only supports Apple Silicon (arm64) on macOS. Current platform: ${process.platform}-${process.arch}`);
+}
+
+let nativeBinding = null;
+
+try {
+  nativeBinding = require('./uzu.node');
+} catch (e) {
+  throw new Error(`Failed to load native binding: ${e.message}`);
+}
+
+// Re-export all runtime exports as named exports  
+export const {
+  Engine,
+  ModelDownloadHandle,
+  ProgressStream,
+  ProgressUpdate,
+  Session,
+  FinishReason,
+  ModelDownloadPhase,
+  Role,
+  version,
+  ClassificationFeature,
+  CloudModel,
+  Config,
+  LocalModel,
+  Message,
+  ModelDownloadState,
+  Output,
+  ParsedText,
+  RunConfig,
+  RunStats,
+  Stats,
+  StepStats,
+  Text,
+  TotalStats,
+  ContextLength,
+  Input,
+  LicenseStatus,
+  ModelID,
+  ModelStorageError,
+  PrefillStepSize,
+  Preset,
+  SamplingMethod,
+  SamplingPolicy,
+  SamplingSeed,
+  StorageError
+} = nativeBinding;
+
+// Also provide default export
+export default nativeBinding;

package/src/tsconfig.json

@@ -0,0 +1,11 @@
+{
+    // this config is included in the published src directory to prevent TS errors
+    // from appearing when users go to source, and VSCode opens the source .ts file
+    // via declaration maps
+    "include": ["index.ts"],
+    "compilerOptions": {
+        "target": "ES2015",
+        "lib": ["DOM", "DOM.Iterable", "ES2018"],
+        "moduleResolution": "node"
+    }
+}

package/src/utilities/env.ts

@@ -0,0 +1,9 @@
+export const readEnv = (env: string): string | undefined => {
+    if (typeof (globalThis as any).process !== 'undefined') {
+        return (globalThis as any).process.env?.[env]?.trim() ?? undefined;
+    }
+    if (typeof (globalThis as any).Deno !== 'undefined') {
+        return (globalThis as any).Deno.env?.get?.(env)?.trim();
+    }
+    return undefined;
+};

package/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = '0.1.22';

package/utilities/env.d.mts

@@ -0,0 +1,2 @@
+export declare const readEnv: (env: string) => string | undefined;
+//# sourceMappingURL=env.d.mts.map

package/utilities/env.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.mts","sourceRoot":"","sources":["../src/utilities/env.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,GAAI,KAAK,MAAM,KAAG,MAAM,GAAG,SAQ9C,CAAC"}

package/utilities/env.d.ts

@@ -0,0 +1,2 @@
+export declare const readEnv: (env: string) => string | undefined;
+//# sourceMappingURL=env.d.ts.map