@coffer-org/server 3.3.0 → 4.0.0

package/dist/mutate.js

@@ -1,34 +1,70 @@
 import { serialize } from '@mikro-orm/core';
-import { buildZodObject, buildZodObjectPartial, fieldEntries } from '@coffer-org/sdk/shelf';
+import { buildZodObject, buildZodObjectPartial, fieldEntries, collectionGroups } 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";
 import { notifyRecordsChanged } from "./index-signal.js";
 import { encodeTemporal, decodeTemporal } from "./temporal.js";
-import { splitCollections, writeCollections, deleteCollections, flattenEmbedded, nestEmbedded, readCollections, } from "./collection-io.js";
-import { injectParts, applyStoredParts } from "./part-injection.js";
+import { splitCollections, writeCollections, deleteCollections, flattenEmbedded, flattenEmbeddedAt, nestEmbedded, readCollections, readCollectionsWithMeta, } from "./collection-io.js";
+import { stripClockKeysDeep, clockValuesOf } from "./cache-clock.js";
+import { refreshCachedUnits } from "./cache-refresh.js";
+import { hasStoredPartWork, newPartMemo } from "./part-injection.js";
+import { changedFields, runTriggers } from "./trigger-queue.js";
+import { getActiveRegistry } from "./registry-context.js";
+import { sameValue } from "./value-compare.js";
 const EMPTY_SETTINGS = {};
 const EMPTY_GLOBAL = {};
 function nowIso() {
     return new Date().toISOString();
 }
-function partCtx(m, record) {
+function partCtx(m, memo, now, em) {
     return {
-        record,
         settings: EMPTY_SETTINGS,
         global: EMPTY_GLOBAL,
         meta: { library: m.library, shelf: m.shelf },
+        ...(memo ? { memo } : {}),
+        ...(em ? { em } : {}),
+        ...(now !== undefined ? { now } : {}),
     };
 }
-async function mergeStoredParts(m, record) {
-    const computed = await applyStoredParts(m.fields, record, partCtx(m, record));
-    if (computed === record)
-        return false;
-    Object.assign(record, computed);
-    return true;
+async function driveTriggers(m, before, after, memo, now, em, opts = {}) {
+    const changed = changedFields(before, after, m.fields);
+    const graph = getActiveRegistry().mutateGraph;
+    const shelfKey = `${m.library}/${m.shelf}`;
+    const preTrigger = { ...after };
+    const touched = [];
+    const triggered = await runTriggers(m.fields, after, changed, graph, shelfKey, partCtx(m, memo, now, em), {
+        ...opts,
+        touched,
+    });
+    Object.assign(after, triggered);
+    return { changed: changedFields(preTrigger, after, m.fields).map((c) => c.path.join('.')), touched };
+}
+async function persistUntouchedCollectionDiffs(tx, m, id, patchedKeys, before, beforeMeta, after) {
+    for (const c of collectionGroups(m.fields)) {
+        if (patchedKeys.has(c.key))
+            continue;
+        const beforeRows = before[c.key] ?? [];
+        const afterRows = after[c.key] ?? [];
+        const metas = beforeMeta[c.key] ?? [];
+        const childFields = c.group.fields;
+        const table = `${m.library}__${m.shelf}__${c.key}`;
+        const n = Math.min(beforeRows.length, afterRows.length, metas.length);
+        for (let i = 0; i < n; i++) {
+            const rowId = metas[i].id;
+            const flatBefore = encodeJsonAt(childFields, flattenEmbeddedAt(childFields, beforeRows[i]));
+            const flatAfter = encodeJsonAt(childFields, flattenEmbeddedAt(childFields, afterRows[i]));
+            const rowPatch = {};
+            for (const [k, v] of Object.entries(flatAfter)) {
+                if (!sameValue(flatBefore[k] ?? null, v ?? null))
+                    rowPatch[k] = v ?? null;
+            }
+            if (Object.keys(rowPatch).length > 0)
+                await tx.nativeUpdate(table, { id: rowId }, rowPatch);
+        }
+    }
 }
 export function encodeJsonAt(fields, data) {
     const out = { ...data };
@@ -83,15 +119,11 @@ export async function getRecord(m, entityName, id, opts = {}) {
     if (!row)
         return undefined;
     const flat = decodeTemporal(m, row);
+    const clocks = clockValuesOf(flat);
     const nested = nestEmbedded(m, flat);
-    const collections = await readCollections(fork, m, id);
+    const { collections, meta } = await readCollectionsWithMeta(fork, m, id);
     const record = { ...nested, ...collections };
-    return injectParts(m.fields, record, {
-        record,
-        settings: EMPTY_SETTINGS,
-        global: EMPTY_GLOBAL,
-        meta: { library: m.library, shelf: m.shelf },
-    });
+    return refreshCachedUnits(m, entityName, record, clocks, meta, partCtx(m));
 }
 export async function createRecord(m, entityName, input, ctx, afterBase) {
     const parsed = buildZodObject(m).safeParse(input);
@@ -102,7 +134,10 @@ export async function createRecord(m, entityName, input, ctx, afterBase) {
     const fileIssues = normalizeFileFields(m, parsedData);
     if (fileIssues.length)
         throw new ValidationError(fileIssues);
-    await mergeStoredParts(m, parsedData);
+    const memo = newPartMemo();
+    const triggerResult = hasStoredPartWork(m.fields)
+        ? await driveTriggers(m, {}, parsedData, memo, ts, undefined, { seedAll: true })
+        : { changed: [], touched: [] };
     const { base, collections } = splitCollections(m, { ...parsedData });
     const data = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, { ...base, created_at: ts, updated_at: ts })));
     let id;
@@ -113,26 +148,16 @@ export async function createRecord(m, entityName, input, ctx, afterBase) {
         await tx.flush();
         id = entity.id;
         await writeCollections(tx, m, id, collections);
-        const derived = await 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,
-            id,
-            ...(_extends ? { _extends } : {}),
-        });
+        writeEvent(tx, ctx.actor, 'create', `${m.library}/${m.shelf}`, id, null, stripClockKeysDeep(m.fields, { ...parsedData, id, ...(_extends ? { _extends } : {}) }));
     });
     notifyRecordsChanged();
     const record = { ...parsedData, id, created_at: ts, updated_at: ts };
