@coffer-org/plugin-webchat 7.0.0 → 7.1.0

package/dist/index.js

@@ -5,6 +5,8 @@ export default definePlugin({
     id: 'webchat',
     version: '1.0.0',
     dependsOn: [],
+    label: 'webchat.plugin.label',
+    description: 'webchat.plugin.description',
     settings: defineSettings({
         label: 'webchat.settings.label',
         fields: {

package/dist/runtime/actions.d.ts

@@ -1,11 +1,19 @@
 import { type ActionCaller } from '@coffer-org/server/plugin-hooks';
-import { type AgentDescriptor } from '@coffer-org/server/orchestrator';
-import { type ThreadSelection } from './chain-store.ts';
+import { type AgentDescriptor, type ConnectorCapabilities } from '@coffer-org/server/orchestrator';
+import { type Conversation as ThreadSelection } from '@coffer-org/server/conversation-store';
+export interface StreamCtx {
+    caller: ActionCaller;
+    emit: (event: string, data: unknown) => void;
+    signal: AbortSignal;
+}
 export interface ThreadSummary {
     convId: string;
     title: string;
     lastTs: number;
     count: number;
+    ownerName: string | null;
+    mine: boolean;
+    private: boolean;
 }
 export interface HistoryMsg {
     msgId: string;
@@ -38,3 +46,11 @@ export declare function agentsAction(body: Record<string, unknown>, caller: Acti
 export declare function selectAgentAction(body: Record<string, unknown>, caller: ActionCaller): Promise<{
     selection: ThreadSelection;
 }>;
+export declare function channelAction(body: Record<string, unknown>, ctx: StreamCtx): Promise<void>;
+export interface SetVisibilityDeps {
+    capabilities?: ConnectorCapabilities;
+}
+export declare function setVisibilityAction(body: Record<string, unknown>, caller: ActionCaller, deps?: SetVisibilityDeps): Promise<{
+    visibility: 'private' | null;
+}>;
+export declare function stopAction(body: Record<string, unknown>, caller: ActionCaller): Promise<void>;

package/dist/runtime/actions.js

@@ -1,6 +1,12 @@
 import { HttpError } from '@coffer-org/server/plugin-hooks';
-import { listAgentCatalog, getDefaultAgentId, listRegisteredAgents, getConversationStarters, } from '@coffer-org/server/orchestrator';
-import { chatIdFor, conversations, history, getSelection, setSelection } from "./chain-store.js";
+import { SIDECAR_ROLES } from '@coffer-org/server/conversation-store';
+import { listUsers } from '@coffer-org/server/auth-store';
+import { abortTurn } from '@coffer-org/server/turn-gate';
+import { listAgentCatalog, getDefaultAgentId, listRegisteredAgents, getConversationStarters, mayBePrivate, mayRead, } from '@coffer-org/server/orchestrator';
+import { getConversation, setConversation, listConversations, readConversation, } from '@coffer-org/server/conversation-store';
+import { mayWrite } from '@coffer-org/server/orchestrator';
+import { CAPABILITIES } from "./send.js";
+import { subscribe, evictWhere } from "./channel-registry.js";
 const TITLE_MAX = 60;
 function parseSuggestions(text) {
     try {
@@ -16,14 +22,18 @@ function title(firstUserText) {
     return t.length <= TITLE_MAX ? t : `${t.slice(0, TITLE_MAX - 1)}…`;
 }
 export async function threadsAction(_body, caller) {
-    const chats = await conversations(caller.id);
-    const prefixLen = `u:${caller.id}:`.length;
+    const chats = await listConversations(caller.id).then((rows) => rows.map((r) => ({ ...r, convId: r.id })));
+    const users = await listUsers();
+    const nameById = new Map(users.map((u) => [String(u.id), u.displayName]));
     return {
         threads: chats.map((c) => ({
-            convId: c.chatId.slice(prefixLen),
-            title: title(c.firstUserText),
+            convId: c.convId,
+            title: c.title ?? title(c.firstUserText),
             lastTs: c.lastTs,
             count: c.count,
+            ownerName: c.owner === null ? null : (nameById.get(c.owner) ?? null),
+            mine: c.owner === caller.id,
+            private: c.visibility === 'private',
         })),
     };
 }
@@ -33,15 +43,27 @@ function requireConvId(body) {
         throw new HttpError(400, 'missing required field: convId');
     return convId;
 }
+const EMPTY_SELECTION = {
+    id: '',
+    agentId: null,
+    presetId: null,
+    title: null,
+    owner: null,
+    visibility: null,
+    updatedAt: '',
+};
 export async function historyAction(body, caller) {
     const convId = requireConvId(body);
-    const rows = await history(chatIdFor(caller.id, convId));
+    const conversationId = await openConversation(convId, caller.id, 'read');
+    if (conversationId === null)
+        return { convId, messages: [], headMsgId: null };
+    const rows = await readConversation(conversationId);
     const reasoningByBot = new Map(rows.filter((m) => m.role === 'reasoning').map((m) => [m.msgId.slice(0, -2), m.text]));
     const suggestionsByBot = new Map(rows
         .filter((m) => m.role === 'suggestions')
         .map((m) => [m.msgId.slice(0, -2), parseSuggestions(m.text)])
         .filter((entry) => entry[1] !== null));
-    const visible = rows.filter((m) => m.role !== 'reasoning' && m.role !== 'suggestions');
+    const visible = rows.filter((m) => !SIDECAR_ROLES.includes(m.role));
     return {
         convId,
         messages: visible.map((m) => ({
@@ -58,16 +80,19 @@ export async function historyAction(body, caller) {
 }
 export async function agentsAction(body, caller) {
     const convId = requireConvId(body);
+    const conversationId = await openConversation(convId, caller.id, 'read');
     return {
         agents: await listAgentCatalog(),
         defaultAgentId: getDefaultAgentId() ?? null,
-        selection: await getSelection(chatIdFor(caller.id, convId)),
+        selection: conversationId === null ? EMPTY_SELECTION : await getConversation(conversationId),
         starters: await getConversationStarters(),
     };
 }
 export async function selectAgentAction(body, caller) {
     const convId = requireConvId(body);
-    const chatId = chatIdFor(caller.id, convId);
+    const conversationId = await openConversation(convId, caller.id, 'write');
+    if (conversationId === null)
+        return { selection: EMPTY_SELECTION };
     const patch = {};
     if ('agentId' in body) {
         const agentId = typeof body['agentId'] === 'string' && body['agentId'] ? body['agentId'] : null;
@@ -77,6 +102,60 @@ export async function selectAgentAction(body, caller) {
     }
     if ('presetId' in body)
         patch.presetId = typeof body['presetId'] === 'string' && body['presetId'] ? body['presetId'] : null;
-    await setSelection(chatId, patch);
-    return { selection: await getSelection(chatId) };
+    await setConversation(conversationId, patch);
+    return { selection: await getConversation(conversationId) };
+}
+export async function channelAction(body, ctx) {
+    const convId = requireConvId(body);
+    const conversationId = await openConversation(convId, ctx.caller.id, 'read');
+    if (conversationId === null)
+        return;
+    let resolveHeld;
+    const held = new Promise((resolve) => {
+        resolveHeld = resolve;
+    });
+    const off = subscribe(conversationId, {
+        viewerId: ctx.caller.id,
+        emit: ctx.emit,
+        close: () => resolveHeld(),
+    });
+    try {
+        if (!ctx.signal.aborted) {
+            ctx.signal.addEventListener('abort', () => resolveHeld(), { once: true });
+            await held;
+        }
+    }
+    finally {
+        off();
+    }
+}
+export async function setVisibilityAction(body, caller, deps = {}) {
+    const convId = requireConvId(body);
+    const makePrivate = body['private'] === true;
+    const conversationId = await openConversation(convId, caller.id, 'write');
+    if (conversationId === null)
+        return { visibility: null };
+    const selection = await getConversation(conversationId);
+    if (selection.owner !== caller.id)
+        return { visibility: selection.visibility };
+    if (makePrivate && !mayBePrivate(deps.capabilities ?? CAPABILITIES))
+        return { visibility: selection.visibility };
+    const visibility = makePrivate ? 'private' : null;
+    await setConversation(conversationId, { visibility });
+    evictWhere(conversationId, (viewerId) => !mayRead({ owner: selection.owner, visibility }, viewerId));
+    return { visibility };
+}
+export async function stopAction(body, caller) {
+    const convId = requireConvId(body);
+    const conversationId = await openConversation(convId, caller.id, 'write');
+    if (conversationId === null)
+        return;
+    abortTurn('webchat', conversationId);
+}
+async function openConversation(convId, viewerId, need) {
+    if (!convId || convId.includes(':'))
+        return null;
+    const conv = await getConversation(convId);
+    const allowed = need === 'read' ? mayRead(conv, viewerId) : mayWrite(conv, viewerId);
+    return allowed ? convId : null;
 }

package/dist/runtime/chain-store.d.ts

@@ -1,9 +1,8 @@
-import { type ThreadChat, type StoredMsg } from '@coffer-org/server/thread-store';
+import { type StoredMsg } from '@coffer-org/server/thread-store';
 import { type ThreadSelection } from '@coffer-org/server/thread-state';
-import type { ConvMessage } from '@coffer-org/server/orchestrator';
+import type { ConvMessage, ContextFact } from '@coffer-org/server/orchestrator';
 export declare const CONNECTOR = "webchat";
 export declare function chatIdFor(userId: string, convId: string): string;
-export declare function chatPrefixFor(userId: string): string;
 export declare function recordUser(m: {
     chatId: string;
     msgId: string;
@@ -34,13 +33,30 @@ export declare function recordSuggestions(m: {
     suggestions: string[];
     now: number;
 }): Promise<boolean>;
+export declare function recordContext(m: {
+    chatId: string;
+    userMsgId: string;
+    facts: ContextFact[];
+    ts: number;
+}): Promise<void>;
+export declare function userTurnCount(chatId: string): Promise<number>;
 export declare function buildChain(headMsgId: string, opts: {
     chatId: string;
     maxDepth?: number;
 }): Promise<ConvMessage[]>;
 export declare function history(chatId: string, limit?: number): Promise<StoredMsg[]>;
-export declare function conversations(userId: string): Promise<ThreadChat[]>;
+export interface ConversationSummary {
+    convId: string;
+    lastTs: number;
+    count: number;
+    firstUserText: string;
+    title: string | null;
+    owner: string | null;
+    visibility: 'private' | null;
+}
+export declare function conversations(viewerId: string): Promise<ConversationSummary[]>;
 export type { ThreadSelection };
+export declare function openConversation(convId: string, viewerId: string, need: 'read' | 'write'): Promise<string | null>;
 export declare function getSelection(chatId: string): Promise<ThreadSelection>;
 export declare function setSelection(chatId: string, patch: Partial<ThreadSelection>): Promise<void>;
 export declare function readSelectionForTurn(chatId: string): Promise<ThreadSelection>;

package/dist/runtime/chain-store.js

@@ -1,5 +1,6 @@
-import { getThreadMessage, putThreadMessage, listThreadMessages, listThreadChats, } from '@coffer-org/server/thread-store';
-import { getThreadState, setThreadState, readAndTouchThreadState, } from '@coffer-org/server/thread-state';
+import { getThreadMessage, putThreadMessage, listThreadMessages, listAllThreadChats, countUserTurns, SIDECAR_ROLES, } from '@coffer-org/server/thread-store';
+import { getThreadState, getThreadStates, setThreadState, readAndTouchThreadState, findChatByConvId, } from '@coffer-org/server/thread-state';
+import { CONNECTOR_FACT_NAME, mayRead, mayWrite } from '@coffer-org/server/orchestrator';
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('webchat');
 export const CONNECTOR = 'webchat';
@@ -7,8 +8,10 @@ const DEFAULT_MAX_DEPTH = 40;
 export function chatIdFor(userId, convId) {
     return `u:${userId}:${convId}`;
 }
-export function chatPrefixFor(userId) {
-    return `u:${userId}:`;
+function convIdOf(chatId) {
+    const first = chatId.indexOf(':');
+    const second = first === -1 ? -1 : chatId.indexOf(':', first + 1);
+    return second === -1 ? null : chatId.slice(second + 1);
 }
 export async function recordUser(m) {
     await putThreadMessage({
@@ -65,17 +68,46 @@ export async function recordSuggestions(m) {
     });
     return true;
 }
+export async function recordContext(m) {
+    await putThreadMessage({
+        connector: CONNECTOR,
+        chatId: m.chatId,
+        msgId: `${m.userMsgId}~c`,
+        role: 'context',
+        text: JSON.stringify(m.facts),
+        ts: m.ts,
+        replyToId: null,
+    });
+}
+function parseFacts(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return Array.isArray(parsed)
+            ? parsed.filter((f) => typeof f?.name === 'string' &&
+                CONNECTOR_FACT_NAME.test(f.name) &&
+                typeof f.value === 'string' &&
+                Object.entries(f.attrs ?? {}).every(([k, v]) => CONNECTOR_FACT_NAME.test(k) && typeof v === 'string'))
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function userTurnCount(chatId) {
+    return countUserTurns(CONNECTOR, chatId);
+}
 export async function buildChain(headMsgId, opts) {
     const max = opts.maxDepth ?? DEFAULT_MAX_DEPTH;
     const acc = [];
+    let turns = 0;
     let cur = headMsgId;
     const seen = new Set();
-    while (cur && acc.length < max && !seen.has(cur)) {
+    while (cur && turns < max && !seen.has(cur)) {
         seen.add(cur);
         const stored = await getThreadMessage(CONNECTOR, opts.chatId, cur);
         if (!stored)
             break;
-        if (stored.role !== 'reasoning' && stored.role !== 'suggestions') {
+        if (!SIDECAR_ROLES.includes(stored.role)) {
             acc.push({
                 role: stored.role,
                 content: stored.text,
@@ -84,10 +116,17 @@ export async function buildChain(headMsgId, opts) {
                 msgId: stored.msgId,
                 ts: stored.ts,
             });
+            turns += 1;
+            if (stored.role === 'user') {
+                const ctx = await getThreadMessage(CONNECTOR, opts.chatId, `${stored.msgId}~c`);
+                const facts = ctx ? parseFacts(ctx.text) : [];
+                if (facts.length)
+                    acc[acc.length - 1].context = facts;
+            }
         }
         cur = stored.replyToId;
     }
-    if (acc.length >= max)
+    if (turns >= max)
         log.info(`chain capped at ${max} for ${headMsgId}`);
     while (acc.length && acc.at(-1)?.role !== 'user')
         acc.pop();
@@ -96,8 +135,46 @@ export async function buildChain(headMsgId, opts) {
 export function history(chatId, limit) {
     return listThreadMessages(CONNECTOR, chatId, limit);
 }
-export function conversations(userId) {
-    return listThreadChats(CONNECTOR, chatPrefixFor(userId));
+export async function conversations(viewerId) {
+    const chats = await listAllThreadChats(CONNECTOR);
+    const states = await getThreadStates(CONNECTOR, chats.map((c) => c.chatId));
+    const out = [];
+    for (const c of chats) {
+        const access = states.get(c.chatId) ?? {
+            agentId: null,
+            presetId: null,
+            title: null,
+            owner: null,
+            visibility: null,
+        };
+        if (!mayRead(access, viewerId))
+            continue;
+        const convId = convIdOf(c.chatId);
+        if (convId === null)
+            continue;
+        out.push({
+            convId,
+            lastTs: c.lastTs,
+            count: c.count,
+            firstUserText: c.firstUserText,
+            title: access.title,
+            owner: access.owner,
+            visibility: access.visibility,
+        });
+    }
+    return out;
+}
+export async function openConversation(convId, viewerId, need) {
+    if (!convId || convId.includes(':'))
+        return null;
+    const lookup = await findChatByConvId(CONNECTOR, convId);
+    if (lookup.found === 'ambiguous')
+        return null;
+    if (lookup.found === 'none')
+        return chatIdFor(viewerId, convId);
+    const access = await getThreadState(CONNECTOR, lookup.chatId);
+    const allowed = need === 'read' ? mayRead(access, viewerId) : mayWrite(access, viewerId);
+    return allowed ? lookup.chatId : null;
 }
 export async function getSelection(chatId) {
     return getThreadState(CONNECTOR, chatId);

package/dist/runtime/channel-registry.d.ts

@@ -0,0 +1,16 @@
+export interface Subscriber {
+    viewerId: string;
+    emit(event: string, data: unknown): void;
+    close(): void;
+}
+export type ChannelCallback = (frame: {
+    event: string;
+    data: unknown;
+}) => void;
+export declare function subscribe(conversationId: string, sub: Subscriber | ChannelCallback): () => void;
+export declare function subscribeAs(conversationId: string, viewerId: string, cb: ChannelCallback): Promise<() => void>;
+export declare function broadcast(conversationId: string, event: string, data: unknown): void;
+export declare function evictWhere(conversationId: string, drop: (viewerId: string) => boolean): void;
+export declare function subscriberCount(conversationId: string): number;
+export declare function initFanout(): () => void;
+export declare function teardownFanout(): void;

package/dist/runtime/channel-registry.js

@@ -0,0 +1,126 @@
+import { getLogger } from '@coffer-org/sdk/logger';
+import { getConversation, onMessage, conversationEmitter, HIDDEN_ROLES } from '@coffer-org/server/conversation-store';
+import { mayRead } from '@coffer-org/server/orchestrator';
+const log = getLogger('webchat');
+const channels = new Map();
+export function subscribe(conversationId, sub) {
+    if (typeof sub === 'function') {
+        return subscribe(conversationId, {
+            viewerId: '*',
+            emit: (event, data) => sub({ event, data }),
+            close: () => { },
+        });
+    }
+    let set = channels.get(conversationId);
+    if (!set) {
+        set = new Set();
+        channels.set(conversationId, set);
+    }
+    set.add(sub);
+    return () => {
+        const current = channels.get(conversationId);
+        if (!current)
+            return;
+        current.delete(sub);
+        if (current.size === 0)
+            channels.delete(conversationId);
+    };
+}
+export async function subscribeAs(conversationId, viewerId, cb) {
+    if (viewerId !== '*') {
+        try {
+            const conv = await getConversation(conversationId);
+            if (conv && !mayRead(conv, viewerId)) {
+                return () => { };
+            }
+        }
+        catch {
+        }
+    }
+    return subscribe(conversationId, {
+        viewerId,
+        emit: (event, data) => cb({ event, data }),
+        close: () => { },
+    });
+}
+export function broadcast(conversationId, event, data) {
+    const set = channels.get(conversationId);
+    if (!set)
+        return;
+    for (const sub of set) {
+        try {
+            sub.emit(event, data);
+        }
+        catch (err) {
+            log.warn(`channel emit failed for viewer ${sub.viewerId} on ${conversationId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+export function evictWhere(conversationId, drop) {
+    const set = channels.get(conversationId);
+    if (!set)
+        return;
+    for (const sub of set) {
+        if (!drop(sub.viewerId))
+            continue;
+        set.delete(sub);
+        sub.close();
+    }
+    if (set.size === 0)
+        channels.delete(conversationId);
+}
+export function subscriberCount(conversationId) {
+    return channels.get(conversationId)?.size ?? 0;
+}
+let unsubscribeMessage;
+let unsubscribeConversation;
+export function initFanout() {
+    if (!unsubscribeMessage) {
+        unsubscribeMessage = onMessage((m) => {
+            if (HIDDEN_ROLES.includes(m.role))
+                return;
+            if (m.role === 'assistant') {
+                broadcast(m.conversationId, 'message', { msgId: m.msgId, text: m.text });
+            }
+            else if (m.role === 'user') {
+                broadcast(m.conversationId, 'user', {
+                    msgId: m.msgId,
+                    text: m.text,
+                    ts: m.ts,
+                    ...(m.attachments?.length ? { attachments: m.attachments } : {}),
+                });
+            }
+        });
+    }
+    if (!unsubscribeConversation) {
+        const handler = (e) => {
+            if (e instanceof CustomEvent) {
+                const { id, patch } = e.detail;
+                if (patch && (patch.visibility !== undefined || patch.owner !== undefined)) {
+                    void (async () => {
+                        try {
+                            const conv = await getConversation(id);
+                            evictWhere(id, (viewerId) => !mayRead(conv, viewerId));
+                        }
+                        catch {
+                        }
+                    })();
+                }
+            }
+        };
+        conversationEmitter.addEventListener('conversation', handler);
+        unsubscribeConversation = () => {
+            conversationEmitter.removeEventListener('conversation', handler);
+        };
+    }
+    return () => {
+        teardownFanout();
+    };
+}
+export function teardownFanout() {
+    unsubscribeMessage?.();
+    unsubscribeMessage = undefined;
+    unsubscribeConversation?.();
+    unsubscribeConversation = undefined;
+}
+initFanout();

package/dist/runtime/config.js

@@ -1,6 +1,5 @@
 export function policy() {
     return {
-        accessPassword: '',
         triggerPrefix: '',
         replyWindow: 1800,
     };

package/dist/runtime/connector.d.ts

@@ -1,5 +1,5 @@
 import type { Connector } from '@coffer-org/server/orchestrator';
-import { recordAssistant as storeAssistant, recordReasoning as storeReasoning, recordSuggestions as storeSuggestions } from './chain-store.ts';
+import { setConversation as storeSelection } from '@coffer-org/server/conversation-store';
 import type { ReasoningDisplay } from './settings.ts';
 export interface StreamingConnector {
     connector: Connector;
@@ -7,12 +7,9 @@ export interface StreamingConnector {
     suggestions(): string[] | null;
 }
 export interface StreamingConnectorOpts {
-    chatId: string;
-    botMsgId: string;
-    emit: (event: string, data: unknown) => void;
+    conversationId?: string;
+    botMsgId?: string;
     display: ReasoningDisplay;
-    record?: typeof storeAssistant;
-    recordReasoning?: typeof storeReasoning;
-    recordSuggestions?: typeof storeSuggestions;
+    setSelection?: typeof storeSelection;
 }
 export declare function makeStreamingConnector(opts: StreamingConnectorOpts): StreamingConnector;

package/dist/runtime/connector.js

@@ -1,76 +1,70 @@
-import { makeLiveChannel, plainRender } from '@coffer-org/server/orchestrator';
-import { recordAssistant as storeAssistant, recordReasoning as storeReasoning, recordSuggestions as storeSuggestions, } from "./chain-store.js";
+import { makeLiveSink, plainRender } from '@coffer-org/server/orchestrator';
+import { setConversation as storeSelection } from '@coffer-org/server/conversation-store';
+import { broadcast } from "./channel-registry.js";
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('webchat');
 const WEBCHAT_THROTTLE_MS = 250;
 const WEBCHAT_MAX = 100_000;
 export function makeStreamingConnector(opts) {
-    const record = opts.record ?? storeAssistant;
-    const recordReasoningFn = opts.recordReasoning ?? storeReasoning;
-    const recordSuggestionsFn = opts.recordSuggestions ?? storeSuggestions;
+    const setSelectionFn = opts.setSelection ?? storeSelection;
     let recordedId = null;
     let lastSuggestions = null;
+    let hasAnswer = false;
     const connector = {
         id: 'webchat',
-        reply(_chatId, _ctx) {
-            const ch = makeLiveChannel({
+        open(envelope, msgId) {
+            const activeBotMsgId = msgId ?? opts.botMsgId ?? '';
+            const conversationId = envelope.conversationId ?? opts.conversationId ?? '';
+            const inner = makeLiveSink({
                 ops: {
                     send: async (text) => {
-                        opts.emit('message', { msgId: opts.botMsgId, text });
-                        return opts.botMsgId;
+                        broadcast(conversationId, 'delta', { msgId: activeBotMsgId, text });
+                        return activeBotMsgId;
                     },
-                    edit: async (msgId, text) => {
-                        opts.emit('delta', { msgId, text });
+                    edit: async (id, text) => {
+                        broadcast(conversationId, 'delta', { msgId: id, text });
                     },
                 },
                 throttleMs: WEBCHAT_THROTTLE_MS,
                 maxLength: WEBCHAT_MAX,
                 render: plainRender(WEBCHAT_MAX),
             });
+            let afterwordWork = Promise.resolve();
             return {
-                ...ch,
-                async finish(r) {
-                    lastSuggestions = r.suggestions;
-                    return ch.finish(r);
-                },
-                updateReasoning(acc) {
-                    if (opts.display === 'off')
+                emit(e) {
+                    if (e.kind === 'reasoning') {
+                        if (opts.display !== 'off')
+                            broadcast(conversationId, 'reasoning', { msgId: activeBotMsgId, text: e.text });
+                        return;
+                    }
+                    if (e.kind === 'suggestions') {
+                        lastSuggestions = e.items;
+                        return;
+                    }
+                    if (e.kind === 'title') {
+                        afterwordWork = afterwordWork.then(() => setSelectionFn(conversationId, { title: e.text }).catch((err) => {
+                            log.warn(`setSelection(title) failed: ${err instanceof Error ? err.message : String(err)}`);
+                        }));
                         return;
-                    opts.emit('reasoning', { msgId: opts.botMsgId, text: acc });
+                    }
+                    if (e.kind === 'answer') {
+                        hasAnswer = true;
+                        recordedId = activeBotMsgId;
+                    }
+                    inner.emit(e);
+                },
+                async done() {
+                    await inner.done();
+                    await afterwordWork;
                 },
             };
         },
-        async recordAssistant(m) {
-            const now = Math.floor(Date.now() / 1000);
-            const wrote = await record({
-                chatId: opts.chatId,
-                parentMsgId: m.parentMsgId,
-                botMsgId: m.botMsgId,
-                text: m.text,
-                now,
-            });
-            recordedId = wrote ? m.botMsgId : null;
-            if (wrote && opts.display !== 'off' && m.reasoning && m.botMsgId) {
-                await recordReasoningFn({
-                    chatId: opts.chatId,
-                    botMsgId: m.botMsgId,
-                    parentMsgId: m.parentMsgId,
-                    text: m.reasoning,
-                    now,
-                });
-            }
-            if (wrote && lastSuggestions?.length && m.botMsgId) {
-                await recordSuggestionsFn({
-                    chatId: opts.chatId,
-                    botMsgId: m.botMsgId,
-                    parentMsgId: m.parentMsgId,
-                    suggestions: lastSuggestions,
-                    now,
-                });
-            }
+        async bindMessage(_envelope, _msgId, _externalId) {
         },
     };
     return {
         connector,
-        recorded: () => recordedId,
+        recorded: () => (hasAnswer ? recordedId : null),
         suggestions: () => lastSuggestions,
     };
 }

package/dist/runtime/format.d.ts

@@ -1,2 +1 @@
-export declare const WEB_FORMAT: string;
 export declare function webChannelSystem(): Promise<string>;