@dinoxx/dinox-cli 2.3.0 → 2.5.2

package/dist/gateway/runExecutor.js

@@ -0,0 +1,422 @@
+import os from 'node:os';
+import { AssistantProjection, projectPendingApprovals, toTranscriptMessage } from './assistantProjection.js';
+import { CONTEXT_MESSAGE_LIMIT, withConversationContext } from './conversationContext.js';
+import { commitRunTerminal, enqueueRun, finishMergedRun, startQueuedRuns, withdrawQueuedRun, readAgentInstructions, readCurrentTopic, readSessionBinding, readTranscriptPage, resolveTrustedResource, updateRunSnapshot, waitForMessage, withGatewaySession, writeSessionBinding, } from './threadStore.js';
+import { readAgentConfig } from './protocol.js';
+const SNAPSHOT_PERSIST_INTERVAL_MS = 1_000;
+/** Turns waiting behind a thread's active one; more are refused as `busy`. */
+export const MAX_QUEUED_TURNS = 10;
+const APPROVAL_TIMEOUT_MS = 30 * 60 * 1000;
+/** The agent's instructions travel with a new session's first prompt; longer ones are cut. */
+const MAX_INSTRUCTIONS_CHARS = 8_000;
+/** How long a turn waits for the client's latest messages to sync to this machine. */
+export const CLIENT_TAIL_SYNC_TIMEOUT_MS = 5_000;
+/** Client tails that never synced, so later turns of their thread do not wait for them again. */
+const MAX_REMEMBERED_MISSING_TAILS = 200;
+export class QueueFullError extends Error {
+    constructor() {
+        super(`At most ${MAX_QUEUED_TURNS} messages can wait in one conversation`);
+        this.name = 'QueueFullError';
+    }
+}
+function statusForStop(stopReason) {
+    if (stopReason === 'cancelled')
+        return 'cancelled';
+    if (stopReason === 'error')
+        return 'failed';
+    return 'succeeded';
+}
+/** The user's instructions for the agent, as the start of a new session. */
+export function agentInstructionsPreamble(instructions) {
+    const text = instructions.trim();
+    if (!text)
+        return undefined;
+    const clipped = text.length > MAX_INSTRUCTIONS_CHARS ? `${text.slice(0, MAX_INSTRUCTIONS_CHARS)}…` : text;
+    return [
+        '<dinox_agent_instructions>',
+        'Instructions the user set for you in Dinox. Follow them throughout this conversation.',
+        '',
+        clipped.replaceAll('</dinox_agent_instructions>', '<\\/dinox_agent_instructions>'),
+        '</dinox_agent_instructions>',
+    ].join('\n');
+}
+function withErrorText(message, error) {
+    return { ...message, metadata: { ...(message.metadata ?? {}), error } };
+}
+/**
+ * Runs accepted turns on one gateway. A thread has at most one active run;
+ * turns sent meanwhile wait in a per-thread FIFO and, when it ends, run
+ * together as one turn (each keeps its own message; the reply follows the
+ * last). The agent session is scoped to the thread's current topic: a "new
+ * topic" marker in Dinox starts a fresh agent session, everything else continues it.
+ * The thread may have been answered by other agents meanwhile, so each turn
+ * also carries the messages this gateway's session has not seen.
+ */
+export class GatewayRunExecutor {
+    deps;
+    activeByThread = new Map();
+    /** The request each active run answers, for parenting turns queued behind it. */
+    activeRequests = new Map();
+    queuedByThread = new Map();
+    queueIndex = 0;
+    /** Accepts of one thread run one at a time, so two can never both start a turn. */
+    acceptChains = new Map();
+    missingTails = new Set();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** Threads with an active or waiting turn. */
+    busyThreadIds() {
+        return [...new Set([...this.activeByThread.keys(), ...this.queuedByThread.keys()])];
+    }
+    isBusy(threadId) {
+        return this.activeByThread.has(threadId) || this.queuedByThread.has(threadId);
+    }
+    /** Persists the turn, then runs it now or queues it behind the thread's active turn. */
+    accept(request, emit) {
+        const previous = this.acceptChains.get(request.threadId) ?? Promise.resolve();
+        const next = previous.catch(() => undefined).then(() => this.acceptInOrder(request, emit));
+        this.acceptChains.set(request.threadId, next);
+        void next
+            .catch(() => undefined)
+            .finally(() => {
+            if (this.acceptChains.get(request.threadId) === next)
+                this.acceptChains.delete(request.threadId);
+        });
+        return next;
+    }
+    async acceptInOrder(request, emit) {
+        const waiting = this.queuedByThread.get(request.threadId) ?? [];
+        const queued = this.isBusy(request.threadId);
+        if (queued && waiting.length >= MAX_QUEUED_TURNS)
+            throw new QueueFullError();
+        // Strictly increasing within this process, like the desktop's queue index.
+        this.queueIndex = Math.max(Date.now(), this.queueIndex + 1);
+        const { threadCreated } = await enqueueRun(this.deps.db, {
+            runId: request.runId,
+            threadId: request.threadId,
+            userId: this.deps.userId,
+            requestId: request.requestId,
+            userMessage: request.userMessage,
+            assistantMessage: request.assistantMessage,
+            parentMessageId: request.parentMessageId ?? null,
+            createThread: request.createThread ?? null,
+            requestPayload: { trigger: 'submit-message', gatewayId: this.deps.gateway.id, prompt: request.prompt },
+            queued,
+            queueIndex: this.queueIndex,
+            ...(queued ? { queuedAfterMessageId: this.queuedParentFor(request.threadId) } : {}),
+        });
+        // The active turn may have ended while this one was being persisted.
+        if (queued && this.isBusy(request.threadId)) {
+            this.queuedByThread.set(request.threadId, [...(this.queuedByThread.get(request.threadId) ?? []), { request, emit }]);
+            emit({ revision: 0, status: 'queued', assistant: request.assistantMessage, pendingApprovals: [] });
+            return { threadCreated, queued: true };
+        }
+        if (queued) {
+            // Persisted as queued but nothing is ahead any more: start it, dropping the marker.
+            await startQueuedRuns(this.deps.db, [request.userMessage.id]);
+        }
+        this.start(request, emit, []);
+        return { threadCreated, queued: false };
+    }
+    /** Stops the active turn, or withdraws a waiting one. */
+    cancel(runId, threadId) {
+        const active = this.activeByThread.get(threadId);
+        if (active?.runId === runId) {
+            active.controller.abort(new Error('cancelled by user'));
+            for (const approval of active.approvals.values())
+                approval.resolve(false);
+            return true;
+        }
+        const waiting = this.queuedByThread.get(threadId) ?? [];
+        const turn = waiting.find((item) => item.request.runId === runId);
+        if (!turn)
+            return false;
+        this.setQueue(threadId, waiting.filter((item) => item !== turn));
+        void withdrawQueuedRun(this.deps.db, {
+            runId,
+            userMessageId: turn.request.userMessage.id,
+            assistant: turn.request.assistantMessage,
+        })
+            .then((assistant) => turn.emit({ revision: 1, status: 'cancelled', assistant, pendingApprovals: [] }))
+            .catch((error) => this.deps.log('withdraw queued turn failed', { runId, error: String(error) }));
+        return true;
+    }
+    cancelAll() {
+        // Waiting turns are left to the next start, which marks them interrupted.
+        this.queuedByThread.clear();
+        for (const active of this.activeByThread.values())
+            this.cancel(active.runId, active.threadId);
+    }
+    /** A queued turn follows the last one waiting, else the reply being written. */
+    queuedParentFor(threadId) {
+        const waiting = this.queuedByThread.get(threadId);
+        return (waiting?.at(-1)?.request.userMessage.id ?? this.activeRequests.get(threadId)?.assistantMessage.id);
+    }
+    setQueue(threadId, turns) {
+        if (turns.length > 0)
+            this.queuedByThread.set(threadId, turns);
+        else
+            this.queuedByThread.delete(threadId);
+    }
+    start(request, emit, merged) {
+        const active = {
+            runId: request.runId,
+            threadId: request.threadId,
+            controller: new AbortController(),
+            approvals: new Map(),
+            answered: new Set(),
+        };
+        this.activeByThread.set(request.threadId, active);
+        this.activeRequests.set(request.threadId, request);
+        const releaseAwake = this.deps.keepAwake?.();
+        void this.execute(request, active, emit, merged).finally(() => {
+            releaseAwake?.();
+            if (this.activeByThread.get(request.threadId) === active) {
+                this.activeByThread.delete(request.threadId);
+                this.activeRequests.delete(request.threadId);
+            }
+            void this.drain(request.threadId).catch((error) => this.deps.log('start queued turns failed', { threadId: request.threadId, error: String(error) }));
+        });
+    }
+    /**
+     * Runs everything that waited as one turn: the agent reads the messages
+     * together, as the user meant them, instead of answering each in isolation.
+     * Earlier turns end as merged into the last, which carries the reply.
+     */
+    async drain(threadId) {
+        if (this.activeByThread.has(threadId))
+            return;
+        const waiting = this.queuedByThread.get(threadId) ?? [];
+        this.queuedByThread.delete(threadId);
+        const last = waiting.at(-1);
+        if (!last)
+            return;
+        const earlier = waiting.slice(0, -1);
+        await startQueuedRuns(this.deps.db, waiting.map((turn) => turn.request.userMessage.id));
+        for (const turn of earlier) {
+            const assistant = await finishMergedRun(this.deps.db, {
+                runId: turn.request.runId,
+                mergedIntoRunId: last.request.runId,
+                assistant: turn.request.assistantMessage,
+            });
+            turn.emit({ revision: 1, status: 'succeeded', assistant, pendingApprovals: [] });
+        }
+        this.start(last.request, last.emit, earlier.map((turn) => turn.request));
+    }
+    respondApproval(input) {
+        const active = this.activeByThread.get(input.threadId);
+        if (!active || active.runId !== input.runId)
+            return 'stale';
+        if (active.answered.has(input.approvalId))
+            return 'already_applied';
+        const pending = active.approvals.get(input.approvalId);
+        if (!pending)
+            return 'stale';
+        pending.resolve(input.approved);
+        return 'applied';
+    }
+    async execute(request, active, emit, 
+    /** Earlier queued turns answered together with this one. */
+    merged) {
+        const { db, gateway, adapter, log } = this.deps;
+        const projection = new AssistantProjection(request.assistantMessage);
+        let status = 'running';
+        let lastPersistedAt = 0;
+        const publish = (persist) => {
+            const assistant = projection.snapshot();
+            emit({
+                revision: projection.revision,
+                status,
+                assistant,
+                pendingApprovals: projectPendingApprovals(assistant, { runId: active.runId, threadId: active.threadId }),
+            });
+            const now = Date.now();
+            if (persist || now - lastPersistedAt >= SNAPSHOT_PERSIST_INTERVAL_MS) {
+                lastPersistedAt = now;
+                void updateRunSnapshot(db, { runId: active.runId, status, assistant }).catch((error) => log('persist run snapshot failed', { runId: active.runId, error: String(error) }));
+            }
+        };
+        // Registered when the approval request is emitted, so a reply that races
+        // ahead of the adapter's await is still applied.
+        const decisions = new Map();
+        const registerApproval = (approvalId) => {
+            const existing = decisions.get(approvalId);
+            if (existing)
+                return existing;
+            const decision = new Promise((resolve) => {
+                const finish = (approved) => {
+                    clearTimeout(timer);
+                    active.approvals.delete(approvalId);
+                    active.answered.add(approvalId);
+                    status = active.approvals.size > 0 ? 'waiting_approval' : 'running';
+                    resolve(approved);
+                };
+                const timer = setTimeout(() => finish(false), APPROVAL_TIMEOUT_MS);
+                active.approvals.set(approvalId, { resolve: finish, timer });
+                if (active.controller.signal.aborted)
+                    finish(false);
+            });
+            decisions.set(approvalId, decision);
+            return decision;
+        };
+        const awaitApproval = registerApproval;
+        let errorText = null;
+        let nextBinding = null;
+        try {
+            publish(true);
+            const [topic, binding] = await Promise.all([
+                readCurrentTopic(db, active.threadId),
+                readSessionBinding(db, active.threadId, gateway.id),
+            ]);
+            const topicId = topic?.id ?? null;
+            const continued = binding?.topicId === topicId ? binding : null;
+            const turns = [...merged, request];
+            const [resources, context, instructions] = await Promise.all([
+                Promise.all(turns.map((turn) => this.resolveResources(turn.userMessage))).then((lists) => lists.flat()),
+                this.clientTailSynced(turns[0], active.controller.signal).then((synced) => this.unseenContext(active.threadId, turns[0].userMessage.id, topic?.createdAt ?? null, continued, synced)),
+                readAgentInstructions(db, active.threadId).catch(() => ''),
+            ]);
+            // A session keeps the directory it started in; changing the default only affects new ones.
+            const cwd = continued ? (continued.cwd ?? gateway.previousCwd ?? gateway.cwd ?? os.homedir()) : (gateway.cwd ?? os.homedir());
+            // Validated on receipt; a malformed value never reaches here.
+            const requestedConfig = readAgentConfig(request);
+            const agentConfig = requestedConfig && requestedConfig !== 'invalid' ? requestedConfig : undefined;
+            const prompt = turns.map((turn) => turn.prompt.trim()).filter(Boolean).join('\n\n');
+            const result = await adapter.runTurn({
+                sessionId: continued?.sessionId ?? null,
+                cwd,
+                sessionPreamble: agentInstructionsPreamble(instructions),
+                prompt: withConversationContext(prompt, context, { canReadConversation: gateway.dinoxTools !== false }),
+                resources,
+                signal: active.controller.signal,
+                config: agentConfig,
+                awaitApproval,
+                onEvent: (event) => {
+                    projection.apply(event);
+                    if (event.type === 'approval-request') {
+                        void registerApproval(event.approvalId);
+                        status = 'waiting_approval';
+                    }
+                    publish(event.type === 'approval-request' || event.type === 'approval-resolved');
+                },
+            });
+            nextBinding = {
+                sessionId: result.sessionId,
+                topicId,
+                cwd,
+                lastSeenMessageId: context?.incomplete
+                    ? // Messages that had not synced yet sort before this turn: keep the mark so the
+                        // next turn still catches up on them (its own turns are left out by session).
+                        continued && continued.sessionId === result.sessionId && !continued.legacy
+                            ? continued.lastSeenMessageId
+                            : null
+                    : // Its own reply is the newest message the session has seen.
+                        request.assistantMessage.id,
+            };
+            status = statusForStop(result.stopReason);
+            errorText = result.error ?? null;
+        }
+        catch (error) {
+            status = active.controller.signal.aborted ? 'cancelled' : 'failed';
+            errorText = error instanceof Error ? error.message : String(error);
+            log('gateway run failed', { runId: active.runId, error: errorText });
+        }
+        finally {
+            for (const approval of active.approvals.values())
+                clearTimeout(approval.timer);
+        }
+        projection.finish();
+        const assistant = errorText ? withErrorText(projection.snapshot(), errorText) : projection.snapshot();
+        try {
+            await commitRunTerminal(db, {
+                runId: active.runId,
+                threadId: active.threadId,
+                userId: this.deps.userId,
+                userMessageId: request.userMessage.id,
+                status,
+                assistant: nextBinding
+                    ? withGatewaySession(toTranscriptMessage(assistant), { gatewayId: gateway.id, sessionId: nextBinding.sessionId })
+                    : toTranscriptMessage(assistant),
+                errorText,
+            });
+        }
+        catch (error) {
+            log('commit run terminal failed', { runId: active.runId, error: String(error) });
+        }
+        if (nextBinding) {
+            // After the commit, so the reply it marks as seen is in the transcript.
+            await writeSessionBinding(db, active.threadId, gateway.id, nextBinding).catch((error) => log('write session binding failed', { runId: active.runId, error: String(error) }));
+        }
+        emit({ revision: projection.revision, status, assistant, pendingApprovals: [] });
+    }
+    /**
+     * The client sends the last message it saw; a turn reads the transcript only
+     * once that message has synced here (its upload may still be in flight), or
+     * gives up after a short wait. A tail that never arrived is not waited for again.
+     */
+    async clientTailSynced(request, signal) {
+        const tailId = request.parentMessageId;
+        if (!tailId)
+            return true;
+        const key = `${request.threadId}:${tailId}`;
+        const synced = await waitForMessage(this.deps.db, tailId, {
+            timeoutMs: this.missingTails.has(key) ? 0 : (this.deps.clientTailSyncTimeoutMs ?? CLIENT_TAIL_SYNC_TIMEOUT_MS),
+            signal,
+        });
+        if (synced) {
+            this.missingTails.delete(key);
+        }
+        else {
+            if (this.missingTails.size >= MAX_REMEMBERED_MISSING_TAILS)
+                this.missingTails.clear();
+            this.missingTails.add(key);
+            this.deps.log('client messages not synced yet', { threadId: request.threadId, tailId });
+        }
+        return synced;
+    }
+    /**
+     * Messages before this turn that the session has not seen: the whole topic
+     * for a new session, those after the session's mark for a continued one,
+     * leaving out the turns the session answered itself. A session bound before
+     * seen messages were tracked is assumed to be up to date.
+     */
+    async unseenContext(threadId, turnMessageId, topicStartedAt, continued, synced) {
+        if (continued?.legacy)
+            return synced ? null : { threadId, messages: [], earlier: 0, incomplete: true };
+        try {
+            const page = await readTranscriptPage(this.deps.db, {
+                threadId,
+                since: topicStartedAt,
+                afterMessageId: continued?.lastSeenMessageId ?? null,
+                beforeMessageId: turnMessageId,
+                excludeSessionId: continued?.sessionId ?? null,
+                limit: CONTEXT_MESSAGE_LIMIT,
+            });
+            return { threadId, ...page, ...(synced ? {} : { incomplete: true }) };
+        }
+        catch (error) {
+            // Missing context degrades the answer; it must not fail the turn. Marked
+            // incomplete so the session's mark stays and the next turn retries.
+            this.deps.log('read conversation context failed', { threadId, error: String(error) });
+            return { threadId, messages: [], earlier: 0, incomplete: true };
+        }
+    }
+    async resolveResources(message) {
+        const resources = [];
+        for (const part of message.parts) {
+            if (part.type !== 'file')
+                continue;
+            const dinox = part.providerMetadata?.dinox;
+            if (typeof dinox?.resourceId !== 'string')
+                continue;
+            const resource = await resolveTrustedResource(this.deps.db, {
+                resourceId: dinox.resourceId,
+                userId: this.deps.userId,
+            });
+            if (resource)
+                resources.push({ uri: resource.url, name: resource.name, mediaType: resource.mediaType });
+        }
+        return resources;
+    }
+}

package/dist/gateway/service.d.ts

@@ -0,0 +1,30 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type DeviceHostStatus } from './deviceHost.js';
+type Logger = (message: string, details?: Record<string, unknown>) => void;
+export type GatewayServiceDeps = {
+    db: AbstractPowerSyncDatabase;
+    userId: string;
+    authorization: string;
+    log?: Logger;
+    credentialsUrl?: string;
+};
+/**
+ * Runs every enabled gateway inside the daemon: the daemon owns the PowerSync
+ * database, so gateway writes share its connection and upload queue.
+ */
+export declare class GatewayService {
+    private readonly deps;
+    private hosts;
+    private readonly log;
+    private readonly keepAwake;
+    constructor(deps: GatewayServiceDeps);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Re-reads the account's gateways (after add/remove) without restarting the daemon. */
+    reload(): Promise<DeviceHostStatus[]>;
+    /** Saves a change made in the app, applies it to the running gateway and syncs the robot row. */
+    private updateSettings;
+    private robotRegistration;
+    status(): DeviceHostStatus[];
+}
+export {};

package/dist/gateway/service.js

@@ -0,0 +1,112 @@
+import os from 'node:os';
+import { getPackageVersion } from '../utils/version.js';
+import { createGatewayAdapter } from './adapters/index.js';
+import { getMachineId, loadGateways, updateGatewaySettings } from './config.js';
+import { GatewayDeviceHost } from './deviceHost.js';
+import { KeepAwake } from './keepAwake.js';
+import { interruptOrphanedRuns, retireRemovedRobots, upsertRobot } from './threadStore.js';
+/** Settings the owner changes from the app; the running gateway picks them up without a restart. */
+const LIVE_SETTINGS = ['cwd', 'previousCwd', 'approval', 'paused', 'dinoxTools'];
+function applyLiveSettings(target, source) {
+    for (const key of LIVE_SETTINGS) {
+        if (source[key] === undefined)
+            delete target[key];
+        else
+            target[key] = source[key];
+    }
+}
+const defaultLog = (message, details) => {
+    process.stderr.write(`[dinox-gateway] ${message}${details ? ` ${JSON.stringify(details)}` : ''}\n`);
+};
+/**
+ * Runs every enabled gateway inside the daemon: the daemon owns the PowerSync
+ * database, so gateway writes share its connection and upload queue.
+ */
+export class GatewayService {
+    deps;
+    hosts = [];
+    log;
+    keepAwake;
+    constructor(deps) {
+        this.deps = deps;
+        this.log = deps.log ?? defaultLog;
+        this.keepAwake = new KeepAwake(this.log);
+    }
+    async start() {
+        const configured = await loadGateways(this.deps.userId);
+        const machineId = await getMachineId();
+        // Reconcile before anything else, also when the last gateway was removed.
+        const retired = await retireRemovedRobots(this.deps.db, {
+            userId: this.deps.userId,
+            machineId,
+            keepIds: configured.map((gateway) => gateway.id),
+        }).catch((error) => {
+            this.log('retire removed robots failed', { error: String(error) });
+            return [];
+        });
+        if (retired.length > 0)
+            this.log('retired robots of removed gateways', { count: retired.length });
+        const gateways = configured.filter((gateway) => gateway.enabled);
+        if (gateways.length === 0)
+            return;
+        const interrupted = await interruptOrphanedRuns(this.deps.db, this.deps.userId);
+        if (interrupted > 0)
+            this.log('marked runs from a previous host as interrupted', { count: interrupted });
+        for (const gateway of gateways) {
+            await upsertRobot(this.deps.db, this.robotRegistration(gateway, machineId)).catch((error) => this.log('register robot failed', { gateway: gateway.name, error: String(error) }));
+            const host = new GatewayDeviceHost({
+                gateway,
+                db: this.deps.db,
+                userId: this.deps.userId,
+                authorization: this.deps.authorization,
+                adapter: createGatewayAdapter(gateway, (message, details) => this.log(message, { gateway: gateway.name, ...details })),
+                appVersion: getPackageVersion(),
+                log: (message, details) => this.log(message, { gateway: gateway.name, ...details }),
+                credentialsUrl: this.deps.credentialsUrl,
+                updateSettings: (change) => this.updateSettings(gateway, machineId, change),
+                keepAwake: () => this.keepAwake.acquire(),
+            });
+            host.start();
+            this.hosts.push(host);
+        }
+    }
+    async stop() {
+        const hosts = this.hosts;
+        this.hosts = [];
+        await Promise.allSettled(hosts.map((host) => host.stop()));
+        this.keepAwake.dispose();
+    }
+    /** Re-reads the account's gateways (after add/remove) without restarting the daemon. */
+    async reload() {
+        await this.stop();
+        await this.start();
+        return this.status();
+    }
+    /** Saves a change made in the app, applies it to the running gateway and syncs the robot row. */
+    async updateSettings(gateway, machineId, change) {
+        const updated = await updateGatewaySettings(this.deps.userId, gateway.id, change);
+        applyLiveSettings(gateway, updated);
+        await upsertRobot(this.deps.db, this.robotRegistration(gateway, machineId)).catch((error) => this.log('sync robot settings failed', { gateway: gateway.name, error: String(error) }));
+    }
+    robotRegistration(gateway, machineId) {
+        return {
+            id: gateway.id,
+            userId: this.deps.userId,
+            name: gateway.name,
+            deviceId: gateway.deviceId,
+            agentType: gateway.kind,
+            cwd: gateway.cwd ?? null,
+            deviceName: os.hostname(),
+            machineId,
+            ...(gateway.agentId ? { agentId: gateway.agentId } : {}),
+            settings: {
+                approval: gateway.approval ?? 'ask',
+                paused: gateway.paused === true,
+                dinoxTools: gateway.dinoxTools !== false,
+            },
+        };
+    }
+    status() {
+        return this.hosts.map((host) => host.status());
+    }
+}