-    return injectParts(m.fields, record, {
-        record,
-        settings: EMPTY_SETTINGS,
-        global: EMPTY_GLOBAL,
-        meta: { library: m.library, shelf: m.shelf },
-    });
+    return {
+        ...stripClockKeysDeep(m.fields, record),
+        changed: triggerResult.changed,
+        ...(triggerResult.touched.length ? { changedRecords: triggerResult.touched } : {}),
+    };
 }
 export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
     let patch = input;
@@ -147,7 +172,9 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
     const parsed = buildZodObjectPartial(m).safeParse(patch);
     if (!parsed.success)
         throw new ValidationError(parsed.error.issues.map(toIssue));
+    const memo = newPartMemo();
     let result;
+    let triggerResult = { changed: [], touched: [] };
     await getEm()
         .fork()
         .transactional(async (tx) => {
@@ -165,7 +192,7 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
         const merged = { ...existing, ...base };
         const reqIssues = [];
         for (const [key, f] of fieldEntries(m.fields)) {
-            if (f.virtual || f.required === true)
+            if (f.required === true)
                 continue;
             if (key.includes('__'))
                 continue;
@@ -177,30 +204,37 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
         }
         if (reqIssues.length)
             throw new ValidationError(reqIssues);
-        const target = { ...merged, ...collections };
-        if (await mergeStoredParts(m, target)) {
+        const storedWithMeta = hasStoredPartWork(m.fields)
+            ? await readCollectionsWithMeta(tx, m, id)
+            : { collections: {}, meta: {} };
+        const storedCollections = storedWithMeta.collections;
+        const target = { ...merged, ...storedCollections, ...collections };
+        if (hasStoredPartWork(m.fields)) {
+            const before = { ...existing, ...storedCollections };
+            triggerResult = await driveTriggers(m, before, target, memo, ts, tx);
             const resplit = splitCollections(m, target);
             Object.assign(merged, resplit.base);
-            Object.assign(collections, resplit.collections);
+            const patchedKeys = new Set(Object.keys(collections));
+            for (const k of patchedKeys) {
+                const rows = resplit.collections[k];
+                if (rows)
+                    collections[k] = rows;
+            }
+            await persistUntouchedCollectionDiffs(tx, m, id, patchedKeys, storedCollections, storedWithMeta.meta, resplit.collections);
         }
         const dbRow = encodeJson(m, encodeTemporal(m, flattenEmbedded(m, { ...merged, updated_at: ts })));
         await tx.upsert(entityName, dbRow);
         await writeCollections(tx, m, id, collections);
         const allCollections = await readCollections(tx, m, id);
-        const derived = await 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 } : {}) };
+        stripClockKeysDeep(m.fields, after);
         writeEvent(tx, ctx.actor, 'update', `${m.library}/${m.shelf}`, id, existing, after);
