@coffer-org/server 7.2.0 → 7.4.0

package/dist/thread-state.d.ts

@@ -1,8 +1,22 @@
 export interface ThreadSelection {
     agentId: string | null;
     presetId: string | null;
+    title: string | null;
+    owner: string | null;
+    visibility: 'private' | null;
 }
+export declare const TITLE_MAX = 60;
 export declare function getThreadState(connector: string, chatId: string): Promise<ThreadSelection>;
+export declare function getThreadStates(connector: string, chatIds: string[]): Promise<Map<string, ThreadSelection>>;
 export declare function setThreadState(connector: string, chatId: string, patch: Partial<ThreadSelection>): Promise<void>;
 export declare function readAndTouchThreadState(connector: string, chatId: string): Promise<ThreadSelection>;
+export declare function findChatByConvId(connector: string, convId: string): Promise<ChatLookup>;
+export type ChatLookup = {
+    found: 'one';
+    chatId: string;
+} | {
+    found: 'none';
+} | {
+    found: 'ambiguous';
+};
 export declare function pruneThreadState(connector: string, cutoffIso: string): Promise<void>;

package/dist/thread-state.js

@@ -1,26 +1,63 @@
 import { getEm } from "./db.js";
-const EMPTY = { agentId: null, presetId: null };
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('thread-state');
+export const TITLE_MAX = 60;
+function capTitle(title) {
+    const t = title.trim();
+    return t.length <= TITLE_MAX ? t : `${t.slice(0, TITLE_MAX - 1)}…`;
+}
+const EMPTY = { agentId: null, presetId: null, title: null, owner: null, visibility: null };
+function toSelection(row) {
+    return {
+        agentId: row.agent_id,
+        presetId: row.preset_id,
+        title: row.title,
+        owner: row.owner,
+        visibility: row.visibility === 'private' ? 'private' : null,
+    };
+}
 export async function getThreadState(connector, chatId) {
     const em = getEm().fork();
     const row = (await em.findOne('_ThreadState', { connector, chat_id: chatId }));
     if (!row)
         return { ...EMPTY };
-    return { agentId: row.agent_id, presetId: row.preset_id };
+    return toSelection(row);
+}
+export async function getThreadStates(connector, chatIds) {
+    if (chatIds.length === 0)
+        return new Map();
+    const em = getEm().fork();
+    const rows = (await em.find('_ThreadState', { connector, chat_id: { $in: chatIds } }));
+    return new Map(rows.map((row) => [row.chat_id, toSelection(row)]));
 }
 export async function setThreadState(connector, chatId, patch) {
     const em = getEm().fork();
-    const current = await getThreadState(connector, chatId);
-    const next = {
-        agentId: 'agentId' in patch ? (patch.agentId ?? null) : current.agentId,
-        presetId: 'presetId' in patch ? (patch.presetId ?? null) : current.presetId,
-    };
+    const data = { updated_at: new Date().toISOString() };
+    if ('agentId' in patch)
+        data['agent_id'] = patch.agentId ?? null;
+    if ('presetId' in patch)
+        data['preset_id'] = patch.presetId ?? null;
+    if ('title' in patch)
+        data['title'] = patch.title ? capTitle(patch.title) : null;
+    if ('owner' in patch)
+        data['owner'] = patch.owner ?? null;
+    if ('visibility' in patch)
+        data['visibility'] = patch.visibility ?? null;
     const existing = await em.findOne('_ThreadState', { connector, chat_id: chatId });
-    const data = { agent_id: next.agentId, preset_id: next.presetId, updated_at: new Date().toISOString() };
     if (existing) {
         em.assign(existing, data);
     }
     else {
-        em.persist(em.create('_ThreadState', { connector, chat_id: chatId, ...data }));
+        em.persist(em.create('_ThreadState', {
+            connector,
+            chat_id: chatId,
+            agent_id: data['agent_id'] ?? null,
+            preset_id: data['preset_id'] ?? null,
+            title: data['title'] ?? null,
+            owner: data['owner'] ?? null,
+            visibility: data['visibility'] ?? null,
+            updated_at: data['updated_at'],
+        }));
     }
     await em.flush();
 }
