@qvac/harness 0.1.0 → 0.1.1

package/dist-lib/lib/connect.js

@@ -0,0 +1,789 @@
+import EventEmitter from 'events';
+import fs from 'fs';
+import { settleOnClose } from "./rpc-session.js";
+import { harnessClient } from '../spec/calls.js';
+import HRPC from '../spec/hrpc/index.js';
+import { unsupportedKvCacheDeletion } from "./capabilities/kv-cache.js";
+import { hlog } from "./log.js";
+import { assertEmbedDevice } from "./models/embed-config.js";
+import { errorCode, errorMessage } from "./error-fields.js";
+import { pushQueue } from "./queue.js";
+import { stageFile, sweepStaging } from "./staging.js";
+import { readInstall, readSetup } from "./tools/skills/manifest-parse.js";
+import { SKILL_STATE } from "./tools/skills/skill-state.js";
+import { asToolset } from "./tools/toolsets.js";
+import { fromDownloadWire, fromWire, unpackVectors } from "./wire.js";
+export const HARNESS_DIED = 'HARNESS_DIED';
+export function connectHarness(transport) {
+    return new RemoteHarness(transport);
+}
+export function readEmbeddingDeviceResponse(response) {
+    const device = typeof response === 'object' && response !== null ? Reflect.get(response, 'device') : undefined;
+    if (typeof device !== 'string')
+        throw new Error('invalid embedding device response');
+    assertEmbedDevice(device);
+    return device;
+}
+export class RemoteHarness extends EventEmitter {
+    _transport;
+    _session = null;
+    _opening = null;
+    _closed = false;
+    _customModels = [];
+    constructor(transport) {
+        super();
+        this._transport = transport;
+    }
+    _ensure() {
+        if (this._closed)
+            return Promise.reject(died('harness closed'));
+        if (this._session) {
+            return this._session.dead
+                ? Promise.reject(died('harness is dead'))
+                : Promise.resolve(this._session);
+        }
+        this._opening ??= this._open();
+        return this._opening;
+    }
+    async _open() {
+        sweepStaging();
+        let stream;
+        try {
+            stream = await this._transport();
+        }
+        catch (err) {
+            const details = errorDetails(err);
+            this.emit('status', { state: 'died', ...details });
+            throw died(`harness failed to open: ${details.error}`);
+        }
+        if (this._closed) {
+            stream.destroy();
+            throw died('harness closed');
+        }
+        const session = {
+            client: harnessClient(settleOnClose(new HRPC(stream))),
+            stream,
+            dead: false
+        };
+        let streamError = null;
+        stream.on('error', (err) => {
+            streamError = err;
+        });
+        stream.on('close', () => {
+            session.dead = true;
+            if (this._closed)
+                return;
+            this.emit('status', streamError ? { state: 'died', ...errorDetails(streamError) } : { state: 'died' });
+        });
+        this._session = session;
+        this.emit('status', { state: 'running' });
+        const models = session.client.modelEvents({});
+        models.on('data', (state) => this.emit('model', state));
+        models.on('error', noop);
+        if (this._customModels.length) {
+            try {
+                await session.client.setCustomModels({ models: this._customModels });
+            }
+            catch (err) {
+                hlog('custom model restore failed', { message: errorMessage(err) });
+            }
+        }
+        return session;
+    }
+    async *completion(context) {
+        const { client } = await this._ensure();
+        let duplex = null;
+        let emittedAborted = false;
+        const staged = [];
+        let closed = false;
+        let received = 0;
+        const reclaim = () => {
+            while (staged.length)
+                void fs.promises.unlink(staged.pop()).catch(noop);
+        };
+        const onAbort = () => duplex?.destroy();
+        try {
+            duplex = client.completion();
+            duplex.write({
+                type: 'start',
+                model: context.model,
+                agent: knobs(context.agent),
+                cacheKey: context.cacheKey,
+                thinkingDefault: context.thinkingDefault,
+                generationParams: context.generationParams,
+                responseFormat: context.responseFormat,
+                messages: context.messages.map(({ role, content, attachments }) => ({
+                    role,
+                    content,
+                    attachments: attachments?.map(({ path: file }) => ({ path: file }))
+                })),
+                toolConfigs: context.toolConfigs,
+                grantedDirs: context.grantedDirs,
+                grantedDrives: context.grantedDrives,
+                grantedWriteDirs: context.grantedWriteDirs
+            });
+            if (context.signal?.aborted) {
+                duplex.destroy();
+                yield { type: 'aborted' };
+                return;
+            }
+            context.signal?.addEventListener?.('abort', onAbort, { once: true });
+            hlog('client wire open', { model: context.model });
+            for await (const event of frames(duplex)) {
+                received++;
+                if (event.type !== 'content' && event.type !== 'thinking') {
+                    hlog('client frame', { type: event.type, n: received });
+                }
+                if (event.type === 'done')
+                    break;
+                if (event.type === 'approval-ask') {
+                    const callId = event.callId;
+                    void Promise.resolve()
+                        .then(() => context.approve?.({
+                        name: event.name ?? '',
+                        arguments: (event.arguments ?? {}),
+                        resource: event.resource ?? null,
+                        effect: event.effect === 'read' ? 'read' : 'write',
+                        intent: event.intent || null,
+                        display: event.display ?? null
+                    }))
+                        .then((approved) => {
+                        if (!closed) {
+                            duplex.write({ type: 'decision', callId, approved: approved === true });
+                        }
+                    }, () => {
+                        if (!closed) {
+                            duplex.write({ type: 'decision', callId, approved: false });
+                        }
+                    })
+                        .catch((err) => hlog('approval reply failed', { callId, message: errorMessage(err) }));
+                    continue;
+                }
+                if (event.type === 'attach-ask') {
+                    const callId = event.callId;
+                    void bridgeAttach(event, context.attach)
+                        .then((frame) => {
+                        if (!closed)
+                            duplex.write({ ...frame, callId });
+                    }, (err) => {
+                        if (!closed) {
+                            duplex.write({
+                                type: 'attach-result',
+                                callId,
+                                message: errorMessage(err)
+                            });
+                        }
+                    })
+                        .catch((err) => hlog('attach reply failed', { callId, message: errorMessage(err) }));
+                    continue;
+                }
+                if (event.type === 'fetch-ask') {
+                    const callId = event.callId;
+                    void bridgeFetch(event, context, staged)
+                        .then((frame) => {
+                        if (closed)
+                            return reclaim();
+                        duplex.write({ ...frame, callId });
+                    }, (err) => {
+                        if (closed)
+                            return reclaim();
+                        duplex.write({ type: 'fetch-result', callId, message: errorMessage(err) });
+                    })
+                        .catch((err) => hlog('fetch reply failed', { callId, message: errorMessage(err) }));
+                    continue;
+                }
+                if (event.type === 'drive-ask') {
+                    const callId = event.callId;
+                    void bridgeDrive(event, context)
+                        .then((frame) => {
+                        if (!closed)
+                            return duplex.write({ ...frame, callId });
+                        const stagedPath = frame.payload?.path;
+                        if (stagedPath)
+                            void fs.promises.unlink(stagedPath).catch(noop);
+                    }, (err) => {
+                        if (!closed) {
+                            duplex.write({
+                                type: 'drive-result',
+                                callId,
+                                message: errorMessage(err)
+                            });
+                        }
+                    })
+                        .catch((err) => hlog('drive reply failed', { callId, message: errorMessage(err) }));
+                    continue;
+                }
+                if (event.type === 'rag-ask') {
+                    const callId = event.callId;
+                    void bridgeRag(event, context)
+                        .then((frame) => {
+                        if (!closed)
+                            duplex.write({ ...frame, callId });
+                    }, (err) => {
+                        if (!closed) {
+                            duplex.write({
+                                type: 'rag-result',
+                                callId,
+                                message: errorMessage(err)
+                            });
+                        }
+                    })
+                        .catch((err) => hlog('rag reply failed', { callId, message: errorMessage(err) }));
+                    continue;
+                }
+                if (event.type === 'question-ask') {
+                    const callId = event.callId;
+                    const askUser = context.askUser;
+                    if (!askUser) {
+                        if (!closed) {
+                            duplex.write({
+                                type: 'question-result',
+                                callId,
+                                message: 'the host cannot ask questions'
+                            });
+                        }
+                        continue;
+                    }
+                    void Promise.resolve()
+                        .then(() => askUser({
+                        question: event.question ?? '',
+                        ...(Array.isArray(event.options)
+                            ? { options: event.options.map(String) }
+                            : {})
+                    }))
+                        .then((answer) => {
+                        if (!closed) {
+                            duplex.write({ type: 'question-result', callId, answer: answer ?? '' });
+                        }
+                    }, (err) => {
+                        if (!closed) {
+                            duplex.write({
+                                type: 'question-result',
+                                callId,
+                                message: errorMessage(err)
+                            });
+                        }
+                    })
+                        .catch((err) => hlog('question reply failed', { callId, message: errorMessage(err) }));
+                    continue;
+                }
+                if (event.type === 'progress') {
+                    context.progress?.(event.cleared ? null : { percentage: event.percentage ?? 0 });
+                    continue;
+                }
+                const wire = fromWire(event);
+                if (wire.type === 'aborted')
+                    emittedAborted = true;
+                yield wire;
+            }
+            hlog('client wire ended', { received });
+        }
+        catch (err) {
+            if (context.signal?.aborted) {
+                if (!emittedAborted)
+                    yield { type: 'aborted' };
+                return;
+            }
+            throw died(`harness died mid-run: ${err.message}`);
+        }
+        finally {
+            hlog('client completion end', { received, aborted: Boolean(context.signal?.aborted) });
+            context.signal?.removeEventListener?.('abort', onAbort);
+            duplex?.destroy();
+            closed = true;
+            reclaim();
+        }
+        if (context.signal?.aborted && !emittedAborted)
+            yield { type: 'aborted' };
+    }
+    async *download(context) {
+        const { client } = await this._ensure();
+        let stream = null;
+        let emittedAborted = false;
+        const onAbort = () => stream?.destroy();
+        try {
+            stream = client.download({
+                model: context.model,
+                addon: context.addon,
+                seed: context.seed
+            });
+            if (context.signal?.aborted) {
+                stream.destroy();
+                yield { type: 'aborted' };
+                return;
+            }
+            context.signal?.addEventListener?.('abort', onAbort, { once: true });
+            for await (const event of downloadFrames(stream)) {
+                const wire = fromDownloadWire(event);
+                if (wire.type === 'aborted')
+                    emittedAborted = true;
+                yield wire;
+            }
+        }
+        catch (err) {
+            if (context.signal?.aborted) {
+                if (!emittedAborted)
+                    yield { type: 'aborted' };
+                return;
+            }
+            throw died(`harness died mid-download: ${err.message}`);
+        }
+        finally {
+            context.signal?.removeEventListener?.('abort', onAbort);
+            stream?.destroy();
+        }
+        if (context.signal?.aborted && !emittedAborted)
+            yield { type: 'aborted' };
+    }
+    async embed(context) {
+        const { client } = await this._ensure();
+        const response = await abortable(client.embed({ model: context.model, texts: context.texts }), context.signal);
+        const rows = unpackVectors(response.dimensions, response.vectors);
+        if (rows.length !== context.texts.length) {
+            throw new Error(`embed returned ${rows.length} vectors for ${context.texts.length} texts`);
+        }
+        return rows;
+    }
+    async transcribe(context) {
+        const { client } = await this._ensure();
+        const response = await abortable(client.transcribe({ model: context.model, audio: context.audio }), context.signal);
+        return response.text;
+    }
+    async speak(context) {
+        const { client } = await this._ensure();
+        const response = await abortable(client.speak({ model: context.model, text: context.text }), context.signal);
+        return { audio: response.audio, sampleRate: response.sampleRate };
+    }
+    async *speakStream(context) {
+        const { client } = await this._ensure();
+        const duplex = client.speakStream();
+        const pump = (async () => {
+            try {
+                for await (const fragment of context.text)
+                    duplex.write({ text: fragment });
+                duplex.end();
+            }
+            catch {
+                duplex.destroy();
+            }
+        })();
+        try {
+            for await (const frame of frames(duplex)) {
+                const chunk = frame;
+                yield { audio: chunk.audio, sampleRate: chunk.sampleRate };
+            }
+        }
+        finally {
+            await pump.catch(() => { });
+        }
+    }
+    async getEmbeddingDevice() {
+        const { client } = await this._ensure();
+        return readEmbeddingDeviceResponse(await client.getEmbeddingDevice({}));
+    }
+    async setEmbeddingDevice(device) {
+        const { client } = await this._ensure();
+        await client.setEmbeddingDevice({ device });
+    }
+    async setCredentials(entries) {
+        const { client } = await this._ensure();
+        await client.setCredentials({ entries });
+    }
+    async setSkillSettings(entries) {
+        const { client } = await this._ensure();
+        await client.setSkillSettings({ entries });
+    }
+    async listManagedSkills() {
+        const { client } = await this._ensure();
+        const response = await client.listManagedSkills({});
+        return (response.skills ?? []).map((s) => ({
+            name: s.name,
+            origin: s.origin === 'overlay' ? 'overlay' : 'base',
+            overridesBase: s.overridesBase === true
+        }));
+    }
+    async readSkillFile(name) {
+        const { client } = await this._ensure();
+        const response = await client.readSkillFile({ name });
+        return response?.found
+            ? {
+                content: response.content ?? '',
+                origin: response.origin === 'overlay' ? 'overlay' : 'base'
+            }
+            : null;
+    }
+    async writeSkillFile(name, content) {
+        const { client } = await this._ensure();
+        const response = await client.writeSkillFile({ name, content });
+        return { ok: response?.ok === true };
+    }
+    async copyBaseForEdit(name) {
+        const { client } = await this._ensure();
+        const response = await client.copySkillForEdit({ name });
+        return { copied: response?.copied === true };
+    }
+    async deleteOverlaySkill(name) {
+        const { client } = await this._ensure();
+        const response = await client.deleteOverlaySkill({ name });
+        return { removed: response?.removed === true };
+    }
+    async setCustomModels(entries) {
+        this._customModels = entries;
+        const { client } = await this._ensure();
+        await client.setCustomModels({ models: entries });
+    }
+    async skills(agentId, modelName, options) {
+        const { client } = await this._ensure();
+        const response = await client.skills({
+            agentId: agentId ?? undefined,
+            modelName: modelName ?? undefined,
+            refresh: options?.refresh === true,
+            skipCredentialProbe: options?.skipCredentialProbe === true
+        });
+        return (response.skills ?? []).map((skill) => {
+            const install = readInstall(skill.install);
+            const setup = readSetup(skill.setupV2 ?? skill.setup);
+            const binaries = skill.requirements?.binaries ?? [];
+            const binMinVersions = Object.fromEntries(binaries.flatMap((binary) => {
+                const minVersion = binary.minVersion;
+                return minVersion
+                    ? [
+                        [
+                            binary.bin,
+                            {
+                                min: minVersion,
+                                ...(binary.command ? { command: binary.command } : {})
+                            }
+                        ]
+                    ]
+                    : [];
+            }));
+            return {
+                name: skill.name,
+                description: skill.description,
+                tools: skill.tools ?? [],
+                credentials: skill.credentials ?? [],
+                allowList: skill.allowList ?? [],
+                platform: skill.platforms ?? [],
+                status: parseSkillState(skill.status),
+                ...(skill.requirements
+                    ? {
+                        requires: {
+                            bins: binaries.map((binary) => binary.bin),
+                            ...(skill.requirements?.credentials?.length
+                                ? { credentials: skill.requirements.credentials }
+                                : {}),
+                            ...(Object.keys(binMinVersions).length > 0 ? { binMinVersions } : {})
+                        }
+                    }
+                    : {}),
+                ...(install ? { install } : {}),
+                ...(setup ? { setup } : {}),
+                ...(skill.stub === true ? { stub: true } : {}),
+                ...(skill.minCapabilityProfile ? { minCapabilityProfile: skill.minCapabilityProfile } : {}),
+                ...(skill.emoji ? { emoji: skill.emoji } : {})
+            };
+        });
+    }
+    async tools() {
+        const { client } = await this._ensure();
+        const response = await client.tools({});
+        return (response.tools ?? []).map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            skillGated: tool.skillGated === true,
+            scopeRequired: tool.scopeRequired === true,
+            toolset: asToolset(tool.toolset),
+            rootsRequired: tool.rootsRequired === true,
+            writeRootsRequired: tool.writeRootsRequired === true,
+            promptChars: tool.promptChars ?? 0
+        }));
+    }
+    async warmModel(context) {
+        const { client } = await this._ensure();
+        await abortable(client.warmModel({
+            model: context.model,
+            ...(context.agent ? { agent: knobs(context.agent) } : {})
+        }), context.signal);
+    }
+    async list(options = {}) {
+        const { client } = await this._ensure();
+        const response = (await client.listModels({
+            type: options.type,
+            cachedOnly: options.cachedOnly,
+            fullRegistry: options.fullRegistry
+        }));
+        return (response.models ?? []).map(({ actualSize, ...row }) => ({
+            ...row,
+            ...(actualSize ? { actualSize } : {})
+        }));
+    }
+    async deleteModel(name) {
+        const { client } = await this._ensure();
+        const response = (await client.deleteModel({ name }));
+        return { name: response.name, removed: response.removed, freedBytes: response.freedBytes };
+    }
+    async clearKvCache() {
+        try {
+            const { client } = await this._ensure();
+            const info = await client.describe({});
+            if (info.supportsKvCacheDeletion !== true)
+                return unsupportedKvCacheDeletion();
+            const response = await client.clearKvCache({});
+            if (response.status === 'success')
+                return { status: 'success' };
+            if (response.status === 'failure') {
+                return { status: 'failure', error: response.error ?? 'Harness cache deletion failed' };
+            }
+            return unsupportedKvCacheDeletion(response.error ?? undefined);
+        }
+        catch (error) {
+            return {
+                status: 'failure',
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async infraModels(profile) {
+        const { client } = await this._ensure();
+        const response = (await client.infraModels({ profile }));
+        return response.models ?? [];
+    }
+    async capability() {
+        const { client } = await this._ensure();
+        const response = await client.capability({});
+        const memoryBudget = response.memoryBudget;
+        return {
+            capabilityProfile: response.capabilityProfile,
+            recommendedModelName: response.recommendedModelName,
+            ...(memoryBudget
+                ? {
+                    memoryBudget: {
+                        totalBytes: memoryBudget.totalBytes,
+                        availableBytes: memoryBudget.availableBytes,
+                        source: memoryBudget.source,
+                        ...(memoryBudget.gpuClass ? { gpuClass: memoryBudget.gpuClass } : {})
+                    }
+                }
+                : {})
+        };
+    }
+    close() {
+        this._closed = true;
+        this._session?.stream.destroy();
+    }
+    async describe() {
+        const { client } = await this._ensure();
+        const describe = client.describe;
+        if (!describe)
+            return null;
+        const info = await describe.call(client, {});
+        return {
+            toolNames: info?.toolNames ?? [],
+            skills: info?.skills ?? [],
+            supportsImages: info?.supportsImages ?? false,
+            supportsKvCacheDeletion: info?.supportsKvCacheDeletion ?? false
+        };
+    }
+    async fetchDiagnostics() {
+        const session = this._session;
+        if (!session || session.dead)
+            return null;
+        const client = session.client;
+        const diagnostics = client.diagnostics;
+        if (!diagnostics)
+            return null;
+        const snapshot = await diagnostics.call(client, {});
+        const device = snapshot?.device;
+        return {
+            models: (snapshot?.models ?? []).map((row) => ({ model: row.model, refs: row.refs })),
+            suspended: snapshot?.suspended ?? false,
+            sdkLoaded: snapshot?.sdkLoaded ?? false,
+            toolNames: snapshot?.toolNames ?? [],
+            skills: snapshot?.skills ?? [],
+            ...(device ? { device } : {})
+        };
+    }
+}
+function parseSkillState(value) {
+    return value ? value : SKILL_STATE.failed;
+}
+function errorDetails(err) {
+    return { error: errorMessage(err), code: errorCode(err) };
+}
+function died(message) {
+    const err = new Error(message);
+    err.code = HARNESS_DIED;
+    return err;
+}
+const noop = () => { };
+function abortable(promise, signal) {
+    if (!signal)
+        return promise;
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            promise.then(noop, noop);
+            reject(new Error('embed aborted'));
+            return;
+        }
+        const onAbort = () => reject(new Error('embed aborted'));
+        signal.addEventListener?.('abort', onAbort, { once: true });
+        promise.then(resolve, reject).finally(() => signal.removeEventListener?.('abort', onAbort));
+    });
+}
+function knobs(agent) {
+    return {
+        id: agent.id,
+        name: agent.name,
+        bio: agent.bio,
+        reasoning: agent.reasoning ?? undefined,
+        enabledTools: agent.enabledTools ?? undefined,
+        enabledSkills: agent.enabledSkills ?? undefined,
+        toolsScope: agent.toolsScope ?? undefined,
+        skillsScope: agent.skillsScope ?? undefined,
+        ctxSize: agent.ctxSize ?? undefined,
+        kvCacheK: agent.kvCacheK ?? undefined,
+        kvCacheV: agent.kvCacheV ?? undefined,
+        imageModelChoice: agent.imageModelChoice ?? undefined,
+        imageSteps: agent.imageSteps ?? undefined,
+        imageWidth: agent.imageWidth ?? undefined,
+        imageHeight: agent.imageHeight ?? undefined,
+        approvalMode: agent.approvalMode ?? undefined,
+        disabledToolsets: agent.disabledToolsets ?? undefined
+    };
+}
+async function bridgeAttach(event, attach) {
+    try {
+        if (!attach)
+            return { type: 'attach-result', message: 'the host cannot persist attachments' };
+        const bytes = await fs.promises.readFile(event.path ?? '');
+        const record = await attach({
+            fileName: event.fileName ?? '',
+            mimeType: event.mimeType ?? '',
+            bytes,
+            raw: event.raw === true
+        });
+        return {
+            type: 'attach-result',
+            attachment: {
+                id: record.id,
+                fileName: record.fileName,
+                mimeType: record.mimeType,
+                byteLength: record.byteLength
+            }
+        };
+    }
+    catch (err) {
+        return { type: 'attach-result', message: err.message };
+    }
+    finally {
+        if (event.path)
+            void fs.promises.unlink(event.path).catch(noop);
+    }
+}
+async function bridgeFetch(event, context, staged) {
+    if (!context.fetchAttachment) {
+        return { type: 'fetch-result', message: 'the host cannot read attachments' };
+    }
+    try {
+        const metaOnly = event.meta === true;
+        const found = await context.fetchAttachment({
+            attachmentId: event.attachmentId ?? undefined,
+            ...(metaOnly ? { meta: true } : {}),
+            signal: context.signal
+        });
+        if (!found)
+            return { type: 'fetch-result' };
+        const size = 'bytes' in found && found.bytes !== null ? found.bytes.byteLength : found.byteLength;
+        if (metaOnly) {
+            return {
+                type: 'fetch-result',
+                meta: true,
+                fileName: found.fileName,
+                mimeType: found.mimeType,
+                attachmentId: found.id,
+                size
+            };
+        }
+        if (!('bytes' in found) || found.bytes === null) {
+            return { type: 'fetch-result', message: 'attachment has no bytes' };
+        }
+        const file = await stageFile('fetch', found.bytes);
+        staged.push(file);
+        return {
+            type: 'fetch-result',
+            path: file,
+            fileName: found.fileName,
+            mimeType: found.mimeType,
+            attachmentId: found.id,
+            size
+        };
+    }
+    catch (err) {
+        return { type: 'fetch-result', message: err.message };
+    }
+}
+async function bridgeDrive(event, context) {
+    if (!context.driveOp)
+        return { type: 'drive-result', message: 'the host cannot proxy drives' };
+    try {
+        const payload = await context.driveOp(event.payload);
+        return { type: 'drive-result', payload };
+    }
+    catch (err) {
+        return { type: 'drive-result', message: err instanceof Error ? err.message : String(err) };
+    }
+}
+async function bridgeRag(event, context) {
+    if (!context.ragSearch) {
+        return {
+            type: 'rag-result',
+            result: { enabled: false, indexEmpty: true, hasKnowledge: false, hits: [] }
+        };
+    }
+    try {
+        const result = await context.ragSearch({
+            query: event.query ?? '',
+            limit: event.limit ?? undefined
+        });
+        return { type: 'rag-result', result };
+    }
+    catch (err) {
+        return { type: 'rag-result', message: err instanceof Error ? err.message : String(err) };
+    }
+}
+async function* frames(stream) {
+    const queue = pushQueue();
+    let error = null;
+    stream.on('data', (frame) => queue.push(frame));
+    stream.on('end', () => {
+        hlog('client stream event', { event: 'end' });
+        queue.end();
+    });
+    stream.on('close', () => {
+        hlog('client stream event', { event: 'close' });
+        queue.end();
+    });
+    stream.on('error', (err) => {
+        hlog('client stream event', { event: 'error', err: err.message });
+        error = err;
+        queue.end();
+    });
+    yield* queue;
+    if (error)
+        throw error;
+}
+async function* downloadFrames(stream) {
+    const queue = pushQueue();
+    let error = null;
+    stream.on('data', (frame) => queue.push(frame));
+    stream.on('end', () => queue.end());
+    stream.on('close', () => queue.end());
+    stream.on('error', (err) => {
+        error = err;
+        queue.end();
+    });
+    yield* queue;
+    if (error)
+        throw error;
+}