package/dist/gateway/streamPublisher.d.ts

@@ -0,0 +1,33 @@
+import type { ChatUIMessage, ThreadRunEventStatus } from '../vendor/electron/shared/external-types.js';
+import { type RemoteDeviceRunStreamEvent, type RemoteToolApprovalPrompt } from '../vendor/electron/shared/remote-device-agent.js';
+export type RunSnapshot = {
+    revision: number;
+    status: ThreadRunEventStatus;
+    assistant: ChatUIMessage;
+    pendingApprovals: RemoteToolApprovalPrompt[];
+};
+/**
+ * Keeps an event under the NATS payload budget: drop parts (the snapshot is
+ * self-correcting and `run.status` recovers the rest), then drop extras.
+ */
+export declare function boundRunEvent(event: RemoteDeviceRunStreamEvent): RemoteDeviceRunStreamEvent;
+/**
+ * One per run. Streaming snapshots are coalesced to the latest per 100ms;
+ * approval and terminal states go out immediately (and supersede a pending one).
+ */
+export declare class RunStreamPublisher {
+    private readonly ids;
+    private readonly publish;
+    private sequence;
+    private pending;
+    private timer;
+    private disposed;
+    constructor(ids: {
+        runId: string;
+        threadId: string;
+    }, publish: (event: RemoteDeviceRunStreamEvent) => void);
+    push(snapshot: RunSnapshot): void;
+    dispose(): void;
+    private clearTimer;
+    private emit;
+}