@coffer-org/server 7.2.0 → 7.4.0

package/dist/orchestrator/pipeline.js

@@ -1,27 +1,30 @@
-import { loadAllowed, saveAllowed, isAllowed, addAllowed, makeThrottle, allowFileFor } from "./allow.js";
 import { loadAgentId, loadGatePolicy } from "./config.js";
-import { buildSystem } from "./system-assembly.js";
+import { assembleSystem, mergeAreas } from "./system-areas.js";
 import { attachmentMaterializer } from "./attachments.js";
 import { makeAttachmentCapabilities } from "./agent-capabilities.js";
 import { makeSystemCapabilities } from "./system-capabilities.js";
-import { makeSuggestionCapabilities } from "./suggestion-capabilities.js";
 import { resolveAgent } from "./registry.js";
 import { recordDiagnostic } from "./diagnostics.js";
 import { getLogger } from '@coffer-org/sdk/logger';
+import { buildContextFacts } from "./context-facts.js";
+import { systemTimeZone } from "./environment.js";
+import { discoverPlugins } from "../plugin-discovery.js";
+import { SchemaCache } from "../mcp-contract/schema.js";
+import { LocalClient } from "../mcp-local.js";
+import { loadComposedLocales } from "../locale-registry.js";
+import { buildDomainAreas } from "../mcp-tools.js";
+import { getActiveRegistry } from "../registry-context.js";
+import { DEFAULT_MAX_DEPTH, countUserMessages, newMessageId, putMessage, readConversation, readAll, } from "../conversation-store.js";
 const log = getLogger('orchestrator');
+const DEFAULT_MEDIA = {
+    image: { maxBytes: 5 * 1024 * 1024, maxEdge: 1568, accepts: ['image/*'], encode: ['image/jpeg', 'image/png'] },
+    document: { maxBytes: 10 * 1024 * 1024, accepts: ['application/pdf'] },
+    text: { maxBytes: 512 * 1024, accepts: ['text/*'] },
+};
 let logDb;
 export function setLogDb(db) {
     logDb = db;
 }
-const throttleByConnector = new Map();
-function passThrottle(connectorId) {
-    let t = throttleByConnector.get(connectorId);
-    if (!t) {
-        t = makeThrottle(5, 60_000);
-        throttleByConnector.set(connectorId, t);
-    }
-    return t;
-}
 let cachedBase;
 let cachedBaseAgentId;
 function cachedAgentBase() {
@@ -32,14 +35,125 @@ function cachedAgentBase() {
     }
     return cachedBase;
 }
