@coffer-org/server 7.3.0 → 7.5.0

package/dist/auth-api.js

@@ -2,8 +2,7 @@ import { field } from '@coffer-org/sdk/fields';
 import { materializeTree } from '@coffer-org/sdk/materialize/pipeline';
 import { countUsers, createUser, findUserByLogin, findUserById, getPasswordHash, listUsers, updateUser, deleteUser, countAdmins, createSession, resolveSession, deleteSession, createApiToken, resolveApiToken, listApiTokens, revokeApiToken, } from "./auth-store.js";
 import { resolveAccessToken } from "./oauth-store.js";
-import { listLinks, unlink, mintLinkCode } from "./identity-link.js";
-import { listLinkableConnectors, connectorLinkUrl } from "./orchestrator/index.js";
+import { listIdentityProviders, getIdentityProvider } from "./identity-providers.js";
 import { mcpResource } from "./public-url.js";
 import { verifyPassword } from "./auth-crypto.js";
 import { maskSecrets, preserveSecrets } from "./field-masking.js";
@@ -13,7 +12,6 @@ import { USERS_SHELF } from '@coffer-org/sdk/users-shelf';
 const PASSWORD_FIELDS = materializeTree({ password: field.password({}) });
 const SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const COOKIE_NAME = 'sid';