-        result = await injectParts(m.fields, after, {
-            record: after,
-            settings: EMPTY_SETTINGS,
-            global: EMPTY_GLOBAL,
-            meta: { library: m.library, shelf: m.shelf },
-        });
+        result = {
+            ...after,
+            changed: triggerResult.changed,
+            ...(triggerResult.touched.length ? { changedRecords: triggerResult.touched } : {}),
+        };
     });
     notifyRecordsChanged();
     return result;
@@ -235,12 +269,7 @@ export async function restoreRecord(m, entityName, id, ctx, afterBase) {
         const _extends = afterBase ? await afterBase(tx, id) : undefined;
         const restored = { ...nested, ...collections, ...(_extends ? { _extends } : {}) };
         writeEvent(tx, ctx.actor, 'restore', `${m.library}/${m.shelf}`, id, null, restored);
-        result = await injectParts(m.fields, restored, {
-            record: restored,
-            settings: EMPTY_SETTINGS,
-            global: EMPTY_GLOBAL,
-            meta: { library: m.library, shelf: m.shelf },
-        });
+        result = restored;
     });
     notifyRecordsChanged();
     return result;

package/dist/orchestrator/agent-capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { AgentToolProvider, AttachmentRef } from './types.ts';
+export declare function makeAttachmentCapabilities(attachments: AttachmentRef[]): Promise<AgentToolProvider>;

package/dist/orchestrator/agent-capabilities.js

@@ -0,0 +1,201 @@
+import { collectMcpTools } from "../mcp-tools.js";
+import { LocalClient } from "../mcp-local.js";
+import { inspectUpload } from "./file-inspection.js";
+const ok = (data) => ({
+    content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+});
+const fail = (text) => ({ content: [{ type: 'text', text }], isError: true });
+function textOf(result) {
+    const block = result.content.find((b) => b.type === 'text');
+    return block?.type === 'text' ? block.text : '';
+}
+function resultData(result) {
+    try {
+        return JSON.parse(textOf(result));
+    }
+    catch {
+        return undefined;
+    }
+}
+function fieldType(items, key) {
+    for (const item of items) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const raw = item;
+        if (raw.key === key && raw.type)
+            return raw.type;
+        if (raw.kind === 'group' && Array.isArray(raw.fields)) {
+            const nested = fieldType(raw.fields, key);
+            if (nested)
+                return nested;
+        }
+    }
+    return undefined;
+}
+async function findFileField(library, shelf, key) {
+    const schema = (await new LocalClient().getSchema());
+    const lib = schema.find((item) => item.id === library);
+    const sh = lib?.shelves?.find((item) => item.shelf === shelf);
+    return sh?.fields ? fieldType(sh.fields, key) : undefined;
+}
+function parseStoredValue(value) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function fileItems(value) {
+    const parsed = parseStoredValue(value);
+    if (Array.isArray(parsed))
+        return parsed.filter((item) => !!item && typeof item === 'object');
+    return parsed && typeof parsed === 'object' ? [parsed] : [];
+}
+function findTool(defs, name) {
+    return defs.find((def) => def.server === 'coffer' && def.bareName === name);
+}
+export async function makeAttachmentCapabilities(attachments) {
+    const defs = await collectMcpTools();
+    const getRecord = findTool(defs, 'get_record');
+    const updateRecord = findTool(defs, 'update_record');
+    const tools = [];
+    if (getRecord) {
+        tools.push({
+            name: 'mcp__coffer__inspect_record_file',
+            description: 'Read an existing file/image/PDF/text item stored in a Coffer record. ' +
+                'Call get_record first, then pass the exact file name from the field value. ' +
+                'Do not use local paths or URLs. If a field contains multiple files, file_name is required.',
+            inputSchema: {
+                library: { type: 'string', description: 'Library identifier, e.g. things' },
+                shelf: { type: 'string', description: 'Shelf identifier, e.g. item' },
+                id: { type: 'integer', description: 'Record id' },
+                field: { type: 'string', description: 'File/image/document field key' },
+                file_name: {
+                    type: 'string',
+                    description: 'Exact stored file name from get_record; required for multiple files',
+                },
+            },
+            handler: async (args) => {
+                const library = String(args['library'] ?? '');
+                const shelf = String(args['shelf'] ?? '');
+                const id = Number(args['id']);
+                const field = String(args['field'] ?? '');
+                if (!library || !shelf || !field || !Number.isInteger(id))
+                    return fail('library, shelf, field and integer id are required');
+                const type = await findFileField(library, shelf, field);
+                if (!type || type.prim !== 'file')
+                    return fail(`Field is not a file field: ${library}/${shelf}.${field}`);
+                const currentResult = await getRecord.handler({ library, shelf, id });
+                if (currentResult.isError)
+                    return currentResult;
+                const current = resultData(currentResult);
+                if (!current || typeof current !== 'object')
+                    return fail(`Record not found: ${library}/${shelf}/${id}`);
+                const existing = fileItems(current[field]);
+                if (!existing.length)
+                    return fail(`Record field is empty: ${library}/${shelf}/${id}.${field}`);
+                const requested = typeof args['file_name'] === 'string' ? args['file_name'] : '';
+                const item = requested
+                    ? existing.find((entry) => entry['name'] === requested)
+                    : existing.length === 1
+                        ? existing[0]
+                        : undefined;
+                if (!item || typeof item['name'] !== 'string') {
+                    const available = existing
+                        .map((entry) => String(entry['name'] ?? ''))
+                        .filter(Boolean)
+                        .join(', ');
+                    return fail(existing.length > 1
+                        ? `Multiple files are stored in this field; file_name is required. Available: ${available}`
+                        : `Stored file was not found in record field: ${requested}`);
+                }
+                return inspectUpload(item['name'], {
+                    ...(typeof item['mime'] === 'string' ? { mime: item['mime'] } : {}),
+                    ...(typeof item['size'] === 'number' ? { size: item['size'] } : {}),
+                });
+            },
+        });
+    }
+    if (!attachments.length || !getRecord || !updateRecord)
+        return { tools };
+    const attach = {
+        name: 'mcp__coffer__attach_conversation_attachments',
+        description: 'Attach files already received in the current conversation to a file/image/document field in a Coffer record. ' +
+            'Use attachment_names for selected files, or omit it to attach every current-conversation attachment. ' +
+            'The default mode appends to a multiple field; use mode="replace" only when explicitly requested. ' +
+            'This is the unified attachment tool for every connector — never use a local path or invent an upload name.',
+        inputSchema: {
+            library: { type: 'string', description: 'Library identifier, e.g. things' },
+            shelf: { type: 'string', description: 'Shelf identifier, e.g. item' },
+            id: { type: 'integer', description: 'Record id' },
+            field: { type: 'string', description: 'File/image/document field key' },
+            attachment_names: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Exact server-generated names from the current conversation; omit to use all attachments',
+            },
+            mode: {
+                type: 'string',
+                enum: ['append', 'replace'],
+                description: 'append by default; replace only on explicit request',
+            },
+        },
+        handler: async (args) => {
+            const library = String(args['library'] ?? '');
+            const shelf = String(args['shelf'] ?? '');
+            const id = Number(args['id']);
+            const field = String(args['field'] ?? '');
+            const mode = args['mode'] === 'replace' ? 'replace' : 'append';
+            if (!library || !shelf || !field || !Number.isInteger(id))
+                return fail('library, shelf, field and integer id are required');
+            const names = Array.isArray(args['attachment_names'])
+                ? args['attachment_names'].filter((name) => typeof name === 'string')
+                : attachments.map((item) => item.name);
+            const uniqueNames = [...new Set(names)];
+            const refs = uniqueNames.map((name) => attachments.find((item) => item.name === name));
+            if (refs.some((ref) => !ref)) {
+                const missing = uniqueNames.filter((name) => !attachments.some((item) => item.name === name));
+                return fail(`Attachment is not available in the current conversation: ${missing.join(', ')}`);
+            }
+            if (!refs.length)
+                return fail('No conversation attachments were selected');
+            const type = await findFileField(library, shelf, field);
+            if (!type || type.prim !== 'file')
+                return fail(`Field is not a file field: ${library}/${shelf}.${field}`);
+            const multiple = type.hints?.multiple === true;
+            const currentResult = await getRecord.handler({ library, shelf, id });
+            if (currentResult.isError)
+                return currentResult;
+            const current = resultData(currentResult);
+            if (!current || typeof current !== 'object')
+                return fail(`Record not found: ${library}/${shelf}/${id}`);
+            const existing = fileItems(current[field]);
+            const incoming = refs.map((ref) => ({ name: ref.name }));
+            if (!multiple && mode === 'append' && existing.length)
+                return fail(`Field already contains a file; use mode="replace" to replace it`);
+            if (!multiple && incoming.length > 1)
+                return fail(`Field accepts one file; select one attachment or use a multiple field`);
+            const next = mode === 'replace'
+                ? incoming
+                : [...existing, ...incoming.filter((item) => !existing.some((old) => old.name === item.name))];
+            const value = multiple ? next : (next[0] ?? null);
+            const updated = await updateRecord.handler({ library, shelf, id, fields: { [field]: value } });
+            if (updated.isError)
+                return updated;
+            return ok({
+                attached: incoming.map((item) => item.name),
+                mode,
+                library,
+                shelf,
+                id,
+                field,
+                record: resultData(updated),
+            });
+        },
+    };
+    tools.push(attach);
+    return { tools };
+}