-function openChannel(connector, chatId, ctx) {
+let cachedWorld;
+export function liveWorld() {
+    if (!cachedWorld) {
+        cachedWorld = (async () => {
+            const [plugins, locales] = await Promise.all([discoverPlugins(), loadComposedLocales()]);
+            const shelves = await new SchemaCache(new LocalClient(), locales).index();
+            const pluginIds = new Set(plugins.map((p) => p.id));
+            const shelfKeys = new Set(shelves.map((s) => `${s.library}/${s.shelf}`));
+            let libraryIds;
+            try {
+                libraryIds = new Set(getActiveRegistry().libraries.map((v) => v.meta.id));
+            }
+            catch {
+                libraryIds = new Set(shelves.map((s) => s.library));
+            }
+            return {
+                hasPlugin: (id) => pluginIds.has(id),
+                hasLibrary: (id) => libraryIds.has(id),
+                hasShelf: (library, shelf) => shelfKeys.has(`${library}/${shelf}`),
+            };
+        })();
+    }
+    return cachedWorld;
+}
+let cachedDomain;
+function cachedDomainAreas() {
+    if (!cachedDomain)
+        cachedDomain = buildDomainAreas();
+    return cachedDomain;
+}
+export function foldContextFacts(messages) {
+    const acc = new Map();
+    for (const m of messages) {
+        let facts;
+        if ('role' in m && m.role === 'context') {
+            try {
+                const parsed = JSON.parse(m.text);
+                if (Array.isArray(parsed))
+                    facts = parsed;
+            }
+            catch {
+            }
+        }
+        else if ('context' in m && Array.isArray(m.context)) {
+            facts = m.context;
+        }
+        if (facts) {
+            for (const fact of facts) {
+                if (fact.name === 'cleared')
+                    acc.delete(fact.value);
+                else
+                    acc.set(fact.name, fact);
+            }
+        }
+    }
+    return [...acc.values()];
+}
+export function lastContextAt(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if ('role' in m && m.role === 'context') {
+            try {
+                const parsed = JSON.parse(m.text);
+                if (Array.isArray(parsed) && parsed.length > 0) {
+                    return new Date(m.ts * 1000);
+                }
+            }
+            catch {
+            }
+        }
+        if ('context' in m && m.context && m.context.length > 0) {
+            return new Date(m.ts * 1000);
+        }
+    }
+    return null;
+}
+export function toConvMessages(stored, facts, userMsgId, queryText, contextSource = stored) {
+    const contextMap = new Map();
+    for (const m of contextSource) {
+        if (m.role === 'context') {
+            try {
+                const parsed = JSON.parse(m.text);
+                if (Array.isArray(parsed)) {
+                    contextMap.set(m.msgId, parsed);
+                }
+            }
+            catch {
+            }
+        }
+    }
+    const out = [];
+    for (const m of stored) {
+        if (m.role !== 'user' && m.role !== 'assistant')
+            continue;
+        const isCurrentUser = m.msgId === userMsgId;
+        const itemContext = isCurrentUser ? (facts.length ? facts : undefined) : contextMap.get(`${m.msgId}~c`);
+        out.push({
+            role: m.role,
+            content: isCurrentUser ? queryText : m.text,
+            sender: m.sender,
+            ...(m.attachments ? { attachments: m.attachments } : {}),
+            msgId: m.msgId,
+            ts: m.ts,
+            ...(itemContext?.length ? { context: itemContext } : {}),
+        });
+    }
+    while (out.length && out[0]?.role !== 'user')
+        out.shift();
+    return out;
+}
+const storeLookup = async (id) => (await import("../auth-store.js")).findUserById(id);
+function openSink(connector, envelope, msgId) {
     try {
-        return connector.reply(chatId, ctx);
+        return connector.open(envelope, msgId);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        log.error(`connector error in reply: ${message}`);
-        recordDiagnostic('error', 'connector.reply', message);
+        log.error(`connector error in open: ${message}`);
+        recordDiagnostic('error', 'connector.open', message);
         return null;
     }
 }
@@ -54,145 +168,232 @@ async function safeCall(fn, fallback, label) {
         return fallback;
     }
 }