-const LINK_CODE_TTL_MS = 10 * 60 * 1000;
 export const PUBLIC_API_PATHS = ['/api/auth/status', '/api/auth/login', '/api/auth/setup'];
 function readCookie(req, name) {
     const header = req.headers.cookie;
@@ -234,29 +232,30 @@ export async function registerAuthApi(app) {
     app.get('/api/auth/links', async (req, reply) => {
         if (!req.user)
             return reply.code(401).send({ error: 'unauthorized' });
-        return { links: await listLinks(req.user.id), linkable: listLinkableConnectors() };
+        const providers = listIdentityProviders();
+        const links = (await Promise.all(providers.map(async (p) => (await p.listLinks(req.user.id)).map((l) => ({ provider: p.id, ...l }))))).flat();
+        return { providers: providers.map(({ id, label, icon }) => ({ id, label, icon })), links };
     });
-    app.post('/api/auth/links', async (req, reply) => {
+    app.post('/api/auth/links/:provider', async (req, reply) => {
         if (!req.user)
             return reply.code(401).send({ error: 'unauthorized' });
-        const minted = await mintLinkCode(req.user.id, LINK_CODE_TTL_MS);
-        const links = {};
-        for (const connectorId of listLinkableConnectors()) {
-            const url = connectorLinkUrl(connectorId, minted.raw);
-            if (url)
-                links[connectorId] = url;
-        }
-        return { ...minted, links };
+        const { provider } = req.params;
+        const p = getIdentityProvider(provider);
+        if (!p)
+            return reply.code(404).send({ error: 'not_found' });
+        const started = await p.beginLink(req.user.id);
+        if (!started)
+            return reply.code(503).send({ error: 'unavailable' });
+        return started;
     });
-    app.delete('/api/auth/links/:connector/:externalId', async (req, reply) => {
+    app.delete('/api/auth/links/:provider/:externalId', async (req, reply) => {
         if (!req.user)
             return reply.code(401).send({ error: 'unauthorized' });
-        const { connector, externalId } = req.params;
-        const own = await listLinks(req.user.id);
-        const owns = own.some((l) => l.connector === connector && l.externalId === externalId);
-        if (!owns)
+        const { provider, externalId } = req.params;
+        const p = getIdentityProvider(provider);
+        if (!p)
             return reply.code(404).send({ error: 'not_found' });
-        const ok = await unlink(connector, externalId);
+        const ok = await p.unlink(req.user.id, externalId);
         if (!ok)
             return reply.code(404).send({ error: 'not_found' });
         return { ok: true };

package/dist/compute-unit.js

@@ -1,5 +1,4 @@
 import { hasChildren, isNamedField, isCollectionGroup, isEmbeddedGroup, isStorageGroup, } from '@coffer-org/sdk/fields';
-import { mandatedClientParts } from '@coffer-org/sdk/parts';
 import { PartContractError } from "./part-errors.js";
 import { createRefLoader } from "./part-ref.js";
 import { wholeClockColumn, partClockColumn } from "./cache-clock.js";
@@ -267,8 +266,6 @@ export function materializable(fm) {
     const parts = fm.parts ?? [];
     if (!parts.some((p) => p.mode === 'computedStored'))
         return false;
-    if (mandatedClientParts(fm.required, parts).length > 0)
-        return false;
     return true;
 }
 export function storedFilled(fm, value) {

package/dist/conversation-store.d.ts

@@ -0,0 +1,61 @@
+export declare const HIDDEN_ROLES: readonly ["reasoning", "suggestions", "context"];
+export declare const SIDECAR_ROLES: readonly ["reasoning", "suggestions"];
+export declare const TITLE_MAX = 60;
+export declare const DEFAULT_MAX_DEPTH = 40;
+export declare const conversationEmitter: EventTarget;
+export interface PutMessageInput {
+    conversationId: string;
+    msgId: string;
+    role: string;
+    sender?: string | null;
+    text: string;
+    attachments?: StoredAttachment[];
+    ts: number;
+    replyToId?: string | null;
+}
+export declare function onMessage(cb: (m: PutMessageInput) => void | Promise<void>): () => void;
+export interface StoredMsg {
+    msgId: string;
+    role: string;
+    sender: string | null;
+    text: string;
+    attachments?: StoredAttachment[];
+    ts: number;
+    replyToId: string | null;
+}
+export interface StoredAttachment {
+    name: string;
+    mime?: string;
+    size?: number;
+    label?: string;
+}
+export interface Conversation {
+    id: string;
+    owner: string | null;
+    title: string | null;
+    agentId: string | null;
+    presetId: string | null;
+    visibility: 'private' | null;
+    updatedAt: string;
+}
+export interface ConversationSummary extends Conversation {
+    lastTs: number;
+    count: number;
+    firstUserText: string;
+}
+export declare function newConversationId(): string;
+export declare function newMessageId(): string;
+export declare function getConversation(id: string): Promise<Conversation>;
+export declare function setConversation(id: string, patch: Partial<Omit<Conversation, 'id' | 'updatedAt'>>): Promise<void>;
+export declare function readAndTouchConversation(id: string): Promise<Conversation>;
+export declare function listConversations(viewerId: string): Promise<ConversationSummary[]>;
+export declare function putMessage(m: PutMessageInput): Promise<void>;
+export declare const insertMessage: typeof putMessage;
+export declare function getMessage(conversationId: string, msgId: string): Promise<StoredMsg | null>;
+export declare function readConversation(conversationId: string, opts?: {
+    limit?: number;
+}): Promise<StoredMsg[]>;
+export declare function readAll(conversationId: string): Promise<StoredMsg[]>;
+export declare function countUserMessages(conversationId: string): Promise<number>;
+export declare function lastMessageId(conversationId: string): Promise<string | null>;
+export declare function pruneConversations(cutoffTs: number, cutoffIso: string): Promise<void>;

package/dist/conversation-store.js

@@ -0,0 +1,223 @@
+import { randomUUID } from 'node:crypto';
+import { getEm } from "./db.js";
+import { mayRead } from "./orchestrator/conversation-access.js";
+export const HIDDEN_ROLES = ['reasoning', 'suggestions', 'context'];
+export const SIDECAR_ROLES = ['reasoning', 'suggestions'];
+export const TITLE_MAX = 60;
+export const DEFAULT_MAX_DEPTH = 40;
+export const conversationEmitter = new EventTarget();
+export function onMessage(cb) {
+    const handler = (e) => {
+        if (e instanceof CustomEvent) {
+            void cb(e.detail);
+        }
+    };
+    conversationEmitter.addEventListener('message', handler);
+    return () => {
+        conversationEmitter.removeEventListener('message', handler);
+    };
+}
+function capTitle(title) {
+    const t = title.trim();
+    return t.length <= TITLE_MAX ? t : `${t.slice(0, TITLE_MAX - 1)}…`;
+}
+function emptyConversation(id) {
+    return {
+        id,
+        owner: null,
+        title: null,
+        agentId: null,
+        presetId: null,
+        visibility: null,
+        updatedAt: '',
+    };
+}
+function toConversation(row) {
+    return {
+        id: row.id,
+        owner: row.owner,
+        title: row.title,
+        agentId: row.agent_id,
+        presetId: row.preset_id,
+        visibility: row.visibility === 'private' ? 'private' : null,
+        updatedAt: row.updated_at,
+    };
+}
+function toStored(r) {
+    let attachments;
+    if (r.attachments) {
+        try {
+            const parsed = JSON.parse(r.attachments);
+            if (Array.isArray(parsed)) {
+                const valid = parsed.filter((v) => typeof v === 'object' && v !== null && typeof v.name === 'string');
+                if (valid.length)
+                    attachments = valid;
+            }
+        }
+        catch {
+        }
+    }
+    return {
+        msgId: r.msg_id,
+        role: r.role,
+        sender: r.sender,
+        text: r.text,
+        ...(attachments ? { attachments } : {}),
+        ts: r.ts,
+        replyToId: r.reply_to_id,
+    };
+}
+export function newConversationId() {
+    return randomUUID();
+}
+export function newMessageId() {
+    return randomUUID();
+}
+export async function getConversation(id) {
+    const em = getEm().fork();
+    const row = (await em.findOne('_Conversation', { id }));
+    if (!row)
+        return emptyConversation(id);
+    return toConversation(row);
+}
+export async function setConversation(id, patch) {
+    const em = getEm().fork();
+    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('_Conversation', { id }));
+    if (existing) {
+        em.assign(existing, data);
+    }
+    else {
+        em.persist(em.create('_Conversation', {
+            id,
+            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();
+    conversationEmitter.dispatchEvent(new CustomEvent('conversation', { detail: { id, patch } }));
+}
+export async function readAndTouchConversation(id) {
+    const em = getEm().fork();
+    const row = (await em.findOne('_Conversation', { id }));
+    if (!row)
+        return emptyConversation(id);
+    const now = new Date().toISOString();
+    em.assign(row, { updated_at: now });
+    await em.flush();
+    return toConversation(row);
+}
+export async function listConversations(viewerId) {
+    const em = getEm().fork();
+    const convRows = (await em.find('_Conversation', {}));
+    const msgRows = (await em.find('_ConversationMessage', {}, { orderBy: { ts: 'asc', msg_id: 'asc' } }));
+    const msgSummaries = new Map();
+    for (const r of msgRows) {
+        if (HIDDEN_ROLES.includes(r.role))
+            continue;
+        const cur = msgSummaries.get(r.conversation_id);
+        if (!cur) {
+            msgSummaries.set(r.conversation_id, {
+                lastTs: r.ts,
+                count: 1,
+                firstUserText: r.role === 'user' ? r.text : '',
+            });
+            continue;
+        }
+        cur.count += 1;
+        if (r.ts > cur.lastTs)
+            cur.lastTs = r.ts;
+        if (!cur.firstUserText && r.role === 'user')
+            cur.firstUserText = r.text;
+    }
+    const convMap = new Map();
+    for (const r of convRows) {
+        convMap.set(r.id, toConversation(r));
+    }
+    const allIds = new Set([...convMap.keys(), ...msgSummaries.keys()]);
+    const out = [];
+    for (const id of allIds) {
+        const conv = convMap.get(id) ?? emptyConversation(id);
+        if (!mayRead(conv, viewerId))
+            continue;
+        const summary = msgSummaries.get(id);
+        out.push({
+            ...conv,
+            lastTs: summary?.lastTs ?? 0,
+            count: summary?.count ?? 0,
+            firstUserText: summary?.firstUserText ?? '',
+        });
+    }
+    return out.sort((a, b) => {
+        if (b.lastTs !== a.lastTs)
+            return b.lastTs - a.lastTs;
+        return (b.updatedAt || '').localeCompare(a.updatedAt || '') || b.id.localeCompare(a.id);
+    });
+}
+export async function putMessage(m) {
+    const em = getEm().fork();
+    await em.upsert('_ConversationMessage', {
+        conversation_id: m.conversationId,
+        msg_id: m.msgId,
+        role: m.role,
+        sender: m.sender ?? null,
+        attachments: m.attachments?.length ? JSON.stringify(m.attachments) : null,
+        text: m.text,
+        ts: m.ts,
+        reply_to_id: m.replyToId ?? null,
+    });
+    await em.flush();
+    conversationEmitter.dispatchEvent(new CustomEvent('message', { detail: m }));
+}
+export const insertMessage = putMessage;
+export async function getMessage(conversationId, msgId) {
+    const em = getEm().fork();
+    const row = (await em.findOne('_ConversationMessage', { conversation_id: conversationId, msg_id: msgId }));
+    return row ? toStored(row) : null;
+}
+export async function readConversation(conversationId, opts) {
+    const limit = opts?.limit ?? DEFAULT_MAX_DEPTH;
+    const em = getEm().fork();
+    const visible = (await em.find('_ConversationMessage', { conversation_id: conversationId, role: { $nin: HIDDEN_ROLES } }, { orderBy: { ts: 'desc', msg_id: 'desc' }, limit }));
+    const oldest = visible.at(-1)?.ts;
+    const sidecars = oldest === undefined
+        ? []
+        : (await em.find('_ConversationMessage', { conversation_id: conversationId, role: { $in: SIDECAR_ROLES }, ts: { $gte: oldest - 1 } }, { orderBy: { ts: 'desc', msg_id: 'desc' } }));
+    return [...visible, ...sidecars]
+        .sort((a, b) => b.ts - a.ts || (a.msg_id < b.msg_id ? 1 : a.msg_id > b.msg_id ? -1 : 0))
+        .reverse()
+        .map(toStored);
+}
+export async function readAll(conversationId) {
+    const em = getEm().fork();
+    const rows = (await em.find('_ConversationMessage', { conversation_id: conversationId }, { orderBy: { ts: 'asc', msg_id: 'asc' } }));
+    return rows.map(toStored);
+}
+export async function countUserMessages(conversationId) {
+    const em = getEm().fork();
+    return em.count('_ConversationMessage', { conversation_id: conversationId, role: 'user' });
+}
+export async function lastMessageId(conversationId) {
+    const em = getEm().fork();
+    const row = (await em.findOne('_ConversationMessage', { conversation_id: conversationId, role: { $nin: HIDDEN_ROLES } }, { orderBy: { ts: 'desc', msg_id: 'desc' } }));
+    return row ? row.msg_id : null;
+}
+export async function pruneConversations(cutoffTs, cutoffIso) {
+    const em = getEm().fork();
+    await em.nativeDelete('_ConversationMessage', { ts: { $lt: cutoffTs } });
+    await em.nativeDelete('_Conversation', { updated_at: { $lt: cutoffIso }, owner: null, visibility: null });
+}

package/dist/entity-schema.d.ts

@@ -3,10 +3,13 @@ import type { ShelfDef } from '@coffer-org/sdk/shelf';
 import type { ExtendDef } from '@coffer-org/sdk/extend';
 import type { SettingsDef } from '@coffer-org/sdk/settings';
 import type { PluginManifest } from '@coffer-org/sdk/plugin';
+import type { PrivateTableDef } from './plugin-hooks.ts';
 export declare function shelfTableName(library: string, shelf: string): string;
 export declare function buildEntitySchema(m: ShelfDef): EntitySchema;
 export declare function buildExtendEntitySchema(e: ExtendDef): EntitySchema;
 export declare function buildSettingsEntitySchema(pluginId: string, settings: SettingsDef): EntitySchema;
+export declare function privateTableName(pluginId: string, name: string): string;
+export declare function buildPrivateTableEntity(pluginId: string, t: PrivateTableDef): EntitySchema;
 export declare function childTableName(library: string, shelf: string, key: string): string;
 export declare function buildCollectionEntities(m: ShelfDef): EntitySchema[];
 export declare function buildExtendCollectionEntities(e: ExtendDef): EntitySchema[];
@@ -18,15 +21,13 @@ export declare const SeedRowSchema: EntitySchema<any, never, import("@mikro-orm/
 export declare const EmbeddingSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 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 const ConversationMessageSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
+export declare const ConversationSchema: 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>>;
 export declare const SessionSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const ApiTokenSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
-export declare const IdentityLinkSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
-export declare const LinkCodeSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const OAuthClientSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const OAuthCodeSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;
 export declare const OAuthTokenSchema: EntitySchema<any, never, import("@mikro-orm/core").EntityCtor<any>>;

package/dist/entity-schema.js

@@ -23,14 +23,14 @@ function columnProp(field, nullable) {
         p['default'] = field.default;
     return p;
 }
-function addFieldProps(properties, fields, plainNullable) {
+function addFieldProps(properties, fields) {
     for (const [key, field] of fieldEntries(fields)) {
         if (field.columns) {
             for (const [col, type] of storageColumns(key, field))
                 properties[col] = { type: mikroType(type), nullable: true };
         }
         else {
-            properties[key] = columnProp(field, plainNullable(field));
+            properties[key] = columnProp(field, true);
         }
     }
     for (const col of cacheClockColumns(fields))
@@ -46,7 +46,7 @@ export function buildEntitySchema(m) {
         updated_at: { type: 'text' },
         deleted_at: { type: 'text', nullable: true },
     };
-    addFieldProps(properties, m.fields, (f) => !f.required);
+    addFieldProps(properties, m.fields);
     const name = shelfTableName(m.library, m.shelf);
     return new EntitySchema({ name, tableName: name, properties });
 }
@@ -54,7 +54,7 @@ export function buildExtendEntitySchema(e) {
     const properties = {
         base_id: { type: 'integer', primary: true },
     };
-    addFieldProps(properties, e.fields, () => true);
+    addFieldProps(properties, e.fields);
     const name = `extend__${e.id}`;
     return new EntitySchema({ name, tableName: name, properties });
 }
@@ -62,10 +62,26 @@ export function buildSettingsEntitySchema(pluginId, settings) {
     const properties = {
         plugin_id: { type: 'text', primary: true },
     };
-    addFieldProps(properties, settings.fields, (f) => !f.required);
+    addFieldProps(properties, settings.fields);
     const name = `_settings__${pluginId}`;
     return new EntitySchema({ name, tableName: name, properties });
 }
+export function privateTableName(pluginId, name) {
+    return `_${pluginId}__${name}`;
+}
+export function buildPrivateTableEntity(pluginId, t) {
+    const properties = {
+        id: { type: 'integer', primary: true, autoincrement: true },
+    };
+    addFieldProps(properties, t.fields);
+    const name = privateTableName(pluginId, t.name);
+    return new EntitySchema({
+        name,
+        tableName: name,
+        properties,
+        uniques: (t.unique ?? []).map((properties) => ({ properties })),
+    });
+}
 export function childTableName(library, shelf, key) {
     return `${library}__${shelf}__${key}`;
 }
@@ -75,7 +91,7 @@ function buildChildSchemaAt(prefix, c) {
         parent_id: { type: 'integer', index: true },
         position: { type: 'integer' },
     };
-    addFieldProps(properties, c.group.fields, (f) => !f.required);
+    addFieldProps(properties, c.group.fields);
     const name = `${prefix}__${c.key}`;
     return new EntitySchema({ name, tableName: name, properties });
 }
@@ -186,12 +202,11 @@ export const RecordActivitySchema = new EntitySchema({
         last_viewed_at: { type: 'text', nullable: true },
     },
 });
-export const ThreadMessageSchema = new EntitySchema({
-    name: '_ThreadMessage',
-    tableName: '_thread_message',
+export const ConversationMessageSchema = new EntitySchema({
+    name: '_ConversationMessage',
+    tableName: '_conversation_message',
     properties: {
-        connector: { type: 'text', primary: true },
-        chat_id: { type: 'text', primary: true },
+        conversation_id: { type: 'text', primary: true },
         msg_id: { type: 'text', primary: true },
         role: { type: 'text' },
         sender: { type: 'text', nullable: true },
@@ -201,12 +216,11 @@ export const ThreadMessageSchema = new EntitySchema({
         reply_to_id: { type: 'text', nullable: true },
     },
 });
-export const ThreadStateSchema = new EntitySchema({
-    name: '_ThreadState',
-    tableName: '_thread_state',
+export const ConversationSchema = new EntitySchema({
+    name: '_Conversation',
+    tableName: '_conversation',
     properties: {
-        connector: { type: 'text', primary: true },
-        chat_id: { type: 'text', primary: true },
+        id: { type: 'text', primary: true },
         agent_id: { type: 'text', nullable: true },
         preset_id: { type: 'text', nullable: true },
         title: { type: 'text', nullable: true },
@@ -277,27 +291,6 @@ export const ApiTokenSchema = new EntitySchema({
         revoked: { type: 'integer' },
     },
 });
-export const IdentityLinkSchema = new EntitySchema({
-    name: '_IdentityLink',
-    tableName: '_identity_links',
-    properties: {
-        id: { type: 'integer', primary: true, autoincrement: true },
-        connector: { type: 'text' },
-        external_id: { type: 'text' },
-        user_id: { type: 'integer' },
-        linked_at: { type: 'text' },
-    },
-});
-export const LinkCodeSchema = new EntitySchema({
-    name: '_LinkCode',
-    tableName: '_link_codes',
-    properties: {
-        code_hash: { type: 'text', primary: true },
-        user_id: { type: 'integer' },
-        expires_at: { type: 'text' },
-        created_at: { type: 'text' },
-    },
-});
 export const OAuthClientSchema = new EntitySchema({
     name: '_OAuthClient',
     tableName: '_oauth_clients',
@@ -353,9 +346,7 @@ export const systemEntities = [
     OAuthClientSchema,
     OAuthCodeSchema,
     OAuthTokenSchema,
-    ThreadMessageSchema,
-    ThreadStateSchema,
-    IdentityLinkSchema,
-    LinkCodeSchema,
+    ConversationMessageSchema,
+    ConversationSchema,
     buildSettingsEntitySchema(SYSTEM_SETTINGS_ID, SYSTEM_SETTINGS),
 ];

package/dist/identity-providers.d.ts

@@ -0,0 +1,17 @@
+export interface IdentityProvider {
+    id: string;
+    label: string;
+    icon: string;
+    beginLink(userId: number): Promise<{
+        url?: string;
+        code?: string;
+    } | null>;
+    listLinks(userId: number): Promise<{
+        externalId: string;
+        linkedAt: string;
+    }[]>;
+    unlink(userId: number, externalId: string): Promise<boolean>;
+}
+export declare function registerIdentityProvider(p: IdentityProvider): () => void;
+export declare function listIdentityProviders(): IdentityProvider[];
+export declare function getIdentityProvider(id: string): IdentityProvider | undefined;

package/dist/identity-providers.js

@@ -0,0 +1,14 @@
+const providers = new Map();
+export function registerIdentityProvider(p) {
+    providers.set(p.id, p);
+    return () => {
+        if (providers.get(p.id) === p)
+            providers.delete(p.id);
+    };
+}
+export function listIdentityProviders() {
+    return [...providers.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+export function getIdentityProvider(id) {
+    return providers.get(id);
+}

package/dist/index.js

@@ -8,6 +8,7 @@ import Fastify from 'fastify';
 import cors from '@fastify/cors';
 import multipart from '@fastify/multipart';
 import fastifyStatic from '@fastify/static';
+import { layoutToClient } from '@coffer-org/sdk/shelf';
 import { shelfTableName } from "./entity-schema.js";
 import { getEm, closeDb } from "./db.js";
 import { recordCounts } from "./counts.js";
@@ -306,7 +307,7 @@ app.post('/api/system/orchestrator-diagnostics', async (req, reply) => {
         return;
     reply.send(await orchestratorDiagnostics());
 });
-app.get('/api/settings', async () => (await settingsGroups()).map((g) => ({ id: g.id, label: g.label, fields: g.fields })));
+app.get('/api/settings', async () => (await settingsGroups()).map((g) => ({ id: g.id, label: g.label, fields: layoutToClient(g.fields) })));
 app.get('/api/settings/:id', async (req, reply) => {
     if (!requireAdmin(req, reply))
         return;

package/dist/mcp-contract/schema.d.ts

@@ -35,7 +35,6 @@ export interface FieldInfo {
     key: string;
     kind: string;
     prim: string;
-    required: boolean;
     agent?: string;
     relation?: {
         library: string;

package/dist/mcp-contract/schema.js

@@ -52,7 +52,6 @@ export function flattenFields(items) {
         key,
         kind: t.kind,
         prim: t.prim,
-        required: t.required,
         ...(t.agent ? { agent: t.agent } : {}),
         ...(t.relation ? { relation: t.relation } : {}),
         ...(t.options ? { options: t.options } : {}),
@@ -69,7 +68,6 @@ export function flattenFields(items) {
                 key: it.key,
                 kind: 'group',
                 prim: 'group',
-                required: it.required === true,
                 ...(it.agent ? { agent: it.agent } : {}),
                 ...(it.multiple ? { multiple: true } : {}),
                 fields: flattenFields(it.fields),

package/dist/mutate.js

@@ -1,7 +1,6 @@
 import { serialize } from '@mikro-orm/core';
 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 { getEm } from "./db.js";
 import { selectRows } from "./read-rows.js";
 import { normalizeFileFields, dropUnchangedFileFields, touchesFileFields } from "./file-fields.js";
@@ -190,20 +189,6 @@ export async function updateRecord(m, entityName, id, input, ctx, afterBase) {
             throw new ValidationError(fileIssues);
         const { base, collections } = splitCollections(m, { ...patchData });
         const merged = { ...existing, ...base };
-        const reqIssues = [];
-        for (const [key, f] of fieldEntries(m.fields)) {
-            if (f.required === true)
-                continue;
-            if (key.includes('__'))
-                continue;
-            if (!resolveFlag(f.required, merged))
-                continue;
-            const v = merged[key];
-            if (v == null || v === '' || (Array.isArray(v) && v.length === 0))
-                reqIssues.push({ field: key, code: 'required', path: [key] });
-        }
-        if (reqIssues.length)
-            throw new ValidationError(reqIssues);
         const storedWithMeta = hasStoredPartWork(m.fields)
             ? await readCollectionsWithMeta(tx, m, id)
             : { collections: {}, meta: {} };

package/dist/orchestrator/draft-message.d.ts

@@ -0,0 +1,18 @@
+import type { TurnSink } from './types.ts';
+import type { RenderFn } from './live-message.ts';
+export interface DraftChannelOps {
+    draft(text: string): Promise<void>;
+    send(text: string): Promise<string | null>;
+}
+export interface DraftSinkOpts {
+    ops: DraftChannelOps;
+    throttleMs: number;
+    keepAliveMs: number;
+    render: RenderFn;
+    preview: (r: {
+        text: string | null;
+        reasoning: string | null;
+    }) => string;
+    maxLength: number;
+}
+export declare function makeDraftSink(o: DraftSinkOpts): TurnSink;