@dinoxx/dinox-cli 2.3.0 → 2.5.2

package/dist/gateway/keepAwake.js

@@ -0,0 +1,64 @@
+import { spawn } from 'node:child_process';
+/**
+ * Keeps the computer from idle-sleeping while any agent turn runs, so a task
+ * started from the phone is not cut off when the screen locks. macOS only
+ * (`caffeinate -i`, released as soon as the last turn ends); elsewhere a no-op.
+ * It cannot stop sleep from closing a laptop lid on battery.
+ */
+export class KeepAwake {
+    log;
+    platform;
+    spawnProcess;
+    holders = 0;
+    child = null;
+    constructor(log = () => { }, platform = process.platform, spawnProcess = (command, args) => spawn(command, args, { stdio: 'ignore' })) {
+        this.log = log;
+        this.platform = platform;
+        this.spawnProcess = spawnProcess;
+    }
+    /** Holds the computer awake until the returned release is called (idempotent). */
+    acquire() {
+        this.holders += 1;
+        if (this.holders === 1)
+            this.start();
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.holders -= 1;
+            if (this.holders === 0)
+                this.stop();
+        };
+    }
+    /** Releases everything, e.g. when the daemon stops. */
+    dispose() {
+        this.holders = 0;
+        this.stop();
+    }
+    start() {
+        if (this.platform !== 'darwin' || this.child)
+            return;
+        try {
+            const child = this.spawnProcess('caffeinate', ['-i']);
+            child.once('error', (error) => {
+                this.log('keep awake unavailable', { error: String(error) });
+                if (this.child === child)
+                    this.child = null;
+            });
+            child.once('exit', () => {
+                if (this.child === child)
+                    this.child = null;
+            });
+            this.child = child;
+        }
+        catch (error) {
+            this.log('keep awake unavailable', { error: String(error) });
+        }
+    }
+    stop() {
+        const child = this.child;
+        this.child = null;
+        child?.kill('SIGTERM');
+    }
+}

package/dist/gateway/mcpServer.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export type DaemonCall = (method: string, params?: unknown) => Promise<unknown>;
+export declare function createDinoxMcpServer(call?: DaemonCall): McpServer;
+export declare function serveDinoxMcpOverStdio(): Promise<void>;

package/dist/gateway/mcpServer.js

