@coffer-org/server 4.0.0 → 6.0.0

package/dist/frontend-agent.d.ts

@@ -1 +1 @@
-export declare function frontendInstructions(): Promise<string | null>;
+export declare function frontendInstructions(siteUrl: string): Promise<string | null>;

package/dist/frontend-agent.js

@@ -10,9 +10,8 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { getLogger } from '@coffer-org/sdk/logger';
-import { configuredPublicUrl } from "./public-url.js";
 const log = getLogger('frontend-agent');
-export async function frontendInstructions() {
+export async function frontendInstructions(siteUrl) {
     const dist = process.env['WEB_DIST'];
     if (!dist)
         return null;
@@ -27,7 +26,7 @@ export async function frontendInstructions() {
             log.warn(`frontend ${rel} exports no agent() — no site-link instructions`);
             return null;
         }
-        const text = await mod.agent({ siteUrl: await configuredPublicUrl() });
+        const text = await mod.agent({ siteUrl });
         return typeof text === 'string' && text.trim() ? text : null;
     }
     catch (e) {

package/dist/locale-registry.d.ts

@@ -0,0 +1,9 @@
+export interface LocaleResolver {
+    lang: string;
+    resolve(key: string): string | undefined;
+}
+export declare function loadComposedLocales(opts?: {
+    dirs?: string[];
+    lang?: string;
+}): Promise<LocaleResolver>;
+export declare function clearComposedLocaleCache(): void;

package/dist/locale-registry.js

@@ -0,0 +1,51 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pluginPackageNames } from "./plugin-discovery.js";
+import { systemLanguage } from "./plugin-i18n.js";
+function deepMerge(into, from) {
+    for (const [k, v] of Object.entries(from)) {
+        const prev = into[k];
+        if (v && typeof v === 'object' && !Array.isArray(v) && prev && typeof prev === 'object' && !Array.isArray(prev)) {
+            deepMerge(prev, v);
+        }
+        else {
+            into[k] = v;
+        }
+    }
+}
+async function pluginLocaleDirs() {
+    const nm = join(process.cwd(), 'node_modules');
+    return (await pluginPackageNames(nm)).map((name) => join(nm, name, 'locales'));
+}
+function makeResolver(lang, dict) {
+    return {
+        lang,
+        resolve(key) {
+            const value = key
+                .split('.')
+                .reduce((node, part) => (node == null ? undefined : node[part]), dict);
+            return typeof value === 'string' ? value : undefined;
+        },
+    };
+}
+let cached = null;
+export async function loadComposedLocales(opts = {}) {
+    const lang = opts.lang ?? (await systemLanguage('uk'));
+    if (!opts.dirs && cached?.lang === lang)
+        return makeResolver(lang, cached.dict);
+    const dirs = opts.dirs ?? (await pluginLocaleDirs());
+    const dict = {};
+    for (const dir of dirs) {
+        try {
+            deepMerge(dict, JSON.parse(await readFile(join(dir, `${lang}.json`), 'utf8')));
+        }
+        catch {
+        }
+    }
+    if (!opts.dirs)
+        cached = { lang, dict };
+    return makeResolver(lang, dict);
+}
+export function clearComposedLocaleCache() {
+    cached = null;
+}

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

@@ -1,3 +1,4 @@
+import type { LocaleResolver } from '../locale-registry.ts';
 export interface ShelfIndexEntry {
     library: string;
     libraryLabel: string;
@@ -9,6 +10,7 @@ export interface FieldInfo {
     kind: string;
     prim: string;
     required: boolean;
+    agent?: string;
     relation?: {
         library: string;
         shelf: string;
@@ -27,6 +29,7 @@ export interface ShelfDescription {
     library: string;
     shelf: string;
     label: string;
+    agent?: string;
     fields: FieldInfo[];
 }
 interface SchemaClient {
@@ -35,8 +38,10 @@ interface SchemaClient {
 export declare function flattenFields(items: unknown[]): FieldInfo[];
 export declare class SchemaCache {
     private client;
+    private locales?;
     private cached?;
-    constructor(client: SchemaClient);
+    constructor(client: SchemaClient, locales?: LocaleResolver | undefined);
+    private display;
     refresh(): void;
     private load;
     index(): Promise<ShelfIndexEntry[]>;

package/dist/mcp-contract/schema.js

@@ -34,6 +34,7 @@ export function flattenFields(items) {
         kind: t.kind,
         prim: t.prim,
         required: t.required,
+        ...(t.agent ? { agent: t.agent } : {}),
         ...(t.relation ? { relation: t.relation } : {}),
         ...(t.options ? { options: t.options } : {}),
         ...(t.prim === 'file' ? { write: FILE_WRITE_HINT } : {}),
@@ -50,6 +51,7 @@ export function flattenFields(items) {
                 kind: 'group',
                 prim: 'group',
                 required: it.required === true,
+                ...(it.agent ? { agent: it.agent } : {}),
                 ...(it.multiple ? { multiple: true } : {}),
                 fields: flattenFields(it.fields),
             });
@@ -60,9 +62,14 @@ export function flattenFields(items) {
 }
 export class SchemaCache {
     client;
+    locales;
     cached;
-    constructor(client) {
+    constructor(client, locales) {
         this.client = client;
+        this.locales = locales;
+    }
+    display(labelKey, id) {
+        return (labelKey ? this.locales?.resolve(labelKey) : undefined) ?? id;
     }
     refresh() {
         this.cached = undefined;
@@ -74,7 +81,12 @@ export class SchemaCache {
     }
     async index() {
         const libraries = await this.load();
-        return libraries.flatMap((v) => v.shelves.map((m) => ({ library: v.id, libraryLabel: v.label, shelf: m.shelf, label: m.label })));
+        return libraries.flatMap((v) => v.shelves.map((m) => ({
+            library: v.id,
+            libraryLabel: this.display(v.label, v.id),
+            shelf: m.shelf,
+            label: this.display(m.label, m.shelf),
+        })));
     }
     async describeShelf(library, shelf) {
         let m = this.find(await this.load(), library, shelf);
@@ -82,7 +94,13 @@ export class SchemaCache {
             m = this.find(await this.load(true), library, shelf);
         if (!m)
             throw new Error(`unknown_shelf ${library}/${shelf}`);
-        return { library, shelf, label: m.label, fields: flattenFields(m.fields) };
+        return {
+            library,
+            shelf,
+            label: this.display(m.label, m.shelf),
+            ...(m.agent ? { agent: m.agent } : {}),
+            fields: flattenFields(m.fields),
+        };
     }
     find(libraries, library, shelf) {
         return libraries.find((v) => v.id === library)?.shelves.find((m) => m.shelf === shelf);

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { type CofferClientApi } from './client.ts';
 import { SchemaCache } from './schema.ts';
+import type { LocaleResolver } from '../locale-registry.ts';
 export interface ToolResult {
     content: {
         type: 'text';
@@ -16,4 +17,4 @@ export interface ToolDef {
 }
 export declare const LIST_DEFAULT_LIMIT = 25;
 export declare const LIST_MAX_LIMIT = 200;
-export declare function buildTools(client: CofferClientApi, cache: SchemaCache): ToolDef[];
+export declare function buildTools(client: CofferClientApi, cache: SchemaCache, locales?: LocaleResolver): ToolDef[];

package/dist/mcp-contract/tools.js

@@ -40,7 +40,7 @@ async function guard(fn) {
 }
 export const LIST_DEFAULT_LIMIT = 25;
 export const LIST_MAX_LIMIT = 200;
-export function buildTools(client, cache) {
+export function buildTools(client, cache, locales) {
     const library = z.string().describe('Library identifier, e.g. "things"');
     const shelf = z.string().describe('Shelf identifier, e.g. "item"');
     const id = z.coerce.number().int().describe('record id');
@@ -53,12 +53,38 @@ export function buildTools(client, cache) {
         },
         {
             name: 'describe_shelf',
-            description: 'Detailed shelf schema: fields with kind/prim/required and relation/options. A collection is one entry with ' +
-                'multiple:true and its row shape in fields[]. A field with derived:true is computed by the server and rejects ' +
-                'writes — omit it when writing. Call BEFORE create_record/update_record.',
+            description: 'Detailed shelf schema: the shelf note (agent), then fields with kind/prim/required, relation/options, and ' +
+                'a per-field note (agent) saying what that field means. A collection is one entry with multiple:true and its ' +
+                'row shape in fields[]. A field with derived:true is computed by the server and rejects writes — omit it when ' +
+                'writing. Call BEFORE create_record/update_record.',
             inputSchema: { library, shelf },
             handler: (a) => guard(() => cache.describeShelf(a.library, a.shelf)),
         },
+        {
+            name: 'translate',
+            description: "Resolve interface text keys (dotted, e.g. 'things.item.options.condition.good') to their words in this " +
+                "instance's language. Use it when a payload hands you a key instead of a word — an option's title, an " +
+                'extra field-set name — and you need to say that thing to the user. It is for NAMING things in your answer: ' +
+                'tool arguments still take machine ids, so never send a translated word back as a library, shelf, field or ' +
+                'value. A key this instance cannot resolve comes back under "missing" — say you do not have a name for it ' +
+                'rather than inventing one.',
+            inputSchema: {
+                keys: z.array(z.string()).describe('Dotted interface text keys to resolve'),
+            },
+            handler: async (a) => {
+                const keys = Array.isArray(a.keys) ? a.keys.map((k) => String(k)) : [];
+                const resolved = {};
+                const missing = [];
+                for (const k of keys) {
+                    const v = locales?.resolve(k);
+                    if (v === undefined)
+                        missing.push(k);
+                    else
+                        resolved[k] = v;
+                }
+                return ok({ resolved, missing });
+            },
+        },
         {
             name: 'refresh_schema',
             description: 'Re-read the schema from the server. Call after enabling/installing a plugin (server restart required).',

package/dist/mcp-http.js

@@ -1,12 +1,14 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { collectMcpTools, resolveRagDeps, buildDomainSections, buildMcpInstructions } from "./mcp-tools.js";
+import { collectMcpTools, resolveRagDeps, buildDomainSections, buildMcpInstructions, siteSection, } from "./mcp-tools.js";
+import { configuredPublicUrl } from "./public-url.js";
 import { getLogger } from "./log.js";
 const log = getLogger('mcp-http');
 export async function buildMcpServer(role, actor) {
     const rag = await resolveRagDeps();
     const tools = (await collectMcpTools({ rag, includeAdmin: role === 'admin', actor })).filter((t) => role === 'admin' || t.role === 'member');
-    const sections = await buildDomainSections();
+    const site = await siteSection(await configuredPublicUrl());
+    const sections = [...(await buildDomainSections()), ...(site ? [site] : [])];
     const server = new McpServer({ name: 'coffer', version: '1.0.0' }, { instructions: buildMcpInstructions(sections) });
     const registerTool = server.registerTool.bind(server);
     for (const t of tools) {

package/dist/mcp-tools.d.ts

@@ -1,6 +1,7 @@
 import type { EntityManager } from '@mikro-orm/core';
 import { z } from 'zod';
 import { type ToolResult } from './mcp-contract/tools.ts';
+import { type LocaleResolver } from './locale-registry.ts';
 import { type AuthRole, type PluginHooks } from './plugin-hooks.ts';
 import { type Condition } from '@coffer-org/sdk/condition';
 import { type RagHit } from './rag-search.ts';
@@ -31,23 +32,24 @@ export declare function collectPluginInstructions(hooks?: Record<string, PluginH
 type SingleShelf = {
     library: string;
     shelf: string;
-    claude: string;
+    agent: string;
 };
 export declare function collectSingleShelves(reg?: {
     shelves: {
         library: string;
         shelf: string;
         single?: boolean;
-        claude?: string;
+        agent?: string;
     }[];
 }): SingleShelf[];
 type LibraryPurpose = {
     id: string;
+    name: string;
     agent: string;
     extends: {
         id: string;
         shelf: string;
-        claude: string;
+        agent: string;
         showWhen?: Condition;
     }[];
 };
@@ -55,28 +57,31 @@ export declare function collectLibraryPurposes(reg?: {
     libraries: {
         meta: {
             id: string;
+            label?: string;
             agent?: string;
         };
     }[];
     extends_: {
         id: string;
-        claude?: string;
+        agent?: string;
         showWhen?: Condition;
         attachTo: {
             library: string;
             shelf: string;
         }[];
     }[];
-}): LibraryPurpose[];
-export declare function buildDomainSections(): Promise<string[]>;
+}, locales?: LocaleResolver): LibraryPurpose[];
+export declare function siteSection(siteUrl: string): Promise<string | null>;
+export declare function buildDomainSections(locales?: LocaleResolver): Promise<string[]>;
 export declare function collectStarterHints(hooks?: Record<string, PluginHooks>, emFactory?: () => EntityManager, reg?: {
     libraries: {
         meta: {
             id: string;
+            label?: string;
             starterHint?: string;
         };
     }[];
-}): Promise<{
+}, locales?: LocaleResolver): Promise<{
     combined: string;
     hash: string;
 }>;

package/dist/mcp-tools.js

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { buildTools } from "./mcp-contract/tools.js";
 import { SchemaCache } from "./mcp-contract/schema.js";
 import { LocalClient } from "./mcp-local.js";
+import { loadComposedLocales } from "./locale-registry.js";
 import { frontendInstructions } from "./frontend-agent.js";
 import { mintUploadTicket } from "./upload-ticket.js";
 import { pluginHooks, pluginCtx } from "./plugin-hooks.js";
@@ -48,8 +49,9 @@ export async function resolveRagDeps() {
 export async function collectMcpTools(opts = {}) {
     const out = [];
     const client = new LocalClient();
-    const cache = new SchemaCache(client);
-    for (const t of buildTools(client, cache)) {
+    const locales = await loadComposedLocales();
+    const cache = new SchemaCache(client, locales);
+    for (const t of buildTools(client, cache, locales)) {
         out.push({
             server: 'coffer',
             bareName: t.name,
@@ -278,10 +280,10 @@ export function collectSingleShelves(reg) {
     if (!registry)
         return [];
     return registry.shelves
-        .filter((s) => s.single && s.claude)
-        .map((s) => ({ library: s.library, shelf: s.shelf, claude: s.claude }));
+        .filter((s) => s.single && s.agent)
+        .map((s) => ({ library: s.library, shelf: s.shelf, agent: s.agent }));
 }
-export function collectLibraryPurposes(reg) {
+export function collectLibraryPurposes(reg, locales) {
     let registry = reg;
     if (!registry) {
         try {
@@ -297,27 +299,33 @@ export function collectLibraryPurposes(reg) {
         .filter((v) => v.meta.agent)
         .map((v) => ({
         id: v.meta.id,
+        name: (v.meta.label ? locales?.resolve(v.meta.label) : undefined) ?? v.meta.id,
         agent: v.meta.agent,
-        extends: registry.extends_.flatMap((e) => e.claude
+        extends: registry.extends_.flatMap((e) => e.agent
             ? e.attachTo
                 .filter((a) => a.library === v.meta.id)
-                .map((a) => ({ id: e.id, shelf: a.shelf, claude: e.claude, showWhen: e.showWhen }))
+                .map((a) => ({ id: e.id, shelf: a.shelf, agent: e.agent, showWhen: e.showWhen }))
             : []),
     }));
 }
-export async function buildDomainSections() {
-    const libraries = collectLibraryPurposes();
+export async function siteSection(siteUrl) {
+    const site = await frontendInstructions(siteUrl);
+    return site ? `## web\n${site}` : null;
+}
+export async function buildDomainSections(locales) {
+    const i18n = locales ?? (await loadComposedLocales());
+    const libraries = collectLibraryPurposes(undefined, i18n);
     let overview = null;
     if (libraries.length) {
         const blocks = libraries.map((v) => {
-            let s = `### ${v.id} — ${v.agent}`;
+            let s = v.name === v.id ? `### ${v.id} — ${v.agent}` : `### ${v.id} ("${v.name}") — ${v.agent}`;
             if (v.extends.length) {
                 s +=
                     '\nExtra field-sets some records carry (which one depends on the record):\n' +
                         v.extends
                             .map((e) => {
                             const when = describeCondition(e.showWhen, (f) => f).join(' and ');
-                            return `- ${e.id} (on ${e.shelf}${when ? `, when ${when}` : ''}): ${e.claude.replace(/\s*\n\s*/g, ' ')}`;
+                            return `- ${e.id} (on ${e.shelf}${when ? `, when ${when}` : ''}): ${e.agent.replace(/\s*\n\s*/g, ' ')}`;
                         })
                             .join('\n');
             }
@@ -329,7 +337,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.agent.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. ' +
@@ -341,16 +349,9 @@ export async function buildDomainSections() {
         'For duplicates, read both records completely, compare fields/collections/extends/attachments, recommend the less complete record for trash, and offer a field-by-field merge first. ' +
         'Use list_trash and restore_record for recovery; purge_record is irreversible and requires explicit confirmation.';
     const rules = (await collectPluginInstructions()).map(({ id, instructions }) => `## ${id}\n${instructions}`);
-    const site = await frontendInstructions();
-    return [
-        dataModel,
-        ...(overview ? [overview] : []),
-        ...(singleSection ? [singleSection] : []),
-        ...(site ? [`## web\n${site}`] : []),
-        ...rules,
-    ];
+    return [dataModel, ...(overview ? [overview] : []), ...(singleSection ? [singleSection] : []), ...rules];
 }
-export async function collectStarterHints(hooks = pluginHooks, emFactory = () => getEm().fork(), reg) {
+export async function collectStarterHints(hooks = pluginHooks, emFactory = () => getEm().fork(), reg, locales) {
     const parts = [];
     for (const [id, h] of Object.entries(hooks)) {
         const hint = h.agent?.starterHint;
@@ -374,9 +375,12 @@ export async function collectStarterHints(hooks = pluginHooks, emFactory = () =>
             registry = undefined;
         }
     }
+    const i18n = locales ?? (await loadComposedLocales());
     for (const v of registry?.libraries ?? []) {
-        if (v.meta.starterHint)
-            parts.push(`- ${v.meta.id}: ${v.meta.starterHint}`);
+        if (!v.meta.starterHint)
+            continue;
+        const name = v.meta.label ? i18n.resolve(v.meta.label) : undefined;
+        parts.push(`- ${v.meta.id}${name ? ` ("${name}")` : ''}: ${v.meta.starterHint}`);
     }
     const combined = parts.join('\n');
     const hash = createHash('sha1').update(combined).digest('hex');

package/dist/orchestrator/environment.d.ts

@@ -1,3 +1,2 @@
 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

@@ -12,19 +12,3 @@ function part(now, timeZone, locale, options) {
 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/index.d.ts

@@ -8,7 +8,7 @@ export { makeAttachmentCapabilities } from './agent-capabilities.ts';
 export { makeSystemCapabilities } from './system-capabilities.ts';
 export { makeSuggestionCapabilities } from './suggestion-capabilities.ts';
 export type { SuggestionCapability } from './suggestion-capabilities.ts';
-export { currentEnvironment, systemTimeZone } from './environment.ts';
+export { systemTimeZone } from './environment.ts';
 export { inspectUpload, isAgentToolContentResult } from './file-inspection.ts';
 export type { PipelineDeps, RunAgentFn } from './pipeline.ts';
 export { buildPolicy, loadGatePolicy, loadAgentId } from './config.ts';
@@ -17,7 +17,7 @@ export { isSenderAllowed } from './allow.ts';
 export { makeLiveChannel, plainRender } from './live-message.ts';
 export type { LiveChannelOps, LiveChannelOpts, RenderFn } from './live-message.ts';
 export { chunk } from './format.ts';
-export type { Connector, IncomingConversation, GatePolicy, ReplyContext, ReplyPayload, ReplyChannel, AttachmentRef, AttachmentMaterializer, AgentToolDefinition, AgentToolProvider, ConvMessage, SystemLayer, AgentRequest, AgentResult, AgentRuntime, AgentCapabilities, AgentPreset, AgentDescriptor, ConnectorRegistration, AgentToolContentBlock, AgentToolContentResult, } from './types.ts';
+export type { Connector, IncomingConversation, GatePolicy, ReplyContext, ReplyPayload, ReplyChannel, AttachmentRef, AttachmentMaterializer, AgentToolDefinition, AgentToolProvider, ConvMessage, AgentRequest, AgentResult, AgentRuntime, AgentCapabilities, AgentPreset, AgentDescriptor, ConnectorRegistration, AgentToolContentBlock, AgentToolContentResult, } from './types.ts';
 export declare function startOrchestrator(): void;
 export declare function stopOrchestrator(): void;
 export declare const orchestratorStartersTask: BackgroundTask;

package/dist/orchestrator/index.js

@@ -12,7 +12,7 @@ export { attachmentMaterializer } from "./attachments.js";
 export { makeAttachmentCapabilities } from "./agent-capabilities.js";
 export { makeSystemCapabilities } from "./system-capabilities.js";
 export { makeSuggestionCapabilities } from "./suggestion-capabilities.js";
-export { currentEnvironment, systemTimeZone } from "./environment.js";
+export { systemTimeZone } from "./environment.js";
 export { inspectUpload, isAgentToolContentResult } from "./file-inspection.js";
 export { buildPolicy, loadGatePolicy, loadAgentId } from "./config.js";
 export { getConversationStarters, refreshSystemStarters } from "./starters.js";

package/dist/orchestrator/pipeline.js

@@ -101,15 +101,15 @@ export async function handleIncoming(connector, conversation, deps) {
     const preparedMessages = conversation.prepareAttachments
         ? await safeCall(() => conversation.prepareAttachments(attachmentMaterializer), messages, 'prepareAttachments')
         : messages;
-    const agentMessages = policy.triggerPrefix
-        ? preparedMessages.map((m, i) => (i === preparedMessages.length - 1 ? { ...m, content: queryText } : m))
-        : preparedMessages;
+    const agentMessages = preparedMessages.map((m, i) => i === preparedMessages.length - 1
+        ? {
+            ...m,
+            ...(policy.triggerPrefix ? { content: queryText } : {}),
+            ...(conversation.turnContext ? { context: conversation.turnContext } : {}),
+        }
+        : m);
     const base = await agentBase();
-    const system = buildSystem({
-        base,
-        channelSystem: conversation.channelSystem,
-        volatileSystem: conversation.volatileSystem,
-    });
+    const system = buildSystem({ base, channelSystem: conversation.channelSystem });
     db?.logTurn({
         connector: connectorId,
         chatId,

package/dist/orchestrator/system-assembly.d.ts

@@ -1,7 +1,4 @@
-import type { SystemLayer } from './types.ts';
 export declare function buildSystem(input: {
     base: string;
     channelSystem?: string;
-    volatileSystem?: string;
-    environment?: string;
-}): SystemLayer[];
+}): string;

package/dist/orchestrator/system-assembly.js

@@ -1,13 +1,3 @@
-import { currentEnvironment } from "./environment.js";
 export function buildSystem(input) {
-    const text = [input.base, input.channelSystem].filter(Boolean).join('\n\n');
-    const layers = [{ text, stable: true }];
-    const environment = input.environment ?? currentEnvironment();
-    const volatile = [environment, input.volatileSystem]
-        .map((part) => part?.trim())
-        .filter(Boolean)
-        .join('\n\n');
-    if (volatile)
-        layers.push({ text: volatile, stable: false });
-    return layers;
+    return [input.base, input.channelSystem].filter(Boolean).join('\n\n');
 }

package/dist/orchestrator/types.d.ts

@@ -34,15 +34,12 @@ export interface AgentToolContentResult {
 export interface ConvMessage {
     role: 'user' | 'assistant';
     content: string;
+    context?: string;
     attachments?: AttachmentRef[];
     sender?: string | null;
     msgId: string;
     ts: number;
 }
-export interface SystemLayer {
-    text: string;
-    stable: boolean;
-}
 export interface AgentCapabilities {
     vision?: boolean;
     documents?: boolean;
@@ -64,7 +61,7 @@ export interface AgentDescriptor {
     presets: AgentPreset[];
 }
 export interface AgentRequest {
-    system: SystemLayer[];
+    system: string;
     messages: ConvMessage[];
     toolProvider?: AgentToolProvider;
     presetId?: string;
@@ -103,7 +100,7 @@ export interface IncomingConversation {
     presetId?: string;
     chatId: string;
     channelSystem?: string;
-    volatileSystem?: string;
+    turnContext?: string;
     sender: {
         id: string;
         displayName?: string;

package/dist/plugin-discovery.d.ts

@@ -1,5 +1,6 @@
 import type { PluginManifest } from '@coffer-org/sdk/plugin';
 import type { PluginHooks } from './plugin-hooks.ts';
+export declare function pluginPackageNames(nm: string): Promise<string[]>;
 export interface PluginAssetPaths {
     schema: string;
     web?: string;

package/dist/plugin-discovery.js

@@ -11,7 +11,7 @@ import { join, sep } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('discovery');
-async function pkgNames(nm) {
+export async function pluginPackageNames(nm) {
     const names = [];
     try {
         for (const d of await readdir(join(nm, '@coffer-org'))) {
@@ -58,7 +58,7 @@ export async function discoverPluginAssets() {
     if (assetsCache)
         return assetsCache;
     const nm = join(process.cwd(), 'node_modules');
-    const names = await pkgNames(nm);
+    const names = await pluginPackageNames(nm);
     const out = [];
     for (const name of names) {
         try {
@@ -121,7 +121,7 @@ async function loadManifest(nm, name) {
 }
 export async function discoverPlugins() {
     const nm = join(process.cwd(), 'node_modules');
-    const names = await pkgNames(nm);
+    const names = await pluginPackageNames(nm);
     const manifests = [];
     for (const name of names) {
         const m = await loadManifest(nm, name);
@@ -132,7 +132,7 @@ export async function discoverPlugins() {
 }
 export async function loadServerHooks() {
     const nm = join(process.cwd(), 'node_modules');
-    const names = await pkgNames(nm);
+    const names = await pluginPackageNames(nm);
     const hooks = {};
     for (const name of names) {
         try {

package/dist/plugin-i18n.d.ts

@@ -1,3 +1,4 @@
+export declare function systemLanguage(fallback: string): Promise<string>;
 export interface PluginI18n {
     lang: string;
     t(key: string, fallback?: string): string;

package/dist/plugin-i18n.js

@@ -1,6 +1,6 @@
 import { readFile } from 'node:fs/promises';
 const cache = new Map();
-async function systemLanguage(fallback) {
+export async function systemLanguage(fallback) {
     try {
         const { getPluginSettings } = await import("./plugin-runtime.js");
         const { SYSTEM_SETTINGS_ID } = await import("./system-settings.js");

package/dist/system-settings.js

@@ -12,14 +12,14 @@ export const SYSTEM_SETTINGS = defineSettings({
             label: 'core.settings.language',
             default: 'uk',
             strict: true,
-            view: { noSearch: true },
+            noSearch: true,
             options: [
                 { value: 'uk', title: 'Українська' },
                 { value: 'ru', title: 'Русский' },
                 { value: 'en', title: 'English' },
             ],
         }),
-        agent_id: field.string({ label: 'core.settings.agent_id', strict: true, view: { noSearch: true } }),
+        agent_id: field.string({ label: 'core.settings.agent_id', strict: true, noSearch: true }),
         access_password: field.password({ label: 'core.settings.access_password' }),
         trigger_prefix: field.string({ label: 'core.settings.trigger_prefix' }),
         reply_window: field.int({ label: 'core.settings.reply_window', default: 1800 }),

package/package.json

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