@coffer-org/server 2.6.1 → 3.0.0

package/dist/auth-api.js

@@ -75,9 +75,18 @@ export async function registerAuthApi(app) {
             return reply.code(409).send({ error: 'already_setup' });
         const body = (req.body ?? {});
         if (!body.login || !body.password || !body.displayName) {
-            return reply.code(422).send({ issues: [{ field: !body.login ? 'login' : !body.password ? 'password' : 'displayName', code: 'required' }] });
+            return reply
+                .code(422)
+                .send({
+                issues: [{ field: !body.login ? 'login' : !body.password ? 'password' : 'displayName', code: 'required' }],
+            });
         }
-        const user = await createUser({ login: body.login, password: body.password, displayName: body.displayName, role: 'admin' });
+        const user = await createUser({
+            login: body.login,
+            password: body.password,
+            displayName: body.displayName,
+            role: 'admin',
+        });
         const { raw } = await createSession(user.id, SESSION_TTL_MS);
         setCookie(reply, raw, SESSION_TTL_MS / 1000);
         return publicUser(user);
@@ -129,7 +138,12 @@ export async function registerAuthApi(app) {
         if (!body.login || !body.password || !body.displayName || (body.role !== 'admin' && body.role !== 'member')) {
             return reply.code(422).send({ issues: [{ field: 'login', code: 'required' }] });
         }
-        const user = await createUser({ login: body.login, password: body.password, displayName: body.displayName, role: body.role });
+        const user = await createUser({
+            login: body.login,
+            password: body.password,
+            displayName: body.displayName,
+            role: body.role,
+        });
         return publicUser(user);
     });
     app.patch('/api/auth/users/:id', async (req, reply) => {

package/dist/auth-store.js

@@ -1,7 +1,13 @@
 import { getEm } from "./db.js";
 import { hashPassword, generateToken, hashToken } from "./auth-crypto.js";
 function toAuthUser(row) {
-    return { id: row.id, login: row.login, displayName: row.display_name, role: row.role, disabled: Boolean(row.disabled) };
+    return {
+        id: row.id,
+        login: row.login,
+        displayName: row.display_name,
+        role: row.role,
+        disabled: Boolean(row.disabled),
+    };
 }
 export async function countUsers() {
     const em = getEm().fork();

package/dist/background-scheduler.js

@@ -22,7 +22,10 @@ export function makeScheduler(opts = {}) {
     function arm(cb, ms) {
         if (stopped)
             return;
-        const h = setTimer(() => { timers.delete(h); cb(); }, ms);
+        const h = setTimer(() => {
+            timers.delete(h);
+            cb();
+        }, ms);
         timers.add(h);
     }
     function enqueue(task) {
@@ -51,7 +54,11 @@ export function makeScheduler(opts = {}) {
         const timeoutMs = task.timeoutMs ?? defaultTimeoutMs;
         let to;
         const timeout = new Promise((resolve) => {
-            to = setTimer(() => { timers.delete(to); log.warn(`${task.name}: timed out after ${timeoutMs}ms`); resolve(); }, timeoutMs);
+            to = setTimer(() => {
+                timers.delete(to);
+                log.warn(`${task.name}: timed out after ${timeoutMs}ms`);
+                resolve();
+            }, timeoutMs);
             timers.add(to);
         });
         try {
@@ -62,7 +69,10 @@ export function makeScheduler(opts = {}) {
             catch (e) {
                 runPromise = Promise.reject(e);
             }
-            await Promise.race([runPromise.catch((e) => log.warn(`${task.name}: ${e.message}`)), timeout]);
+            await Promise.race([
+                runPromise.catch((e) => log.warn(`${task.name}: ${e.message}`)),
+                timeout,
+            ]);
         }
         finally {
             clearTimer(to);
@@ -70,13 +80,17 @@ export function makeScheduler(opts = {}) {
         }
     }
     return {
-        register(task) { tasks.push(task); },
+        register(task) {
+            tasks.push(task);
+        },
         start() {
             if (started || stopped)
                 return;
             started = true;
-            arm(() => { for (const t of tasks)
-                enqueue(t); }, startupDelayMs);
+            arm(() => {
+                for (const t of tasks)
+                    enqueue(t);
+            }, startupDelayMs);
         },
         stop() {
             stopped = true;

package/dist/collection-io.js

@@ -47,14 +47,17 @@ export async function writeAt(tx, prefix, fields, parentId, collections) {
             await deleteAt(tx, table, childFields, ex.id);
         await tx.nativeDelete(table, { parent_id: parentId });
         const sKeys = scalarKeys(childFields);
-        const jsonKeys = new Set(fieldEntries(childFields).filter(([, fm]) => isJsonStored(fm)).map(([k]) => k));
+        const jsonKeys = new Set(fieldEntries(childFields)
+            .filter(([, fm]) => isJsonStored(fm))
+            .map(([k]) => k));
         let position = 0;
         for (const r of rows) {
             const flatR = flattenEmbeddedAt(childFields, r);
             const picked = {};
             for (const k of sKeys)
                 if (flatR[k] !== undefined)
-                    picked[k] = jsonKeys.has(k) && flatR[k] !== null && typeof flatR[k] === 'object' ? JSON.stringify(flatR[k]) : flatR[k];
+                    picked[k] =
+                        jsonKeys.has(k) && flatR[k] !== null && typeof flatR[k] === 'object' ? JSON.stringify(flatR[k]) : flatR[k];
             const child = tx.create(table, { parent_id: parentId, position, ...picked });
             await tx.flush();
             const childId = child.id;

package/dist/embed-openai.js

@@ -29,7 +29,8 @@ function parseErrorBody(body) {
 }
 function classifyEmbeddingFailure(status, code, detail) {
     const marker = `${code ?? ''} ${detail ?? ''}`.toLowerCase();
-    if (status === 402 || /insufficient_quota|billing|payment_required|payment required|hard.?limit|quota exceeded/.test(marker))
+    if (status === 402 ||
+        /insufficient_quota|billing|payment_required|payment required|hard.?limit|quota exceeded/.test(marker))
         return 'billing';
     if (status === 401 || status === 403)
         return 'auth';

package/dist/embeddings.js

@@ -12,7 +12,10 @@ async function loadCache() {
     const em = getEm().fork();
     const rows = (await em.find('_Embedding', {}));
     cache = rows.map((r) => ({
-        shelfKey: r.shelf_key, recordId: r.record_id, snippet: r.snippet, full: decodeVector(r.vector),
+        shelfKey: r.shelf_key,
+        recordId: r.record_id,
+        snippet: r.snippet,
+        full: decodeVector(r.vector),
     }));
     return cache;
 }
@@ -30,7 +33,9 @@ export async function migrateEmbeddingVectorsToBlob() {
     const em = getEm().fork();
     if (dialectOf(em) !== 'sqlite')
         return 0;
-    const [{ n }] = (await em.getConnection().execute("SELECT count(*) AS n FROM _embeddings WHERE typeof(vector) = 'text'"));
+    const [{ n }] = (await em
+        .getConnection()
+        .execute("SELECT count(*) AS n FROM _embeddings WHERE typeof(vector) = 'text'"));
     if (n === 0)
         return 0;
     const rows = (await em.find('_Embedding', {}));
@@ -105,6 +110,9 @@ export async function searchEmbeddings(queryVec, k, opts = {}) {
 }
 export async function listEventsSince(lastId, limit) {
     const em = getEm().fork();
-    const rows = (await em.find('_Event', { id: { $gt: lastId } }, { orderBy: { id: 'ASC' }, limit }));
+    const rows = (await em.find('_Event', { id: { $gt: lastId } }, {
+        orderBy: { id: 'ASC' },
+        limit,
+    }));
     return rows;
 }

package/dist/entity-schema.d.ts

@@ -18,6 +18,7 @@ export declare const EmbeddingSchema: EntitySchema<any, never, import("@mikro-or
 export declare const PluginStateSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const RecordActivitySchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const ThreadMessageSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
+export declare const ThreadStateSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare function buildPluginEntities(plugins: PluginManifest[]): EntitySchema[];
 export declare const MsgLogSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const UserSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;

package/dist/entity-schema.js

@@ -180,6 +180,17 @@ export const ThreadMessageSchema = new EntitySchema({
         reply_to_id: { type: 'text', nullable: true },
     },
 });
+export const ThreadStateSchema = new EntitySchema({
+    name: '_ThreadState',
+    tableName: '_thread_state',
+    properties: {
+        connector: { type: 'text', primary: true },
+        chat_id: { type: 'text', primary: true },
+        agent_id: { type: 'text', nullable: true },
+        preset_id: { type: 'text', nullable: true },
+        updated_at: { type: 'text' },
+    },
+});
 export function buildPluginEntities(plugins) {
     return plugins.flatMap((p) => [
         ...(p.libraries ?? []).flatMap((v) => v.shelves.flatMap((m) => [buildEntitySchema(m), ...buildCollectionEntities(m)])),
@@ -202,6 +213,8 @@ export const MsgLogSchema = new EntitySchema({
         tokens_in: { type: 'integer', nullable: true },
         tokens_out: { type: 'integer', nullable: true },
         ms: { type: 'integer', nullable: true },
+        agent_id: { type: 'text', nullable: true },
+        preset_id: { type: 'text', nullable: true },
     },
 });
 export const UserSchema = new EntitySchema({
@@ -280,9 +293,20 @@ export const OAuthTokenSchema = new EntitySchema({
     },
 });
 export const systemEntities = [
-    EventSchema, PluginRowSchema, MigrationRowSchema, SeedRowSchema,
-    EmbeddingSchema, PluginStateSchema, RecordActivitySchema, MsgLogSchema,
-    UserSchema, SessionSchema, ApiTokenSchema,
-    OAuthClientSchema, OAuthCodeSchema, OAuthTokenSchema,
+    EventSchema,
+    PluginRowSchema,
+    MigrationRowSchema,
+    SeedRowSchema,
+    EmbeddingSchema,
+    PluginStateSchema,
+    RecordActivitySchema,
+    MsgLogSchema,
+    UserSchema,
+    SessionSchema,
+    ApiTokenSchema,
+    OAuthClientSchema,
+    OAuthCodeSchema,
+    OAuthTokenSchema,
     ThreadMessageSchema,
+    ThreadStateSchema,
 ];

package/dist/extend-io.js

@@ -2,6 +2,7 @@ import { getExtendsFor } from "./registry-context.js";
 import { buildExtendZodPartial } from '@coffer-org/sdk/extend';
 import { upsertExtendRecord, deleteExtendRecord, getExtendRecord } from "./extend-table.js";
 import { toIssue, ValidationError } from "./mutate.js";
+import { normalizeFileFieldsAt } from "./file-fields.js";
 export function splitBody(body) {
     const raw = (body ?? {});
     const base = {};
@@ -48,7 +49,11 @@ export async function saveExtends(em, library, shelf, baseId, extData) {
             continue;
         const parsed = buildExtendZodPartial(e).safeParse(data);
         if (parsed.success && Object.keys(parsed.data).length > 0) {
-            await upsertExtendRecord(em, e, baseId, parsed.data);
+            const row = parsed.data;
+            const fileIssues = normalizeFileFieldsAt(e.fields, row);
+            if (fileIssues.length)
+                throw new ValidationError(fileIssues);
+            await upsertExtendRecord(em, e, baseId, row);
         }
     }
 }

package/dist/extend-table.js

@@ -1,5 +1,7 @@
 import { getEm } from "./db.js";
-import { splitAt, writeAt, readAt, readAtMany, deleteAt } from "./collection-io.js";
+import { splitAt, writeAt, readAt, readAtMany, deleteAt, flattenEmbeddedAt, nestEmbeddedAt } from "./collection-io.js";
+import { encodeJsonAt } from "./mutate.js";
+import { encodeTemporalAt, decodeTemporalAt } from "./temporal.js";
 import { chunk } from "./batch.js";
 import { selectRows } from "./read-rows.js";
 export function extendEntityName(e) {
@@ -11,8 +13,9 @@ export async function getExtendRecord(e, baseId, em) {
     const [flat] = (await selectRows(fork, name, { base_id: baseId }, { limit: 1 }));
     if (!flat)
         return undefined;
+    const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
     const collections = await readAt(fork, name, e.fields, baseId);
-    return { ...flat, ...collections };
+    return { ...decoded, ...collections };
 }
 export async function getExtendRecords(e, baseIds, em) {
     const out = new Map();
@@ -30,14 +33,16 @@ export async function getExtendRecords(e, baseIds, em) {
     const collectionsById = await readAtMany(fork, name, e.fields, presentIds);
     for (const flat of flats) {
         const id = Number(flat.base_id);
-        out.set(id, { ...flat, ...(collectionsById.get(id) ?? {}) });
+        const decoded = nestEmbeddedAt(e.fields, decodeTemporalAt(e.fields, flat));
+        out.set(id, { ...decoded, ...(collectionsById.get(id) ?? {}) });
     }
     return out;
 }
 export async function upsertExtendRecord(em, e, baseId, data) {
     const name = extendEntityName(e);
     const { base, collections } = splitAt(e.fields, data);
-    await em.upsert(name, { base_id: baseId, ...base });
+    const flat = encodeJsonAt(e.fields, encodeTemporalAt(e.fields, flattenEmbeddedAt(e.fields, base)));
+    await em.upsert(name, { base_id: baseId, ...flat });
     await writeAt(em, name, e.fields, baseId, collections);
 }
 export async function deleteExtendRecord(em, e, baseId) {

package/dist/file-fields.d.ts

@@ -1,6 +1,8 @@
 import type { ShelfDef } from '@coffer-org/sdk/shelf';
+import type { LayoutEl } from '@coffer-org/sdk/fields';
 import type { ValidationIssue } from './mutate.ts';
 export declare function mimeForName(name: string): string | undefined;
 export declare function touchesFileFields(m: ShelfDef, input: unknown): boolean;
 export declare function dropUnchangedFileFields(m: ShelfDef, input: Record<string, unknown>, stored: Record<string, unknown>): Record<string, unknown>;
+export declare function normalizeFileFieldsAt(fields: LayoutEl[], data: Record<string, unknown>): ValidationIssue[];
 export declare function normalizeFileFields(m: ShelfDef, data: Record<string, unknown>): ValidationIssue[];

package/dist/file-fields.js

@@ -1,6 +1,6 @@
 import { statSync } from 'node:fs';
 import { join } from 'node:path';
-import { fieldEntries } from '@coffer-org/sdk/shelf';
+import { fieldEntries, collectionGroups } from '@coffer-org/sdk/shelf';
 import { jsonValue } from '@coffer-org/sdk/fields';
 import { uploadsDir } from "./uploads.js";
 const MIME_BY_EXT = {
@@ -87,9 +87,9 @@ export function dropUnchangedFileFields(m, input, stored) {
     }
     return out ?? input;
 }
-export function normalizeFileFields(m, data) {
+function normalizeLevel(fields, data, path) {
     const issues = [];
-    for (const [key, f] of fieldEntries(m.fields)) {
+    for (const [key, f] of fieldEntries(fields)) {
         if (f.prim !== 'file')
             continue;
         if (!(key in data))
@@ -101,21 +101,40 @@ export function normalizeFileFields(m, data) {
         const isArray = Array.isArray(parsed);
         const items = (isArray ? parsed : [parsed]);
         const out = [];
+        let failed = false;
         for (const it of items) {
             if (typeof it !== 'object' || it === null || typeof it.name !== 'string') {
-                issues.push({ field: key, code: 'file_not_uploaded', path: [key] });
+                issues.push({ field: key, code: 'file_not_uploaded', path: [...path, key] });
+                failed = true;
                 continue;
             }
             const resolved = resolveEntry(it);
             if (!resolved) {
-                issues.push({ field: key, code: 'file_not_uploaded', params: { name: it.name }, path: [key] });
+                issues.push({ field: key, code: 'file_not_uploaded', params: { name: it.name }, path: [...path, key] });
+                failed = true;
                 continue;
             }
             out.push(resolved);
         }
-        if (issues.length)
+        if (failed)
             continue;
         data[key] = isArray ? out : out[0];
     }
+    for (const c of collectionGroups(fields)) {
+        const rows = data[c.key];
+        if (!Array.isArray(rows))
+            continue;
+        rows.forEach((row, i) => {
+            if (typeof row !== 'object' || row === null)
+                return;
+            issues.push(...normalizeLevel(c.group.fields, row, [...path, c.key, i]));
+        });
+    }
     return issues;
 }
+export function normalizeFileFieldsAt(fields, data) {
+    return normalizeLevel(fields, data, []);
+}
+export function normalizeFileFields(m, data) {
+    return normalizeFileFieldsAt(m.fields, data);
+}

package/dist/index.js

@@ -546,7 +546,10 @@ app.patch('/api/:library/:shelf/:id', (req, reply) => guard(reply, async () => {
                 const bk = `_extend_${def.id}`;
                 const sub = body[bk];
                 if (sub && typeof sub === 'object') {
-                    body = { ...body, [bk]: preserveTree(def.fields, sub, (exRecs[def.id] ?? {})) };
+                    body = {
+                        ...body,
+                        [bk]: preserveTree(def.fields, sub, (exRecs[def.id] ?? {})),
+                    };
                 }
             }
         }

package/dist/mcp-http.test-helpers.js

@@ -13,7 +13,10 @@ export async function freshMcpApp(opts = {}) {
     await orm.schema.update({ safe: false, dropTables: false });
     const app = Fastify();
     app.addHook('onRequest', async (req, reply) => {
-        const gated = req.url.startsWith('/api/') || req.url.startsWith('/uploads/') || req.url === '/mcp' || req.url.startsWith('/mcp?');
+        const gated = req.url.startsWith('/api/') ||
+            req.url.startsWith('/uploads/') ||
+            req.url === '/mcp' ||
+            req.url.startsWith('/mcp?');
         if (!gated)
             return;
         if (PUBLIC_API_PATHS.some((p) => req.url.startsWith(p)))

package/dist/mcp-tools.js

@@ -39,7 +39,7 @@ const fail = (text) => ({ content: [{ type: 'text', text }], isError: true });
 export async function resolveRagDeps() {
     const db = (await getPluginSettings('claude-agent'));
     const enabled = db['rag_enabled'] !== false;
-    const embeddingApiKey = (process.env.OPENAI_API_KEY ?? db['openai_api_key'] ?? '');
+    const embeddingApiKey = process.env.OPENAI_API_KEY ?? db['openai_api_key'] ?? '';
     if (!enabled || !embeddingApiKey)
         return null;
     return { embeddingApiKey };
@@ -81,7 +81,7 @@ export async function collectMcpTools(opts = {}) {
                     how_to: `curl -H "Authorization: Bearer <token>" -F "file=@<path>" ${uploadUrl}  →  {"name":"<name>"}. Then set a file field to {"name":"<name>"}. mime/size are filled in by the server — do not send your own.` +
                         (base
                             ? ''
-                            : ' The server has no public URL configured (core settings publicUrl / PUBLIC_URL env), so the path is relative — resolve it against this MCP server\'s own origin.'),
+                            : " The server has no public URL configured (core settings publicUrl / PUBLIC_URL env), so the path is relative — resolve it against this MCP server's own origin."),
                 });
             },
         });
@@ -328,9 +328,7 @@ export async function buildDomainSections() {
     const singles = collectSingleShelves();
     const singleSection = singles.length
         ? '## Single-record shelves (one document each — read the record, do not search the shelf)\n\n' +
-            singles
-                .map((s) => `- ${s.library}/${s.shelf}: ${s.claude.replace(/\s*\n\s*/g, ' ')}`)
-                .join('\n')
+            singles.map((s) => `- ${s.library}/${s.shelf}: ${s.claude.replace(/\s*\n\s*/g, ' ')}`).join('\n')
         : null;
     const dataModel = '## Data model\n' +
         'Library (top-level area) → shelf (a kind of record, e.g. things/item) → record (addressed library/shelf/id) → fields. ' +

package/dist/msg-log.d.ts

@@ -7,6 +7,8 @@ export interface MsgLogRow {
     tokensIn: number | null;
     tokensOut: number | null;
     ms: number | null;
+    agentId: string | null;
+    presetId: string | null;
 }
 export interface MsgLogDiagnosticRow {
     id: number;

package/dist/msg-log.js

@@ -1,11 +1,29 @@
 import { getEm } from "./db.js";
 export async function logMessage(row) {
-    await getEm().fork().getConnection().execute(`INSERT INTO _orch_msg_log (ts, connector, chat_id, user_id, role, text, tokens_in, tokens_out, ms)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [new Date().toISOString(), row.connector, row.chatId, row.userId, row.role, row.text, row.tokensIn, row.tokensOut, row.ms]);
+    await getEm()
+        .fork()
+        .getConnection()
+        .execute(`INSERT INTO _orch_msg_log (ts, connector, chat_id, user_id, role, text, tokens_in, tokens_out, ms, agent_id, preset_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        new Date().toISOString(),
+        row.connector,
+        row.chatId,
+        row.userId,
+        row.role,
+        row.text,
+        row.tokensIn,
+        row.tokensOut,
+        row.ms,
+        row.agentId,
+        row.presetId,
+    ]);
 }
 export async function listRecentMessageMetrics(limit = 25) {
     const bounded = Math.max(1, Math.min(100, Math.trunc(limit)));
-    const rows = (await getEm().fork().getConnection().execute(`SELECT id, ts, connector, role, tokens_in, tokens_out, ms
+    const rows = (await getEm()
+        .fork()
+        .getConnection()
+        .execute(`SELECT id, ts, connector, role, tokens_in, tokens_out, ms
        FROM _orch_msg_log
       ORDER BY id DESC
       LIMIT ?`, [bounded]));

package/dist/mutate.d.ts

@@ -1,7 +1,9 @@
 import type { EntityManager } from '@mikro-orm/core';
 import type { ShelfDef } from '@coffer-org/sdk/shelf';
+import type { LayoutEl } from '@coffer-org/sdk/fields';
 import { z } from 'zod';
-export declare function encodeJson(m: ShelfDef, data: Record<string, unknown>): Record<string, unknown>;
+export declare function encodeJsonAt(fields: LayoutEl[], data: Record<string, unknown>): Record<string, unknown>;
+export declare const encodeJson: (m: ShelfDef, data: Record<string, unknown>) => Record<string, unknown>;
 export interface MutateCtx {
     actor: string;
 }

package/dist/mutate.js

@@ -2,6 +2,7 @@ import { serialize } from '@mikro-orm/core';
 import { buildZodObject, buildZodObjectPartial, fieldEntries } from '@coffer-org/sdk/shelf';
 import { isJsonStored, decodeVmsg } from '@coffer-org/sdk/fields';
 import { resolveFlag } from '@coffer-org/sdk/condition';
+import { applyDerived } from '@coffer-org/sdk/derive';
 import { getEm } from "./db.js";
 import { selectRows } from "./read-rows.js";
 import { normalizeFileFields, dropUnchangedFileFields, touchesFileFields } from "./file-fields.js";
@@ -11,15 +12,16 @@ import { splitCollections, writeCollections, deleteCollections, flattenEmbedded,
 function nowIso() {
     return new Date().toISOString();
 }
-export function encodeJson(m, data) {
+export function encodeJsonAt(fields, data) {
     const out = { ...data };
-    for (const [k, f] of fieldEntries(m.fields)) {
+    for (const [k, f] of fieldEntries(fields)) {
         if (isJsonStored(f) && out[k] !== null && out[k] !== undefined && typeof out[k] === 'object') {
             out[k] = JSON.stringify(out[k]);
         }
     }
     return out;
 }
+export const encodeJson = (m, data) => encodeJsonAt(m.fields, data);
 export class ValidationError extends Error {
     issues;
     constructor(issues) {
@@ -86,6 +88,11 @@ export async function createRecord(m, entityName, input, ctx, afterBase) {
         await tx.flush();
         id = entity.id;
         await writeCollections(tx, m, id, collections);
+        const derived = applyDerived(m.fields, { ...parsedData, id });
+        if (Object.keys(derived).length) {
+            await tx.nativeUpdate(entityName, { id }, encodeJson(m, encodeTemporal(m, flattenEmbedded(m, derived))));
+            Object.assign(parsedData, derived);
+        }
         const _extends = afterBase ? await afterBase(tx, id) : undefined;
         writeEvent(tx, ctx.actor, 'create', `${m.library}/${m.shelf}`, id, null, {
             ...parsedData,
@@ -119,10 +126,11 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
         const existingFlat = decodeTemporal(m, serialize(found));
         const existing = nestEmbedded(m, existingFlat);
         const ts = nowIso();
-        const { base, collections } = splitCollections(m, { ...parsed.data });
-        const fileIssues = normalizeFileFields(m, base);
+        const patchData = parsed.data;
+        const fileIssues = normalizeFileFields(m, patchData);
         if (fileIssues.length)
             throw new ValidationError(fileIssues);
+        const { base, collections } = splitCollections(m, { ...patchData });
         const merged = { ...existing, ...base };
         const reqIssues = [];
         for (const [key, f] of fieldEntries(m.fields)) {
@@ -142,6 +150,11 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
         await tx.upsert(entityName, dbRow);
         await writeCollections(tx, m, id, collections);
         const allCollections = await readCollections(tx, m, id);
+        const derived = applyDerived(m.fields, { ...merged, ...allCollections });
+        if (Object.keys(derived).length) {
+            await tx.nativeUpdate(entityName, { id }, encodeJson(m, encodeTemporal(m, flattenEmbedded(m, derived))));
+            Object.assign(merged, derived);
+        }
         const _extends = afterBase ? await afterBase(tx, id) : undefined;
         const after = { ...merged, ...allCollections, updated_at: ts, ...(_extends ? { _extends } : {}) };
         writeEvent(tx, ctx.actor, 'update', `${m.library}/${m.shelf}`, id, existing, after);

package/dist/oauth-api.js

@@ -3,10 +3,7 @@ import { resolveRequestUser, startPasswordSession } from "./auth-api.js";
 import { baseUrl, mcpResource } from "./public-url.js";
 import { getLogger } from "./log.js";
 const log = getLogger('oauth');
-const DEFAULT_REDIRECT_ALLOW = [
-    'https://claude.ai/api/mcp/auth_callback',
-    'https://claude.com/api/mcp/auth_callback',
-];
+const DEFAULT_REDIRECT_ALLOW = ['https://claude.ai/api/mcp/auth_callback', 'https://claude.com/api/mcp/auth_callback'];
 function redirectAllowlist() {
     const extra = (process.env['OAUTH_REDIRECT_ALLOW'] ?? '')
         .split(',')
@@ -147,7 +144,10 @@ export function registerOAuthApi(app) {
                 .code(400)
                 .send({ error: 'invalid_redirect_uri', error_description: `redirect_uri not allowed: ${bad}` });
         }
-        const client = await registerClient({ clientName: body.client_name?.slice(0, 200) || 'MCP client', redirectUris: uris });
+        const client = await registerClient({
+            clientName: body.client_name?.slice(0, 200) || 'MCP client',
+            redirectUris: uris,
+        });
         log.info(`registered client ${client.clientId} (${client.clientName})`);
         return reply.code(201).send({
             client_id: client.clientId,
@@ -160,14 +160,23 @@ export function registerOAuthApi(app) {
     });
     async function validateAuthz(p) {
         if (!p.client_id || !p.redirect_uri) {
-            return { ok: false, html: page('Invalid request', '<h1>Invalid request</h1><p>Missing client_id or redirect_uri.</p>') };
+            return {
+                ok: false,
+                html: page('Invalid request', '<h1>Invalid request</h1><p>Missing client_id or redirect_uri.</p>'),
+            };
         }
         const client = await findClient(p.client_id);
         if (!client) {
-            return { ok: false, html: page('Unknown client', '<h1>Unknown client</h1><p>This application is not registered.</p>') };
+            return {
+                ok: false,
+                html: page('Unknown client', '<h1>Unknown client</h1><p>This application is not registered.</p>'),
+            };
         }
         if (!client.redirectUris.includes(p.redirect_uri)) {
-            return { ok: false, html: page('Invalid redirect', '<h1>Invalid redirect</h1><p>redirect_uri does not match this client.</p>') };
+            return {
+                ok: false,
+                html: page('Invalid redirect', '<h1>Invalid redirect</h1><p>redirect_uri does not match this client.</p>'),
+            };
         }
         return { ok: true, clientName: client.clientName };
     }
@@ -197,12 +206,18 @@ export function registerOAuthApi(app) {
                 return reply.code(429).type('text/html').send(page('Slow down', '<h1>Too many attempts</h1>'));
             const user = await startPasswordSession(reply, String(body['login'] ?? ''), String(body['password'] ?? ''));
             if (!user)
-                return reply.code(401).type('text/html').send(loginForm(p, check.clientName, 'Wrong login or password.'));
+                return reply
+                    .code(401)
+                    .type('text/html')
+                    .send(loginForm(p, check.clientName, 'Wrong login or password.'));
             return reply.type('text/html').send(consentForm(p, check.clientName, user));
         }
         const user = await resolveRequestUser(req);
         if (!user)
-            return reply.code(401).type('text/html').send(loginForm(p, check.clientName, 'Your session expired. Sign in again.'));
+            return reply
+                .code(401)
+                .type('text/html')
+                .send(loginForm(p, check.clientName, 'Your session expired. Sign in again.'));
         if (body['action'] !== 'approve')
             return redirectWithError(reply, p, 'access_denied');
         if (!p.code_challenge)

package/dist/plugin-i18n.d.ts

@@ -0,0 +1,6 @@
+export interface PluginI18n {
+    lang: string;
+    t(key: string, fallback?: string): string;
+}
+export declare function loadPluginI18n(localesDir: URL | string, fallbackLang?: string): Promise<PluginI18n>;
+export declare function clearPluginI18nCache(): void;

package/dist/plugin-i18n.js

@@ -0,0 +1,38 @@
+import { readFile } from 'node:fs/promises';
+const cache = new Map();
+async function systemLanguage(fallback) {
+    try {
+        const { getPluginSettings } = await import("./plugin-runtime.js");
+        return (await getPluginSettings('core'))['language'] || fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function loadPluginI18n(localesDir, fallbackLang = 'uk') {
+    const lang = await systemLanguage(fallbackLang);
+    const url = new URL(`${lang}.json`, localesDir);
+    let dict = cache.get(url.href);
+    if (!dict) {
+        try {
+            dict = JSON.parse(await readFile(url, 'utf8'));
+        }
+        catch {
+            dict = {};
+        }
+        cache.set(url.href, dict);
+    }
+    const loaded = dict;
+    return {
+        lang,
+        t(key, fallback) {
+            const value = key
+                .split('.')
+                .reduce((node, part) => (node == null ? undefined : node[part]), loaded);
+            return typeof value === 'string' ? value : (fallback ?? key);
+        },
+    };
+}
+export function clearPluginI18nCache() {
+    cache.clear();
+}

package/dist/rag-search.js

@@ -89,7 +89,6 @@ export async function hybridSearch(opts, deps = {}) {
             score: entry.score,
         };
     })
-        .sort((a, b) => b.score - a.score ||
-        hitKey(a.shelfKey, a.recordId).localeCompare(hitKey(b.shelfKey, b.recordId)))
+        .sort((a, b) => b.score - a.score || hitKey(a.shelfKey, a.recordId).localeCompare(hitKey(b.shelfKey, b.recordId)))
         .slice(0, opts.k);
 }

package/dist/recompute-derived.d.ts

@@ -0,0 +1,6 @@
+import type { ShelfDef } from '@coffer-org/sdk/shelf';
+export interface RecomputeResult {
+    scanned: number;
+    changed: number;
+}
+export declare function recomputeDerivedFields(m: ShelfDef, entityName: string): Promise<RecomputeResult>;

package/dist/recompute-derived.js

@@ -0,0 +1,40 @@
+import { derivedEntries, applyDerived } from '@coffer-org/sdk/derive';
+import { getEm } from "./db.js";
+import { selectRows } from "./read-rows.js";
+import { encodeJson } from "./mutate.js";
+import { encodeTemporal, decodeTemporal } from "./temporal.js";
+import { flattenEmbedded, nestEmbedded, readCollections } from "./collection-io.js";
+function sameValue(a, b) {
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() === b.getTime();
+    if (a instanceof Date || b instanceof Date)
+        return false;
+    return a === b;
+}
+export async function recomputeDerivedFields(m, entityName) {
+    if (derivedEntries(m.fields).length === 0)
+        return { scanned: 0, changed: 0 };
+    const fork = getEm().fork();
+    const rows = await selectRows(fork, entityName, {}, { orderBy: { id: 'asc' } });
+    let changed = 0;
+    for (const row of rows) {
+        const id = row['id'];
+        const flat = decodeTemporal(m, row);
+        const nested = nestEmbedded(m, flat);
+        const collections = await readCollections(fork, m, id);
+        const derived = applyDerived(m.fields, { ...nested, ...collections });
+        if (Object.keys(derived).length === 0)
+            continue;
+        const encoded = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, derived)));
+        const dirty = {};
+        for (const [k, v] of Object.entries(encoded)) {
+            if (!sameValue(row[k], v))
+                dirty[k] = v;
+        }
+        if (Object.keys(dirty).length === 0)
+            continue;
+        await fork.nativeUpdate(entityName, { id }, dirty);
+        changed += 1;
+    }
+    return { scanned: rows.length, changed };
+}

package/dist/records-api.js

@@ -116,7 +116,9 @@ export async function recordCount(library, shelf, query = {}, opts = {}) {
         where.deleted_at = { $ne: null };
     if (m.standalone === false && Object.keys(filterParams).length === 0)
         return 0;
-    return getEm().fork().count(ename, where);
+    return getEm()
+        .fork()
+        .count(ename, where);
 }
 async function listRecords(library, shelf, query = {}, opts = {}) {
     const { view = 'full', extends: withExt = true, deleted = 'active' } = opts;

package/dist/search-index.js

@@ -57,11 +57,7 @@ export async function upsertSearchRow(shelf, recordId, folded) {
     await conn.execute('DELETE FROM "_search" WHERE shelf = ? AND record_id = ?', [shelf, recordId]);
     if (!folded)
         return;
-    await conn.execute('INSERT INTO "_search" (shelf, record_id, folded) VALUES (?, ?, ?)', [
-        shelf,
-        recordId,
-        folded,
-    ]);
+    await conn.execute('INSERT INTO "_search" (shelf, record_id, folded) VALUES (?, ?, ?)', [shelf, recordId, folded]);
 }
 export async function deleteSearchRow(shelf, recordId) {
     if (!ftsAvailable())
@@ -81,9 +77,7 @@ export async function ftsCandidates(tokens) {
         const rows = (await getEm()
             .fork()
             .getConnection()
-            .execute('SELECT shelf, record_id FROM "_search" WHERE "_search" MATCH ?', [
-            buildFtsMatchQuery(tokens),
-        ]));
+            .execute('SELECT shelf, record_id FROM "_search" WHERE "_search" MATCH ?', [buildFtsMatchQuery(tokens)]));
         for (const r of rows) {
             const list = out.get(r.shelf);
             if (list)

package/dist/temporal.d.ts

@@ -1,5 +1,8 @@
 import type { ShelfDef } from '@coffer-org/sdk/shelf';
+import type { LayoutEl } from '@coffer-org/sdk/fields';
 export declare function dtStringToDate(s: string): Date;
 export declare function dateToDtString(d: Date): string;
-export declare function encodeTemporal(m: ShelfDef, row: Record<string, unknown>): Record<string, unknown>;
-export declare function decodeTemporal(m: ShelfDef, row: Record<string, unknown>): Record<string, unknown>;
+export declare function encodeTemporalAt(fields: LayoutEl[], row: Record<string, unknown>): Record<string, unknown>;
+export declare function decodeTemporalAt(fields: LayoutEl[], row: Record<string, unknown>): Record<string, unknown>;
+export declare const encodeTemporal: (m: ShelfDef, row: Record<string, unknown>) => Record<string, unknown>;
+export declare const decodeTemporal: (m: ShelfDef, row: Record<string, unknown>) => Record<string, unknown>;

package/dist/temporal.js

@@ -7,22 +7,22 @@ export function dateToDtString(d) {
     return (`${d.getUTCFullYear()}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())}` +
         `T${p(d.getUTCHours())}:${p(d.getUTCMinutes())}`);
 }
-function datetimeKeys(m) {
-    const fm = fieldMap(m.fields);
+function datetimeKeysAt(fields) {
+    const fm = fieldMap(fields);
     return Object.keys(fm).filter((k) => fm[k]?.column === 'datetime');
 }
-export function encodeTemporal(m, row) {
+export function encodeTemporalAt(fields, row) {
     const out = { ...row };
-    for (const k of datetimeKeys(m)) {
+    for (const k of datetimeKeysAt(fields)) {
         const v = out[k];
         if (typeof v === 'string' && v)
             out[k] = dtStringToDate(v);
     }
     return out;
 }
-export function decodeTemporal(m, row) {
+export function decodeTemporalAt(fields, row) {
     const out = { ...row };
-    for (const k of datetimeKeys(m)) {
+    for (const k of datetimeKeysAt(fields)) {
         const v = out[k];
         if (v instanceof Date)
             out[k] = dateToDtString(v);
@@ -31,3 +31,5 @@ export function decodeTemporal(m, row) {
     }
     return out;
 }
+export const encodeTemporal = (m, row) => encodeTemporalAt(m.fields, row);
+export const decodeTemporal = (m, row) => decodeTemporalAt(m.fields, row);

package/dist/thread-state.d.ts

@@ -0,0 +1,8 @@
+export interface ThreadSelection {
+    agentId: string | null;
+    presetId: string | null;
+}
+export declare function getThreadState(connector: string, chatId: string): Promise<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 pruneThreadState(connector: string, cutoffIso: string): Promise<void>;

package/dist/thread-state.js

@@ -0,0 +1,39 @@
+import { getEm } from "./db.js";
+const EMPTY = { agentId: null, presetId: 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 };
+}
+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 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 }));
+    }
+    await em.flush();
+}
+export async function readAndTouchThreadState(connector, chatId) {
+    const em = getEm().fork();
+    const row = (await em.findOne('_ThreadState', { connector, chat_id: chatId }));
+    if (!row)
+        return { ...EMPTY };
+    em.assign(row, { updated_at: new Date().toISOString() });
+    await em.flush();
+    return { agentId: row.agent_id, presetId: row.preset_id };
+}
+export async function pruneThreadState(connector, cutoffIso) {
+    const em = getEm().fork();
+    await em.nativeDelete('_ThreadState', { connector, updated_at: { $lt: cutoffIso } });
+}

package/dist/thread-store.js

@@ -51,7 +51,9 @@ export async function listThreadMessages(connector, chatId, limit = 200) {
     const em = getEm().fork();
     const visible = (await em.find('_ThreadMessage', { connector, chat_id: chatId, role: { $ne: 'reasoning' } }, { orderBy: { ts: 'desc', msg_id: 'desc' }, limit }));
     const oldest = visible.at(-1)?.ts;
-    const reasoning = oldest === undefined ? [] : (await em.find('_ThreadMessage', { connector, chat_id: chatId, role: 'reasoning', ts: { $gte: oldest - 1 } }, { orderBy: { ts: 'desc', msg_id: 'desc' } }));
+    const reasoning = oldest === undefined
+        ? []
+        : (await em.find('_ThreadMessage', { connector, chat_id: chatId, role: 'reasoning', ts: { $gte: oldest - 1 } }, { orderBy: { ts: 'desc', msg_id: 'desc' } }));
     return [...visible, ...reasoning]
         .sort((a, b) => b.ts - a.ts || (a.msg_id < b.msg_id ? 1 : a.msg_id > b.msg_id ? -1 : 0))
         .reverse()

package/dist/uploads.js

@@ -28,7 +28,7 @@ export async function saveUploadBytes(bytes, opts = {}) {
     if (bytes.byteLength > maxBytes)
         throw new Error(`upload exceeds ${maxBytes} bytes`);
     const originalExt = opts.originalName ? extname(basename(opts.originalName)).toLowerCase() : '';
-    const ext = originalExt && /^[.][a-z0-9]{1,10}$/.test(originalExt) ? originalExt : MIME_EXT[opts.mime ?? ''] ?? '';
+    const ext = originalExt && /^[.][a-z0-9]{1,10}$/.test(originalExt) ? originalExt : (MIME_EXT[opts.mime ?? ''] ?? '');
     const name = `${randomUUID()}${ext}`;
     await writeFile(join(uploadsDir(), name), bytes);
     const mime = opts.mime === 'application/octet-stream' ? undefined : opts.mime;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/server",
-  "version": "2.6.1",
+  "version": "3.0.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -24,8 +24,8 @@
     "postpack": "node ../../scripts/swap-exports.mjs src"
   },
   "dependencies": {
-    "@coffer-org/core": "^2.1.4",
-    "@coffer-org/sdk": "^2.2.0",
+    "@coffer-org/core": "^3.0.0",
+    "@coffer-org/sdk": "^3.0.0",
     "@extractus/oembed-extractor": "^4.1.0",
     "@fastify/cors": "^11.2.0",
     "@fastify/multipart": "^10.0.0",