@@ -0,0 +1,138 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { sendDaemonRequest } from '../daemon/client.js';
+import { READ_CONVERSATION_MAX_LIMIT } from './conversationContext.js';
+import { getPackageVersion } from '../utils/version.js';
+/**
+ * Dinox knowledge tools for gateway agents, served over stdio MCP. The agent
+ * launches this as a child process (`dino gateway mcp`); every read goes
+ * through the daemon, which owns the database. Read-only by design: writes
+ * from a third-party agent would bypass the app's approval flow.
+ */
+const MAX_NOTE_CHARS = 20_000;
+const MAX_RESULTS = 50;
+function text(value) {
+    return { content: [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }] };
+}
+function failure(error) {
+    return { ...text(`Dinox is unavailable: ${error instanceof Error ? error.message : String(error)}`), isError: true };
+}
+export function createDinoxMcpServer(call = (method, params) => sendDaemonRequest(method, params)) {
+    const server = new McpServer({ name: 'dinox', version: getPackageVersion() });
+    server.registerTool('search_notes', {
+        description: "Search the user's Dinox notes by keyword. Returns id, title, summary, tags and folders; use read_note for full content.",
+        inputSchema: {
+            query: z.string().describe('Keywords; empty string lists recent notes'),
+            tags: z.string().optional().describe('Tag filter expression, e.g. "work AND !draft"'),
+            createdFrom: z.string().optional().describe('ISO date lower bound'),
+            createdTo: z.string().optional().describe('ISO date upper bound'),
+            limit: z.number().int().min(1).max(MAX_RESULTS).optional(),
+        },
+    }, async ({ query, tags, createdFrom, createdTo, limit }) => {
+        try {
+            const result = (await call('note.search', {
+                keyword: query,
+                includeDeleted: false,
+                tagsExpression: tags || undefined,
+                createdAtFrom: createdFrom,
+                createdAtTo: createdTo,
+                boxValues: [],
+                matchEmptyZettelBoxes: false,
+                limit: limit ?? 10,
+                offset: 0,
+            }));
+            return text({ totalCount: result.totalCount, notes: result.rows });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('read_note', {
+        description: 'Read one Dinox note as Markdown, with title, tags, folders and properties.',
+        inputSchema: { id: z.string().describe('Note id from search_notes') },
+    }, async ({ id }) => {
+        try {
+            const { note } = (await call('note.detail', { id }));
+            if (!note)
+                return { ...text(`Note not found: ${id}`), isError: true };
+            const markdown = String(note.content_md ?? note.content_text ?? '');
+            return text({
+                id: note.id,
+                title: note.title,
+                tags: note.tags,
+                folders: note.zettel_boxes,
+                properties: note.properties,
+                createdAt: note.created_at,
+                updatedAt: note.updated_at,
+                truncated: markdown.length > MAX_NOTE_CHARS,
+                content: markdown.slice(0, MAX_NOTE_CHARS),
+            });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('search_todos', {
+        description: "Search the user's Dinox todo items.",
+        inputSchema: {
+            query: z.string().describe('Keywords; empty string lists all'),
+            status: z.enum(['all', 'completed', 'uncompleted']).optional(),
+            limit: z.number().int().min(1).max(MAX_RESULTS).optional(),
+        },
+    }, async ({ query, status, limit }) => {
+        try {
+            const result = await call('todo.search', {
+                query,
+                includeDeleted: false,
+                taskStatus: status ?? 'uncompleted',
+                taskTagFilter: [],
+                limit: limit ?? 20,
+                scanLimit: 500,
+            });
+            return text(result);
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('related_notes', {
+        description: 'Notes linked to a note (backlinks and outlinks, up to the given depth).',
+        inputSchema: {
+            id: z.string().describe('Note id'),
+            depth: z.number().int().min(1).max(3).optional(),
+        },
+    }, async ({ id, depth }) => {
+        try {
+            return text(await call('graph.related', { id, depth: depth ?? 2 }));
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('read_conversation', {
+        description: 'Read messages of a Dinox conversation, oldest first: who said what (the user, or which agent answered). ' +
+            'Use it when the conversation context you were given says earlier messages are not shown. Returns the newest ' +
+            'messages before `before`; pass the first returned id as `before` to page further back.',
+        inputSchema: {
+            conversationId: z.string().describe('Conversation id from the context block'),
+            before: z.string().optional().describe('Message id; only messages before it are returned'),
+            limit: z.number().int().min(1).max(READ_CONVERSATION_MAX_LIMIT).optional(),
+        },
+    }, async ({ conversationId, before, limit }) => {
+        try {
+            const result = (await call('thread.messages', { threadId: conversationId, beforeMessageId: before, limit }));
+            // `stale`: this machine is not fully synced, so the newest messages may be missing.
+            return text({ messages: result.messages, hasMore: result.hasMore, stale: result.stale === true });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    return server;
+}
+export async function serveDinoxMcpOverStdio() {
+    const server = createDinoxMcpServer();
+    await server.connect(new StdioServerTransport());
+    await new Promise((resolve) => process.stdin.once('close', resolve));
+}

package/dist/gateway/protocol.d.ts

@@ -0,0 +1,116 @@
+import { REMOTE_DEVICE_PROTOCOL_VERSION, type RemoteDeviceCancelRequest, type RemoteDeviceRunRequest, type RemoteDeviceRunStatusRequest } from '../vendor/electron/shared/remote-device-agent.js';
+import type { GatewayApprovalMode, GatewayConfigOption } from './types.js';
+export declare function validateRunRequest(value: unknown, byteLength: number): string | null;
+export type AgentConfigQuery = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.config.get';
+    requestId: string;
+    clientDeviceId: string;
+};
+export type AgentConfigResult = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.config.result';
+    requestId: string;
+    ok: boolean;
+    options: GatewayConfigOption[];
+    fetchedAt: string;
+    error?: {
+        code: 'unsupported' | 'query_failed';
+        message: string;
+    };
+};
+export declare function isAgentConfigQuery(value: unknown): value is AgentConfigQuery;
+export type AgentHostSettings = {
+    /** Folder new conversations start in; null until chosen (the home folder is used). */
+    cwd: string | null;
+    approval: GatewayApprovalMode;
+    /** Online but refusing new turns. */
+    paused: boolean;
+    /** The agent may search and read the user's notes. */
+    dinoxTools: boolean;
+};
+export type AgentSettingsChange = {
+    /** An existing folder (absolute or `~/...`), checked on this computer. */
+    cwd?: string;
+    /** Creates and uses the agent's own folder (`~/Dinox Agents/<name>`). */
+    useAgentFolder?: true;
+    approval?: GatewayApprovalMode;
+    paused?: boolean;
+    dinoxTools?: boolean;
+};
+export type AgentSettingsQuery = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.settings.get';
+    requestId: string;
+    clientDeviceId: string;
+};
+export type AgentSettingsUpdate = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.settings.set';
+    requestId: string;
+    clientDeviceId: string;
+    settings: AgentSettingsChange;
+};
+export type AgentSettingsErrorCode = 'invalid_request' | 'not_found' | 'not_allowed' | 'failed';
+export type AgentSettingsResult = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.settings.result';
+    requestId: string;
+    ok: boolean;
+    settings: AgentHostSettings;
+    /** For showing paths as `~/...`. */
+    home: string;
+    /** Where `useAgentFolder` puts the agent's own folder. */
+    agentFolder: string;
+    fetchedAt: string;
+    error?: {
+        code: AgentSettingsErrorCode;
+        message: string;
+    };
+};
+export type AgentFoldersQuery = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.folders.list';
+    requestId: string;
+    clientDeviceId: string;
+    /** Folder to list; absent lists the home folder with suggestions. */
+    path?: string | null;
+};
+export type AgentFolder = {
+    name: string;
+    path: string;
+    isProject: boolean;
+};
+export type AgentFoldersResult = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.folders.result';
+    requestId: string;
+    ok: boolean;
+    path: string;
+    parent: string | null;
+    folders: AgentFolder[];
+    truncated: boolean;
+    /** Only for the home listing: the current folder and recently used ones. */
+    suggestions: AgentFolder[];
+    home: string;
+    fetchedAt: string;
+    error?: {
+        code: AgentSettingsErrorCode;
+        message: string;
+    };
+};
+export declare function isAgentSettingsQuery(value: unknown): value is AgentSettingsQuery;
+export declare function isAgentFoldersQuery(value: unknown): value is AgentFoldersQuery;
+/** The change an `agent.settings.set` asks for, or why it is malformed. */
+export declare function readAgentSettingsUpdate(value: unknown, byteLength: number): {
+    update: AgentSettingsUpdate;
+} | {
+    error: string;
+} | null;
+/** The run's chosen agent settings, `null` when none, `'invalid'` when malformed. */
+export declare function readAgentConfig(request: RemoteDeviceRunRequest): Record<string, string> | null | 'invalid';
+export declare function validateApprovalRequest(value: unknown, byteLength: number): string | null;
+export declare function isCancelRequest(value: unknown): value is RemoteDeviceCancelRequest;
+export declare function isRunStatusRequest(value: unknown): value is RemoteDeviceRunStatusRequest;
+/** `Math.max(250, rand * min(60s, 1s * 2^attempt))`, the desktop's full-jitter backoff. */
+export declare function reconnectDelayMs(attempt: number, random?: () => number): number;

package/dist/gateway/protocol.js

@@ -0,0 +1,182 @@
+import { REMOTE_DEVICE_PROTOCOL_VERSION, } from '../vendor/electron/shared/remote-device-agent.js';
+/** Request validation, rule-for-rule with the desktop host (RemoteDeviceHostModule). */
+const SUBJECT_ID = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+const DEVICE_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const OPAQUE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+const MAX_REQUEST_BYTES = 900_000;
+const MAX_PROMPT_LENGTH = 100_000;
+const MAX_FILE_PARTS = 16;
+const MAX_APPROVAL_REQUEST_BYTES = 16 * 1024;
+const MAX_APPROVAL_REASON_LENGTH = 500;
+const MAX_AGENT_CONFIG_ENTRIES = 8;
+const MAX_AGENT_CONFIG_TEXT = 512;
+const isSubjectId = (value) => typeof value === 'string' && SUBJECT_ID.test(value);
+const isDeviceId = (value) => typeof value === 'string' && DEVICE_ID.test(value);
+function isMessageOfType(value, type) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    return record.protocolVersion === REMOTE_DEVICE_PROTOCOL_VERSION && record.type === type && isSubjectId(record.requestId);
+}
+function isChatMessage(value, role) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const message = value;
+    return isSubjectId(message.id) && message.role === role && Array.isArray(message.parts);
+}
+function isHttpsUrl(value) {
+    if (typeof value !== 'string')
+        return false;
+    try {
+        return new URL(value.trim()).protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+export function validateRunRequest(value, byteLength) {
+    if (!isMessageOfType(value, 'run.request'))
+        return 'invalid protocol version or type';
+    if (byteLength > MAX_REQUEST_BYTES)
+        return 'request payload too large';
+    if (!isDeviceId(value.clientDeviceId))
+        return 'invalid clientDeviceId';
+    if (!isSubjectId(value.runId) || !isSubjectId(value.threadId))
+        return 'invalid request ids';
+    if (typeof value.prompt !== 'string' || !value.prompt.trim())
+        return 'prompt is empty';
+    if (value.prompt.length > MAX_PROMPT_LENGTH)
+        return 'prompt too long';
+    if (!isChatMessage(value.userMessage, 'user'))
+        return 'invalid userMessage';
+    if (!isChatMessage(value.assistantMessage, 'assistant'))
+        return 'invalid assistantMessage';
+    const fileParts = value.userMessage.parts.filter((part) => part.type === 'file' && typeof part.url === 'string');
+    if (fileParts.length > MAX_FILE_PARTS)
+        return 'too many attachments';
+    for (const part of fileParts) {
+        const dinox = part.providerMetadata?.dinox;
+        if (!isSubjectId(dinox?.resourceId))
+            return 'invalid attachment resourceId';
+        if (!isHttpsUrl(part.url))
+            return 'attachment URL must use HTTPS';
+    }
+    if (value.createThread && value.createThread.id !== value.threadId)
+        return 'createThread.id must equal threadId';
+    if (readAgentConfig(value) === 'invalid')
+        return 'invalid agentConfig';
+    return null;
+}
+export function isAgentConfigQuery(value) {
+    return isMessageOfType(value, 'agent.config.get') && isDeviceId(value.clientDeviceId);
+}
+/*
+ * Gateway extension (`capabilities.executor.settings`): the owner reads and
+ * changes how this computer runs the agent with `agent.settings.get` /
+ * `agent.settings.set`, and picks a working folder with `agent.folders.list`.
+ */
+const MAX_SETTINGS_REQUEST_BYTES = 16 * 1024;
+const MAX_PATH_LENGTH = 4096;
+export function isAgentSettingsQuery(value) {
+    return isMessageOfType(value, 'agent.settings.get') && isDeviceId(value.clientDeviceId);
+}
+export function isAgentFoldersQuery(value) {
+    if (!isMessageOfType(value, 'agent.folders.list') || !isDeviceId(value.clientDeviceId))
+        return false;
+    const folder = value.path;
+    return folder === undefined || folder === null || (typeof folder === 'string' && folder.length <= MAX_PATH_LENGTH);
+}
+/** The change an `agent.settings.set` asks for, or why it is malformed. */
+export function readAgentSettingsUpdate(value, byteLength) {
+    if (!isMessageOfType(value, 'agent.settings.set'))
+        return null;
+    if (byteLength > MAX_SETTINGS_REQUEST_BYTES)
+        return { error: 'request too large' };
+    if (!isDeviceId(value.clientDeviceId))
+        return { error: 'invalid clientDeviceId' };
+    const raw = value.settings;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return { error: 'invalid settings' };
+    const input = raw;
+    const change = {};
+    if (input.cwd !== undefined) {
+        if (typeof input.cwd !== 'string' || !input.cwd.trim() || input.cwd.length > MAX_PATH_LENGTH)
+            return { error: 'invalid cwd' };
+        change.cwd = input.cwd;
+    }
+    if (input.useAgentFolder !== undefined) {
+        if (input.useAgentFolder !== true || change.cwd !== undefined)
+            return { error: 'invalid useAgentFolder' };
+        change.useAgentFolder = true;
+    }
+    if (input.approval !== undefined) {
+        if (input.approval !== 'ask' && input.approval !== 'auto_read')
+            return { error: 'invalid approval' };
+        change.approval = input.approval;
+    }
+    for (const key of ['paused', 'dinoxTools']) {
+        if (input[key] === undefined)
+            continue;
+        if (typeof input[key] !== 'boolean')
+            return { error: `invalid ${key}` };
+        change[key] = input[key];
+    }
+    if (Object.keys(change).length === 0)
+        return { error: 'nothing to change' };
+    return { update: { ...value, settings: change } };
+}
+/** The run's chosen agent settings, `null` when none, `'invalid'` when malformed. */
+export function readAgentConfig(request) {
+    const raw = request.agentConfig;
+    if (raw === undefined || raw === null)
+        return null;
+    if (typeof raw !== 'object' || Array.isArray(raw))
+        return 'invalid';
+    const entries = Object.entries(raw);
+    if (entries.length > MAX_AGENT_CONFIG_ENTRIES)
+        return 'invalid';
+    const config = {};
+    for (const [id, value] of entries) {
+        if (!id || id.length > MAX_AGENT_CONFIG_TEXT)
+            return 'invalid';
+        if (typeof value !== 'string' || !value || value.length > MAX_AGENT_CONFIG_TEXT)
+            return 'invalid';
+        config[id] = value;
+    }
+    return entries.length > 0 ? config : null;
+}
+export function validateApprovalRequest(value, byteLength) {
+    if (byteLength > MAX_APPROVAL_REQUEST_BYTES)
+        return 'approval request too large';
+    if (!isMessageOfType(value, 'tool.approval.respond')) {
+        return 'invalid protocol version or type';
+    }
+    if (!isSubjectId(value.runId) ||
+        !isSubjectId(value.threadId) ||
+        typeof value.approvalId !== 'string' ||
+        !OPAQUE_ID.test(value.approvalId) ||
+        !isDeviceId(value.clientDeviceId)) {
+        return 'invalid approval ids';
+    }
+    if (typeof value.approved !== 'boolean')
+        return 'approved must be a boolean';
+    if (value.reason !== undefined &&
+        (typeof value.reason !== 'string' || value.reason.length > MAX_APPROVAL_REASON_LENGTH)) {
+        return 'invalid approval reason';
+    }
+    return null;
+}
+export function isCancelRequest(value) {
+    return (isMessageOfType(value, 'run.cancel') &&
+        isSubjectId(value.runId) &&
+        isSubjectId(value.threadId));
+}
+export function isRunStatusRequest(value) {
+    return (isMessageOfType(value, 'run.status') &&
+        isSubjectId(value.runId) &&
+        isSubjectId(value.threadId));
+}
+/** `Math.max(250, rand * min(60s, 1s * 2^attempt))`, the desktop's full-jitter backoff. */
+export function reconnectDelayMs(attempt, random = Math.random) {
+    return Math.max(250, Math.floor(random() * Math.min(60_000, 1000 * 2 ** attempt)));
+}

package/dist/gateway/runExecutor.d.ts

@@ -0,0 +1,91 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { RemoteDeviceRunRequest, RemoteDeviceToolApprovalAckCode } from '../vendor/electron/shared/remote-device-agent.js';
+import type { RunSnapshot } from './streamPublisher.js';
+import type { GatewayAdapter, GatewayDefinition } from './types.js';
+/** Turns waiting behind a thread's active one; more are refused as `busy`. */
+export declare const MAX_QUEUED_TURNS = 10;
+/** How long a turn waits for the client's latest messages to sync to this machine. */
+export declare const CLIENT_TAIL_SYNC_TIMEOUT_MS = 5000;
+type Logger = (message: string, details?: Record<string, unknown>) => void;
+type Emit = (snapshot: RunSnapshot) => void;
+export declare class QueueFullError extends Error {
+    constructor();
+}
+export type RunExecutorDeps = {
+    db: AbstractPowerSyncDatabase;
+    userId: string;
+    gateway: GatewayDefinition;
+    adapter: GatewayAdapter;
+    log: Logger;
+    /** Overrides CLIENT_TAIL_SYNC_TIMEOUT_MS (tests). */
+    clientTailSyncTimeoutMs?: number;
+    /** Keeps the computer awake while a turn runs; returns the release. */
+    keepAwake?: () => () => void;
+};
+/** The user's instructions for the agent, as the start of a new session. */
+export declare function agentInstructionsPreamble(instructions: string): string | undefined;
+/**
+ * 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 declare class GatewayRunExecutor {
+    private readonly deps;
+    private readonly activeByThread;
+    /** The request each active run answers, for parenting turns queued behind it. */
+    private readonly activeRequests;
+    private readonly queuedByThread;
+    private queueIndex;
+    /** Accepts of one thread run one at a time, so two can never both start a turn. */
+    private readonly acceptChains;
+    private readonly missingTails;
+    constructor(deps: RunExecutorDeps);
+    /** Threads with an active or waiting turn. */
+    busyThreadIds(): string[];
+    isBusy(threadId: string): boolean;
+    /** Persists the turn, then runs it now or queues it behind the thread's active turn. */
+    accept(request: RemoteDeviceRunRequest, emit: Emit): Promise<{
+        threadCreated: boolean;
+        queued: boolean;
+    }>;
+    private acceptInOrder;
+    /** Stops the active turn, or withdraws a waiting one. */
+    cancel(runId: string, threadId: string): boolean;
+    cancelAll(): void;
+    /** A queued turn follows the last one waiting, else the reply being written. */
+    private queuedParentFor;
+    private setQueue;
+    private start;
+    /**
+     * 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.
+     */
+    private drain;
+    respondApproval(input: {
+        runId: string;
+        threadId: string;
+        approvalId: string;
+        approved: boolean;
+    }): RemoteDeviceToolApprovalAckCode;
+    private execute;
+    /**
+     * 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.
+     */
+    private clientTailSynced;
+    /**
+     * 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.
+     */
+    private unseenContext;
+    private resolveResources;
+}
+export {};