@coffer-org/plugin-webchat 7.0.0 → 7.1.0

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, chatPrefixFor, 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,31 +1,34 @@
-import { pruneThreadMessages } from '@coffer-org/server/thread-store';
-import { pruneThreadState } from '@coffer-org/server/thread-state';
-import { threadsAction, historyAction, agentsAction, selectAgentAction } from "./actions.js";
+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, chatPrefixFor, 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,
         history: historyAction,
         agents: agentsAction,
         selectAgent: selectAgentAction,
+        setVisibility: (body, caller) => setVisibilityAction(body, caller),
+        send: (body, caller) => sendAction(body, caller),
+        stop: (body, caller) => stopAction(body, caller),
     },
     streamActions: {
-        send: (body, ctx) => sendAction(body, ctx),
+        channel: (body, ctx) => channelAction(body, ctx),
     },
     backgroundTasks: [
         {
@@ -33,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,12 +1,15 @@
 import { handleIncoming } from '@coffer-org/server/orchestrator';
-import type { ActionCaller } from '@coffer-org/server/plugin-hooks';
+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;
 }
-export interface StreamCtx {
-    caller: ActionCaller;
-    emit: (event: string, data: unknown) => void;
-    signal: AbortSignal;
+export declare function pageContext(ctx: unknown): ContextFact[];
+export interface SendResult {
+    msgId: string | null;
+    botMsgId: string | null;
 }
-export declare function pageContext(ctx: unknown): string;
-export declare function sendAction(body: Record<string, unknown>, ctx: StreamCtx, deps?: SendDeps): Promise<void>;
+export declare function sendAction(body: Record<string, unknown>, caller: ActionCaller, deps?: SendDeps): Promise<SendResult>;

package/dist/runtime/send.js

@@ -1,65 +1,115 @@
 import { randomUUID } from 'node:crypto';
 import { handleIncoming, liveAgentId } from '@coffer-org/server/orchestrator';
-import { chatIdFor, recordUser, buildChain, history, readSelectionForTurn } from "./chain-store.js";
+import { beginTurn } from '@coffer-org/server/turn-gate';
+import { HttpError } from '@coffer-org/server/plugin-hooks';
+import { lastMessageId, conversationEmitter, onMessage, } from '@coffer-org/server/conversation-store';
+import { getConversation, setConversation, readAndTouchConversation, } from '@coffer-org/server/conversation-store';
+import { mayWrite, mayRead } from '@coffer-org/server/orchestrator';
 import { policy } from "./config.js";
 import { makeStreamingConnector } from "./connector.js";
+import { broadcast, initFanout } from "./channel-registry.js";
 import { webChannelSystem } from "./format.js";
 import { loadReasoningDisplay } from "./settings.js";
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('webchat');
+initFanout();
+export { conversationEmitter };
+export const CAPABILITIES = {
+    events: ['delta', 'reasoning', 'segment', 'suggestions', 'title'],
+    privateChats: true,
+};
 export function pageContext(ctx) {
     if (typeof ctx !== 'object' || ctx === null)
-        return '';
+        return [];
     const c = ctx;
     const path = typeof c['path'] === 'string' ? c['path'] : '';
     if (!path)
-        return '';
+        return [];
     const library = typeof c['library'] === 'string' ? c['library'] : '';
-    const type = typeof c['type'] === 'string' ? c['type'] : '';
+    const shelf = typeof c['type'] === 'string' ? c['type'] : '';
     const id = typeof c['id'] === 'string' ? c['id'] : '';
-    const where = library && type && id ? `record ${library}/${type}/${id}` : library && type ? `the ${library}/${type} list` : path;
-    return `CURRENT PAGE — the user is looking at ${where} (SPA path ${path}). When they say "this", "here", or "this record", they most likely mean it. Do not mention this note unless it is relevant.`;
+    const title = typeof c['title'] === 'string' ? c['title'] : '';
+    if (library && shelf && id)
+        return [{ name: 'record', value: title, attrs: { library, shelf, id } }];
+    if (library && shelf)
+        return [{ name: 'page', value: '', attrs: { library, shelf } }];
+    return [{ name: 'page', value: path }];
 }
-export async function sendAction(body, ctx, deps = {}) {
+export async function sendAction(body, caller, deps = {}) {
     const doHandle = deps.handleIncoming ?? handleIncoming;
     const convId = typeof body['convId'] === 'string' ? body['convId'] : '';
     const text = typeof body['text'] === 'string' ? body['text'] : '';
-    if (!convId) {
-        ctx.emit('error', { message: 'missing required field: convId' });
-        return;
+    if (!convId)
+        throw new HttpError(400, 'missing required field: convId');
+    if (!text.trim())
+        throw new HttpError(400, 'missing required field: text');
+    const conversationId = await openConversation(convId, caller.id, 'write');
+    if (conversationId === null) {
+        return { msgId: null, botMsgId: null };
     }
-    if (!text.trim()) {
-        ctx.emit('error', { message: 'missing required field: text' });
-        return;
+    const selection = await readAndTouchConversation(conversationId);
+    if (selection.owner === null) {
+        await setConversation(conversationId, { owner: caller.id });
     }
-    const chatId = chatIdFor(ctx.caller.id, convId);
-    const selection = await readSelectionForTurn(chatId);
     const agentId = liveAgentId(selection.agentId);
     const msgId = randomUUID();
     const botMsgId = randomUUID();
-    const nowSec = Math.floor(Date.now() / 1000);
     const attachments = parseAttachments(body['attachments']);
     const explicitReplyTo = typeof body['replyTo'] === 'string' && body['replyTo'] ? body['replyTo'] : null;
-    const replyTo = explicitReplyTo ?? (await history(chatId, 1)).at(-1)?.msgId ?? null;
-    await recordUser({ chatId, msgId, sender: ctx.caller.id, text, attachments, ts: nowSec, replyToId: replyTo });
-    const messages = await buildChain(msgId, { chatId });
+    const replyTo = explicitReplyTo ?? (await lastMessageId(conversationId));
+    let userMsgId = msgId;
+    let userMsgResolved = false;
+    let resolveUserMsg;
+    const userMsgPromise = new Promise((resolve) => {
+        resolveUserMsg = resolve;
+    });
+    const unsubUserMsg = onMessage((m) => {
+        if (!userMsgResolved && m.conversationId === conversationId && m.role === 'user') {
+            userMsgResolved = true;
+            resolveUserMsg(m.msgId);
+        }
+    });
     const { connector, recorded, suggestions } = makeStreamingConnector({
-        chatId,
+        conversationId,
         botMsgId,
-        emit: ctx.emit,
         display: await loadReasoningDisplay(),
     });
     const turnContext = pageContext(body['context']);
-    await doHandle(connector, {
-        connectorId: 'webchat',
-        channelSystem: await webChannelSystem(),
-        ...(turnContext ? { turnContext } : {}),
-        ...(agentId ? { agentId } : {}),
-        ...(selection.presetId ? { presetId: selection.presetId } : {}),
-        chatId,
-        sender: { id: ctx.caller.id },
-        messages,
-        supportsSuggestions: true,
-    }, { policy: policy() });
-    ctx.emit('done', { msgId: recorded(), parentMsgId: msgId, suggestions: suggestions() });
+    const gate = await beginTurn('webchat', conversationId, { supersede: true });
+    const turnPromise = (async () => {
+        try {
+            await doHandle(connector, {
+                envelope: { connectorId: 'webchat', conversationId, turnId: msgId },
+                sender: { userId: Number(caller.id) },
+                message: {
+                    text,
+                    ...(attachments?.length ? { attachments } : {}),
+                    replyToMsgId: replyTo,
+                },
+                capabilities: CAPABILITIES,
+                systemPrompt: { channel: [await webChannelSystem()] },
+                ...(turnContext.length ? { turnContext } : {}),
+                ...(agentId ? { agentId } : {}),
+                ...(selection.presetId ? { presetId: selection.presetId } : {}),
+                signal: gate.signal,
+            }, { policy: policy() });
+            broadcast(conversationId, 'done', {
+                msgId: recorded() ?? botMsgId,
+                parentMsgId: userMsgId,
+                suggestions: suggestions(),
+            });
+        }
+        catch (err) {
+            log.error(`sendAction: handleIncoming threw for chat ${conversationId}: ${err instanceof Error ? err.message : String(err)}`);
+            broadcast(conversationId, 'error', { message: null, parentMsgId: userMsgId });
+        }
+        finally {
+            gate.end();
+        }
+    })();
+    userMsgId = await Promise.race([userMsgPromise, turnPromise.then(() => msgId)]);
+    unsubUserMsg();
+    return { msgId: userMsgId, botMsgId };
 }
 function parseAttachments(value) {
     if (!Array.isArray(value))
@@ -73,11 +123,18 @@ function parseAttachments(value) {
         return [
             {
                 name: r['name'],
-                ...(typeof r['mime'] === 'string' ? { mime: r['mime'] } : {}),
-                ...(typeof r['size'] === 'number' ? { size: r['size'] } : {}),
-                ...(typeof r['label'] === 'string' ? { label: r['label'] } : {}),
+                ...(typeof r['mime'] === 'string' && r['mime'] ? { mime: r['mime'] } : {}),
+                ...(typeof r['size'] === 'number' && Number.isFinite(r['size']) ? { size: r['size'] } : {}),
+                ...(typeof r['label'] === 'string' && r['label'] ? { label: r['label'] } : {}),
             },
         ];
     });
     return refs.length ? refs : undefined;
 }
+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;
+}