package/dist/orchestrator/allow.d.ts

@@ -0,0 +1,16 @@
+import type { GatePolicy } from './types.ts';
+export declare const stateDir: () => string;
+export declare function carryLegacyState(): void;
+export declare function allowFileFor(connectorId: string): string;
+export interface AllowState {
+    ids: Record<string, number>;
+}
+export declare function emptyAllowed(): AllowState;
+export declare function loadAllowed(file: string): AllowState;
+export declare function saveAllowed(file: string, state: AllowState): void;
+export declare function isAllowed(state: AllowState, id: string | number | null | undefined): boolean;
+export declare function addAllowed(state: AllowState, id: string | number, now: number): AllowState;
+export declare function isSenderAllowed(connectorId: string, senderId: string, deps?: {
+    policy?: GatePolicy;
+}): Promise<boolean>;
+export declare function makeThrottle(maxAttempts?: number, windowMs?: number): (id: string | number, now?: number) => boolean;

package/dist/orchestrator/allow.js

@@ -0,0 +1,65 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadGatePolicy } from "./config.js";
+import { carryInto, dataDir } from "../data-dir.js";
+export const stateDir = () => process.env['ORCHESTRATOR_STATE_DIR'] ?? path.join(dataDir(), 'state');
+function legacyStateDirs() {
+    return [
+        path.join(process.cwd(), 'packages', 'plugin-orchestrator', 'runtime', 'state'),
+        path.join(process.cwd(), 'node_modules', '@coffer-org', 'plugin-orchestrator', 'runtime', 'state'),
+    ];
+}
+export function carryLegacyState() {
+    carryInto(stateDir(), ...legacyStateDirs());
+}
+export function allowFileFor(connectorId) {
+    return path.join(stateDir(), `${connectorId}.allowed.json`);
+}
+export function emptyAllowed() {
+    return { ids: {} };
+}
+export function loadAllowed(file) {
+    try {
+        const obj = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        if (obj && typeof obj === 'object' && 'ids' in obj && typeof obj.ids === 'object') {
+            return obj;
+        }
+        return emptyAllowed();
+    }
+    catch {
+        return emptyAllowed();
+    }
+}
+export function saveAllowed(file, state) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(state), 'utf-8');
+    fs.renameSync(tmp, file);
+}
+export function isAllowed(state, id) {
+    return id != null && Object.prototype.hasOwnProperty.call(state.ids, String(id));
+}
+export function addAllowed(state, id, now) {
+    return { ids: { ...state.ids, [String(id)]: now } };
+}
+export async function isSenderAllowed(connectorId, senderId, deps) {
+    const policy = deps?.policy ?? (await loadGatePolicy());
+    if (!policy.accessPassword)
+        return true;
+    return isAllowed(loadAllowed(allowFileFor(connectorId)), senderId);
+}
+export function makeThrottle(maxAttempts = 5, windowMs = 60_000) {
+    const hits = new Map();
+    return function allowAttempt(id, now = Date.now()) {
+        const key = String(id);
+        const rec = hits.get(key);
+        if (!rec || now - rec.start >= windowMs) {
+            hits.set(key, { start: now, count: 1 });
+            return true;
+        }
+        if (rec.count >= maxAttempts)
+            return false;
+        rec.count += 1;
+        return true;
+    };
+}