-export async function handleIncoming(connector, conversation, deps) {
+export async function handleIncoming(connector, turn, deps) {
     const policy = deps?.policy ?? (await loadGatePolicy());
-    const selectedAgentId = conversation.agentId ?? policy.agentId ?? (deps?.runAgent ? undefined : await loadAgentId());
+    const selectedAgentId = turn.agentId ?? policy.agentId ?? (deps?.runAgent ? undefined : await loadAgentId());
     const runtime = deps?.runAgent ? undefined : resolveAgent(selectedAgentId);
     const agent = deps?.runAgent ?? runtime.run.bind(runtime);
+    const agentMedia = () => deps?.media ?? runtime?.media ?? DEFAULT_MEDIA;
     const db = deps && 'logDb' in deps ? deps.logDb : logDb;
     const agentBase = deps?.agentBase ?? (() => (selectedAgentId ? runtime.systemBase() : cachedAgentBase()));
-    const { connectorId, chatId, sender, messages } = conversation;
-    const last = messages[messages.length - 1];
-    if (!last || last.role !== 'user')
+    const { connectorId } = turn.envelope;
+    const conversationId = turn.envelope.conversationId;
+    const { sender } = turn;
+    const text = turn.message?.text ?? '';
+    const replyToId = turn.message?.replyToMsgId ?? null;
+    const rawAttachments = turn.prepareAttachments
+        ? await safeCall(() => turn.prepareAttachments(attachmentMaterializer), [], 'prepareAttachments')
+        : turn.message?.attachments;
+    const attachments = Array.isArray(rawAttachments) && rawAttachments.length > 0 && 'role' in rawAttachments[0]
+        ? rawAttachments.at(-1)?.attachments
+        : rawAttachments;
+    const userMsgId = newMessageId();
+    const now = deps?.now ? deps.now() : new Date();
+    const ts = Math.floor(now.getTime() / 1000);
+    await putMessage({
+        conversationId,
+        msgId: userMsgId,
+        role: 'user',
+        sender: String(sender.userId),
+        text,
+        ...(attachments ? { attachments } : {}),
+        ts,
+        replyToId,
+    });
+    if (policy.triggerPrefix && !text.toLowerCase().startsWith(policy.triggerPrefix.toLowerCase()))
         return;
-    const incomingMsgId = last.msgId;
-    const allowFile = allowFileFor(connectorId);
-    if (policy.accessPassword) {
-        let allow = loadAllowed(allowFile);
-        if (!isAllowed(allow, sender.id)) {
-            if (last.content.trim() === policy.accessPassword) {
-                allow = addAllowed(allow, sender.id, Date.now());
-                saveAllowed(allowFile, allow);
-                const ch = openChannel(connector, chatId, { parentMsgId: incomingMsgId });
-                if (ch)
-                    await safeCall(() => ch.finish({ text: '✅ Access granted. Send your requests.', reasoning: null, suggestions: null }), null, 'finish(enroll)');
-            }
-            else if (passThrottle(connectorId)(sender.id)) {
-                const ch = openChannel(connector, chatId, { parentMsgId: incomingMsgId });
-                if (ch)
-                    await safeCall(() => ch.finish({
-                        text: '🔒 Access locked. Send the password to gain access.',
-                        reasoning: null,
-                        suggestions: null,
-                    }), null, 'finish(locked)');
-            }
-            return;
-        }
-    }
-    if (policy.triggerPrefix && !last.content.toLowerCase().startsWith(policy.triggerPrefix.toLowerCase()))
+    const speakerRow = await (deps?.lookupUser ?? storeLookup)(sender.userId);
+    if (!speakerRow || speakerRow.disabled)
         return;
-    const queryText = policy.triggerPrefix ? last.content.slice(policy.triggerPrefix.length).trim() : last.content.trim();
-    if (!queryText) {
-        if (conversation.prepareAttachments && !policy.triggerPrefix) {
-            await safeCall(() => conversation.prepareAttachments(attachmentMaterializer), messages, 'prepareAttachments');
-        }
+    if (turn.signal?.aborted)
+        return;
+    const queryText = policy.triggerPrefix ? text.slice(policy.triggerPrefix.length).trim() : text.trim();
+    if (!queryText)
         return;
+    const speaker = {
+        id: String(sender.userId),
+        name: speakerRow.displayName ?? sender.displayName ?? String(sender.userId),
+        role: speakerRow.role,
+    };
+    const stored = await readConversation(conversationId, { limit: DEFAULT_MAX_DEPTH });
+    const all = await readAll(conversationId);
+    const facts = buildContextFacts({
+        connectorFacts: turn.turnContext ?? [],
+        speaker,
+        now,
+        timeZone: deps?.timeZone ?? systemTimeZone(),
+        previous: foldContextFacts(all),
+        previousAt: lastContextAt(all),
+    });
+    if (facts.length) {
+        await putMessage({
+            conversationId,
+            msgId: `${userMsgId}~c`,
+            role: 'context',
+            text: JSON.stringify(facts),
+            ts: ts - 1,
+        });
     }
-    const preparedMessages = conversation.prepareAttachments
-        ? await safeCall(() => conversation.prepareAttachments(attachmentMaterializer), messages, 'prepareAttachments')
-        : messages;
-    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 });
+    const agentMessages = toConvMessages(stored, facts, userMsgId, queryText, all);
+    const authored = turn.systemPrompt ?? {};
+    const domain = await (deps?.domainAreas ?? cachedDomainAreas)();
+    const areas = mergeAreas({ root: [await agentBase()] }, domain, authored);
+    const system = assembleSystem(areas, deps?.world ?? (await liveWorld()));
+    if (turn.signal?.aborted)
+        return;
     db?.logTurn({
         connector: connectorId,
-        chatId,
-        userId: sender.id,
+        chatId: conversationId,
+        userId: String(sender.userId),
         role: 'user',
         text: queryText,
         tokensIn: null,
         tokensOut: null,
         ms: null,
         agentId: selectedAgentId ?? null,
-        presetId: conversation.presetId ?? null,
+        presetId: turn.presetId ?? null,
     });
     const startedAt = Date.now();
-    const ch = openChannel(connector, chatId, { parentMsgId: incomingMsgId });
-    if (!ch)
+    const botMsgId = newMessageId();
+    const sink = openSink(connector, turn.envelope, botMsgId);
+    if (!sink)
         return;
-    let result;
-    const suggestionCaps = conversation.supportsSuggestions ? makeSuggestionCapabilities() : undefined;
+    let usage;
+    let answerText = null;
+    let reasoningText = null;
+    let runFailed = false;
+    let agentTurn;
     try {
-        const attachmentTools = await makeAttachmentCapabilities(agentMessages.flatMap((m) => m.attachments ?? []));
+        const attachmentTools = await makeAttachmentCapabilities(agentMessages.flatMap((m) => m.attachments ?? []), agentMedia());
         const toolProvider = {
-            tools: [...attachmentTools.tools, ...makeSystemCapabilities().tools, ...(suggestionCaps?.tools ?? [])],
+            tools: [...attachmentTools.tools, ...makeSystemCapabilities().tools],
         };
-        result = await agent({
-            system,
-            messages: agentMessages,
+        const userMessageCount = await countUserMessages(conversationId);
+        agentTurn = {
+            envelope: turn.envelope,
+            body: { system, messages: agentMessages, userMessageCount },
             toolProvider,
-            ...(conversation.presetId ? { presetId: conversation.presetId } : {}),
-            onDelta: (acc) => {
-                try {
-                    ch.update(acc);
+            ...(turn.presetId ? { presetId: turn.presetId } : {}),
+            senderRole: speaker.role,
+            ...(turn.signal ? { signal: turn.signal } : {}),
+        };
+        await agent(agentTurn, (event) => {
+            try {
+                if (event.kind === 'usage') {
+                    usage = { tokensIn: event.tokensIn, tokensOut: event.tokensOut, presetId: event.presetId };
                 }
-                catch (err) {
-                    log.error(`connector error in update: ${err instanceof Error ? err.message : String(err)}`);
+                else if (event.kind === 'reasoning') {
+                    reasoningText = event.text;
                 }
-            },
-            onReasoning: (acc) => {
+                else if (event.kind === 'answer') {
+                    answerText = event.text;
+                    if (event.reasoning !== null) {
+                        reasoningText = event.reasoning;
+                    }
+                }
+                sink.emit(event);
+            }
+            catch (err) {
+                log.error(`connector error in ${event.kind}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        });
+    }
+    catch (err) {
+        runFailed = true;
+        const message = err instanceof Error ? err.message : String(err);
+        log.error(`agent error: ${message}`);
+        recordDiagnostic('error', 'agent.run', message);
+        try {
+            sink.emit({ kind: 'error', message });
+        }
+        catch (sinkErr) {
+            log.error(`connector error in error: ${sinkErr instanceof Error ? sinkErr.message : String(sinkErr)}`);
+        }
+    }
+    await safeCall(() => sink.done(), undefined, 'done');
+    const capabilities = turn.capabilities ?? { events: [], privateChats: false };
+    const botTs = Math.max(ts + 2, Math.floor(Date.now() / 1000));
+    if (answerText !== null) {
+        await putMessage({
+            conversationId,
+            msgId: botMsgId,
+            role: 'assistant',
+            sender: null,
+            text: answerText,
+            ts: botTs,
+            replyToId: userMsgId,
+        });
+        if (reasoningText && capabilities.events.includes('reasoning')) {
+            await putMessage({
+                conversationId,
+                msgId: `${botMsgId}~r`,
+                role: 'reasoning',
+                text: reasoningText,
+                ts: botTs - 1,
+            });
+        }
+    }
+    let extraSuggestions;
+    if (!runFailed && answerText && agentTurn) {
+        const events = capabilities.events;
+        const want = { suggestions: events.includes('suggestions'), title: events.includes('title') };
+        const afterwordFn = deps?.afterword ?? runtime?.afterword;
+        if ((want.suggestions || want.title) && afterwordFn) {
+            let extra;
+            try {
+                extra = await afterwordFn(agentTurn, answerText, want);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                recordDiagnostic('error', 'agent.afterword', message);
+            }
+            if (extra?.suggestions?.length) {
+                extraSuggestions = extra.suggestions;
                 try {
-                    ch.updateReasoning?.(acc);
+                    sink.emit({ kind: 'suggestions', items: extra.suggestions });
                 }
                 catch (err) {
-                    log.error(`connector error in updateReasoning: ${err instanceof Error ? err.message : String(err)}`);
+                    log.error(`connector error in suggestions: ${err instanceof Error ? err.message : String(err)}`);
                 }
-            },
-            onSegment: () => {
+            }
+            if (extra?.title) {
                 try {
-                    ch.segment();
+                    sink.emit({ kind: 'title', text: extra.title });
                 }
                 catch (err) {
-                    log.error(`connector error in segment: ${err instanceof Error ? err.message : String(err)}`);
+                    log.error(`connector error in title: ${err instanceof Error ? err.message : String(err)}`);
                 }
-            },
-        });
+            }
+            if (usage && extra && (extra.tokensIn !== undefined || extra.tokensOut !== undefined)) {
+                usage = {
+                    ...usage,
+                    tokensIn: usage.tokensIn === null ? null : usage.tokensIn + (extra.tokensIn ?? 0),
+                    tokensOut: usage.tokensOut === null ? null : usage.tokensOut + (extra.tokensOut ?? 0),
+                };
+            }
+        }
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        log.error(`agent error: ${message}`);
-        recordDiagnostic('error', 'agent.run', message);
+    await safeCall(() => sink.done(), undefined, 'done');
+    if (extraSuggestions?.length && capabilities.events.includes('suggestions')) {
+        await putMessage({
+            conversationId,
+            msgId: `${botMsgId}~s`,
+            role: 'suggestions',
+            text: JSON.stringify(extraSuggestions),
+            ts: botTs - 1,
+        });
     }
-    if (result && suggestionCaps)
-        result.suggestions = suggestionCaps.getCaptured();
-    const botMsgId = await safeCall(() => ch.finish({
-        text: result?.text ?? null,
-        reasoning: result?.reasoning ?? null,
-        suggestions: result?.suggestions ?? null,
-    }), null, 'finish');
-    if (result?.text)
+    if (!runFailed && usage && answerText)
         db?.logTurn({
             connector: connectorId,
-            chatId,
-            userId: sender.id,
+            chatId: conversationId,
+            userId: String(sender.userId),
             role: 'assistant',
-            text: result.text,
-            tokensIn: result.tokensIn,
-            tokensOut: result.tokensOut,
+            text: answerText,
+            tokensIn: usage.tokensIn,
+            tokensOut: usage.tokensOut,
             ms: Date.now() - startedAt,
             agentId: selectedAgentId ?? null,
-            presetId: result.presetId,
+            presetId: usage.presetId,
         });
-    await safeCall(() => connector.recordAssistant({
-        parentMsgId: incomingMsgId,
-        botMsgId,
-        text: result?.text ?? '',
-        reasoning: result?.reasoning ?? null,
-    }), undefined, 'recordAssistant');
 }

package/dist/orchestrator/registry.d.ts

@@ -1,4 +1,4 @@
-import type { AgentDescriptor, AgentRuntime, ConnectorRegistration } from './types.ts';
+import type { AgentCatalogEntry, AgentRuntime, ConnectorRegistration } from './types.ts';
 export declare function registerAgent(runtime: AgentRuntime, opts?: {
     default?: boolean;
 }): () => void;
@@ -8,6 +8,6 @@ export declare function registerConnector(registration: ConnectorRegistration):
 export declare function isConnectorRegistered(id: string): boolean;
 export declare function listRegisteredAgents(): string[];
 export declare function listRegisteredConnectors(): string[];
-export declare function listAgentCatalog(): Promise<AgentDescriptor[]>;
+export declare function listAgentCatalog(): Promise<AgentCatalogEntry[]>;
 export declare function getDefaultAgentId(): string | undefined;
 export declare function clearRuntimeRegistries(): void;

package/dist/orchestrator/registry.js

@@ -56,7 +56,7 @@ export async function listAgentCatalog() {
         if (!runtime)
             continue;
         try {
-            out.push(await runtime.describe());
+            out.push({ ...(await runtime.describe()), media: runtime.media });
         }
         catch (err) {
             log.error(`agent describe failed for ${id}: ${err instanceof Error ? err.message : String(err)}`);

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

@@ -0,0 +1,12 @@
+export type SystemAreas = Record<string, string[]>;
+export interface AreaWorld {
+    hasPlugin(id: string): boolean;
+    hasLibrary(id: string): boolean;
+    hasShelf(library: string, shelf: string): boolean;
+}
+export declare const KIND_ORDER: readonly ["root", "plugin", "library", "shelf", "channel"];
+export declare const UNCONDITIONAL: ReadonlySet<string>;
+export declare function rank(key: string): number;
+export declare const ALL_PRESENT: AreaWorld;
+export declare function mergeAreas(...areas: SystemAreas[]): SystemAreas;
+export declare function assembleSystem(areas: SystemAreas, world: AreaWorld): string[];

package/dist/orchestrator/system-areas.js

@@ -0,0 +1,63 @@
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('orchestrator');
+export const KIND_ORDER = ['root', 'plugin', 'library', 'shelf', 'channel'];
+export const UNCONDITIONAL = new Set(['root', 'channel']);
+function keep(key, world) {
+    if (UNCONDITIONAL.has(key))
+        return true;
+    const colon = key.indexOf(':');
+    if (colon < 0)
+        return null;
+    const kind = key.slice(0, colon);
+    const id = key.slice(colon + 1);
+    if (!id)
+        return null;
+    if (kind === 'plugin')
+        return world.hasPlugin(id);
+    if (kind === 'library')
+        return world.hasLibrary(id);
+    if (kind === 'shelf') {
+        const slash = id.indexOf('/');
+        if (slash < 1 || slash === id.length - 1 || id.indexOf('/', slash + 1) >= 0)
+            return null;
+        return world.hasShelf(id.slice(0, slash), id.slice(slash + 1));
+    }
+    return null;
+}
+export function rank(key) {
+    const colon = key.indexOf(':');
+    const kind = colon < 0 ? key : key.slice(0, colon);
+    const i = KIND_ORDER.indexOf(kind);
+    return i < 0 ? KIND_ORDER.length : i;
+}
+export const ALL_PRESENT = {
+    hasPlugin: () => true,
+    hasLibrary: () => true,
+    hasShelf: () => true,
+};
+export function mergeAreas(...areas) {
+    const out = {};
+    for (const a of areas) {
+        for (const [key, lines] of Object.entries(a)) {
+            out[key] = [...(out[key] ?? []), ...lines];
+        }
+    }
+    return out;
+}
+export function assembleSystem(areas, world) {
+    const kept = [];
+    for (const key of Object.keys(areas)) {
+        const verdict = keep(key, world);
+        if (verdict === null) {
+            log.warn(`unknown system-prompt area '${key}' — dropped`);
+            continue;
+        }
+        if (verdict)
+            kept.push(key);
+    }
+    kept.sort((a, b) => rank(a) - rank(b) || (a < b ? -1 : a > b ? 1 : 0));
+    return kept
+        .flatMap((key) => areas[key] ?? [])
+        .map((line) => line.trim())
+        .filter(Boolean);
+}

package/dist/orchestrator/system-capabilities.js

@@ -42,7 +42,7 @@ export function makeSystemCapabilities() {
             'platform, memory, and the database file path with its size and free disk space. ' +
             'Use it for questions about the instance itself ("which version am I running", "is the disk filling up", ' +
             '"how long has the server been up"). It returns nothing about the user\'s records — use count_records for those. ' +
-            'The current date and time are already given in the system prompt; do not call this tool to find them.',
+            "The current date and time are already given in each turn's context; do not call this tool to find them.",
         inputSchema: {},
         handler: async () => ({
             coffer_version: await runtimeVersion(),

package/dist/orchestrator/turn-context.d.ts

@@ -0,0 +1,18 @@
+import type { AuthRole } from '../plugin-hooks.ts';
+export declare const PAUSE_THRESHOLD_MS: number;
+export interface TurnSpeaker {
+    name: string;
+    role: AuthRole;
+}
+export interface TurnContextInput {
+    connectorLines: readonly string[];
+    speaker: TurnSpeaker;
+    previousSpeakerName: string | null;
+    now: Date;
+    timeZone: string;
+    previousMessageTs: number | null;
+}
+export declare const MAX_SPEAKER_NAME = 80;
+export declare function oneLine(value: string, maxLen?: number): string;
+export declare function humanizePause(ms: number): string;
+export declare function buildTurnContext(input: TurnContextInput): string;