@minionry/sdk 0.4.23

package/dist/provider.js

@@ -0,0 +1,1503 @@
+import { MinionryError } from './types.js';
+import { base64ToBytes, bytesToBase64 } from './base64.js';
+class Emitter {
+    listeners = new Map();
+    on(event, cb) {
+        let list = this.listeners.get(event);
+        if (!list) {
+            list = [];
+            this.listeners.set(event, list);
+        }
+        const entry = { cb };
+        list.push(entry);
+        let removed = false;
+        return () => {
+            if (removed)
+                return;
+            removed = true;
+            const current = this.listeners.get(event);
+            if (!current)
+                return;
+            const index = current.indexOf(entry);
+            if (index !== -1)
+                current.splice(index, 1);
+        };
+    }
+    emit(event, payload) {
+        const list = this.listeners.get(event);
+        if (!list || list.length === 0)
+            return;
+        for (const entry of [...list]) {
+            try {
+                entry.cb(payload);
+            }
+            catch (cause) {
+                console.error('[@minionry/sdk] listener error', cause);
+            }
+        }
+    }
+}
+const CLOSED_MESSAGE = 'the transport is closed — the host frame was torn down or the Space disconnected';
+const TRANSFER_CHUNK_BYTES = 256 * 1024;
+const MAX_TRANSFER_BYTES = 50 * 1024 * 1024;
+const MAX_CHUNK_ATTEMPTS = 6;
+const CHUNK_RETRY_DELAY_MS = 500;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function basenameOf(path) {
+    const idx = path.lastIndexOf('/');
+    return idx === -1 ? path : path.slice(idx + 1);
+}
+const STREAM_RESUME_FEATURE = 'streamResume';
+const APP_ENDPOINTS_FEATURE = 'appEndpoints';
+const AGENTS_APP_ENDPOINT_FEATURE = 'agentsAppEndpoint';
+const AGENT_RUN_APP_ENDPOINT_FIELDS = ['model', 'systemPrompt', 'budget', 'sessionId'];
+const AGENTS_MODEL_SELECTION_FEATURE = 'agentsModelSelection';
+function deliverStreamFrames(tracker, frames) {
+    for (const frame of [...frames].sort((a, b) => a.seq - b.seq)) {
+        if (frame.seq <= tracker.lastSeq)
+            continue;
+        tracker.deliver(frame.event, frame.payload);
+        tracker.lastSeq = frame.seq;
+    }
+}
+function describeGapCause(cause) {
+    return cause instanceof MinionryError ? cause.message : String(cause);
+}
+export function createProvider(transport) {
+    const pending = new Map();
+    const streams = new Map();
+    const providerEvents = new Emitter();
+    let requestCounter = 0;
+    let closed = false;
+    let pendingIntent;
+    let intentListenerCount = 0;
+    const mintRequestId = () => `r${++requestCounter}`;
+    const request = (method, params, requestId = mintRequestId()) => {
+        if (closed) {
+            return Promise.reject(new MinionryError('SPACE_DISCONNECTED', `${method} failed: ${CLOSED_MESSAGE}`));
+        }
+        return new Promise((resolve, reject) => {
+            pending.set(requestId, { resolve, reject });
+            const frame = { requestId, method };
+            if (params !== undefined)
+                frame.params = params;
+            try {
+                transport.send(frame);
+            }
+            catch (cause) {
+                pending.delete(requestId);
+                reject(new MinionryError('SPACE_DISCONNECTED', `${method} failed: transport send threw (${String(cause)})`));
+            }
+        });
+    };
+    let featuresMemo;
+    const hostFeatures = () => {
+        if (!featuresMemo) {
+            const probe = request('features').then((flags) => (Array.isArray(flags) ? flags : []), (cause) => {
+                if (featuresMemo === probe)
+                    featuresMemo = undefined;
+                throw cause;
+            });
+            featuresMemo = probe;
+        }
+        return featuresMemo;
+    };
+    const requireFeature = async (flag, what) => {
+        if (!(await hostFeatures()).includes(flag)) {
+            throw new MinionryError('UNSUPPORTED', `${what} needs a host that advertises the '${flag}' feature — this host does not, so nothing was sent`);
+        }
+    };
+    const supportsResume = () => hostFeatures().then((flags) => flags.includes(STREAM_RESUME_FEATURE), () => false);
+    const registerStream = (requestId, deliver, onGap) => {
+        streams.set(requestId, { lastSeq: 0, resuming: false, pending: [], deliver, onGap });
+    };
+    const unregisterStream = (requestId) => {
+        streams.delete(requestId);
+    };
+    const resumeStream = (requestId, tracker) => {
+        tracker.resuming = true;
+        void supportsResume()
+            .then((canResume) => {
+            if (closed)
+                return;
+            if (!canResume) {
+                throw new MinionryError('SCOPE_DENIED', 'this host does not advertise the streamResume feature');
+            }
+            return request('stream.resume', { requestId, afterSeq: tracker.lastSeq });
+        })
+            .then((result) => {
+            if (closed || !streams.has(requestId))
+                return;
+            deliverStreamFrames(tracker, result && Array.isArray(result.events) ? result.events : []);
+            const queued = tracker.pending;
+            tracker.pending = [];
+            tracker.resuming = false;
+            deliverStreamFrames(tracker, queued);
+        })
+            .catch((cause) => {
+            if (closed || !streams.has(requestId))
+                return;
+            tracker.resuming = false;
+            const queued = tracker.pending;
+            tracker.pending = [];
+            tracker.onGap(describeGapCause(cause));
+            deliverStreamFrames(tracker, queued);
+        });
+    };
+    const routeStreamEvent = (requestId, seq, event, payload) => {
+        const tracker = streams.get(requestId);
+        if (!tracker)
+            return;
+        if (seq === undefined) {
+            tracker.deliver(event, payload);
+            return;
+        }
+        if (tracker.resuming) {
+            tracker.pending.push({ seq, event, payload });
+            return;
+        }
+        if (seq <= tracker.lastSeq)
+            return;
+        if (seq === tracker.lastSeq + 1) {
+            tracker.deliver(event, payload);
+            tracker.lastSeq = seq;
+            return;
+        }
+        tracker.pending.push({ seq, event, payload });
+        resumeStream(requestId, tracker);
+    };
+    const toolRegistrations = new Map();
+    const answerToolCall = (result) => {
+        if (closed)
+            return;
+        request('tools.result', result).catch(() => {
+        });
+    };
+    const retireToolRegistration = (requestId) => {
+        const registration = toolRegistrations.get(requestId);
+        if (!registration)
+            return;
+        toolRegistrations.delete(requestId);
+        for (const controller of registration.calls.values())
+            controller.abort();
+        registration.calls.clear();
+    };
+    const routeToolCall = (frame) => {
+        const registration = toolRegistrations.get(frame.requestId);
+        if (frame.op === 'cancel') {
+            const controller = registration?.calls.get(frame.callId);
+            registration?.calls.delete(frame.callId);
+            controller?.abort();
+            return;
+        }
+        const definition = registration?.tools.get(frame.tool);
+        if (!registration || !definition) {
+            answerToolCall({
+                callId: frame.callId,
+                ok: false,
+                error: {
+                    code: 'APP_UNAVAILABLE',
+                    message: `this app is not serving a tool named '${frame.tool}'`,
+                },
+            });
+            return;
+        }
+        const controller = new AbortController();
+        registration.calls.set(frame.callId, controller);
+        const ctx = { callId: frame.callId, tool: frame.tool, signal: controller.signal };
+        void Promise.resolve()
+            .then(() => definition.handler(frame.input, ctx))
+            .then((result) => {
+            if (!registration.calls.delete(frame.callId))
+                return;
+            answerToolCall({ callId: frame.callId, ok: true, result });
+        }, (cause) => {
+            if (!registration.calls.delete(frame.callId))
+                return;
+            answerToolCall({
+                callId: frame.callId,
+                ok: false,
+                error: {
+                    code: 'APP_ERROR',
+                    message: cause instanceof Error ? cause.message : String(cause),
+                },
+            });
+        });
+    };
+    transport.start({
+        onResponse(frame) {
+            const entry = pending.get(frame.requestId);
+            if (!entry)
+                return;
+            pending.delete(frame.requestId);
+            if (frame.ok)
+                entry.resolve(frame.result);
+            else
+                entry.reject(new MinionryError(frame.error.code, frame.error.message));
+        },
+        onEvent(frame) {
+            routeStreamEvent(frame.requestId, frame.seq, frame.event, frame.payload);
+        },
+        onNotification(frame) {
+            if (frame.event === 'intent') {
+                if (intentListenerCount > 0) {
+                    providerEvents.emit('intent', frame.payload);
+                }
+                else {
+                    pendingIntent = frame.payload;
+                }
+                return;
+            }
+            if (frame.event === 'disconnect' || frame.event === 'spaceChanged') {
+                featuresMemo = undefined;
+            }
+            if (frame.event === 'disconnect' ||
+                frame.event === 'grantsChanged' ||
+                frame.event === 'spaceChanged' ||
+                frame.event === 'themeChanged' ||
+                frame.event === 'localeChanged') {
+                providerEvents.emit(frame.event, frame.payload);
+            }
+        },
+        onToolCall(frame) {
+            if (closed)
+                return;
+            routeToolCall(frame);
+        },
+        onClose() {
+            if (closed)
+                return;
+            closed = true;
+            const cause = new MinionryError('SPACE_DISCONNECTED', CLOSED_MESSAGE);
+            const inflight = [...pending.values()];
+            pending.clear();
+            streams.clear();
+            for (const requestId of [...toolRegistrations.keys()])
+                retireToolRegistration(requestId);
+            for (const entry of inflight)
+                entry.reject(cause);
+            providerEvents.emit('disconnect', undefined);
+        },
+    });
+    return {
+        version: '1',
+        async features() {
+            return (await request('features'));
+        },
+        async connect(req) {
+            return (await request('connect', { scopes: req.scopes }));
+        },
+        async disconnect() {
+            await request('disconnect');
+        },
+        auth: {
+            async getToken() {
+                return (await request('auth.getToken'));
+            },
+        },
+        agents: {
+            async run(req) {
+                const endpointFields = AGENT_RUN_APP_ENDPOINT_FIELDS.filter((field) => req[field] !== undefined);
+                if (endpointFields.length > 0) {
+                    await requireFeature(AGENTS_APP_ENDPOINT_FEATURE, `agents.run with ${endpointFields.join(', ')}`);
+                }
+                if (req.modelSelection !== undefined) {
+                    await requireFeature(AGENTS_MODEL_SELECTION_FEATURE, 'agents.run with modelSelection');
+                }
+                const params = { prompt: req.prompt, title: req.title };
+                for (const field of endpointFields)
+                    params[field] = req[field];
+                if (req.modelSelection !== undefined)
+                    params.modelSelection = req.modelSelection;
+                const requestId = mintRequestId();
+                const runEvents = new Emitter();
+                registerStream(requestId, (event, payload) => runEvents.emit(event, payload), (message) => runEvents.emit('gap', { message }));
+                let runId;
+                let sessionId;
+                try {
+                    const result = (await request('agents.run', params, requestId));
+                    runId = result.runId;
+                    sessionId = typeof result.sessionId === 'string' ? result.sessionId : '';
+                }
+                catch (cause) {
+                    unregisterStream(requestId);
+                    throw cause;
+                }
+                let resultPromise;
+                const run = {
+                    id: runId,
+                    sessionId,
+                    on(event, cb) {
+                        return runEvents.on(event, cb);
+                    },
+                    result() {
+                        resultPromise ??= request('agents.result', { runId }).catch((cause) => {
+                            resultPromise = undefined;
+                            throw cause;
+                        });
+                        return resultPromise;
+                    },
+                    async cancel() {
+                        await request('cancel', { requestId });
+                    },
+                };
+                return run;
+            },
+            sessions: {
+                async list() {
+                    return (await request('agents.sessions.list'));
+                },
+                async create(req) {
+                    return (await request('agents.sessions.create', { name: req?.name }));
+                },
+                async attach(sessionId) {
+                    return (await request('agents.sessions.attach', { sessionId }));
+                },
+                async close(sessionId) {
+                    await request('agents.sessions.close', { sessionId });
+                },
+                async rename(sessionId, req) {
+                    return (await request('agents.sessions.rename', { sessionId, name: req.name }));
+                },
+                async history(sessionId) {
+                    return (await request('agents.sessions.history', { sessionId }));
+                },
+                async replay(sessionId, afterSeq) {
+                    return (await request('agents.sessions.replay', { sessionId, afterSeq }));
+                },
+                async approve(sessionId, approved) {
+                    await request('agents.sessions.approve', { sessionId, approved });
+                },
+                async answerQuestion(sessionId, toolUseId, answers) {
+                    await request('agents.sessions.answerQuestion', { sessionId, toolUseId, answers });
+                },
+                async prompt(sessionId, text, attachments) {
+                    return (await request('agents.sessions.prompt', { sessionId, prompt: text, attachments }));
+                },
+                async stop(sessionId) {
+                    await request('agents.sessions.stop', { sessionId });
+                },
+            },
+        },
+        apps: {
+            async open(req) {
+                await request('apps.open', { app: req.app, params: req.params });
+            },
+        },
+        pm: {
+            async createBoard(req) {
+                return (await request('pm.createBoard', {
+                    prompt: req.prompt,
+                    autoImplement: req.autoImplement,
+                    input: req.input,
+                }));
+            },
+            async getBoard(boardId) {
+                return (await request('pm.getBoard', { boardId }));
+            },
+            async listBoards() {
+                return (await request('pm.listBoards', {}));
+            },
+            async createIssue(req) {
+                return (await request('pm.createIssue', req));
+            },
+            async updateIssue(boardId, issueId, fields) {
+                return (await request('pm.updateIssue', { boardId, issueId, fields }));
+            },
+            async deleteIssue(boardId, issueId) {
+                await request('pm.deleteIssue', { boardId, issueId });
+            },
+            async updateBoard(boardId, fields) {
+                return (await request('pm.updateBoard', { boardId, fields }));
+            },
+            onBoardUpdate(boardId, cb) {
+                const requestId = mintRequestId();
+                let active = true;
+                registerStream(requestId, (event, payload) => {
+                    if (active && event === 'boardUpdate')
+                        cb(payload);
+                }, (message) => {
+                    if (active)
+                        providerEvents.emit('boardGap', { boardId, message });
+                });
+                request('pm.subscribeBoard', { boardId }, requestId).catch((cause) => {
+                    if (!active)
+                        return;
+                    active = false;
+                    unregisterStream(requestId);
+                    console.error(`[@minionry/sdk] pm.onBoardUpdate(${boardId}) subscription failed`, cause);
+                });
+                return () => {
+                    if (!active)
+                        return;
+                    active = false;
+                    unregisterStream(requestId);
+                    if (!closed) {
+                        request('cancel', { requestId }).catch(() => { });
+                    }
+                };
+            },
+            async execute(boardId) {
+                const requestId = mintRequestId();
+                const runEvents = new Emitter();
+                registerStream(requestId, (event, payload) => runEvents.emit(event, payload), (message) => runEvents.emit('gap', { message }));
+                let runId;
+                try {
+                    const result = (await request('pm.execute', { boardId }, requestId));
+                    runId = result.runId;
+                }
+                catch (cause) {
+                    unregisterStream(requestId);
+                    throw cause;
+                }
+                const run = {
+                    id: runId,
+                    boardId,
+                    on(event, cb) {
+                        return runEvents.on(event, cb);
+                    },
+                    async pause() {
+                        await request('pm.pause', { boardId, runId });
+                    },
+                    async resume() {
+                        await request('pm.resume', { boardId, runId });
+                    },
+                    async stop() {
+                        await request('pm.stop', { boardId, runId });
+                    },
+                };
+                return run;
+            },
+            schedules: {
+                async list() {
+                    const result = (await request('pm.schedules.list', {}));
+                    return result.schedules;
+                },
+                async create(req) {
+                    return (await request('pm.schedules.create', req));
+                },
+                async update(scheduleId, patch) {
+                    return (await request('pm.schedules.update', { scheduleId, patch }));
+                },
+                async delete(scheduleId) {
+                    await request('pm.schedules.delete', { scheduleId });
+                },
+            },
+        },
+        files: {
+            async read(path) {
+                return (await request('files.read', { path }));
+            },
+            async readEntry(path) {
+                return (await request('files.readEntry', { path }));
+            },
+            async write(path, content) {
+                await request('files.write', { path, content });
+            },
+            async list(path) {
+                return (await request('files.list', { path }));
+            },
+            async delete(path) {
+                await request('files.delete', { path });
+            },
+            async mkdir(path) {
+                await request('files.mkdir', { path });
+            },
+            async rename(path, newPath) {
+                await request('files.rename', { path, newPath });
+            },
+            async search(path, query, options) {
+                const requestId = mintRequestId();
+                const searchEvents = new Emitter();
+                registerStream(requestId, (event, payload) => searchEvents.emit(event, payload), (message) => searchEvents.emit('gap', { message }));
+                try {
+                    await request('files.search', { path, query, options }, requestId);
+                }
+                catch (cause) {
+                    unregisterStream(requestId);
+                    throw cause;
+                }
+                let cancelled = false;
+                const handle = {
+                    id: requestId,
+                    on(event, cb) {
+                        return searchEvents.on(event, cb);
+                    },
+                    async cancel() {
+                        if (cancelled)
+                            return;
+                        cancelled = true;
+                        unregisterStream(requestId);
+                        await request('cancel', { requestId });
+                    },
+                };
+                return handle;
+            },
+            async definition(path, symbolName, opts) {
+                return (await request('files.definition', {
+                    path,
+                    symbolName,
+                    language: opts?.language,
+                    currentFile: opts?.currentFile,
+                }));
+            },
+            onChanged(path, cb) {
+                const requestId = mintRequestId();
+                let active = true;
+                registerStream(requestId, (event, payload) => {
+                    if (active && event === 'changed')
+                        cb(payload);
+                }, (message) => {
+                    if (active)
+                        providerEvents.emit('fileChangeGap', { path, message });
+                });
+                request('files.subscribeChanges', { path }, requestId).catch((cause) => {
+                    if (!active)
+                        return;
+                    active = false;
+                    unregisterStream(requestId);
+                    console.error(`[@minionry/sdk] files.onChanged(${path}) subscription failed`, cause);
+                });
+                return () => {
+                    if (!active)
+                        return;
+                    active = false;
+                    unregisterStream(requestId);
+                    if (!closed) {
+                        request('cancel', { requestId }).catch(() => { });
+                    }
+                };
+            },
+            async upload(path, data, opts) {
+                if (data.byteLength > MAX_TRANSFER_BYTES) {
+                    throw new MinionryError('BAD_REQUEST', `files.upload: ${data.byteLength} bytes exceeds the 50 MiB cap`);
+                }
+                const requestId = mintRequestId();
+                const transferEvents = new Emitter();
+                registerStream(requestId, (event, payload) => transferEvents.emit(event, payload), () => { });
+                const totalBytes = data.byteLength;
+                const totalChunks = Math.max(1, Math.ceil(totalBytes / TRANSFER_CHUNK_BYTES));
+                let uploadId;
+                try {
+                    const start = (await request('files.uploadStart', {
+                        path,
+                        fileName: basenameOf(path),
+                        fileSize: totalBytes,
+                        totalChunks,
+                        mimeType: opts?.mimeType,
+                        overwrite: opts?.overwrite,
+                    }, requestId));
+                    uploadId = start.uploadId;
+                }
+                catch (cause) {
+                    unregisterStream(requestId);
+                    throw cause;
+                }
+                let cancelled = false;
+                let settle;
+                let settleReject;
+                const donePromise = new Promise((resolve, reject) => {
+                    settle = resolve;
+                    settleReject = reject;
+                });
+                void (async () => {
+                    let chunkIndex = 0;
+                    let attempts = 0;
+                    while (chunkIndex < totalChunks) {
+                        if (cancelled)
+                            return;
+                        const from = chunkIndex * TRANSFER_CHUNK_BYTES;
+                        const to = Math.min(from + TRANSFER_CHUNK_BYTES, totalBytes);
+                        const content = bytesToBase64(data.subarray(from, to));
+                        attempts += 1;
+                        try {
+                            const ack = (await request('files.uploadChunk', { uploadId, chunkIndex, content }));
+                            transferEvents.emit('progress', {
+                                chunkIndex,
+                                totalChunks,
+                                bytesTransferred: ack.bytesWritten,
+                                totalBytes,
+                            });
+                            chunkIndex += 1;
+                            attempts = 0;
+                        }
+                        catch (cause) {
+                            if (cancelled)
+                                return;
+                            if (attempts >= MAX_CHUNK_ATTEMPTS) {
+                                unregisterStream(requestId);
+                                settleReject(cause);
+                                return;
+                            }
+                            await sleep(CHUNK_RETRY_DELAY_MS);
+                            try {
+                                const status = (await request('files.uploadStatus', { uploadId }));
+                                if (status.nextExpectedChunk !== chunkIndex)
+                                    attempts = 0;
+                                chunkIndex = status.nextExpectedChunk;
+                            }
+                            catch {
+                            }
+                        }
+                    }
+                    unregisterStream(requestId);
+                    settle({ path, bytesWritten: totalBytes });
+                })();
+                const handle = {
+                    id: uploadId,
+                    on(event, cb) {
+                        return transferEvents.on(event, cb);
+                    },
+                    result() {
+                        return donePromise;
+                    },
+                    async cancel() {
+                        cancelled = true;
+                        unregisterStream(requestId);
+                        settleReject(new MinionryError('CANCELLED', 'files.upload cancelled'));
+                        await request('files.uploadCancel', { uploadId }).catch(() => { });
+                    },
+                };
+                return handle;
+            },
+            async download(path, opts) {
+                const requestId = mintRequestId();
+                const transferEvents = new Emitter();
+                registerStream(requestId, (event, payload) => transferEvents.emit(event, payload), () => { });
+                let downloadId;
+                let fileSize;
+                let totalChunks;
+                let mimeType;
+                let isZip;
+                try {
+                    const start = (await request('files.downloadStart', { path, asZip: opts?.asZip }, requestId));
+                    downloadId = start.downloadId;
+                    fileSize = start.fileSize;
+                    totalChunks = start.totalChunks;
+                    mimeType = start.mimeType;
+                    isZip = start.isZip;
+                }
+                catch (cause) {
+                    unregisterStream(requestId);
+                    throw cause;
+                }
+                let cancelled = false;
+                let settle;
+                let settleReject;
+                const donePromise = new Promise((resolve, reject) => {
+                    settle = resolve;
+                    settleReject = reject;
+                });
+                void (async () => {
+                    const parts = new Array(totalChunks);
+                    let bytesTransferred = 0;
+                    let chunkIndex = 0;
+                    while (chunkIndex < totalChunks) {
+                        if (cancelled)
+                            return;
+                        let attempt = 0;
+                        let received = false;
+                        while (!received && attempt < MAX_CHUNK_ATTEMPTS) {
+                            attempt += 1;
+                            try {
+                                const chunk = (await request('files.downloadChunk', { downloadId, chunkIndex }));
+                                const bytes = base64ToBytes(chunk.content);
+                                parts[chunkIndex] = bytes;
+                                bytesTransferred += bytes.byteLength;
+                                transferEvents.emit('progress', {
+                                    chunkIndex,
+                                    totalChunks,
+                                    bytesTransferred,
+                                    totalBytes: fileSize,
+                                });
+                                received = true;
+                            }
+                            catch (cause) {
+                                if (cancelled)
+                                    return;
+                                if (attempt >= MAX_CHUNK_ATTEMPTS) {
+                                    unregisterStream(requestId);
+                                    settleReject(cause);
+                                    return;
+                                }
+                                await sleep(CHUNK_RETRY_DELAY_MS);
+                            }
+                        }
+                        chunkIndex += 1;
+                    }
+                    const bytes = new Uint8Array(fileSize);
+                    let offset = 0;
+                    for (const part of parts) {
+                        bytes.set(part, offset);
+                        offset += part.byteLength;
+                    }
+                    unregisterStream(requestId);
+                    settle({ path, bytes, mimeType, isZip, fileSize });
+                })();
+                const handle = {
+                    id: downloadId,
+                    on(event, cb) {
+                        return transferEvents.on(event, cb);
+                    },
+                    result() {
+                        return donePromise;
+                    },
+                    async cancel() {
+                        cancelled = true;
+                        unregisterStream(requestId);
+                        settleReject(new MinionryError('CANCELLED', 'files.download cancelled'));
+                        await request('files.downloadCancel', { downloadId }).catch(() => { });
+                    },
+                };
+                return handle;
+            },
+        },
+        storage: {
+            async get(key) {
+                return await request('storage.get', { key });
+            },
+            async set(key, value) {
+                await request('storage.set', { key, value });
+            },
+            async delete(key) {
+                await request('storage.delete', { key });
+            },
+            async keys() {
+                return (await request('storage.keys'));
+            },
+        },
+        notifications: {
+            async request() {
+                await request('notifications.request');
+            },
+            async status() {
+                return (await request('notifications.status'));
+            },
+            async revoke() {
+                await request('notifications.revoke');
+            },
+        },
+        theme: {
+            async get() {
+                return (await request('theme.get'));
+            },
+        },
+        locale: {
+            async get() {
+                return (await request('locale.get'));
+            },
+        },
+        browser: {
+            tabs: {
+                async list() {
+                    return (await request('browser.tabs.list'));
+                },
+                onChanged(cb) {
+                    const requestId = mintRequestId();
+                    let active = true;
+                    registerStream(requestId, (event, payload) => {
+                        if (active && event === 'tabsChanged')
+                            cb(payload);
+                    }, () => { });
+                    request('browser.tabs.subscribe', undefined, requestId).catch((cause) => {
+                        if (!active)
+                            return;
+                        active = false;
+                        unregisterStream(requestId);
+                        console.error('[@minionry/sdk] browser.tabs.onChanged subscription failed', cause);
+                    });
+                    return () => {
+                        if (!active)
+                            return;
+                        active = false;
+                        unregisterStream(requestId);
+                        if (!closed) {
+                            request('cancel', { requestId }).catch(() => { });
+                        }
+                    };
+                },
+            },
+            view: {
+                async attach(opts) {
+                    const requestId = mintRequestId();
+                    const viewEvents = new Emitter();
+                    registerStream(requestId, (event, payload) => viewEvents.emit(event, payload), (message) => viewEvents.emit('gap', { message }));
+                    let attached;
+                    try {
+                        attached = (await request('browser.view.attach', { tabId: opts?.tabId, bounds: opts?.bounds }, requestId));
+                    }
+                    catch (cause) {
+                        unregisterStream(requestId);
+                        throw cause;
+                    }
+                    const sessionId = attached.sessionId;
+                    let detached = false;
+                    const session = {
+                        id: sessionId,
+                        tabId: attached.tabId,
+                        on(event, cb) {
+                            return viewEvents.on(event, cb);
+                        },
+                        async answer(sdp) {
+                            await request('browser.view.answer', { sessionId, sdp });
+                        },
+                        async addIceCandidate(candidate) {
+                            await request('browser.view.ice', { sessionId, candidate });
+                        },
+                        async setConnectionState(state, reason) {
+                            await request('browser.view.state', { sessionId, state, reason });
+                        },
+                        async sendInput(input) {
+                            return (await request('browser.view.input', { sessionId, input }));
+                        },
+                        async setBounds(bounds) {
+                            await request('browser.view.bounds', { sessionId, bounds });
+                        },
+                        async detach() {
+                            if (detached)
+                                return;
+                            detached = true;
+                            unregisterStream(requestId);
+                            await request('cancel', { requestId });
+                        },
+                    };
+                    return session;
+                },
+            },
+            async navigate(url, tabId) {
+                await request('browser.navigate', { url, tabId });
+            },
+            async back(tabId) {
+                await request('browser.back', { tabId });
+            },
+            async forward(tabId) {
+                await request('browser.forward', { tabId });
+            },
+            async reload(tabId) {
+                await request('browser.reload', { tabId });
+            },
+            async stop(tabId) {
+                await request('browser.stop', { tabId });
+            },
+            async open(url, opts) {
+                return (await request('browser.open', { url, pinnedApp: opts?.pinnedApp }));
+            },
+            async close(tabId) {
+                await request('browser.close', { tabId });
+            },
+            async select(tabId) {
+                await request('browser.select', { tabId });
+            },
+            async snapshot(tabId) {
+                return (await request('browser.snapshot', { tabId }));
+            },
+            async screenshot(tabId, opts) {
+                return (await request('browser.screenshot', {
+                    tabId,
+                    fullPage: opts?.fullPage,
+                    format: opts?.format,
+                    quality: opts?.quality,
+                }));
+            },
+            async evaluate(tabId, expr, opts) {
+                return (await request('browser.evaluate', {
+                    tabId,
+                    expr,
+                    world: opts?.world,
+                    timeoutMs: opts?.timeoutMs,
+                }));
+            },
+            async preflight() {
+                return (await request('browser.preflight'));
+            },
+            async resumeDriver(tabId) {
+                await request('browser.resumeDriver', { tabId });
+            },
+            async setDeviceProfile(tabId, formFactor) {
+                await request('browser.setDeviceProfile', { tabId, formFactor });
+            },
+            async automate(prompt, opts) {
+                const requestId = mintRequestId();
+                const automationEvents = new Emitter();
+                registerStream(requestId, (event, payload) => automationEvents.emit(event, payload), (message) => automationEvents.emit('gap', { message }));
+                let taskId;
+                try {
+                    const result = (await request('browser.automate', { prompt, engine: opts?.engine, model: opts?.model, tabId: opts?.tabId }, requestId));
+                    taskId = result.taskId;
+                }
+                catch (cause) {
+                    unregisterStream(requestId);
+                    throw cause;
+                }
+                let cancelled = false;
+                const automation = {
+                    id: taskId,
+                    on(event, cb) {
+                        return automationEvents.on(event, cb);
+                    },
+                    async approve(proposalId, verdict, editedText) {
+                        await request('browser.automate.approve', { proposalId, verdict, editedText });
+                    },
+                    async cancel() {
+                        if (cancelled)
+                            return;
+                        cancelled = true;
+                        unregisterStream(requestId);
+                        await request('cancel', { requestId });
+                    },
+                };
+                return automation;
+            },
+        },
+        composer: {
+            async autocomplete(query) {
+                return (await request('composer.autocomplete', { query }));
+            },
+            async skills() {
+                return (await request('composer.skills'));
+            },
+            async snippets(query) {
+                return (await request('composer.snippets', { query }));
+            },
+            async settings() {
+                return (await request('composer.settings'));
+            },
+        },
+        terminal: {
+            sessions: {
+                async list() {
+                    return (await request('terminal.sessions.list'));
+                },
+                onChanged(cb) {
+                    const requestId = mintRequestId();
+                    let active = true;
+                    registerStream(requestId, (event, payload) => {
+                        if (active && event === 'sessionChanged')
+                            cb(payload);
+                    }, () => { });
+                    request('terminal.sessions.subscribe', undefined, requestId).catch((cause) => {
+                        if (!active)
+                            return;
+                        active = false;
+                        unregisterStream(requestId);
+                        console.error('[@minionry/sdk] terminal.sessions.onChanged subscription failed', cause);
+                    });
+                    return () => {
+                        if (!active)
+                            return;
+                        active = false;
+                        unregisterStream(requestId);
+                        if (!closed) {
+                            request('cancel', { requestId }).catch(() => { });
+                        }
+                    };
+                },
+            },
+            async open(opts) {
+                return (await request('terminal.open', { cwd: opts.cwd, cols: opts.cols, rows: opts.rows }));
+            },
+            async attach(id) {
+                const requestId = mintRequestId();
+                const termEvents = new Emitter();
+                registerStream(requestId, (event, payload) => termEvents.emit(event, payload), (message) => termEvents.emit('gap', { message }));
+                try {
+                    await request('terminal.attach', { id }, requestId);
+                }
+                catch (cause) {
+                    unregisterStream(requestId);
+                    throw cause;
+                }
+                let detached = false;
+                const handle = {
+                    id,
+                    on(event, cb) {
+                        return termEvents.on(event, cb);
+                    },
+                    async detach() {
+                        if (detached)
+                            return;
+                        detached = true;
+                        unregisterStream(requestId);
+                        await request('cancel', { requestId });
+                    },
+                };
+                return handle;
+            },
+            async write(id, data) {
+                await request('terminal.write', { id, data: Array.isArray(data) ? data.join('') : data });
+            },
+            async resize(id, size) {
+                await request('terminal.resize', { id, cols: size.cols, rows: size.rows });
+            },
+            async close(id) {
+                await request('terminal.close', { id });
+            },
+        },
+        git: {
+            async status(req) {
+                return (await request('git.status', { worktree: req?.worktree }));
+            },
+            async log(req) {
+                return (await request('git.log', {
+                    worktree: req?.worktree,
+                    limit: req?.limit,
+                    skip: req?.skip,
+                    search: req?.search,
+                }));
+            },
+            async diff(req) {
+                return (await request('git.diff', { worktree: req.worktree, path: req.path, staged: req.staged }));
+            },
+            async show(hash, req) {
+                return (await request('git.show', { worktree: req?.worktree, hash }));
+            },
+            async commitDiff(req) {
+                return (await request('git.commitDiff', {
+                    worktree: req.worktree,
+                    hash: req.hash,
+                    path: req.path,
+                }));
+            },
+            branches: {
+                async list(req) {
+                    return (await request('git.branches.list', { worktree: req?.worktree }));
+                },
+                async create(req) {
+                    return (await request('git.branches.create', {
+                        worktree: req.worktree,
+                        name: req.name,
+                        startPoint: req.startPoint,
+                        checkout: req.checkout,
+                    }));
+                },
+                async delete(req) {
+                    await request('git.branches.delete', { worktree: req.worktree, name: req.name, force: req.force });
+                },
+            },
+            tags: {
+                async list(req) {
+                    return (await request('git.tags.list', { worktree: req?.worktree }));
+                },
+                async create(req) {
+                    return (await request('git.tags.create', {
+                        worktree: req.worktree,
+                        name: req.name,
+                        message: req.message,
+                        commit: req.commit,
+                    }));
+                },
+                async push(req) {
+                    return (await request('git.tags.push', {
+                        worktree: req?.worktree,
+                        name: req?.name,
+                        all: req?.all,
+                    }));
+                },
+            },
+            remote: {
+                async info(req) {
+                    return (await request('git.remote.info', { worktree: req?.worktree }));
+                },
+            },
+            repos: {
+                async discover() {
+                    return (await request('git.repos.discover'));
+                },
+            },
+            worktrees: {
+                async list() {
+                    return (await request('git.worktrees.list'));
+                },
+                async create(req) {
+                    return (await request('git.worktrees.create', {
+                        branchName: req.branchName,
+                        baseBranch: req.baseBranch,
+                        path: req.path,
+                        assign: req.assign,
+                    }));
+                },
+                async remove(req) {
+                    await request('git.worktrees.remove', { path: req.path, force: req.force, deleteBranch: req.deleteBranch });
+                },
+                async switchActive(req) {
+                    return (await request('git.worktrees.switchActive', { path: req?.path }));
+                },
+                onChanged(cb) {
+                    const requestId = mintRequestId();
+                    let active = true;
+                    registerStream(requestId, (event, payload) => {
+                        if (active && event === 'worktreesChanged')
+                            cb(payload);
+                    }, () => { });
+                    request('git.worktrees.subscribe', undefined, requestId).catch((cause) => {
+                        if (!active)
+                            return;
+                        active = false;
+                        unregisterStream(requestId);
+                        console.error('[@minionry/sdk] git.worktrees.onChanged subscription failed', cause);
+                    });
+                    return () => {
+                        if (!active)
+                            return;
+                        active = false;
+                        unregisterStream(requestId);
+                        if (!closed) {
+                            request('cancel', { requestId }).catch(() => { });
+                        }
+                    };
+                },
+            },
+            merge: {
+                async preview(req) {
+                    return (await request('git.merge.preview', {
+                        worktree: req.worktree,
+                        sourceBranch: req.sourceBranch,
+                        targetBranch: req.targetBranch,
+                    }));
+                },
+                async run(req) {
+                    return (await request('git.merge.run', {
+                        worktree: req.worktree,
+                        sourceBranch: req.sourceBranch,
+                        targetBranch: req.targetBranch,
+                        strategy: req.strategy,
+                        commitMessage: req.commitMessage,
+                        deleteWorktree: req.deleteWorktree,
+                        deleteBranch: req.deleteBranch,
+                        stashFirst: req.stashFirst,
+                    }));
+                },
+                async abort(req) {
+                    return (await request('git.merge.abort', { worktree: req?.worktree }));
+                },
+                async complete(req) {
+                    return (await request('git.merge.complete', { worktree: req?.worktree }));
+                },
+                async stashPop(req) {
+                    return (await request('git.merge.stashPop', {
+                        worktree: req.worktree,
+                        stashSha: req.stashSha,
+                    }));
+                },
+                async discardBlockers(req) {
+                    return (await request('git.merge.discardBlockers', {
+                        worktree: req.worktree,
+                        paths: req.paths,
+                    }));
+                },
+            },
+            pr: {
+                async generateDescription(req) {
+                    return (await request('git.pr.generateDescription', {
+                        worktree: req?.worktree,
+                        baseBranch: req?.baseBranch,
+                    }));
+                },
+                async create(req) {
+                    return (await request('git.pr.create', {
+                        worktree: req.worktree,
+                        title: req.title,
+                        body: req.body,
+                        baseBranch: req.baseBranch,
+                        draft: req.draft,
+                    }));
+                },
+            },
+            async stage(req) {
+                return (await request('git.stage', {
+                    worktree: req.worktree,
+                    paths: req.paths,
+                    stageAll: req.stageAll,
+                }));
+            },
+            async unstage(req) {
+                return (await request('git.unstage', { worktree: req.worktree, paths: req.paths }));
+            },
+            async commit(req) {
+                return (await request('git.commit', { worktree: req.worktree, message: req.message }));
+            },
+            async generateCommitMessage(req) {
+                return (await request('git.generateCommitMessage', {
+                    worktree: req?.worktree,
+                }));
+            },
+            async checkout(req) {
+                return (await request('git.checkout', {
+                    worktree: req.worktree,
+                    branch: req.branch,
+                    create: req.create,
+                    startPoint: req.startPoint,
+                }));
+            },
+            async push(req) {
+                return (await request('git.push', {
+                    worktree: req?.worktree,
+                    remote: req?.remote,
+                    branch: req?.branch,
+                    setUpstream: req?.setUpstream,
+                }));
+            },
+            async pull(req) {
+                return (await request('git.pull', { worktree: req?.worktree }));
+            },
+            onBranchChanged(cb) {
+                const requestId = mintRequestId();
+                let active = true;
+                registerStream(requestId, (event, payload) => {
+                    if (active && event === 'branchChanged')
+                        cb(payload);
+                }, () => { });
+                request('git.subscribeBranchChanged', undefined, requestId).catch((cause) => {
+                    if (!active)
+                        return;
+                    active = false;
+                    unregisterStream(requestId);
+                    console.error('[@minionry/sdk] git.onBranchChanged subscription failed', cause);
+                });
+                return () => {
+                    if (!active)
+                        return;
+                    active = false;
+                    unregisterStream(requestId);
+                    if (!closed) {
+                        request('cancel', { requestId }).catch(() => { });
+                    }
+                };
+            },
+            onCommitSuggestion(cb) {
+                const requestId = mintRequestId();
+                let active = true;
+                registerStream(requestId, (event, payload) => {
+                    if (active && event === 'commitSuggestion')
+                        cb(payload);
+                }, () => { });
+                request('git.subscribeCommitSuggestion', undefined, requestId).catch((cause) => {
+                    if (!active)
+                        return;
+                    active = false;
+                    unregisterStream(requestId);
+                    console.error('[@minionry/sdk] git.onCommitSuggestion subscription failed', cause);
+                });
+                return () => {
+                    if (!active)
+                        return;
+                    active = false;
+                    unregisterStream(requestId);
+                    if (!closed) {
+                        request('cancel', { requestId }).catch(() => { });
+                    }
+                };
+            },
+        },
+        tools: {
+            async register(req) {
+                const requestId = mintRequestId();
+                const tools = new Map();
+                for (const tool of req.tools) {
+                    if (tools.has(tool.name)) {
+                        throw new MinionryError('BAD_REQUEST', `tools.register: duplicate tool name '${tool.name}'`);
+                    }
+                    tools.set(tool.name, tool);
+                }
+                toolRegistrations.set(requestId, { tools, calls: new Map() });
+                try {
+                    await request('tools.register', {
+                        tools: req.tools.map(({ name, description, inputSchema, timeoutMs }) => ({
+                            name,
+                            description,
+                            inputSchema,
+                            timeoutMs,
+                        })),
+                        profile: req.profile,
+                    }, requestId);
+                }
+                catch (cause) {
+                    retireToolRegistration(requestId);
+                    throw cause;
+                }
+                let unregistered = false;
+                const registration = {
+                    id: requestId,
+                    tools: [...tools.keys()],
+                    async unregister() {
+                        if (unregistered)
+                            return;
+                        unregistered = true;
+                        retireToolRegistration(requestId);
+                        await request('cancel', { requestId });
+                    },
+                };
+                return registration;
+            },
+        },
+        quality: {
+            async state() {
+                return (await request('quality.state'));
+            },
+            async detectTools(path) {
+                return (await request('quality.detectTools', { path }));
+            },
+            async run(path) {
+                const requestId = mintRequestId();
+                const runEvents = new Emitter();
+                registerStream(requestId, (event, payload) => runEvents.emit(event, payload), () => { });
+                let started;
+                try {
+                    started = (await request('quality.run', { path }, requestId));
+                }
+                catch (cause) {
+                    unregisterStream(requestId);
+                    throw cause;
+                }
+                const runPath = started.path;
+                let resultPromise;
+                const run = {
+                    path: runPath,
+                    attached: started.attached === true,
+                    on(event, cb) {
+                        return runEvents.on(event, cb);
+                    },
+                    result() {
+                        resultPromise ??= request('quality.result', { path: runPath }).catch((cause) => {
+                            resultPromise = undefined;
+                            throw cause;
+                        });
+                        return resultPromise;
+                    },
+                };
+                return run;
+            },
+            async cancel(path) {
+                await request('quality.cancel', { path });
+            },
+            async installTools(path, tools) {
+                return (await request('quality.installTools', { path, tools }));
+            },
+            async saveDirectories(directories) {
+                await request('quality.saveDirectories', { directories });
+            },
+            async settings() {
+                return (await request('quality.settings'));
+            },
+            async setSettings(settings) {
+                return (await request('quality.setSettings', settings));
+            },
+            onChanged(cb) {
+                const requestId = mintRequestId();
+                let active = true;
+                registerStream(requestId, (event, payload) => {
+                    if (active && event === 'changed')
+                        cb(payload);
+                }, () => { });
+                request('quality.subscribeChanges', undefined, requestId).catch((cause) => {
+                    if (!active)
+                        return;
+                    active = false;
+                    unregisterStream(requestId);
+                    console.error('[@minionry/sdk] quality.onChanged subscription failed', cause);
+                });
+                return () => {
+                    if (!active)
+                        return;
+                    active = false;
+                    unregisterStream(requestId);
+                    if (!closed) {
+                        request('cancel', { requestId }).catch(() => { });
+                    }
+                };
+            },
+            async setFindingState(update) {
+                return (await request('quality.setFindingState', update));
+            },
+            schedules: {
+                async list() {
+                    const result = (await request('quality.schedules.list', {}));
+                    return result.schedules;
+                },
+                async create(req) {
+                    return (await request('quality.schedules.create', req));
+                },
+                async update(scheduleId, patch) {
+                    return (await request('quality.schedules.update', { scheduleId, patch }));
+                },
+                async delete(scheduleId) {
+                    await request('quality.schedules.delete', { scheduleId });
+                },
+            },
+        },
+        inference: {
+            async chat(req) {
+                const requestId = mintRequestId();
+                const runEvents = new Emitter();
+                registerStream(requestId, (event, payload) => runEvents.emit(event, payload), (message) => runEvents.emit('gap', { message }));
+                let runId;
+                try {
+                    const params = {
+                        messages: req.messages,
+                        system: req.system,
+                        engine: req.engine,
+                        model: req.model,
+                        effortLevel: req.effortLevel,
+                    };
+                    runId = (await request('inference.chat', params, requestId)).runId;
+                }
+                catch (cause) {
+                    unregisterStream(requestId);
+                    throw cause;
+                }
+                let resultPromise;
+                const run = {
+                    id: runId,
+                    on(event, cb) {
+                        return runEvents.on(event, cb);
+                    },
+                    result() {
+                        resultPromise ??= request('inference.result', { runId }).catch((cause) => {
+                            resultPromise = undefined;
+                            throw cause;
+                        });
+                        return resultPromise;
+                    },
+                    async cancel() {
+                        await request('cancel', { requestId });
+                    },
+                };
+                return run;
+            },
+        },
+        endpoints: {
+            async register(req) {
+                await requireFeature(APP_ENDPOINTS_FEATURE, 'endpoints.register');
+                return (await request('endpoints.register', req));
+            },
+            async unregister(id) {
+                await requireFeature(APP_ENDPOINTS_FEATURE, 'endpoints.unregister');
+                await request('endpoints.unregister', { id });
+            },
+            async list() {
+                await requireFeature(APP_ENDPOINTS_FEATURE, 'endpoints.list');
+                return (await request('endpoints.list'));
+            },
+        },
+        on(event, cb) {
+            const unsubscribe = providerEvents.on(event, cb);
+            if (event === 'intent') {
+                intentListenerCount++;
+                if (pendingIntent !== undefined) {
+                    const intent = pendingIntent;
+                    pendingIntent = undefined;
+                    cb(intent);
+                }
+                let done = false;
+                return () => {
+                    if (done)
+                        return;
+                    done = true;
+                    intentListenerCount--;
+                    unsubscribe();
+                };
+            }
+            return unsubscribe;
+        },
+    };
+}