@coffer-org/plugin-webchat 7.0.1 → 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,6 +1,6 @@
 import { type ActionCaller } from '@coffer-org/server/plugin-hooks';
 import { type AgentDescriptor, type ConnectorCapabilities } from '@coffer-org/server/orchestrator';
-import { type ThreadSelection } from './chain-store.ts';
+import { type Conversation as ThreadSelection } from '@coffer-org/server/conversation-store';
 export interface StreamCtx {
     caller: ActionCaller;
     emit: (event: string, data: unknown) => void;

package/dist/runtime/actions.js

@@ -1,9 +1,10 @@
 import { HttpError } from '@coffer-org/server/plugin-hooks';
-import { SIDECAR_ROLES } from '@coffer-org/server/thread-store';
+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 { openConversation, conversations, history, getSelection, setSelection, } from "./chain-store.js";
+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;
@@ -21,7 +22,7 @@ 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 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 {
@@ -42,13 +43,21 @@ function requireConvId(body) {
         throw new HttpError(400, 'missing required field: convId');
     return convId;
 }
-const EMPTY_SELECTION = { agentId: null, presetId: null, title: null, owner: null, visibility: null };
+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 chatId = await openConversation(convId, caller.id, 'read');
-    if (chatId === null)
+    const conversationId = await openConversation(convId, caller.id, 'read');
+    if (conversationId === null)
         return { convId, messages: [], headMsgId: null };
-    const rows = await history(chatId);
+    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')
@@ -71,18 +80,18 @@ export async function historyAction(body, caller) {
 }
 export async function agentsAction(body, caller) {
     const convId = requireConvId(body);
-    const chatId = await openConversation(convId, caller.id, 'read');
+    const conversationId = await openConversation(convId, caller.id, 'read');
     return {
         agents: await listAgentCatalog(),
         defaultAgentId: getDefaultAgentId() ?? null,
-        selection: chatId === null ? EMPTY_SELECTION : await getSelection(chatId),
+        selection: conversationId === null ? EMPTY_SELECTION : await getConversation(conversationId),
         starters: await getConversationStarters(),
     };
 }
 export async function selectAgentAction(body, caller) {
     const convId = requireConvId(body);
-    const chatId = await openConversation(convId, caller.id, 'write');
-    if (chatId === null)
+    const conversationId = await openConversation(convId, caller.id, 'write');
+    if (conversationId === null)
         return { selection: EMPTY_SELECTION };
     const patch = {};
     if ('agentId' in body) {
@@ -93,19 +102,19 @@ 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 chatId = await openConversation(convId, ctx.caller.id, 'read');
-    if (chatId === null)
+    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(chatId, {
+    const off = subscribe(conversationId, {
         viewerId: ctx.caller.id,
         emit: ctx.emit,
         close: () => resolveHeld(),
@@ -123,23 +132,30 @@ export async function channelAction(body, ctx) {
 export async function setVisibilityAction(body, caller, deps = {}) {
     const convId = requireConvId(body);
     const makePrivate = body['private'] === true;
-    const chatId = await openConversation(convId, caller.id, 'write');
-    if (chatId === null)
+    const conversationId = await openConversation(convId, caller.id, 'write');
+    if (conversationId === null)
         return { visibility: null };
-    const selection = await getSelection(chatId);
+    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 setSelection(chatId, { visibility });
-    evictWhere(chatId, (viewerId) => !mayRead({ owner: selection.owner, visibility }, viewerId));
+    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 chatId = await openConversation(convId, caller.id, 'write');
-    if (chatId === null)
+    const conversationId = await openConversation(convId, caller.id, 'write');
+    if (conversationId === null)
         return;
-    abortTurn('webchat', chatId);
+    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/channel-registry.d.ts

@@ -3,7 +3,14 @@ export interface Subscriber {
     emit(event: string, data: unknown): void;
     close(): void;
 }
-export declare function subscribe(chatId: string, sub: Subscriber): () => void;
-export declare function broadcast(chatId: string, event: string, data: unknown): void;
-export declare function evictWhere(chatId: string, drop: (viewerId: string) => boolean): void;
-export declare function subscriberCount(chatId: string): number;
+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

@@ -1,24 +1,50 @@
 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(chatId, sub) {
-    let set = channels.get(chatId);
+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(chatId, set);
+        channels.set(conversationId, set);
     }
     set.add(sub);
     return () => {
-        const current = channels.get(chatId);
+        const current = channels.get(conversationId);
         if (!current)
             return;
         current.delete(sub);
         if (current.size === 0)
-            channels.delete(chatId);
+            channels.delete(conversationId);
     };
 }
-export function broadcast(chatId, event, data) {
-    const set = channels.get(chatId);
+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) {
@@ -26,12 +52,12 @@ export function broadcast(chatId, event, data) {
             sub.emit(event, data);
         }
         catch (err) {
-            log.warn(`channel emit failed for viewer ${sub.viewerId} on ${chatId}: ${err instanceof Error ? err.message : String(err)}`);
+            log.warn(`channel emit failed for viewer ${sub.viewerId} on ${conversationId}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
 }
-export function evictWhere(chatId, drop) {
-    const set = channels.get(chatId);
+export function evictWhere(conversationId, drop) {
+    const set = channels.get(conversationId);
     if (!set)
         return;
     for (const sub of set) {
@@ -41,8 +67,60 @@ export function evictWhere(chatId, drop) {
         sub.close();
     }
     if (set.size === 0)
-        channels.delete(chatId);
+        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 subscriberCount(chatId) {
-    return channels.get(chatId)?.size ?? 0;
+export function teardownFanout() {
+    unsubscribeMessage?.();
+    unsubscribeMessage = undefined;
+    unsubscribeConversation?.();
+    unsubscribeConversation = undefined;
 }
+initFanout();

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, recordContext as storeContext, setSelection as storeSelection } 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,13 +7,9 @@ export interface StreamingConnector {
     suggestions(): string[] | null;
 }
 export interface StreamingConnectorOpts {
-    chatId: string;
-    botMsgId: string;
+    conversationId?: string;
+    botMsgId?: string;
     display: ReasoningDisplay;
-    record?: typeof storeAssistant;
-    recordReasoning?: typeof storeReasoning;
-    recordSuggestions?: typeof storeSuggestions;
-    recordContext?: typeof storeContext;
     setSelection?: typeof storeSelection;
 }
 export declare function makeStreamingConnector(opts: StreamingConnectorOpts): StreamingConnector;

package/dist/runtime/connector.js

@@ -1,111 +1,70 @@
 import { makeLiveSink, plainRender } from '@coffer-org/server/orchestrator';
-import { recordAssistant as storeAssistant, recordReasoning as storeReasoning, recordSuggestions as storeSuggestions, recordContext as storeContext, setSelection as storeSelection, } from "./chain-store.js";
+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 recordContextFn = opts.recordContext ?? storeContext;
     const setSelectionFn = opts.setSelection ?? storeSelection;
     let recordedId = null;
     let lastSuggestions = null;
+    let hasAnswer = false;
     const connector = {
         id: 'webchat',
-        enrolmentNotice: 'unreachable: a web-chat turn is always opened by an already-authenticated session, so ' +
-            'the identity gate never refuses one — this connector has no unidentified sender to say it to.',
-        open(envelope) {
+        open(envelope, msgId) {
+            const activeBotMsgId = msgId ?? opts.botMsgId ?? '';
+            const conversationId = envelope.conversationId ?? opts.conversationId ?? '';
             const inner = makeLiveSink({
                 ops: {
                     send: async (text) => {
-                        broadcast(opts.chatId, 'message', { msgId: opts.botMsgId, text });
-                        return opts.botMsgId;
+                        broadcast(conversationId, 'delta', { msgId: activeBotMsgId, text });
+                        return activeBotMsgId;
                     },
-                    edit: async (msgId, text) => {
-                        broadcast(opts.chatId, '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 answerText = null;
-            let answerReasoning = null;
-            let hasAnswer = false;
-            let persisted = false;
             let afterwordWork = Promise.resolve();
             return {
                 emit(e) {
                     if (e.kind === 'reasoning') {
                         if (opts.display !== 'off')
-                            broadcast(opts.chatId, 'reasoning', { msgId: opts.botMsgId, text: e.text });
+                            broadcast(conversationId, 'reasoning', { msgId: activeBotMsgId, text: e.text });
                         return;
                     }
                     if (e.kind === 'suggestions') {
                         lastSuggestions = e.items;
-                        if (recordedId && e.items.length) {
-                            void recordSuggestionsFn({
-                                chatId: opts.chatId,
-                                botMsgId: opts.botMsgId,
-                                parentMsgId: envelope.turnId,
-                                suggestions: e.items,
-                                now: Math.floor(Date.now() / 1000),
-                            }).catch((err) => {
-                                log.warn(`recordSuggestions failed: ${err instanceof Error ? err.message : String(err)}`);
-                            });
-                        }
                         return;
                     }
                     if (e.kind === 'title') {
-                        afterwordWork = afterwordWork.then(() => setSelectionFn(opts.chatId, { title: e.text }).catch((err) => {
+                        afterwordWork = afterwordWork.then(() => setSelectionFn(conversationId, { title: e.text }).catch((err) => {
                             log.warn(`setSelection(title) failed: ${err instanceof Error ? err.message : String(err)}`);
                         }));
                         return;
                     }
                     if (e.kind === 'answer') {
-                        answerText = e.text;
-                        answerReasoning = e.reasoning;
                         hasAnswer = true;
+                        recordedId = activeBotMsgId;
                     }
                     inner.emit(e);
                 },
                 async done() {
                     await inner.done();
-                    if (hasAnswer && !persisted) {
-                        persisted = true;
-                        const now = Math.floor(Date.now() / 1000);
-                        const wrote = await record({
-                            chatId: opts.chatId,
-                            parentMsgId: envelope.turnId,
-                            botMsgId: opts.botMsgId,
-                            text: answerText ?? '',
-                            now,
-                        });
-                        recordedId = wrote ? opts.botMsgId : null;
-                        if (wrote && opts.display !== 'off' && answerReasoning) {
-                            await recordReasoningFn({
-                                chatId: opts.chatId,
-                                botMsgId: opts.botMsgId,
-                                parentMsgId: envelope.turnId,
-                                text: answerReasoning,
-                                now,
-                            });
-                        }
-                    }
                     await afterwordWork;
                 },
             };
         },
-        async recordContext(m) {
-            await recordContextFn({ ...m, chatId: opts.chatId });
+        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>;

package/dist/runtime/format.js

@@ -1,15 +1,6 @@
 import { frontendInstructions } from '@coffer-org/server/frontend-agent';
-export const WEB_FORMAT = [
-    'CRITICAL OUTPUT FORMAT — MARKDOWN ONLY. Format the reply strictly as Markdown (GFM). NEVER emit raw HTML tags — they are stripped before rendering and their content may be lost.',
-    'Inline: **bold**, *italic*, `inline code`, ~~strikethrough~~. Links: [text](https://…).',
-    'Blocks: blank-line-separated paragraphs, `#`–`###` headings, `>` blockquotes, `---` separators.',
-    'Lists: `- item` for bullets, `1. item` for numbered steps. Nest with two spaces.',
-    'Tables render as real tables — use GFM pipe syntax with a header separator row.',
-    'Code blocks: triple backticks with a language tag (```python) — highlighted on render.',
-    'The reply is read in a narrow chat panel (~360px) — keep it short and skimmable: short paragraphs, lists over prose, narrow tables.',
-    'Use Unicode symbols and emoji to structure replies: arrows (→), status marks (✅ ⚠️ ❌ ⏳), topic emoji (📅 💰 🏥 🛒 🌱 …).',
-].join('\n');
+import { NEUTRAL_FORMAT } from '@coffer-org/markdown';
 export async function webChannelSystem() {
     const site = await frontendInstructions('');
-    return [WEB_FORMAT, site].filter(Boolean).join('\n\n');
+    return [NEUTRAL_FORMAT, site].filter(Boolean).join('\n\n');
 }

package/dist/runtime/index.d.ts

@@ -1,7 +1,6 @@
 import type { PluginHooks } from '@coffer-org/server/plugin-hooks';
 export type { ThreadSummary, HistoryMsg } from './actions.ts';
-export { WEB_FORMAT } from './format.ts';
 export { makeStreamingConnector } from './connector.ts';
-export { chatIdFor, recordUser, recordAssistant, buildChain, getSelection, setSelection } from './chain-store.ts';
+export { getConversation as getSelection, setConversation as setSelection, } from '@coffer-org/server/conversation-store';
 export { sendAction, pageContext } from './send.ts';
 export declare const serverHooks: PluginHooks;

package/dist/runtime/index.js

@@ -1,22 +1,22 @@
-import { pruneThreadMessages } from '@coffer-org/server/thread-store';
-import { pruneThreadState } from '@coffer-org/server/thread-state';
+import { pruneConversations } from '@coffer-org/server/conversation-store';
 import { threadsAction, historyAction, agentsAction, selectAgentAction, setVisibilityAction, channelAction, stopAction, } from "./actions.js";
 import { sendAction } from "./send.js";
-import { CONNECTOR } from "./chain-store.js";
 import { registerConnector } from '@coffer-org/server/orchestrator';
+import { initFanout, teardownFanout } from "./channel-registry.js";
 const THREAD_TTL_MS = Number(process.env['WEBCHAT_THREAD_TTL_MS'] ?? 30 * 86_400_000);
 let unregisterConnector;
-export { WEB_FORMAT } from "./format.js";
 export { makeStreamingConnector } from "./connector.js";
-export { chatIdFor, recordUser, recordAssistant, buildChain, getSelection, setSelection } from "./chain-store.js";
+export { getConversation as getSelection, setConversation as setSelection, } from '@coffer-org/server/conversation-store';
 export { sendAction, pageContext } from "./send.js";
 export const serverHooks = {
     init: () => {
         unregisterConnector = registerConnector({ id: 'webchat' });
+        initFanout();
     },
     teardown: () => {
         unregisterConnector?.();
         unregisterConnector = undefined;
+        teardownFanout();
     },
     userActions: {
         threads: threadsAction,
@@ -36,8 +36,7 @@ export const serverHooks = {
             intervalMs: 86_400_000,
             run: async () => {
                 const cutoff = new Date(Date.now() - THREAD_TTL_MS);
-                await pruneThreadMessages(CONNECTOR, Math.floor(cutoff.getTime() / 1000));
-                await pruneThreadState(CONNECTOR, cutoff.toISOString());
+                await pruneConversations(Math.floor(cutoff.getTime() / 1000), cutoff.toISOString());
             },
         },
     ],

package/dist/runtime/send.d.ts

@@ -1,6 +1,8 @@
 import { handleIncoming } from '@coffer-org/server/orchestrator';
 import { type ActionCaller } from '@coffer-org/server/plugin-hooks';
+import { conversationEmitter } from '@coffer-org/server/conversation-store';
 import type { ConnectorCapabilities, ContextFact } from '@coffer-org/server/orchestrator';
+export { conversationEmitter };
 export declare const CAPABILITIES: ConnectorCapabilities;
 export interface SendDeps {
     handleIncoming?: typeof handleIncoming;