@trymirai/uzu 0.1.21 → 0.1.23

package/src/bridging/licenseStatus.ts

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,50 @@
+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;
+    }
+}

package/src/bridging/model.ts

@@ -0,0 +1,32 @@
+import { CloudModel as NapiCloudModel, LocalModel as NapiLocalModel } from '../napi/uzu';
+
+export enum ModelType {
+    Local = 'local',
+    Cloud = 'cloud',
+}
+
+export enum ModelKind {
+    Text = 'text',
+}
+
+export class Model {
+    readonly repoId: string;
+    readonly type: ModelType;
+    readonly kind: ModelKind;
+    readonly name: string;
+
+    private constructor(repoId: string, type: ModelType, kind: ModelKind, name: string) {
+        this.repoId = repoId;
+        this.type = type;
+        this.kind = kind;
+        this.name = name;
+    }
+
+    static fromNapiLocalModel(napiLocalModel: NapiLocalModel): Model {
+        return new Model(napiLocalModel.identifier, ModelType.Local, ModelKind.Text, napiLocalModel.name);
+    }
+
+    static fromNapiCloudModel(napiCloudModel: NapiCloudModel): Model {
+        return new Model(napiCloudModel.repoId, ModelType.Cloud, ModelKind.Text, napiCloudModel.name);
+    }
+}

package/src/bridging/napi.ts

@@ -0,0 +1,3 @@
+export interface ToNapi<N> {
+    toNapi(): N;
+}

package/src/bridging/output.ts

@@ -0,0 +1,40 @@
+import { EngineError, EngineErrorCode } from '../error';
+import { FinishReason as NapiFinishReason, Output as NapiOutput } from '../napi/uzu';
+import { FinishReason } from './finishReason';
+import { Stats } from './stats';
+import { Text } from './text';
+
+export class Output {
+    readonly text: Text;
+    readonly stats: Stats;
+    readonly finishReason: FinishReason | null;
+
+    private constructor(text: Text, stats: Stats, finishReason: FinishReason | null) {
+        this.text = text;
+        this.stats = stats;
+        this.finishReason = finishReason;
+    }
+
+    private static napiFinishReasonToFinishReason(napiFinishReason: NapiFinishReason): FinishReason {
+        switch (napiFinishReason) {
+            case 0:
+                return FinishReason.Stop;
+            case 1:
+                return FinishReason.Length;
+            case 2:
+                return FinishReason.Cancelled;
+            case 3:
+                return FinishReason.ContextLimitReached;
+            default:
+                throw new EngineError(EngineErrorCode.UnexpectedFinishReason);
+        }
+    }
+
+    static fromNapi(napiEntity: NapiOutput): Output {
+        const text = Text.fromNapi(napiEntity.text);
+        const stats = Stats.fromNapi(napiEntity.stats);
+        const finishReason =
+            napiEntity.finishReason ? Output.napiFinishReasonToFinishReason(napiEntity.finishReason) : null;
+        return new Output(text, stats, finishReason);
+    }
+}

package/src/bridging/parsedText.ts

@@ -0,0 +1,17 @@
+import { ParsedText as NapiParsedText } from '../napi/uzu';
+
+export class ParsedText {
+    readonly chainOfThought: string | null;
+    readonly response: string | null;
+
+    private constructor(chainOfThought: string | null, response: string | null) {
+        this.chainOfThought = chainOfThought;
+        this.response = response;
+    }
+
+    static fromNapi(napiEntity: NapiParsedText): ParsedText {
+        const chainOfThought = napiEntity.chainOfThought ?? null;
+        const response = napiEntity.response ?? null;
+        return new ParsedText(chainOfThought, response);
+    }
+}

package/src/bridging/prefillStepSize.ts

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

package/src/bridging/preset.ts

@@ -0,0 +1,34 @@
+import { Preset as NapiPreset } from '../napi/uzu';
+import { ClassificationFeature } from './classificationFeature';
+import { ToNapi } from './napi';
+
+export class Preset implements ToNapi<NapiPreset> {
+    private readonly napiPreset: NapiPreset;
+
+    private constructor(napiPreset: NapiPreset) {
+        this.napiPreset = napiPreset;
+    }
+
+    static general(): Preset {
+        const napiPreset: NapiPreset = { type: 'General' };
+        return new Preset(napiPreset);
+    }
+
+    static classification(feature: ClassificationFeature): Preset {
+        const napiClassificationFeature = feature.toNapi();
+        const napiPreset: NapiPreset = {
+            type: 'Classification',
+            feature: napiClassificationFeature,
+        };
+        return new Preset(napiPreset);
+    }
+
+    static summarization(): Preset {
+        const napiPreset: NapiPreset = { type: 'Summarization' };
+        return new Preset(napiPreset);
+    }
+
+    toNapi(): NapiPreset {
+        return this.napiPreset;
+    }
+}

package/src/bridging/role.ts

@@ -0,0 +1,5 @@
+export enum Role {
+    System = 'system',
+    User = 'user',
+    Assistant = 'assistant',
+}

package/src/bridging/runConfig.ts

@@ -0,0 +1,41 @@
+import { RunConfig as NapiRunConfig } from '../napi/uzu';
+import { ToNapi } from './napi';
+import { SamplingPolicy } from './samplingPolicy';
+
+export class RunConfig implements ToNapi<NapiRunConfig> {
+    readonly tokensLimit: number;
+    readonly enableThinking: boolean;
+    readonly samplingPolicy: SamplingPolicy;
+
+    private constructor(tokensLimit: number, enableThinking: boolean, samplingPolicy: SamplingPolicy) {
+        this.tokensLimit = tokensLimit;
+        this.enableThinking = enableThinking;
+        this.samplingPolicy = samplingPolicy;
+    }
+
+    static default(): RunConfig {
+        return new RunConfig(1024, true, SamplingPolicy.default());
+    }
+
+    withTokensLimit(tokensLimit: number): RunConfig {
+        return new RunConfig(tokensLimit, this.enableThinking, this.samplingPolicy);
+    }
+
+    withEnableThinking(enableThinking: boolean): RunConfig {
+        return new RunConfig(this.tokensLimit, enableThinking, this.samplingPolicy);
+    }
+
+    withSamplingPolicy(samplingPolicy: SamplingPolicy): RunConfig {
+        return new RunConfig(this.tokensLimit, this.enableThinking, samplingPolicy);
+    }
+
+    toNapi(): NapiRunConfig {
+        const napiSamplingPolicy = this.samplingPolicy.toNapi();
+        const napiRunConfig: NapiRunConfig = {
+            tokensLimit: this.tokensLimit,
+            enableThinking: this.enableThinking,
+            samplingPolicy: napiSamplingPolicy,
+        };
+        return napiRunConfig;
+    }
+}

package/src/bridging/runStats.ts

@@ -0,0 +1,17 @@
+import { RunStats as NapiRunStats } from '../napi/uzu';
+
+export class RunStats {
+    readonly count: number;
+    readonly averageDuration: number;
+
+    private constructor(count: number, averageDuration: number) {
+        this.count = count;
+        this.averageDuration = averageDuration;
+    }
+
+    static fromNapi(napiEntity: NapiRunStats): RunStats {
+        const count = Number(napiEntity.count);
+        const averageDuration = napiEntity.averageDuration;
+        return new RunStats(count, averageDuration);
+    }
+}

package/src/bridging/samplingMethod.ts

@@ -0,0 +1,32 @@
+import { SamplingMethod as NapiSamplingMethod } from '../napi/uzu';
+import { ToNapi } from './napi';
+
+export class SamplingMethod implements ToNapi<NapiSamplingMethod> {
+    private readonly napiSamplingMethod: NapiSamplingMethod;
+
+    private constructor(napiSamplingMethod: NapiSamplingMethod) {
+        this.napiSamplingMethod = napiSamplingMethod;
+    }
+
+    static greedy(): SamplingMethod {
+        const napiSamplingMethod: NapiSamplingMethod = { type: 'Greedy' };
+        return new SamplingMethod(napiSamplingMethod);
+    }
+
+    static temperature(temperature: number): SamplingMethod {
+        const napiSamplingMethod: NapiSamplingMethod = {
+            type: 'Temperature',
+            temperature,
+        };
+        return new SamplingMethod(napiSamplingMethod);
+    }
+
+    static topP(topP: number): SamplingMethod {
+        const napiSamplingMethod: NapiSamplingMethod = { type: 'TopP', topP };
+        return new SamplingMethod(napiSamplingMethod);
+    }
+
+    toNapi(): NapiSamplingMethod {
+        return this.napiSamplingMethod;
+    }
+}

package/src/bridging/samplingPolicy.ts

@@ -0,0 +1,29 @@
+import { SamplingPolicy as NapiSamplingPolicy } from '../napi/uzu';
+import { ToNapi } from './napi';
+import { SamplingMethod } from './samplingMethod';
+
+export class SamplingPolicy implements ToNapi<NapiSamplingPolicy> {
+    private readonly napiSamplingPolicy: NapiSamplingPolicy;
+
+    private constructor(napiSamplingPolicy: NapiSamplingPolicy) {
+        this.napiSamplingPolicy = napiSamplingPolicy;
+    }
+
+    static default(): SamplingPolicy {
+        const napiSamplingPolicy: NapiSamplingPolicy = { type: 'Default' };
+        return new SamplingPolicy(napiSamplingPolicy);
+    }
+
+    static custom(method: SamplingMethod): SamplingPolicy {
+        const napiSamplingMethod = method.toNapi();
+        const napiSamplingPolicy: NapiSamplingPolicy = {
+            type: 'Custom',
+            value: napiSamplingMethod,
+        };
+        return new SamplingPolicy(napiSamplingPolicy);
+    }
+
+    toNapi(): NapiSamplingPolicy {
+        return this.napiSamplingPolicy;
+    }
+}

package/src/bridging/samplingSeed.ts

@@ -0,0 +1,24 @@
+import { SamplingSeed as NapiSamplingSeed } from '../napi/uzu';
+import { ToNapi } from './napi';
+
+export class SamplingSeed implements ToNapi<NapiSamplingSeed> {
+    private readonly napiSamplingSeed: NapiSamplingSeed;
+
+    private constructor(napiSamplingSeed: NapiSamplingSeed) {
+        this.napiSamplingSeed = napiSamplingSeed;
+    }
+
+    static default(): SamplingSeed {
+        const napiSamplingSeed: NapiSamplingSeed = { type: 'Default' };
+        return new SamplingSeed(napiSamplingSeed);
+    }
+
+    static custom(seed: number): SamplingSeed {
+        const napiSamplingSeed: NapiSamplingSeed = { type: 'Custom', seed };
+        return new SamplingSeed(napiSamplingSeed);
+    }
+
+    toNapi(): NapiSamplingSeed {
+        return this.napiSamplingSeed;
+    }
+}

package/src/bridging/session.ts

@@ -0,0 +1,24 @@
+import { Output as NapiOutput, Session as NapiSession } from '../napi/uzu';
+import { Input } from './input';
+import { Output } from './output';
+import { RunConfig } from './runConfig';
+
+export class Session {
+    private readonly napiSession: NapiSession;
+
+    constructor(napiSession: NapiSession) {
+        this.napiSession = napiSession;
+    }
+
+    run(
+        input: Input,
+        config: RunConfig = RunConfig.default(),
+        progress: (partialOutput: Output) => boolean = () => true,
+    ): Output {
+        const napiInput = input.toNapi();
+        const napiConfig = config.toNapi();
+        const napiProgress = (partialOutput: NapiOutput) => progress(Output.fromNapi(partialOutput));
+        const napiOutput = this.napiSession.run(napiInput, napiConfig, napiProgress);
+        return Output.fromNapi(napiOutput);
+    }
+}

package/src/bridging/stats.ts