@@ -31,9 +68,32 @@ export async function readAndTouchThreadState(connector, chatId) {
         return { ...EMPTY };
     em.assign(row, { updated_at: new Date().toISOString() });
     await em.flush();
-    return { agentId: row.agent_id, presetId: row.preset_id };
+    return toSelection(row);
+}
+export async function findChatByConvId(connector, convId) {
+    const suffix = `:${convId}`;
+    const em = getEm().fork();
+    const like = { $like: `%${suffix}` };
+    const stateRows = (await em.find('_ThreadState', { connector, chat_id: like }));
+    const stateMatches = matchingChatIds(stateRows, suffix);
+    if (stateMatches.length > 0)
+        return pickUnambiguous(stateMatches, connector, convId);
+    const messageRows = (await em.find('_ThreadMessage', { connector, chat_id: like }));
+    const messageMatches = matchingChatIds(messageRows, suffix);
+    return pickUnambiguous(messageMatches, connector, convId);
+}
+function matchingChatIds(rows, suffix) {
+    return [...new Set(rows.map((r) => r.chat_id).filter((id) => id.endsWith(suffix)))];
+}
+function pickUnambiguous(matches, connector, convId) {
+    if (matches.length === 0)
+        return { found: 'none' };
+    if (matches.length === 1)
+        return { found: 'one', chatId: matches[0] };
+    log.warn(`ambiguous convId "${convId}" for connector "${connector}": ${matches.length} chats match`);
+    return { found: 'ambiguous' };
 }
 export async function pruneThreadState(connector, cutoffIso) {
     const em = getEm().fork();
-    await em.nativeDelete('_ThreadState', { connector, updated_at: { $lt: cutoffIso } });
+    await em.nativeDelete('_ThreadState', { connector, updated_at: { $lt: cutoffIso }, owner: null, visibility: null });
 }

package/dist/thread-store.d.ts