package/dist/orchestrator/attachments.d.ts

@@ -0,0 +1,2 @@
+import type { AttachmentMaterializer } from './types.ts';
+export declare const attachmentMaterializer: AttachmentMaterializer;

package/dist/orchestrator/attachments.js

@@ -0,0 +1,11 @@
+import { saveUploadBytes } from "../uploads.js";
+export const attachmentMaterializer = {
+    async store(bytes, opts = {}) {
+        const stored = await saveUploadBytes(bytes, opts);
+        return {
+            name: stored.name,
+            ...(stored.mime ? { mime: stored.mime } : {}),
+            size: stored.size,
+        };
+    },
+};

package/dist/orchestrator/config.d.ts

@@ -0,0 +1,4 @@
+import type { GatePolicy } from './types.ts';
+export declare function buildPolicy(dbSettings?: Record<string, unknown>): GatePolicy;
+export declare function loadAgentId(): Promise<string | undefined>;
+export declare function loadGatePolicy(): Promise<GatePolicy>;

package/dist/orchestrator/config.js

@@ -0,0 +1,19 @@
+import { SYSTEM_SETTINGS_ID } from "../system-settings.js";
+export function buildPolicy(dbSettings = {}) {
+    const db = dbSettings;
+    return {
+        ...(typeof db.agent_id === 'string' && db.agent_id ? { agentId: db.agent_id } : {}),
+        accessPassword: db.access_password ?? '',
+        triggerPrefix: db.trigger_prefix ?? '',
+        replyWindow: Number(db.reply_window ?? 1800) || 1800,
+    };
+}
+export async function loadAgentId() {
+    const { getPluginSettings } = await import("../plugin-runtime.js");
+    const value = (await getPluginSettings(SYSTEM_SETTINGS_ID))['agent_id'];
+    return typeof value === 'string' && value ? value : undefined;
+}
+export async function loadGatePolicy() {
+    const { getPluginSettings } = await import("../plugin-runtime.js");
+    return buildPolicy(await getPluginSettings(SYSTEM_SETTINGS_ID));
+}

package/dist/orchestrator/db.d.ts

