@dinoxx/dinox-cli 2.6.0 → 2.8.0

package/dist/gateway/assistantProjection.js

@@ -8,6 +8,27 @@ const APPROVAL_TTL_MS = 30 * 60 * 1000;
 const MAX_PENDING_APPROVALS = 32;
 const PREVIEW_MAX_CHARS = 1500;
 const SENSITIVE_KEY = /password|token|secret|api[-_ ]?key|authorization|cookie|credential|private[-_ ]?key/i;
+/** Tool input/output is shown as a preview; whole files (e.g. a generated image as base64) would overflow every event. */
+const TOOL_STRING_MAX_CHARS = 4000;
+const TOOL_VALUE_MAX_ITEMS = 64;
+const TOOL_VALUE_MAX_DEPTH = 6;
+export function compactToolValue(value, depth = 0) {
+    if (typeof value === 'string') {
+        if (value.startsWith('data:') && value.length > 256) {
+            return `[${value.slice(5, value.indexOf(';') > 0 ? value.indexOf(';') : 32)} data, ${value.length} chars]`;
+        }
+        return value.length > TOOL_STRING_MAX_CHARS ? `${value.slice(0, TOOL_STRING_MAX_CHARS)}… (${value.length} chars)` : value;
+    }
+    if (!value || typeof value !== 'object')
+        return value;
+    if (depth >= TOOL_VALUE_MAX_DEPTH)
+        return '[…]';
+    if (Array.isArray(value))
+        return value.slice(0, TOOL_VALUE_MAX_ITEMS).map((item) => compactToolValue(item, depth + 1));
+    return Object.fromEntries(Object.entries(value)
+        .slice(0, TOOL_VALUE_MAX_ITEMS)
+        .map(([key, item]) => [key, compactToolValue(item, depth + 1)]));
+}
 export class AssistantProjection {
     base;
     parts = [];
@@ -43,7 +64,7 @@ export class AssistantProjection {
                 part.state = 'approval-requested';
                 part.approval = { id: event.approvalId };
                 if (event.input !== undefined)
-                    part.input = event.input;
+                    part.input = compactToolValue(event.input);
                 break;
             }
             case 'approval-resolved': {
@@ -59,6 +80,18 @@ export class AssistantProjection {
         }
         this.revisionCounter += 1;
     }
+    /** A file sent to the user, shown where the agent sent it (the app renders images inline). */
+    addFile(file) {
+        this.closeTextSegment();
+        this.parts.push({
+            type: 'file',
+            mediaType: file.mediaType,
+            url: file.url,
+            filename: file.name,
+            providerMetadata: { dinox: { resourceId: file.resourceId } },
+        });
+        this.revisionCounter += 1;
+    }
     /** Closes streaming parts; called once when the turn ends. */
     finish() {
         for (const part of this.parts) {
@@ -93,13 +126,16 @@ export class AssistantProjection {
         if (index !== undefined)
             return this.parts[index];
         // A tool call closes the text segment before it.
-        const last = this.parts.at(-1);
-        if (last && (last.type === 'text' || last.type === 'reasoning'))
-            last.state = 'done';
+        this.closeTextSegment();
         const part = { type: 'dynamic-tool', toolCallId, toolName, state: 'input-streaming', input: undefined };
         this.toolIndex.set(toolCallId, this.parts.push(part) - 1);
         return part;
     }
+    closeTextSegment() {
+        const last = this.parts.at(-1);
+        if (last && (last.type === 'text' || last.type === 'reasoning'))
+            last.state = 'done';
+    }
     findToolByApproval(approvalId) {
         return this.parts.find((part) => part.type === 'dynamic-tool' && part.approval?.id === approvalId);
     }
@@ -108,26 +144,27 @@ export class AssistantProjection {
         if (event.title)
             part.toolName = event.title;
         if (event.input !== undefined)
-            part.input = event.input;
+            part.input = compactToolValue(event.input);
+        const output = event.output === undefined ? undefined : compactToolValue(event.output);
         switch (event.status) {
             case 'completed':
                 part.state = 'output-available';
-                part.output = event.output ?? part.output ?? null;
+                part.output = output ?? part.output ?? null;
                 break;
             case 'failed':
                 part.state = 'output-error';
-                part.errorText = typeof event.output === 'string' ? event.output : 'Tool failed';
+                part.errorText = typeof output === 'string' ? output : 'Tool failed';
                 break;
             case 'pending':
             case 'running':
                 if (part.state !== 'approval-requested')
                     part.state = 'input-available';
-                if (event.output !== undefined)
-                    part.output = event.output;
+                if (output !== undefined)
+                    part.output = output;
                 break;
             default:
-                if (event.output !== undefined)
-                    part.output = event.output;
+                if (output !== undefined)
+                    part.output = output;
         }
     }
 }

package/dist/gateway/detect.js

@@ -70,7 +70,7 @@ export async function findExecutable(name, envPath = process.env.PATH ?? '') {
 }
 /** Starts the agent, runs `initialize`, and stops it. Never leaves the process running. */
 export async function probeAcpAgent(command, args, timeoutMs = PROBE_TIMEOUT_MS) {
-    const child = spawn(command, args, { stdio: ['pipe', 'pipe', 'ignore'], env: process.env });
+    const child = spawn(command, args, { stdio: ['pipe', 'pipe', 'ignore'], env: process.env, windowsHide: true });
     let timer;
     try {
         const exited = new Promise((_, reject) => {

package/dist/gateway/deviceHost.d.ts

@@ -1,7 +1,7 @@
 import { wsconnect } from '@nats-io/nats-core';
 import type { AbstractPowerSyncDatabase } from '@powersync/common';
 import type { GatewaySettingsPatch } from './config.js';
-import type { GatewayAdapter, GatewayDefinition } from './types.js';
+import type { GatewayAdapter, GatewayDefinition, GatewayFileSource, GatewaySentFile } from './types.js';
 export declare const DEFAULT_NATS_CREDENTIALS_URL = "https://aisdk.chatgo.pro/api/nats/credentials";
 type Logger = (message: string, details?: Record<string, unknown>) => void;
 export type DeviceHostState = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'error';
@@ -59,6 +59,8 @@ export declare class GatewayDeviceHost {
     /** Latest event per run while offline; the snapshot model makes older ones redundant. */
     private readonly pendingEvents;
     constructor(deps: DeviceHostDeps);
+    /** A `send_file` from the Dinox tools of one of this gateway's sessions; `null` when the token is another's. */
+    sendFile(token: string, file: GatewayFileSource): Promise<GatewaySentFile> | null;
     start(): void;
     stop(): Promise<void>;
     status(): DeviceHostStatus;

package/dist/gateway/deviceHost.js

@@ -7,6 +7,7 @@ import { isAgentConfigQuery, isAgentFoldersQuery, isAgentSettingsQuery, isCancel
 import { GatewayRunExecutor, MAX_QUEUED_TURNS, QueueFullError } from './runExecutor.js';
 import { RunStreamPublisher } from './streamPublisher.js';
 import { findRun, readRecentSessionFolders, resolveTrustedResource, TERMINAL_RUN_STATUSES, threadExists, } from './threadStore.js';
+import { uploadToOfficialStorage } from './fileUpload.js';
 import { agentHomeFolder, ensureAgentHomeFolder, existingWorkspaceFolders, listWorkspaceFolders, resolveWorkspaceFolder, WorkspaceFolderError, } from './workspaceFolders.js';
 export const DEFAULT_NATS_CREDENTIALS_URL = 'https://aisdk.chatgo.pro/api/nats/credentials';
 const CREDENTIALS_TIMEOUT_MS = 10_000;
@@ -68,8 +69,13 @@ export class GatewayDeviceHost {
             adapter: deps.adapter,
             log: deps.log,
             keepAwake: deps.keepAwake,
+            uploadFile: (file) => uploadToOfficialStorage({ db: deps.db, userId: deps.userId, authorization: deps.authorization, fetchImpl: deps.fetchImpl }, file),
         });
     }
+    /** A `send_file` from the Dinox tools of one of this gateway's sessions; `null` when the token is another's. */
+    sendFile(token, file) {
+        return this.deps.adapter.sendFile?.(token, file) ?? null;
+    }
     start() {
         this.stopped = false;
         void this.connect();

package/dist/gateway/fileUpload.d.ts

@@ -0,0 +1,12 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { GatewayFileSource, GatewaySentFile } from './types.js';
+export declare const MAX_SENT_FILE_BYTES: number;
+export type OfficialUploadDeps = {
+    db: AbstractPowerSyncDatabase;
+    userId: string;
+    authorization: string;
+    fetchImpl?: typeof fetch;
+    /** Overrides the API host (tests). */
+    apiBaseUrl?: string;
+};
+export declare function uploadToOfficialStorage(deps: OfficialUploadDeps, source: GatewayFileSource): Promise<GatewaySentFile>;

package/dist/gateway/fileUpload.js

@@ -0,0 +1,154 @@
+import crypto from 'node:crypto';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { getTableColumns } from '../commands/storage/repo/configs.js';
+import { generateThumbnailBuffer, loadSharp } from '../commands/storage/repo/remote.js';
+import { OFFICIAL_STORAGE_PROVIDER } from '../commands/storage/repo/shared.js';
+import { buildObjectId, generateThumbnailKey, guessContentType } from '../commands/storage/repo/targets.js';
+import { POWERSYNC_DEFAULT_UPLOAD_BASE_URL } from '../config/serviceEndpoints.js';
+import { toAuthorizationHeaderValue } from '../utils/authToken.js';
+import { generateId } from '../utils/id.js';
+/**
+ * Files an agent hands to the user leave this computer through the official
+ * Dinox storage, the way the app uploads attachments: the API signs a PUT URL,
+ * the bytes go straight to OSS, and a `c_resource` row (synced by PowerSync)
+ * records them. The message only carries the public URL, never the bytes.
+ */
+const OFFICIAL_DOMAIN = 'https://dinoai.oss-accelerate.aliyuncs.com';
+const OFFICIAL_ENDPOINT = 'https://oss-accelerate.aliyuncs.com';
+const OFFICIAL_BUCKET = 'dinoai';
+const CODE_OK = '000000';
+const SIGN_TIMEOUT_MS = 20_000;
+const PUT_TIMEOUT_MS = 120_000;
+export const MAX_SENT_FILE_BYTES = 50 * 1024 * 1024;
+const EXTENSION_BY_MEDIA_TYPE = {
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'image/gif': 'gif',
+    'image/webp': 'webp',
+    'image/svg+xml': 'svg',
+    'application/pdf': 'pdf',
+    'text/plain': 'txt',
+    'text/markdown': 'md',
+};
+function categoryFor(mediaType) {
+    if (mediaType.startsWith('image/'))
+        return 'images';
+    if (mediaType.startsWith('video/'))
+        return 'videos';
+    if (mediaType.startsWith('audio/'))
+        return 'audios';
+    return 'files';
+}
+async function readSource(source) {
+    if (source.kind === 'data') {
+        const bytes = Buffer.from(source.data, 'base64');
+        const extension = EXTENSION_BY_MEDIA_TYPE[source.mediaType];
+        const name = source.name?.trim() || `file${extension ? `.${extension}` : ''}`;
+        if (bytes.byteLength > MAX_SENT_FILE_BYTES)
+            throw new Error(`${name} is larger than 50 MB`);
+        return { bytes, name, mediaType: source.mediaType };
+    }
+    const stats = await fsp.stat(source.path).catch(() => null);
+    if (!stats?.isFile())
+        throw new Error(`Not a file: ${source.path}`);
+    if (stats.size > MAX_SENT_FILE_BYTES)
+        throw new Error(`${path.basename(source.path)} is larger than 50 MB`);
+    return {
+        bytes: await fsp.readFile(source.path),
+        name: source.name?.trim() || path.basename(source.path),
+        mediaType: guessContentType(source.path),
+    };
+}
+async function fetchWithTimeout(fetchImpl, url, init, timeoutMs) {
+    return fetchImpl(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+}
+/** A presigned PUT URL for `key` from the Dinox API. */
+async function signPut(deps, key, contentType) {
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const response = await fetchWithTimeout(fetchImpl, `${deps.apiBaseUrl ?? POWERSYNC_DEFAULT_UPLOAD_BASE_URL}/oss/generatePreSignedUrl`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            accept: 'application/json',
+            Authorization: toAuthorizationHeaderValue(deps.authorization),
+        },
+        body: JSON.stringify({ objectId: key, contentType }),
+    }, SIGN_TIMEOUT_MS);
+    const body = (await response.json().catch(() => null));
+    const url = body?.data?.url;
+    if (!response.ok || body?.code !== CODE_OK || typeof url !== 'string' || !url) {
+        throw new Error(`Signing the upload failed (${response.status}${body?.msg ? `: ${String(body.msg)}` : ''})`);
+    }
+    return url;
+}
+async function putObject(deps, key, bytes, contentType) {
+    const signedUrl = await signPut(deps, key, contentType);
+    const response = await fetchWithTimeout(deps.fetchImpl ?? fetch, signedUrl, { method: 'PUT', headers: { 'Content-Type': contentType }, body: new Uint8Array(bytes) }, PUT_TIMEOUT_MS);
+    if (!response.ok)
+        throw new Error(`Uploading failed (${response.status})`);
+    return response.headers.get('etag');
+}
+/** The thumbnail the app shows in lists; optional, so a missing image library never fails the upload. */
+async function uploadThumbnail(deps, key, bytes) {
+    try {
+        const sharp = await loadSharp();
+        const thumbnail = await generateThumbnailBuffer(sharp, bytes);
+        const thumbnailKey = generateThumbnailKey(key);
+        await putObject(deps, thumbnailKey, thumbnail, 'image/webp');
+        return `${OFFICIAL_DOMAIN}/${thumbnailKey}`;
+    }
+    catch {
+        return null;
+    }
+}
+async function insertResource(db, values) {
+    // Only the columns this schema version has, like `dino storage upload`.
+    const columns = await getTableColumns(db, 'c_resource');
+    const entries = Object.entries(values).filter(([column]) => columns.has(column));
+    await db.execute(`INSERT INTO c_resource (${entries.map(([column]) => column).join(', ')}) VALUES (${entries.map(() => '?').join(', ')})`, entries.map(([, value]) => value));
+}
+export async function uploadToOfficialStorage(deps, source) {
+    const { bytes, name, mediaType } = await readSource(source);
+    const category = categoryFor(mediaType);
+    const extension = path.extname(name) || (EXTENSION_BY_MEDIA_TYPE[mediaType] ? `.${EXTENSION_BY_MEDIA_TYPE[mediaType]}` : '');
+    const key = buildObjectId(deps.userId, category, `file${extension}`);
+    const etag = await putObject(deps, key, bytes, mediaType);
+    const url = `${OFFICIAL_DOMAIN}/${key}`;
+    const thumbnailUrl = category === 'images' && mediaType !== 'image/svg+xml' ? await uploadThumbnail(deps, key, bytes) : null;
+    const id = generateId();
+    const now = new Date().toISOString();
+    // Same row the app writes for an official upload (the thumbnail URL lives in `checksum`).
+    await insertResource(deps.db, {
+        id,
+        user_id: deps.userId,
+        name,
+        mime_type: mediaType,
+        size_bytes: bytes.byteLength,
+        storage_config_id: null,
+        storage_key: key,
+        storage_url: url,
+        storage_provider: OFFICIAL_STORAGE_PROVIDER,
+        bucket: OFFICIAL_BUCKET,
+        is_public: 0,
+        created_at: now,
+        updated_at: now,
+        is_del: 0,
+        status: 'uploaded',
+        uploaded_at: now,
+        etag: etag ?? '',
+        checksum: thumbnailUrl ?? '',
+        category,
+        width: 0,
+        height: 0,
+        duration: 0,
+        endpoint: OFFICIAL_ENDPOINT,
+        domain: OFFICIAL_DOMAIN,
+        extra_data: '{}',
+        deleted_at: null,
+        content_sha256: crypto.createHash('sha256').update(bytes).digest('hex'),
+        content_md: null,
+        summary: null,
+    });
+    return { resourceId: id, url, name, mediaType, sizeBytes: bytes.byteLength };
+}

package/dist/gateway/mcpEnv.d.ts

@@ -0,0 +1,5 @@
+/** Environment the gateway starts `dino gateway mcp` with, for each agent session. */
+/** Names the session whose turn a `send_file` belongs to. */
+export declare const GATEWAY_SESSION_TOKEN_ENV = "DINOX_GATEWAY_SESSION_TOKEN";
+/** `0` offers only `send_file`: the owner turned the knowledge tools off. */
+export declare const GATEWAY_KNOWLEDGE_TOOLS_ENV = "DINOX_GATEWAY_KNOWLEDGE_TOOLS";

package/dist/gateway/mcpEnv.js

@@ -0,0 +1,5 @@
+/** Environment the gateway starts `dino gateway mcp` with, for each agent session. */
+/** Names the session whose turn a `send_file` belongs to. */
+export const GATEWAY_SESSION_TOKEN_ENV = 'DINOX_GATEWAY_SESSION_TOKEN';
+/** `0` offers only `send_file`: the owner turned the knowledge tools off. */
+export const GATEWAY_KNOWLEDGE_TOOLS_ENV = 'DINOX_GATEWAY_KNOWLEDGE_TOOLS';

package/dist/gateway/mcpServer.d.ts

@@ -1,4 +1,14 @@
 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 type DaemonCall = (method: string, params?: unknown, options?: {
+    timeoutMs?: number;
+}) => Promise<unknown>;
+export type DinoxMcpOptions = {
+    /** Offer the knowledge tools (notes, todos, conversations); default true. */
+    knowledgeTools?: boolean;
+    /** The session `send_file` belongs to; absent, `send_file` is not offered. */
+    sessionToken?: string;
+    /** Resolves relative `send_file` paths; default the process directory. */
+    cwd?: string;
+};
+export declare function createDinoxMcpServer(call?: DaemonCall, options?: DinoxMcpOptions): McpServer;
 export declare function serveDinoxMcpOverStdio(): Promise<void>;

package/dist/gateway/mcpServer.js

@@ -1,25 +1,57 @@
+import path from 'node:path';
 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 { GATEWAY_KNOWLEDGE_TOOLS_ENV, GATEWAY_SESSION_TOKEN_ENV } from './mcpEnv.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.
+ * Dinox tools for gateway agents, served over stdio MCP. The agent launches
+ * this as a child process (`dino gateway mcp`); every call goes through the
+ * daemon, which owns the database. The knowledge tools are read-only by
+ * design: writes from a third-party agent would bypass the app's approval
+ * flow. `send_file` only adds a file to the reply the agent is writing.
  */
 const MAX_NOTE_CHARS = 20_000;
 const MAX_RESULTS = 50;
+/** Uploading a large file can take a while; the daemon's default request timeout is 10s. */
+const SEND_FILE_TIMEOUT_MS = 150_000;
 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)) {
+export function createDinoxMcpServer(call = (method, params, options) => sendDaemonRequest(method, params, options), options = {}) {
     const server = new McpServer({ name: 'dinox', version: getPackageVersion() });
+    if (options.sessionToken)
+        registerSendFile(server, call, options.sessionToken, options.cwd ?? process.cwd());
+    if (options.knowledgeTools !== false)
+        registerKnowledgeTools(server, call);
+    return server;
+}
+function registerSendFile(server, call, sessionToken, cwd) {
+    server.registerTool('send_file', {
+        description: 'Show the user a file from this computer (an image you generated, a document, a chart, ...). The user talks to ' +
+            'you from the Dinox app and cannot open files on this computer, so a path alone is useless to them: call this ' +
+            'for every file they should see, then answer as usual. Images appear in the reply; other files as attachments. ' +
+            'Up to 50 MB per file.',
+        inputSchema: {
+            path: z.string().describe('Absolute path of the file (relative paths resolve from your working directory)'),
+            name: z.string().optional().describe('File name to show; defaults to the file name in the path'),
+        },
+    }, async ({ path: filePath, name }) => {
+        try {
+            const sent = (await call('gateway.sendFile', { token: sessionToken, path: path.resolve(cwd, filePath), ...(name ? { name } : {}) }, { timeoutMs: SEND_FILE_TIMEOUT_MS }));
+            return text({ sent: true, name: sent.name, mediaType: sent.mediaType });
+        }
+        catch (error) {
+            return { ...text(`Sending the file failed: ${error instanceof Error ? error.message : String(error)}`), isError: true };
+        }
+    });
+}
+function registerKnowledgeTools(server, call) {
     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: {
@@ -129,10 +161,12 @@ export function createDinoxMcpServer(call = (method, params) => sendDaemonReques
             return failure(error);
         }
     });
-    return server;
 }
 export async function serveDinoxMcpOverStdio() {
-    const server = createDinoxMcpServer();
+    const server = createDinoxMcpServer(undefined, {
+        knowledgeTools: process.env[GATEWAY_KNOWLEDGE_TOOLS_ENV] !== '0',
+        sessionToken: process.env[GATEWAY_SESSION_TOKEN_ENV]?.trim() || undefined,
+    });
     await server.connect(new StdioServerTransport());
     await new Promise((resolve) => process.stdin.once('close', resolve));
 }

package/dist/gateway/runExecutor.d.ts

@@ -1,9 +1,11 @@
 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';
+import type { GatewayAdapter, GatewayDefinition, GatewayFileSource, GatewaySentFile } from './types.js';
 /** Turns waiting behind a thread's active one; more are refused as `busy`. */
 export declare const MAX_QUEUED_TURNS = 10;
+/** Files one reply may carry, like the attachments of one message. */
+export declare const MAX_SENT_FILES_PER_TURN = 16;
 /** 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;
@@ -21,9 +23,15 @@ export type RunExecutorDeps = {
     clientTailSyncTimeoutMs?: number;
     /** Keeps the computer awake while a turn runs; returns the release. */
     keepAwake?: () => () => void;
+    /** Uploads a file the agent sends to the user; absent, sending files fails. */
+    uploadFile?: (file: GatewayFileSource) => Promise<GatewaySentFile>;
 };
 /** The user's instructions for the agent, as the start of a new session. */
 export declare function agentInstructionsPreamble(instructions: string): string | undefined;
+/** How the user sees this conversation, so the agent hands over files instead of printing their paths. */
+export declare const SESSION_DELIVERY_NOTE: string;
+/** What a new session starts with: how replies reach the user, then the user's instructions. */
+export declare function sessionPreamble(instructions: string): string;
 /**
  * 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

package/dist/gateway/runExecutor.js

@@ -1,7 +1,7 @@
 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 { commitRunTerminal, enqueueRun, finishMergedRun, startQueuedRuns, TERMINAL_RUN_STATUSES, 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`. */
@@ -9,6 +9,8 @@ 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;
+/** Files one reply may carry, like the attachments of one message. */
+export const MAX_SENT_FILES_PER_TURN = 16;
 /** 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. */
@@ -40,6 +42,17 @@ export function agentInstructionsPreamble(instructions) {
         '</dinox_agent_instructions>',
     ].join('\n');
 }
+/** How the user sees this conversation, so the agent hands over files instead of printing their paths. */
+export const SESSION_DELIVERY_NOTE = [
+    '<dinox_delivery>',
+    'The user reads your replies in the Dinox app, usually on another device, and cannot open files on this computer.',
+    'To show them a file you made or found (an image, a document, a chart, ...), call the Dinox send_file tool with its path.',
+    '</dinox_delivery>',
+].join('\n');
+/** What a new session starts with: how replies reach the user, then the user's instructions. */
+export function sessionPreamble(instructions) {
+    return [SESSION_DELIVERY_NOTE, agentInstructionsPreamble(instructions)].filter(Boolean).join('\n\n');
+}
 function withErrorText(message, error) {
     return { ...message, metadata: { ...(message.metadata ?? {}), error } };
 }
@@ -261,6 +274,30 @@ export class GatewayRunExecutor {
             return decision;
         };
         const awaitApproval = registerApproval;
+        // Uploads still running when the agent ends its turn finish before the reply is committed.
+        const uploads = new Set();
+        let filesSent = 0;
+        const sendFile = (file) => {
+            const upload = this.deps.uploadFile;
+            if (!upload)
+                return Promise.reject(new Error('Sending files is not available on this computer'));
+            if (filesSent >= MAX_SENT_FILES_PER_TURN) {
+                return Promise.reject(new Error(`At most ${MAX_SENT_FILES_PER_TURN} files can be sent in one reply`));
+            }
+            filesSent += 1;
+            const pending = upload(file).then((sent) => {
+                projection.addFile(sent);
+                // Once the turn has ended, the terminal snapshot carries the file.
+                if (!TERMINAL_RUN_STATUSES.has(status))
+                    publish(true);
+                return sent;
+            });
+            uploads.add(pending);
+            void pending
+                .catch((error) => log('send file failed', { runId: active.runId, error: String(error) }))
+                .finally(() => uploads.delete(pending));
+            return pending;
+        };
         let errorText = null;
         let nextBinding = null;
         try {
@@ -286,12 +323,13 @@ export class GatewayRunExecutor {
             const result = await adapter.runTurn({
                 sessionId: continued?.sessionId ?? null,
                 cwd,
-                sessionPreamble: agentInstructionsPreamble(instructions),
+                sessionPreamble: this.deps.uploadFile ? sessionPreamble(instructions) : agentInstructionsPreamble(instructions),
                 prompt: withConversationContext(prompt, context, { canReadConversation: gateway.dinoxTools !== false }),
                 resources,
                 signal: active.controller.signal,
                 config: agentConfig,
                 awaitApproval,
+                sendFile,
                 onEvent: (event) => {
                     projection.apply(event);
                     if (event.type === 'approval-request') {
@@ -301,6 +339,8 @@ export class GatewayRunExecutor {
                     publish(event.type === 'approval-request' || event.type === 'approval-resolved');
                 },
             });
+            // Files still uploading belong to this reply: the turn ends once they are in it.
+            await Promise.allSettled([...uploads]);
             nextBinding = {
                 sessionId: result.sessionId,
                 topicId,
@@ -326,6 +366,7 @@ export class GatewayRunExecutor {
             for (const approval of active.approvals.values())
                 clearTimeout(approval.timer);
         }
+        await Promise.allSettled([...uploads]);
         projection.finish();
         const assistant = errorText ? withErrorText(projection.snapshot(), errorText) : projection.snapshot();
         try {

package/dist/gateway/service.d.ts

@@ -1,5 +1,6 @@
 import type { AbstractPowerSyncDatabase } from '@powersync/common';
 import { type DeviceHostStatus } from './deviceHost.js';
+import type { GatewayFileSource, GatewaySentFile } from './types.js';
 type Logger = (message: string, details?: Record<string, unknown>) => void;
 export type GatewayServiceDeps = {
     db: AbstractPowerSyncDatabase;
@@ -25,6 +26,8 @@ export declare class GatewayService {
     /** Saves a change made in the app, applies it to the running gateway and syncs the robot row. */
     private updateSettings;
     private robotRegistration;
+    /** Routes a `send_file` from an agent's Dinox tools to the turn of the session that started them. */
+    sendFile(token: string, file: GatewayFileSource): Promise<GatewaySentFile>;
     status(): DeviceHostStatus[];
 }
 export {};

package/dist/gateway/service.js

@@ -105,6 +105,15 @@ export class GatewayService {
             },
         };
     }
+    /** Routes a `send_file` from an agent's Dinox tools to the turn of the session that started them. */
+    sendFile(token, file) {
+        for (const host of this.hosts) {
+            const sent = host.sendFile(token, file);
+            if (sent)
+                return sent;
+        }
+        return Promise.reject(new Error('This conversation is no longer running on this computer'));
+    }
     status() {
         return this.hosts.map((host) => host.status());
     }

package/dist/gateway/types.d.ts

@@ -93,6 +93,25 @@ export type GatewayConfigOption = {
         group: string | null;
     }>;
 };
+/** A file the agent hands to the user: a local path, or bytes it sent inline (base64). */
+export type GatewayFileSource = {
+    kind: 'path';
+    path: string;
+    name?: string;
+} | {
+    kind: 'data';
+    data: string;
+    mediaType: string;
+    name?: string;
+};
+/** A file uploaded for the user, as it appears in the reply. */
+export type GatewaySentFile = {
+    resourceId: string;
+    url: string;
+    name: string;
+    mediaType: string;
+    sizeBytes: number;
+};
 export type GatewayStopReason = 'end_turn' | 'cancelled' | 'max_tokens' | 'refusal' | 'error';
 export type GatewayTurnInput = {
     /** Agent session to continue; absent starts a new one. */
@@ -114,6 +133,8 @@ export type GatewayTurnInput = {
     onEvent: (event: GatewayEvent) => void;
     /** Resolves with the user's decision for an `approval-request` event. */
     awaitApproval: (approvalId: string) => Promise<boolean>;
+    /** Uploads a file for the user and adds it to the reply. */
+    sendFile: (file: GatewayFileSource) => Promise<GatewaySentFile>;
 };
 export type GatewayTurnResult = {
     sessionId: string;
@@ -132,5 +153,11 @@ export interface GatewayAdapter {
     runTurn(input: GatewayTurnInput): Promise<GatewayTurnResult>;
     /** The agent's session settings (models, modes); absent when it has none. */
     describeConfig?(): Promise<GatewayConfigOption[]>;
+    /**
+     * A `send_file` call from the Dinox tools of one of this adapter's sessions,
+     * named by the token the session's tools were started with; `null` when the
+     * token is not this adapter's.
+     */
+    sendFile?(token: string, file: GatewayFileSource): Promise<GatewaySentFile> | null;
     dispose(): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "2.6.0",
+  "version": "2.8.0",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {