@coffer-org/server 7.3.0 → 7.5.0

package/dist/orchestrator/draft-message.js

@@ -0,0 +1,85 @@
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('orchestrator');
+async function swallow(fn, fallback, label) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        log.error(`draft-message ${label}: ${err instanceof Error ? err.message : String(err)}`);
+        return fallback;
+    }
+}
+export function makeDraftSink(o) {
+    let text = '';
+    let reasoning = '';
+    let lastDraft = '';
+    let lastPush = 0;
+    let busy = false;
+    let closed = false;
+    let inFlight = Promise.resolve();
+    const timer = setInterval(() => {
+        if (closed || busy)
+            return;
+        const t = o.preview({ text, reasoning: reasoning || null }).slice(0, o.maxLength);
+        if (!t)
+            return;
+        if (t === lastDraft && Date.now() - lastPush < o.keepAliveMs)
+            return;
+        busy = true;
+        inFlight = swallow(() => o.ops.draft(t), undefined, 'draft')
+            .then(() => {
+            lastDraft = t;
+            lastPush = Date.now();
+        })
+            .finally(() => {
+            busy = false;
+        });
+    }, o.throttleMs);
+    if (typeof timer.unref === 'function')
+        timer.unref();
+    function flushSegment() {
+        const body = text.slice(0, o.maxLength).trim();
+        text = '';
+        lastDraft = '';
+        lastPush = 0;
+        if (!body)
+            return;
+        inFlight = inFlight.then(() => swallow(() => o.ops.send(body), null, 'send(segment)'));
+    }
+    async function deliver(r) {
+        closed = true;
+        clearInterval(timer);
+        await inFlight;
+        for (const part of o.render(r)) {
+            await swallow(() => o.ops.send(part), null, 'send(final)');
+        }
+    }
+    let finished = Promise.resolve();
+    let terminalDelivered = false;
+    function deliverTerminal(kind, r) {
+        if (terminalDelivered) {
+            log.warn(`draft-message: a second terminal event (${kind}) after the turn already finished — dropped`);
+            return;
+        }
+        terminalDelivered = true;
+        finished = deliver(r);
+    }
+    return {
+        emit(e) {
+            if (e.kind === 'delta')
+                text = e.text;
+            else if (e.kind === 'reasoning')
+                reasoning = e.text;
+            else if (e.kind === 'segment')
+                flushSegment();
+            else if (e.kind === 'answer')
+                deliverTerminal('answer', { text: e.text, reasoning: e.reasoning });
+            else if (e.kind === 'error')
+                deliverTerminal('error', { text: null, reasoning: null });
+        },
+        done: () => {
+            clearInterval(timer);
+            return finished;
+        },
+    };
+}

package/dist/orchestrator/index.d.ts

@@ -4,7 +4,7 @@ import { listDiagnostics } from './diagnostics.ts';
 import { type PipelineOptions } from './pipeline.ts';
 import type { Connector, TurnRequest } from './types.ts';
 export declare const handleIncoming: (connector: Connector, turn: TurnRequest, options?: PipelineOptions) => Promise<void>;
-export { registerAgent, resolveAgent, registerConnector, isConnectorRegistered, clearRuntimeRegistries, listRegisteredAgents, listRegisteredConnectors, listLinkableConnectors, connectorLinkUrl, listAgentCatalog, getDefaultAgentId, liveAgentId, } from './registry.ts';
+export { registerAgent, resolveAgent, registerConnector, isConnectorRegistered, clearRuntimeRegistries, listRegisteredAgents, listRegisteredConnectors, listAgentCatalog, getDefaultAgentId, liveAgentId, } from './registry.ts';
 export { attachmentMaterializer } from './attachments.ts';
 export { makeAttachmentCapabilities } from './agent-capabilities.ts';
 export { makeSystemCapabilities } from './system-capabilities.ts';
@@ -15,19 +15,18 @@ export { inspectUpload, isAgentToolContentResult } from './file-inspection.ts';
 export type { PipelineOptions, RunAgentFn } from './pipeline.ts';
 export { buildPolicy, loadGatePolicy, loadAgentId } from './config.ts';
 export { getConversationStarters, refreshSystemStarters } from './starters.ts';
-export { resolveSpeaker } from './pipeline.ts';
 export { mayRead, mayWrite, mayBePrivate } from './conversation-access.ts';
 export type { ConversationAccess } from './conversation-access.ts';
 export { makeLiveSink, plainRender } from './live-message.ts';
 export type { LiveChannelOps, LiveSinkOpts, RenderFn } from './live-message.ts';
-export { chunk } from './format.ts';
+export { makeDraftSink } from './draft-message.ts';
+export type { DraftChannelOps, DraftSinkOpts } from './draft-message.ts';
 export { DEFAULT_TASK_TIMEOUT_MS } from '../background-scheduler.ts';
-export type { Connector, TurnEnvelope, ConnectorCapabilities, TurnBody, TurnRequest, SenderIdKind, GatePolicy, TurnEvent, TurnSink, AttachmentRef, AttachmentMaterializer, AgentToolDefinition, AgentToolProvider, ConvMessage, AgentTurn, AgentRuntime, AgentCapabilities, AgentMediaKind, AgentMediaLimits, AgentPreset, AgentDescriptor, AgentCatalogEntry, ConnectorRegistration, AgentToolContentBlock, AgentToolContentResult, } from './types.ts';
+export type { Connector, TurnEnvelope, ConnectorCapabilities, TurnBody, TurnRequest, GatePolicy, TurnEvent, TurnSink, AttachmentRef, AttachmentMaterializer, AgentToolDefinition, AgentToolProvider, ConvMessage, AgentTurn, AgentRuntime, AgentCapabilities, AgentMediaKind, AgentMediaLimits, AgentPreset, AgentDescriptor, AgentCatalogEntry, ConnectorRegistration, AgentToolContentBlock, AgentToolContentResult, } from './types.ts';
 export type { AuthRole } from '../plugin-hooks.ts';
 export declare function startOrchestrator(): void;
 export declare function stopOrchestrator(): void;
 export declare const orchestratorStartersTask: BackgroundTask;
-export declare const linkCodePruneTask: BackgroundTask;
 export declare function orchestratorDiagnostics(): Promise<{
     generatedAt: string;
     agents: string[];

package/dist/orchestrator/index.js

@@ -6,10 +6,9 @@ import { setLogDb } from "./pipeline.js";
 import { refreshSystemStarters } from "./starters.js";
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('orchestrator');
-import { pruneLinkCodes } from "../identity-link.js";
 import { handleIncoming as handleIncomingImpl } from "./pipeline.js";
 export const handleIncoming = handleIncomingImpl;
-export { registerAgent, resolveAgent, registerConnector, isConnectorRegistered, clearRuntimeRegistries, listRegisteredAgents, listRegisteredConnectors, listLinkableConnectors, connectorLinkUrl, listAgentCatalog, getDefaultAgentId, liveAgentId, } from "./registry.js";
+export { registerAgent, resolveAgent, registerConnector, isConnectorRegistered, clearRuntimeRegistries, listRegisteredAgents, listRegisteredConnectors, listAgentCatalog, getDefaultAgentId, liveAgentId, } from "./registry.js";
 export { attachmentMaterializer } from "./attachments.js";
 export { makeAttachmentCapabilities } from "./agent-capabilities.js";
 export { makeSystemCapabilities } from "./system-capabilities.js";
@@ -18,10 +17,9 @@ export { CONNECTOR_FACT_NAME } from "./context-facts.js";
 export { inspectUpload, isAgentToolContentResult } from "./file-inspection.js";
 export { buildPolicy, loadGatePolicy, loadAgentId } from "./config.js";
 export { getConversationStarters, refreshSystemStarters } from "./starters.js";
-export { resolveSpeaker } from "./pipeline.js";
 export { mayRead, mayWrite, mayBePrivate } from "./conversation-access.js";
 export { makeLiveSink, plainRender } from "./live-message.js";
-export { chunk } from "./format.js";
+export { makeDraftSink } from "./draft-message.js";
 export { DEFAULT_TASK_TIMEOUT_MS } from "../background-scheduler.js";
 let db;
 const STARTERS_CHECK_INTERVAL_MS = 10 * 60_000;
@@ -47,11 +45,6 @@ export const orchestratorStartersTask = {
     intervalMs: STARTERS_CHECK_INTERVAL_MS,
     run: runStartersRefresh,
 };
-export const linkCodePruneTask = {
-    name: 'core:link-code-prune',
-    intervalMs: 86_400_000,
-    run: pruneLinkCodes,
-};
 export async function orchestratorDiagnostics() {
     return {
         generatedAt: new Date().toISOString(),

package/dist/orchestrator/live-message.js

@@ -1,6 +1,11 @@
-import { chunk } from "./format.js";
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('orchestrator');
+function chunk(text, max) {
+    const out = [];
+    for (let i = 0; i < text.length; i += max)
+        out.push(text.slice(i, i + max));
+    return out.length ? out : [''];
+}
 export function plainRender(max) {
     return (r) => chunk((r.text ?? '').trim() || '⚠️ the agent returned no response', max);
 }
@@ -104,8 +109,6 @@ export function makeLiveSink(o) {
             }
             else if (e.kind === 'answer')
                 deliverTerminal('answer', { text: e.text, reasoning: e.reasoning });
-            else if (e.kind === 'notice')
-                deliverTerminal('notice', { text: e.text, reasoning: null });
             else if (e.kind === 'error')
                 deliverTerminal('error', { text: null, reasoning: null });
         },

package/dist/orchestrator/pipeline.d.ts

@@ -1,18 +1,16 @@
-import type { AgentMediaLimits, Connector, TurnRequest, GatePolicy, AgentRuntime } from './types.ts';
+import type { AgentMediaLimits, Connector, ConvMessage, TurnRequest, GatePolicy, AgentRuntime } from './types.ts';
 import type { LogDb } from './db.ts';
 import { type AreaWorld, type SystemAreas } from './system-areas.ts';
 import type { AuthUser } from '../auth-store.ts';
+import { type ContextFact } from './context-facts.ts';
+import { type StoredMsg } from '../conversation-store.ts';
 export declare function setLogDb(db: LogDb | undefined): void;
-export declare const NOTICE_THROTTLE: {
-    readonly max: 5;
-    readonly windowMs: 60000;
-};
 export type RunAgentFn = AgentRuntime['run'];
 export declare function liveWorld(): Promise<AreaWorld>;
+export declare function foldContextFacts(messages: readonly (StoredMsg | ConvMessage)[]): ContextFact[];
+export declare function lastContextAt(messages: readonly (StoredMsg | ConvMessage)[]): Date | null;
+export declare function toConvMessages(stored: readonly StoredMsg[], facts: ContextFact[], userMsgId: string, queryText: string, contextSource?: readonly StoredMsg[]): ConvMessage[];
 export type UserLookup = (id: number) => Promise<AuthUser | null>;
-export declare function defaultResolveUser(id: string, lookup?: UserLookup): Promise<AuthUser | null>;
-export declare function defaultResolveLinkedUser(connectorId: string, externalId: string, lookup?: UserLookup): Promise<AuthUser | null>;
-export declare function resolveSpeaker(connectorId: string, sender: TurnRequest['sender'], deps?: Pick<PipelineDeps, 'resolveUser' | 'resolveLinkedUser'>): Promise<AuthUser | null>;
 export interface PipelineOptions {
     policy?: GatePolicy;
 }
@@ -22,8 +20,7 @@ export interface PipelineDeps extends PipelineOptions {
     logDb?: LogDb | null;
     agentBase?: () => Promise<string>;
     media?: AgentMediaLimits;
-    resolveUser?: (id: string) => Promise<AuthUser | null>;
-    resolveLinkedUser?: (connectorId: string, externalId: string) => Promise<AuthUser | null>;
+    lookupUser?: (id: number) => Promise<AuthUser | null>;
     now?: () => Date;
     timeZone?: string;
     world?: AreaWorld;

package/dist/orchestrator/pipeline.js

@@ -1,4 +1,3 @@
-import { makeThrottle } from "./allow.js";
 import { loadAgentId, loadGatePolicy } from "./config.js";
 import { assembleSystem, mergeAreas } from "./system-areas.js";
 import { attachmentMaterializer } from "./attachments.js";
@@ -7,7 +6,6 @@ import { makeSystemCapabilities } from "./system-capabilities.js";
 import { resolveAgent } from "./registry.js";
 import { recordDiagnostic } from "./diagnostics.js";
 import { getLogger } from '@coffer-org/sdk/logger';
-import { findLinkedUser } from "../identity-link.js";
 import { buildContextFacts } from "./context-facts.js";
 import { systemTimeZone } from "./environment.js";
 import { discoverPlugins } from "../plugin-discovery.js";
@@ -16,21 +14,17 @@ 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;
 }
-export const NOTICE_THROTTLE = { max: 5, windowMs: 60_000 };
-const throttleByConnector = new Map();
-function passThrottle(connectorId) {
-    let t = throttleByConnector.get(connectorId);
-    if (!t) {
-        t = makeThrottle(NOTICE_THROTTLE.max, NOTICE_THROTTLE.windowMs);
-        throttleByConnector.set(connectorId, t);
-    }
-    return t;
-}
 let cachedBase;
 let cachedBaseAgentId;
 function cachedAgentBase() {
@@ -71,40 +65,90 @@ function cachedDomainAreas() {
         cachedDomain = buildDomainAreas();
     return cachedDomain;
 }
-function foldContextFacts(messages) {
+export function foldContextFacts(messages) {
     const acc = new Map();
     for (const m of messages) {
-        for (const fact of m.context ?? []) {
-            if (fact.name === 'cleared')
-                acc.delete(fact.value);
-            else
-                acc.set(fact.name, fact);
+        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()];
 }
-const COFFER_USER_ID = /^[1-9][0-9]*$/;
-const storeLookup = async (id) => (await import("../auth-store.js")).findUserById(id);
-export async function defaultResolveUser(id, lookup = storeLookup) {
-    if (!COFFER_USER_ID.test(id) || !Number.isSafeInteger(Number(id)))
-        return null;
-    const user = await lookup(Number(id));
-    return user && !user.disabled ? user : null;
-}
-export async function defaultResolveLinkedUser(connectorId, externalId, lookup = storeLookup) {
-    const userId = await findLinkedUser(connectorId, externalId);
-    if (userId === null)
-        return null;
-    return await lookup(userId);
+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 async function resolveSpeaker(connectorId, sender, deps) {
-    return sender.idKind === 'coffer-user'
-        ? await (deps?.resolveUser ?? defaultResolveUser)(sender.id)
-        : await (deps?.resolveLinkedUser ?? defaultResolveLinkedUser)(connectorId, sender.id);
+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;
 }
-function openSink(connector, envelope) {
+const storeLookup = async (id) => (await import("../auth-store.js")).findUserById(id);
+function openSink(connector, envelope, msgId) {
     try {
-        return connector.open(envelope);
+        return connector.open(envelope, msgId);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -129,82 +173,78 @@ export async function handleIncoming(connector, turn, deps) {
     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;
+    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 } = turn.envelope;
+    const { connectorId } = turn.envelope;
+    const conversationId = turn.envelope.conversationId;
     const { sender } = turn;
-    const messages = turn.body.messages;
-    const last = messages[messages.length - 1];
-    if (!last || last.role !== 'user')
-        return;
-    const incomingMsgId = last.msgId;
-    if (policy.triggerPrefix && !last.content.toLowerCase().startsWith(policy.triggerPrefix.toLowerCase()))
+    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 speakerRow = await resolveSpeaker(connectorId, sender, deps);
-    if (speakerRow === null) {
-        if (passThrottle(connectorId)(sender.id)) {
-            const sink = openSink(connector, turn.envelope);
-            if (sink) {
-                sink.emit({ kind: 'notice', text: connector.enrolmentNotice });
-                await safeCall(() => sink.done(), undefined, 'done(unidentified)');
-            }
-        }
+    const speakerRow = await (deps?.lookupUser ?? storeLookup)(sender.userId);
+    if (!speakerRow || speakerRow.disabled)
         return;
-    }
     if (turn.signal?.aborted)
         return;
-    const queryText = policy.triggerPrefix ? last.content.slice(policy.triggerPrefix.length).trim() : last.content.trim();
-    if (!queryText) {
-        if (turn.prepareAttachments && !policy.triggerPrefix) {
-            await safeCall(() => turn.prepareAttachments(attachmentMaterializer), messages, 'prepareAttachments');
-        }
+    const queryText = policy.triggerPrefix ? text.slice(policy.triggerPrefix.length).trim() : text.trim();
+    if (!queryText)
         return;
-    }
-    const preparedMessages = turn.prepareAttachments
-        ? await safeCall(() => turn.prepareAttachments(attachmentMaterializer), messages, 'prepareAttachments')
-        : messages;
     const speaker = {
-        id: sender.id,
-        name: speakerRow.displayName ?? sender.displayName ?? sender.id,
+        id: String(sender.userId),
+        name: speakerRow.displayName ?? sender.displayName ?? String(sender.userId),
         role: speakerRow.role,
     };
-    const stated = preparedMessages.filter((m) => m.context?.length);
-    const lastStated = stated[stated.length - 1];
-    const now = deps?.now ? deps.now() : new Date();
+    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: stated.length ? foldContextFacts(preparedMessages) : null,
-        previousAt: lastStated ? new Date(lastStated.ts * 1000) : null,
+        previous: foldContextFacts(all),
+        previousAt: lastContextAt(all),
     });
-    const withText = preparedMessages.map((m, i) => i === preparedMessages.length - 1 && policy.triggerPrefix ? { ...m, content: queryText } : m);
-    const userMsg = withText[withText.length - 1];
-    const agentMessages = facts.length ? [...withText.slice(0, -1), { ...userMsg, context: facts }] : withText;
-    const persistContext = async () => {
-        if (!facts.length)
-            return;
-        await safeCall(() => connector.recordContext({
-            chatId,
-            userMsgId: incomingMsgId,
-            facts,
-            ts: userMsg.ts - 1,
-        }), undefined, 'recordContext');
-    };
-    const authored = turn.body.systemPrompt;
+    if (facts.length) {
+        await putMessage({
+            conversationId,
+            msgId: `${userMsgId}~c`,
+            role: 'context',
+            text: JSON.stringify(facts),
+            ts: ts - 1,
+        });
+    }
+    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) {
-        await persistContext();
+    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,
@@ -214,11 +254,13 @@ export async function handleIncoming(connector, turn, deps) {
         presetId: turn.presetId ?? null,
     });
     const startedAt = Date.now();
-    const sink = openSink(connector, turn.envelope);
+    const botMsgId = newMessageId();
+    const sink = openSink(connector, turn.envelope, botMsgId);
     if (!sink)
         return;
     let usage;
     let answerText = null;
+    let reasoningText = null;
     let runFailed = false;
     let agentTurn;
     try {
@@ -226,9 +268,10 @@ export async function handleIncoming(connector, turn, deps) {
         const toolProvider = {
             tools: [...attachmentTools.tools, ...makeSystemCapabilities().tools],
         };
+        const userMessageCount = await countUserMessages(conversationId);
         agentTurn = {
             envelope: turn.envelope,
-            body: { system, messages: agentMessages, userTurns: turn.body.userTurns },
+            body: { system, messages: agentMessages, userMessageCount },
             toolProvider,
             ...(turn.presetId ? { presetId: turn.presetId } : {}),
             senderRole: speaker.role,
@@ -239,8 +282,14 @@ export async function handleIncoming(connector, turn, deps) {
                 if (event.kind === 'usage') {
                     usage = { tokensIn: event.tokensIn, tokensOut: event.tokensOut, presetId: event.presetId };
                 }
+                else if (event.kind === 'reasoning') {
+                    reasoningText = event.text;
+                }
                 else if (event.kind === 'answer') {
                     answerText = event.text;
+                    if (event.reasoning !== null) {
+                        reasoningText = event.reasoning;
+                    }
                 }
                 sink.emit(event);
             }
@@ -262,8 +311,31 @@ export async function handleIncoming(connector, turn, deps) {
         }
     }
     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 = turn.body.capabilities.events;
+        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) {
@@ -276,6 +348,7 @@ export async function handleIncoming(connector, turn, deps) {
                 recordDiagnostic('error', 'agent.afterword', message);
             }
             if (extra?.suggestions?.length) {
+                extraSuggestions = extra.suggestions;
                 try {
                     sink.emit({ kind: 'suggestions', items: extra.suggestions });
                 }
@@ -301,11 +374,20 @@ export async function handleIncoming(connector, turn, deps) {
         }
     }
     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 (!runFailed && usage && answerText)
         db?.logTurn({
             connector: connectorId,
-            chatId,
-            userId: sender.id,
+            chatId: conversationId,
+            userId: String(sender.userId),
             role: 'assistant',
             text: answerText,
             tokensIn: usage.tokensIn,
@@ -314,5 +396,4 @@ export async function handleIncoming(connector, turn, deps) {
             agentId: selectedAgentId ?? null,
             presetId: usage.presetId,
         });
-    await persistContext();
 }

package/dist/orchestrator/registry.d.ts

@@ -8,8 +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 listLinkableConnectors(): string[];
-export declare function connectorLinkUrl(connectorId: string, code: string): string | undefined;
 export declare function listAgentCatalog(): Promise<AgentCatalogEntry[]>;
 export declare function getDefaultAgentId(): string | undefined;
 export declare function clearRuntimeRegistries(): void;

package/dist/orchestrator/registry.js

@@ -48,15 +48,6 @@ export function listRegisteredAgents() {
 export function listRegisteredConnectors() {
     return [...connectors.keys()].sort();
 }
-export function listLinkableConnectors() {
-    return [...connectors.entries()]
-        .filter(([, registration]) => typeof registration.linkUrl === 'function')
-        .map(([id]) => id)
-        .sort();
-}
-export function connectorLinkUrl(connectorId, code) {
-    return connectors.get(connectorId)?.linkUrl?.(code);
-}
 export async function listAgentCatalog() {
     const ids = [...agents.keys()].sort();
     const out = [];