@@ -1,7 +1,8 @@
+export declare const HIDDEN_ROLES: readonly ["reasoning", "suggestions", "context"];
 export declare const SIDECAR_ROLES: readonly ["reasoning", "suggestions"];
 export interface StoredMsg {
     msgId: string;
-    role: 'user' | 'assistant' | 'reasoning' | 'suggestions';
+    role: 'user' | 'assistant' | 'reasoning' | 'suggestions' | 'context';
     sender: string | null;
     text: string;
     attachments?: StoredAttachment[];
@@ -25,7 +26,7 @@ export declare function putThreadMessage(m: {
     connector: string;
     chatId: string;
     msgId: string;
-    role: 'user' | 'assistant' | 'reasoning' | 'suggestions';
+    role: 'user' | 'assistant' | 'reasoning' | 'suggestions' | 'context';
     sender?: string | null;
     attachments?: StoredAttachment[];
     text: string;
@@ -34,4 +35,5 @@ export declare function putThreadMessage(m: {
 }): Promise<void>;
 export declare function pruneThreadMessages(connector: string, cutoffTs: number): Promise<void>;
 export declare function listThreadMessages(connector: string, chatId: string, limit?: number): Promise<StoredMsg[]>;
-export declare function listThreadChats(connector: string, chatIdPrefix: string): Promise<ThreadChat[]>;
+export declare function countUserTurns(connector: string, chatId: string): Promise<number>;
+export declare function listAllThreadChats(connector: string): Promise<ThreadChat[]>;

package/dist/thread-store.js

@@ -1,4 +1,5 @@
 import { getEm } from "./db.js";
+export const HIDDEN_ROLES = ['reasoning', 'suggestions', 'context'];
 export const SIDECAR_ROLES = ['reasoning', 'suggestions'];
 function toStored(r) {
     let attachments;
@@ -50,7 +51,7 @@ export async function pruneThreadMessages(connector, cutoffTs) {
 }
 export async function listThreadMessages(connector, chatId, limit = 200) {
     const em = getEm().fork();
-    const visible = (await em.find('_ThreadMessage', { connector, chat_id: chatId, role: { $nin: SIDECAR_ROLES } }, { orderBy: { ts: 'desc', msg_id: 'desc' }, limit }));
+    const visible = (await em.find('_ThreadMessage', { connector, chat_id: chatId, role: { $nin: HIDDEN_ROLES } }, { orderBy: { ts: 'desc', msg_id: 'desc' }, limit }));
     const oldest = visible.at(-1)?.ts;
     const sidecars = oldest === undefined
         ? []
@@ -60,17 +61,14 @@ export async function listThreadMessages(connector, chatId, limit = 200) {
         .reverse()
         .map(toStored);
 }
-export async function listThreadChats(connector, chatIdPrefix) {
+export async function countUserTurns(connector, chatId) {
     const em = getEm().fork();
-    if (!chatIdPrefix) {
-        return [];
-    }
-    const last = chatIdPrefix.charCodeAt(chatIdPrefix.length - 1);
-    const upper = chatIdPrefix.slice(0, -1) + String.fromCharCode(last + 1);
-    const rows = (await em.find('_ThreadMessage', { connector, chat_id: { $gte: chatIdPrefix, $lt: upper } }, { orderBy: { ts: 'asc' } }));
+    return em.count('_ThreadMessage', { connector, chat_id: chatId, role: 'user' });
+}
+function groupIntoChats(rows) {
     const byChat = new Map();
     for (const r of rows) {
-        if (SIDECAR_ROLES.includes(r.role))
+        if (HIDDEN_ROLES.includes(r.role))
             continue;
         const cur = byChat.get(r.chat_id);
         if (!cur) {
@@ -90,3 +88,8 @@ export async function listThreadChats(connector, chatIdPrefix) {
     }
     return [...byChat.values()].sort((a, b) => b.lastTs - a.lastTs);
 }
+export async function listAllThreadChats(connector) {
+    const em = getEm().fork();
+    const rows = (await em.find('_ThreadMessage', { connector }, { orderBy: { ts: 'asc' } }));
+    return groupIntoChats(rows);
+}

package/dist/turn-gate.d.ts

@@ -0,0 +1,8 @@
+export interface BeginTurnOpts {
+    supersede: boolean;
+}
+export declare function beginTurn(connector: string, chatId: string, opts: BeginTurnOpts): Promise<{
+    signal: AbortSignal;
+    end(): void;
+}>;
+export declare function abortTurn(connector: string, chatId: string): boolean;

package/dist/turn-gate.js

@@ -0,0 +1,39 @@
+const turns = new Map();
+function turnKey(connector, chatId) {
+    return `${connector}\0${chatId}`;
+}
+export async function beginTurn(connector, chatId, opts) {
+    const key = turnKey(connector, chatId);
+    const previous = turns.get(key);
+    const controller = new AbortController();
+    let resolveDone;
+    const done = new Promise((resolve) => {
+        resolveDone = resolve;
+    });
+    const turn = { controller, done };
+    turns.set(key, turn);
+    if (previous) {
+        if (opts.supersede)
+            previous.controller.abort();
+        await previous.done;
+    }
+    let ended = false;
+    return {
+        signal: controller.signal,
+        end() {
+            if (ended)
+                return;
+            ended = true;
+            if (turns.get(key) === turn)
+                turns.delete(key);
+            resolveDone();
+        },
+    };
+}
+export function abortTurn(connector, chatId) {
+    const turn = turns.get(turnKey(connector, chatId));
+    if (!turn)
+        return false;
+    turn.controller.abort();
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/server",
-  "version": "7.2.0",
+  "version": "7.4.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -17,6 +17,10 @@
       "types": "./dist/orchestrator/index.d.ts",
       "default": "./dist/orchestrator/index.js"
     },
+    "./media": {
+      "types": "./dist/media/index.d.ts",
+      "default": "./dist/media/index.js"
+    },
     "./mcp": {
       "types": "./dist/mcp-contract/tools.d.ts",
       "default": "./dist/mcp-contract/tools.js"
@@ -36,7 +40,7 @@
     "postpack": "node ../../scripts/swap-exports.mjs src"
   },
   "dependencies": {
-    "@coffer-org/sdk": "^7.2.0",
+    "@coffer-org/sdk": "^7.4.0",
     "@extractus/oembed-extractor": "^4.1.0",
     "@fastify/cors": "^11.2.0",
     "@fastify/multipart": "^10.0.0",
@@ -48,6 +52,7 @@
     "open-graph-scraper": "^6.11.0",
     "pino": "^9.14.0",
     "pino-pretty": "^13.1.3",
+    "sharp": "^0.35.4",
     "zod": "^4.4.3"
   },
   "optionalDependencies": {