@@ -0,0 +1,17 @@
+export type LogTurn = {
+    connector: string;
+    chatId: string;
+    userId: string;
+    role: 'user' | 'assistant';
+    text: string;
+    tokensIn: number | null;
+    tokensOut: number | null;
+    ms: number | null;
+    agentId: string | null;
+    presetId: string | null;
+};
+export interface LogDb {
+    logTurn(row: LogTurn): void;
+    close(): void;
+}
+export declare function openLogDb(): LogDb;

package/dist/orchestrator/db.js

@@ -0,0 +1,12 @@
+import { logMessage } from "../msg-log.js";
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('orchestrator');
+export function openLogDb() {
+    return {
+        logTurn(row) {
+            logMessage(row).catch((e) => log.error('logTurn failed', e));
+        },
+        close() {
+        },
+    };
+}

package/dist/orchestrator/diagnostics.d.ts

@@ -0,0 +1,9 @@
+export interface DiagnosticEvent {
+    ts: string;
+    level: 'error' | 'warn';
+    source: string;
+    message: string;
+}
+export declare function recordDiagnostic(level: DiagnosticEvent['level'], source: string, message: string): void;
+export declare function listDiagnostics(limit?: number): DiagnosticEvent[];
+export declare function clearDiagnostics(): void;

package/dist/orchestrator/diagnostics.js

@@ -0,0 +1,13 @@
+const MAX_EVENTS = 100;
+const events = [];
+export function recordDiagnostic(level, source, message) {
+    events.unshift({ ts: new Date().toISOString(), level, source, message: message.slice(0, 500) });
+    if (events.length > MAX_EVENTS)
+        events.length = MAX_EVENTS;
+}
+export function listDiagnostics(limit = 25) {
+    return events.slice(0, Math.max(1, Math.min(100, Math.trunc(limit))));
+}
+export function clearDiagnostics() {
+    events.length = 0;
+}

package/dist/orchestrator/environment.d.ts

@@ -0,0 +1,3 @@
+export declare function systemTimeZone(): string;
+export declare function todayDateString(now?: Date, timeZone?: string): string;
+export declare function currentEnvironment(now?: Date, timeZone?: string): string;

package/dist/orchestrator/environment.js

@@ -0,0 +1,30 @@
+export function systemTimeZone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    }
+    catch {
+        return 'UTC';
+    }
+}
+function part(now, timeZone, locale, options) {
+    return new Intl.DateTimeFormat(locale, { ...options, timeZone }).format(now);
+}
+export function todayDateString(now = new Date(), timeZone = systemTimeZone()) {
+    return part(now, timeZone, 'en-CA', { year: 'numeric', month: '2-digit', day: '2-digit' });
+}
+export function currentEnvironment(now = new Date(), timeZone = systemTimeZone()) {
+    let zone = timeZone;
+    try {
+        new Intl.DateTimeFormat('en-CA', { timeZone: zone }).format(now);
+    }
+    catch {
+        zone = 'UTC';
+    }
+    const date = part(now, zone, 'en-CA', { year: 'numeric', month: '2-digit', day: '2-digit' });
+    const weekday = part(now, zone, 'en-US', { weekday: 'long' });
+    const time = part(now, zone, 'en-GB', { hour: '2-digit', minute: '2-digit', hour12: false });
+    return [
+        `Current moment, refreshed on every turn: ${date} (${weekday}), ${time}, timezone ${zone}.`,
+        'Resolve every relative date against this value — "today", "tomorrow", "this week", ages, and expiry, warranty or due-date checks. Never infer the date from your training data and never tell the user you cannot know it.',
+    ].join('\n');
+}

package/dist/orchestrator/file-inspection.d.ts

@@ -0,0 +1,3 @@
+import type { AgentToolContentResult, AttachmentRef } from './types.ts';
+export declare function inspectUpload(name: string, ref?: Pick<AttachmentRef, 'mime' | 'size' | 'label'>): Promise<AgentToolContentResult>;
+export declare function isAgentToolContentResult(value: unknown): value is AgentToolContentResult;