@@ -0,0 +1,22 @@
+import { Stats as NapiStats } from '../napi/uzu';
+import { StepStats } from './stepStats';
+import { TotalStats } from './totalStats';
+
+export class Stats {
+    readonly prefillStats: StepStats;
+    readonly generateStats: StepStats | null;
+    readonly totalStats: TotalStats;
+
+    private constructor(prefillStats: StepStats, generateStats: StepStats | null, totalStats: TotalStats) {
+        this.prefillStats = prefillStats;
+        this.generateStats = generateStats;
+        this.totalStats = totalStats;
+    }
+
+    static fromNapi(napiEntity: NapiStats): Stats {
+        const prefillStats = StepStats.fromNapi(napiEntity.prefillStats);
+        const generateStats = napiEntity.generateStats ? StepStats.fromNapi(napiEntity.generateStats) : null;
+        const totalStats = TotalStats.fromNapi(napiEntity.totalStats);
+        return new Stats(prefillStats, generateStats, totalStats);
+    }
+}

package/src/bridging/stepStats.ts

@@ -0,0 +1,37 @@
+import { StepStats as NapiStepStats } from '../napi/uzu';
+import { RunStats } from './runStats';
+
+export class StepStats {
+    readonly duration: number;
+    readonly suffixLength: number;
+    readonly tokensCount: number;
+    readonly tokensPerSecond: number;
+    readonly modelRun: RunStats;
+    readonly run: RunStats | null;
+
+    private constructor(
+        duration: number,
+        suffixLength: number,
+        tokensCount: number,
+        tokensPerSecond: number,
+        modelRun: RunStats,
+        run: RunStats | null,
+    ) {
+        this.duration = duration;
+        this.suffixLength = suffixLength;
+        this.tokensCount = tokensCount;
+        this.tokensPerSecond = tokensPerSecond;
+        this.modelRun = modelRun;
+        this.run = run;
+    }
+
+    static fromNapi(napiEntity: NapiStepStats): StepStats {
+        const duration = napiEntity.duration;
+        const suffixLength = Number(napiEntity.suffixLength);
+        const tokensCount = Number(napiEntity.tokensCount);
+        const tokensPerSecond = napiEntity.tokensPerSecond;
+        const modelRun = RunStats.fromNapi(napiEntity.modelRun);
+        const run = napiEntity.run ? RunStats.fromNapi(napiEntity.run) : null;
+        return new StepStats(duration, suffixLength, tokensCount, tokensPerSecond, modelRun, run);
+    }
+}

package/src/bridging/text.ts

@@ -0,0 +1,18 @@
+import { Text as NapiText } from '../napi/uzu';
+import { ParsedText } from './parsedText';
+
+export class Text {
+    readonly original: string;
+    readonly parsed: ParsedText;
+
+    private constructor(original: string, parsed: ParsedText) {
+        this.original = original;
+        this.parsed = parsed;
+    }
+
+    static fromNapi(napiEntity: NapiText): Text {
+        const original = napiEntity.original;
+        const parsed = ParsedText.fromNapi(napiEntity.parsed);
+        return new Text(original, parsed);
+    }
+}

package/src/bridging/totalStats.ts

@@ -0,0 +1,20 @@
+import { TotalStats as NapiTotalStats } from '../napi/uzu';
+
+export class TotalStats {
+    readonly duration: number;
+    readonly tokensCountInput: number;
+    readonly tokensCountOutput: number;
+
+    private constructor(duration: number, tokensCountInput: number, tokensCountOutput: number) {
+        this.duration = duration;
+        this.tokensCountInput = tokensCountInput;
+        this.tokensCountOutput = tokensCountOutput;
+    }
+
+    static fromNapi(napiEntity: NapiTotalStats): TotalStats {
+        const duration = napiEntity.duration;
+        const tokensCountInput = Number(napiEntity.tokensCountInput);
+        const tokensCountOutput = Number(napiEntity.tokensCountOutput);
+        return new TotalStats(duration, tokensCountInput, tokensCountOutput);
+    }
+}

package/src/error.ts

