@coffer-org/server 7.1.0 → 7.3.0

package/dist/orchestrator/types.d.ts

@@ -1,3 +1,10 @@
+import type { ImageTarget } from '../media/index.ts';
+import type { AuthRole } from '../plugin-hooks.ts';
+import type { ContextFact } from './context-facts.ts';
+import type { SystemAreas } from './system-areas.ts';
+export type { ImageTarget };
+export type { ContextFact };
+export type { SystemAreas };
 export interface AttachmentRef {
     name: string;
     mime?: string;
@@ -9,7 +16,6 @@ export interface AgentToolDefinition {
     description: string;
     inputSchema: Record<string, unknown>;
     handler: (args: Record<string, unknown>, signal?: AbortSignal) => Promise<unknown>;
-    forcedAfterAnswer?: boolean;
 }
 export interface AgentToolProvider {
     tools: AgentToolDefinition[];
@@ -34,18 +40,25 @@ export interface AgentToolContentResult {
 export interface ConvMessage {
     role: 'user' | 'assistant';
     content: string;
-    context?: string;
+    context?: ContextFact[];
     attachments?: AttachmentRef[];
     sender?: string | null;
     msgId: string;
     ts: number;
 }
 export interface AgentCapabilities {
-    vision?: boolean;
-    documents?: boolean;
     tools?: boolean;
     reasoning?: boolean;
 }
+export interface AgentMediaKind {
+    maxBytes: number;
+    accepts: readonly string[];
+}
+export interface AgentMediaLimits {
+    image: AgentMediaKind & ImageTarget;
+    document: AgentMediaKind;
+    text: AgentMediaKind;
+}
 export interface AgentPreset {
     id: string;
     title: string;
@@ -60,33 +73,46 @@ export interface AgentDescriptor {
     title: string;
     presets: AgentPreset[];
 }
-export interface AgentRequest {
-    system: string;
-    messages: ConvMessage[];
+export interface AgentCatalogEntry extends AgentDescriptor {
+    media: AgentMediaLimits;
+}
+export interface AgentBudget {
+    responseTimeout?: number;
+    toolRounds?: number;
+}
+export interface AgentTurn {
+    envelope: TurnEnvelope;
+    body: {
+        system: string[];
+        messages: ConvMessage[];
+        userTurns: number;
+    };
     toolProvider?: AgentToolProvider;
     presetId?: string;
-    onDelta?: (accumulated: string) => void;
-    onReasoning?: (accumulated: string) => void;
-    onSegment?: () => void;
-}
-export interface AgentResult {
-    text: string | null;
-    reasoning: string | null;
-    tokensIn: number | null;
-    tokensOut: number | null;
-    stopReason: string | null;
-    presetId: string | null;
-    suggestions?: string[] | null;
+    budget?: AgentBudget;
+    senderRole?: AuthRole;
+    signal?: AbortSignal;
 }
 export interface AgentRuntime {
     id: string;
-    run(request: AgentRequest): Promise<AgentResult>;
+    media: AgentMediaLimits;
+    run(turn: AgentTurn, emit: (e: TurnEvent) => void): Promise<void>;
     systemBase(): Promise<string>;
     describe(): Promise<AgentDescriptor>;
     starters?(hint: string): Promise<string[]>;
+    afterword?(turn: AgentTurn, answer: string, want: {
+        suggestions: boolean;
+        title: boolean;
+    }): Promise<{
+        suggestions?: string[];
+        title?: string;
+        tokensIn?: number;
+        tokensOut?: number;
+    }>;
 }
 export interface ConnectorRegistration {
     id: string;
+    linkUrl?(code: string): string | undefined;
 }
 export interface AttachmentMaterializer {
     store(bytes: Uint8Array, opts?: {
@@ -94,48 +120,84 @@ export interface AttachmentMaterializer {
         mime?: string;
     }): Promise<AttachmentRef>;
 }
-export interface IncomingConversation {
+export type SenderIdKind = 'coffer-user' | 'transport';
+export interface TurnEnvelope {
     connectorId: string;
+    chatId: string;
+    turnId: string;
+}
+export interface ConnectorCapabilities {
+    events: readonly ('delta' | 'reasoning' | 'segment' | 'suggestions' | 'title')[];
+    privateChats: boolean;
+}
+export interface TurnBody {
+    systemPrompt: SystemAreas;
+    messages: ConvMessage[];
+    capabilities: ConnectorCapabilities;
+    userTurns: number;
+}
+export interface TurnRequest {
+    envelope: TurnEnvelope;
+    body: TurnBody;
     agentId?: string;
     presetId?: string;
-    chatId: string;
-    channelSystem?: string;
-    turnContext?: string;
     sender: {
         id: string;
         displayName?: string;
+        idKind?: SenderIdKind;
     };
-    messages: ConvMessage[];
+    turnContext?: ContextFact[];
     prepareAttachments?: (materializer: AttachmentMaterializer) => Promise<ConvMessage[]>;
-    supportsSuggestions?: boolean;
+    signal?: AbortSignal;
 }
-export interface ReplyContext {
-    parentMsgId: string | null;
-}
-export interface ReplyPayload {
+export type TurnEvent = {
+    kind: 'delta';
+    text: string;
+} | {
+    kind: 'reasoning';
+    text: string;
+} | {
+    kind: 'segment';
+} | {
+    kind: 'answer';
     text: string | null;
     reasoning: string | null;
-    suggestions: string[] | null;
-}
-export interface ReplyChannel {
-    update(text: string): void;
-    updateReasoning?(acc: string): void;
-    segment(): void;
-    finish(r: ReplyPayload): Promise<string | null>;
+} | {
+    kind: 'usage';
+    tokensIn: number | null;
+    tokensOut: number | null;
+    presetId: string | null;
+    stopReason: string | null;
+} | {
+    kind: 'error';
+    message: string;
+} | {
+    kind: 'suggestions';
+    items: string[];
+} | {
+    kind: 'title';
+    text: string;
+} | {
+    kind: 'notice';
+    text: string;
+};
+export interface TurnSink {
+    emit(event: TurnEvent): void;
+    done(): Promise<void>;
 }
 export interface Connector {
     id: string;
-    reply(chatId: string, ctx: ReplyContext): ReplyChannel;
-    recordAssistant(m: {
-        parentMsgId: string | null;
-        botMsgId: string | null;
-        text: string;
-        reasoning: string | null;
+    enrolmentNotice: string;
+    open(envelope: TurnEnvelope): TurnSink;
+    recordContext(m: {
+        chatId: string;
+        userMsgId: string;
+        facts: ContextFact[];
+        ts: number;
     }): Promise<void>;
 }
 export interface GatePolicy {
     agentId?: string;
-    accessPassword: string;
     triggerPrefix: string;
     replyWindow: number;
 }

package/dist/plugin-hooks.d.ts

@@ -70,5 +70,31 @@ export interface PluginHooks {
     actions?: Record<string, PluginAction>;
     userActions?: Record<string, PluginUserAction>;
     streamActions?: Record<string, PluginStreamAction>;
+    http?: PluginHttpMount[];
 }
 export declare const pluginHooks: Record<string, PluginHooks>;
+export interface PluginHttpRequest {
+    method: string;
+    path: string;
+    url: string;
+    headers: Record<string, string>;
+    body: string;
+    user: {
+        id: number;
+        login: string;
+        role: AuthRole;
+    };
+}
+export interface PluginHttpResponse {
+    status: number;
+    headers?: Record<string, string>;
+    body?: string;
+}
+export interface PluginHttpMount {
+    prefix: string;
+    methods: string[];
+    auth: 'member' | 'admin' | 'token';
+    body?: 'text' | 'none';
+    wellKnown?: string;
+    handle(req: PluginHttpRequest): Promise<PluginHttpResponse>;
+}

package/dist/plugin-http-mounts.d.ts

@@ -0,0 +1,18 @@
+import type { FastifyInstance, FastifyRequest } from 'fastify';
+import type { AuthRole, PluginHooks, PluginHttpMount } from './plugin-hooks.ts';
+export interface MountEntry {
+    pluginId: string;
+    mount: PluginHttpMount;
+}
+export declare function collectHttpMounts(hooks: Record<string, PluginHooks>): MountEntry[];
+export declare function customMethodsOf(entries: MountEntry[]): string[];
+export declare function registerTextBodyParsers(app: FastifyInstance): void;
+export interface MountDeps {
+    disabledSet: () => Promise<Set<string>>;
+    resolveUser: (req: FastifyRequest) => Promise<{
+        id: number;
+        login: string;
+        role: AuthRole;
+    } | null>;
+}
+export declare function registerPluginHttpMounts(app: FastifyInstance, entries: MountEntry[], deps: MountDeps): void;

package/dist/plugin-http-mounts.js

@@ -0,0 +1,94 @@
+const RESERVED = ['/api', '/mcp', '/health', '/uploads', '/.well-known', '/assets'];
+const DEFAULT_METHODS = new Set(['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'PATCH']);
+export function collectHttpMounts(hooks) {
+    const out = [];
+    const owner = new Map();
+    for (const [pluginId, h] of Object.entries(hooks)) {
+        for (const mount of h.http ?? []) {
+            const prefix = mount.prefix.replace(/\/+$/, '');
+            if (!prefix.startsWith('/') || prefix === '') {
+                throw new Error(`[plugin-http] ${pluginId}: prefix must be absolute, got '${mount.prefix}'`);
+            }
+            if (RESERVED.some((r) => prefix === r || prefix.startsWith(r + '/'))) {
+                throw new Error(`[plugin-http] ${pluginId}: prefix '${prefix}' is reserved for the core`);
+            }
+            const other = owner.get(prefix);
+            if (other)
+                throw new Error(`[plugin-http] prefix '${prefix}' is declared by both ${other} and ${pluginId}`);
+            owner.set(prefix, pluginId);
+            out.push({ pluginId, mount: { ...mount, prefix, methods: mount.methods.map((m) => m.toUpperCase()) } });
+        }
+    }
+    return out;
+}
+export function customMethodsOf(entries) {
+    const seen = new Set();
+    for (const e of entries)
+        for (const m of e.mount.methods)
+            if (!DEFAULT_METHODS.has(m))
+                seen.add(m);
+    return [...seen];
+}
+export function registerTextBodyParsers(app) {
+    const asText = (_req, body, done) => done(null, body);
+    for (const type of ['text/calendar', 'text/xml', 'application/xml', 'text/plain', 'application/octet-stream']) {
+        if (!app.hasContentTypeParser(type))
+            app.addContentTypeParser(type, { parseAs: 'string' }, asText);
+    }
+}
+function flatHeaders(raw) {
+    const out = {};
+    for (const [k, v] of Object.entries(raw)) {
+        if (v === undefined)
+            continue;
+        out[k.toLowerCase()] = Array.isArray(v) ? v.join(', ') : String(v);
+    }
+    return out;
+}
+export function registerPluginHttpMounts(app, entries, deps) {
+    for (const method of customMethodsOf(entries))
+        app.addHttpMethod(method, { hasBody: true });
+    for (const { pluginId, mount } of entries) {
+        const allow = mount.methods.join(', ');
+        const handler = async (req, reply) => {
+            if ((await deps.disabledSet()).has(pluginId))
+                return reply.code(404).send({ error: 'not_found' });
+            if (!mount.methods.includes(req.method.toUpperCase())) {
+                return reply.code(405).header('allow', allow).send();
+            }
+            const user = req.user ?? (await deps.resolveUser(req));
+            if (!user) {
+                if (mount.auth === 'token')
+                    reply.header('www-authenticate', 'Basic realm="Coffer"');
+                return reply.code(401).send({ error: 'unauthorized' });
+            }
+            if (mount.auth === 'admin' && user.role !== 'admin')
+                return reply.code(403).send({ error: 'forbidden' });
+            const full = req.url.split('?')[0];
+            const below = full.slice(mount.prefix.length);
+            const body = mount.body === 'none' ? '' : typeof req.body === 'string' ? req.body : req.body ? JSON.stringify(req.body) : '';
+            const res = await mount.handle({
+                method: req.method.toUpperCase(),
+                path: below === '' ? '/' : below,
+                url: req.url,
+                headers: flatHeaders(req.headers),
+                body,
+                user: { id: user.id, login: user.login, role: user.role },
+            });
+            reply.code(res.status);
+            for (const [k, v] of Object.entries(res.headers ?? {}))
+                reply.header(k, v);
+            return reply.send(res.body ?? '');
+        };
+        const verbs = [...new Set([...mount.methods, ...DEFAULT_METHODS])];
+        app.route({ method: verbs, url: mount.prefix, handler });
+        app.route({ method: verbs, url: `${mount.prefix}/*`, handler });
+        if (mount.wellKnown) {
+            app.route({
+                method: verbs,
+                url: `/.well-known/${mount.wellKnown}`,
+                handler: async (_req, reply) => reply.code(301).header('location', `${mount.prefix}/`).send(),
+            });
+        }
+    }
+}

package/dist/plugin-runtime.js

@@ -13,7 +13,7 @@ import { migrateEmbeddingVectorsToBlob } from "./embeddings.js";
 import { ensureSearchTable } from "./search-index.js";
 import { startScheduler, stopScheduler } from "./background-scheduler.js";
 import { startSearchIndexer, indexSearchOnce } from "./search-indexer.js";
-import { startOrchestrator, stopOrchestrator, orchestratorStartersTask } from "./orchestrator/index.js";
+import { startOrchestrator, stopOrchestrator, orchestratorStartersTask, linkCodePruneTask, } from "./orchestrator/index.js";
 import { SYSTEM_SETTINGS_ID, SYSTEM_SETTINGS } from "./system-settings.js";
 const log = getLogger('plugins');
 let stopSearchIndexer;
@@ -110,7 +110,7 @@ export async function initPlugins() {
     Object.assign(pluginHooks, await loadServerHooks());
     await runSeeds({ em: getEm().fork(), plugins: reg.order, hooks: pluginHooks });
     startOrchestrator();
-    const bgTasks = [orchestratorStartersTask];
+    const bgTasks = [orchestratorStartersTask, linkCodePruneTask];
     for (const p of reg.order) {
         const h = pluginHooks[p.id];
         try {

package/dist/records-api.js

@@ -1,3 +1,5 @@
+import { isJsonArrayStored } from '@coffer-org/sdk/fields';
+import { raw } from '@mikro-orm/core';
 import { fieldMap, textSearchKeys, titleKey, recordTitle, listKeys, storageColumnsFor, magnitudeSub, resolveColumnKey, } from '@coffer-org/sdk/shelf';
 import { tokenize, matchScoreFolded, foldText } from '@coffer-org/sdk/search';
 import { getActiveRegistry, getShelf, getExtendsFor } from "./registry-context.js";
@@ -97,7 +99,7 @@ function resolveFilterKey(m, fm, k) {
     const direct = fm[k];
     if (direct) {
         if (!direct.columns)
-            return { column: k, type: direct.column };
+            return { column: k, type: direct.column, json: isJsonArrayStored(direct) };
         const sub = magnitudeSub(direct);
         if (sub === undefined)
             throw new FilterError(`${m.library}/${m.shelf}: '${k}' is a composite with no stored part — it owns no column to filter on`);
@@ -110,14 +112,24 @@ function resolveFilterKey(m, fm, k) {
         throw new FilterError(`${m.library}/${m.shelf}: '${k}' names no part of composite '${owner.key}' (parts: ${Object.keys(owner.field.columns).join(', ')})`);
     return { column: k, type: owner.field.columns[owner.sub] };
 }
+function jsonMemberClause(column, value) {
+    const col = `"${column.replace(/"/g, '""')}"`;
+    return {
+        [raw(`(json_valid(${col}) AND EXISTS (SELECT 1 FROM json_each(${col}) WHERE CAST(value AS TEXT) = ?))`, [value])]: 1,
+    };
+}
 function buildWhere(m, filterParams) {
-    const where = {};
+    let where = {};
     const fm = fieldMap(m.fields);
     for (const [k, v] of Object.entries(filterParams)) {
         if (k === 'id' || v === undefined)
             continue;
         const target = resolveFilterKey(m, fm, k);
-        if (target)
+        if (!target)
+            continue;
+        if (target.json)
+            where = { ...where, ...jsonMemberClause(target.column, String(v)) };
+        else
             where[target.column] = coerceFilter(String(v), target.type);
     }
     if (filterParams['id']) {

package/dist/system-settings.js

@@ -20,7 +20,6 @@ export const SYSTEM_SETTINGS = defineSettings({
             ],
         }),
         agent_id: field.string({ label: 'core.settings.agent_id', strict: true, noSearch: true }),
-        access_password: field.password({ label: 'core.settings.access_password' }),
         trigger_prefix: field.string({ label: 'core.settings.trigger_prefix' }),
         reply_window: field.int({ label: 'core.settings.reply_window', default: 1800 }),
     },

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;