talon-agent 3.35.0 → 3.36.0

package/src/frontend/native/routes/chats.ts

@@ -1,8 +1,11 @@
 import type { RouteHost } from "./host.js";
 import type { BridgeRoutes } from "./table.js";
-import { asPositiveInt, asString, deviceIdParam } from "./params.js";
-
-const MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+import {
+  asAttachmentRefs,
+  asPositiveInt,
+  asString,
+  deviceIdParam,
+} from "./params.js";
 
 export function chatRoutes(
   host: RouteHost,
@@ -87,27 +90,42 @@ export function chatRoutes(
       const body = await readJson(req);
       const id = asString(body.chatId) ?? "";
       const text = asString(body.text) ?? "";
+      // Multi-file clients send `attachments`; the single-image shape older
+      // clients send is folded into the same list by the handler.
+      const attachments = asAttachmentRefs(body.attachments);
       const imagePath = asString(body.imagePath);
       const attachmentPath = asString(body.attachmentPath);
-      // Text may be empty when an image is attached; require one or the
-      // other.
-      if (!id || (!text.trim() && !attachmentPath))
+      const hasAttachment =
+        attachments.length > 0 || Boolean(attachmentPath || imagePath);
+      // Text may be empty when a file is attached; require one or the other.
+      if (!id || (!text.trim() && !hasAttachment))
         return json(res, 400, {
           ok: false,
           error: "chatId and text (or an attachment) required",
         });
-      h.send(id, text, { imagePath, attachmentPath });
+      h.send(id, text, { attachments, imagePath, attachmentPath });
       json(res, 202, { ok: true });
     },
     "POST /upload": async ({ req, res, url }) => {
       const filename = url.searchParams.get("filename") ?? "upload";
       const contentType =
         req.headers["content-type"] ?? "application/octet-stream";
-      const bytes = await host.readRaw(req, MAX_UPLOAD_BYTES);
-      if (!bytes.length)
-        return json(res, 400, { ok: false, error: "Empty upload" });
-      const result = await h.upload(filename, contentType, bytes);
-      json(res, 200, { ok: true, ...result });
+      try {
+        const attachment = await h.upload(filename, contentType, req);
+        // `imagePath` mirrors the URL for clients written against the
+        // single-image upload response.
+        json(res, 200, { ok: true, ...attachment, imagePath: attachment.url });
+      } catch (err) {
+        // The client can only act on this if it knows why: too large (pick a
+        // smaller file), empty (nothing was read), or a server-side failure.
+        const error = err instanceof Error ? err.message : String(err);
+        const status = /limit/i.test(error)
+          ? 413
+          : /empty/i.test(error)
+            ? 400
+            : 500;
+        json(res, status, { ok: false, error });
+      }
     },
     "GET /media": ({ res, url }) =>
       host.serveMedia(res, url.searchParams.get("id") ?? ""),

package/src/frontend/native/routes/host.ts

@@ -1,6 +1,9 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Readable } from "node:stream";
+import type { AttachmentRef } from "./params.js";
 import type {
   BackendOption,
+  ClientAttachment,
   BridgeEvent,
   BridgeStatus,
   ClientChat,
@@ -18,7 +21,13 @@ import type {
 import type { ConfigSnapshot } from "../settings.js";
 
 /** Optional attachment references carried alongside a sent message. */
-type SendOptions = {
+export type SendOptions = {
+  /**
+   * Every file attached to the message, as the client's references to its
+   * own uploads. `imagePath` and `attachmentPath` below are the single-file
+   * shape older clients send; the handler folds them into the same list.
+   */
+  attachments?: AttachmentRef[];
   /** Relative bridge path to render inline (e.g. `/media?id=…`). */
   imagePath?: string;
   /** Absolute on-disk path handed to the model so it can read the file. */
@@ -41,12 +50,16 @@ export type BridgeServerHandlers = {
   search(query: string, chatId?: string): SearchResult[];
   /** Fire-and-forget: streams its results back through `broadcast`. */
   send(id: string, text: string, opts?: SendOptions): void;
-  /** Persist an uploaded image and return its render path + on-disk path. */
+  /**
+   * Stream an uploaded file to disk and return its wire description. The body
+   * is consumed as it arrives (never buffered whole), so the size ceiling is
+   * disk, not memory.
+   */
   upload(
     filename: string,
     contentType: string,
-    bytes: Buffer,
-  ): Promise<{ imagePath: string; path: string }>;
+    body: Readable,
+  ): Promise<ClientAttachment>;
   listModels(
     id?: string,
   ):
@@ -139,7 +152,6 @@ export type RouteHost = {
   fingerprint: () => string | null;
   json: (res: ServerResponse, code: number, body: unknown) => void;
   readJson: (req: IncomingMessage) => Promise<Record<string, unknown>>;
-  readRaw: (req: IncomingMessage, max: number) => Promise<Buffer>;
   corsHeaders: () => Record<string, string>;
   streamFile: (
     res: ServerResponse,

package/src/frontend/native/routes/params.ts

@@ -27,3 +27,24 @@ export function asPositiveInt(v: string | null): number | undefined {
   const n = Number(v);
   return Number.isInteger(n) && n > 0 ? n : undefined;
 }
+
+/** A client's reference to a file it already uploaded. */
+export type AttachmentRef = { url?: string; path?: string };
+
+/**
+ * Coerce the `attachments` array on a `/send` body to reference shape. Only
+ * the identifying fields are read: name, size and type are whatever the
+ * daemon recorded when it wrote the file, never what the client claims now.
+ */
+export function asAttachmentRefs(v: unknown): AttachmentRef[] {
+  if (!Array.isArray(v)) return [];
+  const refs: AttachmentRef[] = [];
+  for (const item of v) {
+    if (typeof item !== "object" || item === null) continue;
+    const row = item as Record<string, unknown>;
+    const url = asString(row.url);
+    const path = asString(row.path);
+    if (url || path) refs.push({ url, path });
+  }
+  return refs;
+}

package/src/frontend/native/runtime.ts

@@ -12,7 +12,12 @@ import type { TalonConfig } from "../../util/config.js";
 import type { Gateway } from "../../core/engine/gateway.js";
 import { getMeshService, type MeshService } from "../../core/mesh/index.js";
 import { NativeChats } from "./chats.js";
-import type { BridgeEvent, ClientToolCall, ContextInfo } from "./protocol.js";
+import type {
+  BridgeEvent,
+  ClientAttachment,
+  ClientToolCall,
+  ContextInfo,
+} from "./protocol.js";
 
 /** One tool call observed during a running turn, kept for mid-turn replay. */
 export type LiveToolEntry = {
@@ -21,11 +26,10 @@ export type LiveToolEntry = {
   done?: boolean;
 };
 
-/** A chat's single queued follow-up, with its attachment paths intact. */
+/** A chat's single queued follow-up, with its attachments intact. */
 export type QueuedEntry = {
   text: string;
-  imagePath?: string;
-  attachmentPath?: string;
+  attachments: ClientAttachment[];
 };
 
 export type NativeRuntime = {
@@ -51,6 +55,13 @@ export type NativeRuntime = {
    * frontends behave).
    */
   readonly media: Map<string, string>;
+  /**
+   * Uploads this daemon run has accepted, keyed by their media id. `/send`
+   * resolves a client's attachment references through here rather than
+   * trusting the paths in the request body, so a message can only ever point
+   * the model at a file this daemon itself wrote to the uploads dir.
+   */
+  readonly uploads: Map<string, ClientAttachment>;
   /**
    * Live context-window fill per chat, refreshed at the end of each turn.
    * Cached (not computed inline) so the sync `toClientChat` projection stays
@@ -99,6 +110,7 @@ export function createNativeRuntime(
     chats: new NativeChats(),
     mesh: getMeshService(),
     media: new Map(),
+    uploads: new Map(),
     contextByChat: new Map(),
     liveTurns: new Map(),
     queuedByChat: new Map(),

package/src/frontend/native/server.ts

@@ -24,9 +24,9 @@ import { createServer as createTlsServer } from "node:https";
 import { createHash, timingSafeEqual } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { stat } from "node:fs/promises";
-import { extname } from "node:path";
 import { log, logError, logDebug, logWarn } from "../../util/log.js";
 import { formatFingerprint, type BridgeTlsIdentity } from "./tls.js";
+import { contentTypeFor } from "./media.js";
 import { type BridgeEvent } from "./protocol.js";
 import { buildRoutes } from "./routes/index.js";
 import type { BridgeServerHandlers, RouteHost } from "./routes/host.js";
@@ -38,7 +38,7 @@ import {
   type RouteHandler,
 } from "./routes/table.js";
 
-export type { BridgeServerHandlers } from "./routes/host.js";
+export type { BridgeServerHandlers, SendOptions } from "./routes/host.js";
 export { BRIDGE_ROUTE_AUTH, type BridgeRouteKey } from "./routes/table.js";
 
 const SSE_PING_MS = 25_000;
@@ -352,7 +352,6 @@ export class BridgeServer {
       fingerprint: () => this.getFingerprint(),
       json: (res, code, body) => this.json(res, code, body),
       readJson: (req) => this.readJson(req),
-      readRaw: (req, max) => this.readRaw(req, max),
       corsHeaders: () => this.corsHeaders(),
       streamFile: (res, file) => this.streamFile(res, file),
       serveMedia: (res, id) => this.serveMedia(res, id),
@@ -591,17 +590,6 @@ export class BridgeServer {
   }
 
   /** Read a raw request body (binary-safe) up to `max` bytes. */
-  private async readRaw(req: IncomingMessage, max: number): Promise<Buffer> {
-    const chunks: Buffer[] = [];
-    let total = 0;
-    for await (const chunk of req) {
-      total += (chunk as Buffer).length;
-      if (total > max) throw new Error("Upload too large");
-      chunks.push(chunk as Buffer);
-    }
-    return Buffer.concat(chunks);
-  }
-
   private async readJson(
     req: IncomingMessage,
   ): Promise<Record<string, unknown>> {
@@ -621,24 +609,3 @@ export class BridgeServer {
     return parsed as Record<string, unknown>;
   }
 }
-
-/** Minimal image content-type map for the media endpoint. */
-function contentTypeFor(filePath: string): string {
-  switch (extname(filePath).toLowerCase()) {
-    case ".png":
-      return "image/png";
-    case ".jpg":
-    case ".jpeg":
-      return "image/jpeg";
-    case ".gif":
-      return "image/gif";
-    case ".webp":
-      return "image/webp";
-    case ".bmp":
-      return "image/bmp";
-    case ".svg":
-      return "image/svg+xml";
-    default:
-      return "application/octet-stream";
-  }
-}

package/src/frontend/native/status.ts

@@ -12,7 +12,9 @@ export function bridgeStatus(runtime: NativeRuntime): BridgeStatus {
   return {
     app: "talon-bridge",
     protocol: BRIDGE_PROTOCOL_VERSION,
-    capabilities: ["mesh", "mesh-commands", "plugins-skills"],
+    // "attachments": /upload streams any file type and /send takes an
+    // `attachments` list, so a client can stage several files per message.
+    capabilities: ["mesh", "mesh-commands", "plugins-skills", "attachments"],
     botName: runtime.botName,
     backend: config.backend,
     model: resolveModel(config.model)?.displayName ?? config.model,

package/src/frontend/native/turn.ts

@@ -16,7 +16,7 @@ import { recordTurnMeta } from "./turn-meta.js";
 import type { ChatEntry } from "./chats.js";
 import { refreshContext } from "./context.js";
 import { emitAssistant, emitUser } from "./emit.js";
-import type { BridgeEvent } from "./protocol.js";
+import type { BridgeEvent, ClientAttachment } from "./protocol.js";
 import { takeQueued } from "./queue.js";
 import type { LiveToolEntry, NativeRuntime } from "./runtime.js";
 import { summarizeToolResult } from "./tool-result.js";
@@ -24,7 +24,38 @@ import { summarizeToolResult } from "./tool-result.js";
 /** The tool calls of one running turn, in call order. */
 type TurnTools = Map<string, LiveToolEntry>;
 
-export type StartTurnOptions = { imagePath?: string; attachmentPath?: string };
+export type StartTurnOptions = { attachments?: ClientAttachment[] };
+
+/** Human-readable size for the attachment lines handed to the model. */
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${value < 10 ? value.toFixed(1) : Math.round(value)} ${units[unit]}`;
+}
+
+/**
+ * Point the model at the files the user attached. Each gets its own line with
+ * an absolute path so the model can read it with its own tools; images keep
+ * the `[Attached image: …]` wording backends already recognise.
+ */
+export function attachmentPrompt(
+  text: string,
+  attachments: ClientAttachment[],
+): string {
+  if (!attachments.length) return text;
+  const lines = attachments.map((a) =>
+    a.image
+      ? `[Attached image: ${a.path}]`
+      : `[Attached file: ${a.name} (${a.mimeType}, ${formatSize(a.size)}) at ${a.path}]`,
+  );
+  return `${text ? `${text}\n\n` : ""}${lines.join("\n")}`;
+}
 
 /** True when a turn is currently running for a chat (used to decide queue). */
 export function isBusy(runtime: NativeRuntime, chatId: string): boolean {
@@ -247,7 +278,7 @@ async function runTurn(
   entry: ChatEntry,
   text: string,
   messageId: number,
-  attachmentPath?: string,
+  attachments: ClientAttachment[],
 ): Promise<void> {
   const start = Date.now();
   // Tool calls observed during this turn, in call order — recorded into the
@@ -256,10 +287,7 @@ async function runTurn(
   // the activity so far (cleared in the `finally`).
   const turnTools: TurnTools = new Map();
   runtime.liveTurns.set(entry.id, turnTools);
-  // Point the model at an attached image so it can read the file itself.
-  const prompt = attachmentPath
-    ? `${text ? `${text}\n\n` : ""}[Attached image: ${attachmentPath}]`
-    : text;
+  const prompt = attachmentPrompt(text, attachments);
   try {
     const result = await execute({
       chatId: entry.id,
@@ -287,8 +315,7 @@ async function runTurn(
     if (queued) {
       setImmediate(() =>
         startTurn(runtime, entry, queued.text, {
-          imagePath: queued.imagePath,
-          attachmentPath: queued.attachmentPath,
+          attachments: queued.attachments,
         }),
       );
     }
@@ -303,16 +330,11 @@ export function startTurn(
   text: string,
   options?: StartTurnOptions,
 ): void {
-  const messageId = emitUser(
-    runtime,
-    entry,
-    text,
-    options?.imagePath,
-    options?.attachmentPath,
-  );
+  const attachments = options?.attachments ?? [];
+  const messageId = emitUser(runtime, entry, text, attachments);
   runtime.broadcast({ kind: "turn_start", chatId: entry.id });
   runtime.broadcast({ kind: "typing", chatId: entry.id, on: true });
-  void runTurn(runtime, entry, text, messageId, options?.attachmentPath);
+  void runTurn(runtime, entry, text, messageId, attachments);
 }
 
 /** Best-effort interrupt of a chat's in-flight turn. `true` if one was

package/src/storage/db.ts

@@ -68,7 +68,8 @@ let db: SqlDatabase | null = null;
  *
  * Column reconciliation runs first: `ALTER TABLE … ADD COLUMN` has no
  * IF NOT EXISTS form, so columns added to already-shipped tables
- * (media_index.content_hash, sessions.metrics) are ensured by attempting the ALTER and
+ * (media_index.content_hash, sessions.metrics,
+ * history_messages.attachments) are ensured by attempting the ALTER and
  * swallowing the two expected failures — "duplicate column name"
  * (column already there) and "no such table" (fresh database; the
  * CREATE TABLE in schema.sql includes the column).
@@ -94,6 +95,11 @@ function ensureSchema(database: SqlDatabase): void {
   } catch {
     /* duplicate column or no such table — both mean nothing to do */
   }
+  try {
+    database.exec(dbSql.addHistoryAttachmentsColumn);
+  } catch {
+    /* duplicate column or no such table — both mean nothing to do */
+  }
   database.exec("BEGIN");
   try {
     database.exec(SCHEMA);

package/src/storage/history.ts

@@ -26,7 +26,10 @@ import { formatSmartTimestamp, formatRelativeAge } from "../util/time.js";
 import { importLegacyJson } from "./legacy-import.js";
 import * as repo from "./repositories/history-repo.js";
 
-export type { HistoryMessage } from "./repositories/history-repo.js";
+export type {
+  HistoryMessage,
+  MessageAttachment,
+} from "./repositories/history-repo.js";
 import type { HistoryMessage } from "./repositories/history-repo.js";
 
 // ── Persistence lifecycle ───────────────────────────────────────────────────

package/src/storage/repositories/history-repo.ts

@@ -9,6 +9,24 @@ import { escapeLike } from "../../native/sqlguard.js";
 import { getDatabase, inTransaction } from "../db.js";
 import { historySql } from "../sql/statements.generated.js";
 /** One chat message as the domain sees it — the shape the rows map to. */
+/**
+ * A file attached to a message, persisted with it. The bridge's own
+ * `ClientAttachment` is this plus a per-run `/media` URL — storage keeps only
+ * what survives a restart, and the URL is minted fresh on read.
+ */
+export type MessageAttachment = {
+  /** Absolute path on this host. */
+  path: string;
+  /** Original file name, for display. */
+  name: string;
+  /** Size in bytes. */
+  size: number;
+  /** Best-effort MIME type. */
+  mimeType: string;
+  /** True when clients render it inline as an image. */
+  image: boolean;
+};
+
 export type HistoryMessage = {
   msgId: number;
   senderId: number;
@@ -25,8 +43,11 @@ export type HistoryMessage = {
   mediaType?:
     "photo" | "document" | "voice" | "sticker" | "video" | "animation";
   stickerFileId?: string;
-  /** Saved file path for downloaded media. */
+  /** Saved file path for downloaded media (the first attachment's, when
+   *  a message carries several). */
   filePath?: string;
+  /** Every file attached to this message, oldest row shape holds none. */
+  attachments?: MessageAttachment[];
 };
 
 type Row = {
@@ -40,8 +61,31 @@ type Row = {
   media_type: string | null;
   sticker_file_id: string | null;
   file_path: string | null;
+  attachments: string | null;
 };
 
+/**
+ * Parse the persisted attachments column. Anything unreadable (hand-edited
+ * row, a shape from a future version) degrades to "no attachments" rather
+ * than failing the whole history read.
+ */
+function parseAttachments(raw: string | null): MessageAttachment[] | undefined {
+  if (!raw) return undefined;
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return undefined;
+    const rows = parsed.filter(
+      (a): a is MessageAttachment =>
+        typeof a === "object" &&
+        a !== null &&
+        typeof (a as MessageAttachment).path === "string",
+    );
+    return rows.length ? rows : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 function rowToMessage(row: Row): HistoryMessage {
   return {
     msgId: row.msg_id,
@@ -54,6 +98,7 @@ function rowToMessage(row: Row): HistoryMessage {
     mediaType: (row.media_type ?? undefined) as HistoryMessage["mediaType"],
     stickerFileId: row.sticker_file_id ?? undefined,
     filePath: row.file_path ?? undefined,
+    attachments: parseAttachments(row.attachments),
   };
 }
 
@@ -72,6 +117,7 @@ export function insert(chatId: string, msg: HistoryMessage): void {
       msg.mediaType ?? null,
       msg.stickerFileId ?? null,
       msg.filePath ?? null,
+      msg.attachments?.length ? JSON.stringify(msg.attachments) : null,
     );
 }
 

package/src/storage/sql/db.sql

@@ -19,3 +19,9 @@ ALTER TABLE history_messages ADD COLUMN sender_handle TEXT
 -- Column reconciliation for databases that shipped before per-session
 -- metrics existed. Fresh databases get the column via schema.sql.
 ALTER TABLE sessions ADD COLUMN metrics TEXT NOT NULL DEFAULT '{"lifetime":{"counters":{"queries":0,"toolCalls":0,"turnsWithTools":0,"apiCalls":0,"inputTokens":0,"outputTokens":0,"cacheReadTokens":0,"cacheWriteTokens":0,"failedTurns":0,"flowViolationRetries":0,"flowViolationCapExhausted":0,"trailingTextDropped":0},"latency":{"count":0,"sumMs":0,"minMs":null,"maxMs":0},"toolCallsByName":{},"backend":{},"cacheHitPercent":{"count":0,"sumMs":0,"minMs":null,"maxMs":0},"toolCallsPerTurn":{"count":0,"sumMs":0,"minMs":null,"maxMs":0},"apiCallsPerTurn":{"count":0,"sumMs":0,"minMs":null,"maxMs":0}},"buckets":{}}'
+
+-- name: addHistoryAttachmentsColumn
+-- Column reconciliation for databases that shipped before a message could
+-- carry more than one attachment. Fresh databases get the column via
+-- schema.sql.
+ALTER TABLE history_messages ADD COLUMN attachments TEXT

package/src/storage/sql/history.sql

@@ -4,12 +4,13 @@
 -- name: insert
 INSERT OR IGNORE INTO history_messages
   (chat_id, msg_id, sender_id, sender_name, sender_handle, text,
-   reply_to_msg_id, timestamp, media_type, sticker_file_id, file_path)
-VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+   reply_to_msg_id, timestamp, media_type, sticker_file_id, file_path,
+   attachments)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 
 -- name: recent
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
-       timestamp, media_type, sticker_file_id, file_path
+       timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
 WHERE chat_id = ? ORDER BY id DESC LIMIT ?
 
@@ -17,7 +18,7 @@ WHERE chat_id = ? ORDER BY id DESC LIMIT ?
 -- Scroll-back pagination: the window of messages strictly older than a
 -- given msg_id, newest-first (the repository reverses to chronological).
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
-       timestamp, media_type, sticker_file_id, file_path
+       timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
 WHERE chat_id = ? AND msg_id < ? ORDER BY id DESC LIMIT ?
 
@@ -25,7 +26,7 @@ WHERE chat_id = ? AND msg_id < ? ORDER BY id DESC LIMIT ?
 -- Time-cursor variant of recentBefore for the read_history `before` date
 -- parameter: the newest `limit` messages strictly older than a timestamp.
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
-       timestamp, media_type, sticker_file_id, file_path
+       timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
 WHERE chat_id = ? AND timestamp < ? ORDER BY id DESC LIMIT ?
 
@@ -39,7 +40,7 @@ DELETE FROM history_messages WHERE chat_id = ?
 -- The match param must already be a valid FTS5 expression
 -- (see history.ts ftsQuery).
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
-       timestamp, media_type, sticker_file_id, file_path
+       timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
 WHERE chat_id = ?
   AND id IN (SELECT rowid FROM history_fts WHERE history_fts MATCH ?)
@@ -50,7 +51,7 @@ ORDER BY id DESC LIMIT ?
 -- search_history `after` / `before` date parameters. Either bound may be
 -- the open end of the range (0 / a far-future value).
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
-       timestamp, media_type, sticker_file_id, file_path
+       timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
 WHERE chat_id = ?
   AND id IN (SELECT rowid FROM history_fts WHERE history_fts MATCH ?)
@@ -60,20 +61,20 @@ ORDER BY id DESC LIMIT ?
 -- name: bySenderName
 -- The fragment param is LIKE-escaped by the repository (backslash escape).
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
-       timestamp, media_type, sticker_file_id, file_path
+       timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
 WHERE chat_id = ? AND lower(sender_name) LIKE ? ESCAPE '\'
 ORDER BY id DESC LIMIT ?
 
 -- name: byMsgId
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
-       timestamp, media_type, sticker_file_id, file_path
+       timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
 WHERE chat_id = ? AND msg_id = ? ORDER BY id DESC LIMIT 1
 
 -- name: bySenderId
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
-       timestamp, media_type, sticker_file_id, file_path
+       timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
 WHERE chat_id = ? AND sender_id = ? ORDER BY id DESC LIMIT ?
 

package/src/storage/sql/schema.sql

@@ -20,7 +20,12 @@ CREATE TABLE IF NOT EXISTS history_messages (
   timestamp       INTEGER NOT NULL,
   media_type      TEXT,
   sticker_file_id TEXT,
-  file_path       TEXT
+  file_path       TEXT,
+  -- Files attached to this message, as a JSON array of
+  -- {path,name,size,mimeType,image}. A message can carry several (the
+  -- companion's composer stages any number), so file_path above holds
+  -- only the first for the pre-multi-file row shape. Null when none.
+  attachments     TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_history_chat ON history_messages(chat_id, id);
 CREATE UNIQUE INDEX IF NOT EXISTS idx_history_chat_msg ON history_messages(chat_id, msg_id);