@@ -0,0 +1,38 @@
+export enum EngineErrorCode {
+    APIKeyNotFound = 'apiKeyNotFound',
+    ModelNotFound = 'modelNotFound',
+    ExpectedLocalModel = 'expectedLocalModel',
+    ExpectedTextModel = 'expectedTextModel',
+    UnexpectedDownloadPhase = 'unexpectedDownloadPhase',
+    UnexpectedFinishReason = 'unexpectedFinishReason',
+    UnexpectedLicenseStatus = 'unexpectedLicenseStatus',
+    LicenseNotActivated = 'licenseNotActivated',
+    Unknown = 'unknown',
+}
+
+const errorCodeToMessage = {
+    [EngineErrorCode.APIKeyNotFound]: 'API key not found',
+    [EngineErrorCode.ModelNotFound]: 'Model not found',
+    [EngineErrorCode.ExpectedLocalModel]: 'Expected local model',
+    [EngineErrorCode.ExpectedTextModel]: 'Expected text model',
+    [EngineErrorCode.UnexpectedDownloadPhase]: 'Unexpected download phase',
+    [EngineErrorCode.UnexpectedFinishReason]: 'Unexpected finish reason',
+    [EngineErrorCode.UnexpectedLicenseStatus]: 'Unexpected license status',
+    [EngineErrorCode.LicenseNotActivated]: 'License not activated',
+    [EngineErrorCode.Unknown]: 'Unknown error',
+};
+
+export class EngineError extends Error {
+    constructor(code: EngineErrorCode) {
+        const message = errorCodeToMessage[code] ?? errorCodeToMessage[EngineErrorCode.Unknown];
+        super(message);
+        this.name = 'EngineError';
+    }
+}
+
+export function unwrapOrThrow<T>(value: T | null | undefined, errorCode: EngineErrorCode): T {
+    if (value === null || value === undefined) {
+        throw new EngineError(errorCode);
+    }
+    return value;
+}

package/src/index.ts

@@ -0,0 +1,32 @@
+export { ClassificationFeature } from './bridging/classificationFeature';
+export { Config } from './bridging/config';
+export { ContextLength } from './bridging/contextLength';
+export { DownloadHandle } from './bridging/downloadHandle';
+export { DownloadProgressUpdate } from './bridging/downloadProgressUpdate';
+export { DownloadPhase, DownloadState } from './bridging/downloadState';
+export { Engine as default } from './bridging/engine';
+export { FinishReason } from './bridging/finishReason';
+export { Input } from './bridging/input';
+export { Message } from './bridging/message';
+export { Model, ModelKind, ModelType } from './bridging/model';
+export { Output } from './bridging/output';
+export { ParsedText } from './bridging/parsedText';
+export { PrefillStepSize } from './bridging/prefillStepSize';
+export { Preset } from './bridging/preset';
+export { Role } from './bridging/role';
+export { RunConfig } from './bridging/runConfig';
+export { RunStats } from './bridging/runStats';
+export { SamplingMethod } from './bridging/samplingMethod';
+export { SamplingPolicy } from './bridging/samplingPolicy';
+export { SamplingSeed } from './bridging/samplingSeed';
+export { Session } from './bridging/session';
+export { Stats } from './bridging/stats';
+export { StepStats } from './bridging/stepStats';
+export { Text } from './bridging/text';
+export { TotalStats } from './bridging/totalStats';
+export { EngineError } from './error';
+export { DownloadInteractor } from './interactors/downloadInteractor';
+export { EngineInteractor } from './interactors/engineInteractor';
+export { ModelInteractor } from './interactors/modelInteractor';
+export { ModelsInteractor } from './interactors/modelsInteractor';
+export { SessionInteractor } from './interactors/sessionInteractor';

package/src/interactors/downloadInteractor.ts

@@ -0,0 +1,47 @@
+import { DownloadHandle } from '../bridging/downloadHandle';
+import { DownloadProgressUpdate } from '../bridging/downloadProgressUpdate';
+import { Interactor, InteractorEntity } from './interactor';
+import { ModelInteractor } from './modelInteractor';
+
+export class DownloadInteractor implements Interactor<DownloadHandle> {
+    readonly modelInteractor: ModelInteractor;
+    readonly entity: InteractorEntity<DownloadHandle>;
+
+    constructor(modelInteractor: ModelInteractor, 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);
+    }
+}