@coffer-org/plugin-webchat 7.0.0 → 7.0.1

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 AgentDescriptor, type ConnectorCapabilities } from '@coffer-org/server/orchestrator';
 import { type ThreadSelection } from './chain-store.ts';
+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,11 @@
 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/thread-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 { CAPABILITIES } from "./send.js";
+import { subscribe, evictWhere } from "./channel-registry.js";
 const TITLE_MAX = 60;
 function parseSuggestions(text) {
     try {
@@ -17,13 +22,17 @@ function title(firstUserText) {
 }
 export async function threadsAction(_body, caller) {
     const chats = await conversations(caller.id);
-    const prefixLen = `u:${caller.id}:`.length;
+    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 +42,19 @@ 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 };
 export async function historyAction(body, caller) {
     const convId = requireConvId(body);
-    const rows = await history(chatIdFor(caller.id, convId));
+    const chatId = await openConversation(convId, caller.id, 'read');
+    if (chatId === null)
+        return { convId, messages: [], headMsgId: null };
+    const rows = await history(chatId);
     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 +71,19 @@ export async function historyAction(body, caller) {
 }
 export async function agentsAction(body, caller) {
     const convId = requireConvId(body);
+    const chatId = await openConversation(convId, caller.id, 'read');
     return {
         agents: await listAgentCatalog(),
         defaultAgentId: getDefaultAgentId() ?? null,
-        selection: await getSelection(chatIdFor(caller.id, convId)),
+        selection: chatId === null ? EMPTY_SELECTION : await getSelection(chatId),
         starters: await getConversationStarters(),
     };
 }
 export async function selectAgentAction(body, caller) {
     const convId = requireConvId(body);
-    const chatId = chatIdFor(caller.id, convId);
+    const chatId = await openConversation(convId, caller.id, 'write');
+    if (chatId === null)
+        return { selection: EMPTY_SELECTION };
     const patch = {};
     if ('agentId' in body) {
         const agentId = typeof body['agentId'] === 'string' && body['agentId'] ? body['agentId'] : null;
@@ -80,3 +96,50 @@ export async function selectAgentAction(body, caller) {
     await setSelection(chatId, patch);
     return { selection: await getSelection(chatId) };
 }
+export async function channelAction(body, ctx) {
+    const convId = requireConvId(body);
+    const chatId = await openConversation(convId, ctx.caller.id, 'read');
+    if (chatId === null)
+        return;
+    let resolveHeld;
+    const held = new Promise((resolve) => {
+        resolveHeld = resolve;
+    });
+    const off = subscribe(chatId, {
+        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 chatId = await openConversation(convId, caller.id, 'write');
+    if (chatId === null)
+        return { visibility: null };
+    const selection = await getSelection(chatId);
+    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));
+    return { visibility };
+}
+export async function stopAction(body, caller) {
+    const convId = requireConvId(body);
+    const chatId = await openConversation(convId, caller.id, 'write');
+    if (chatId === null)
+        return;
+    abortTurn('webchat', chatId);
+}

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,9 @@
+export interface Subscriber {
+    viewerId: string;
+    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;

package/dist/runtime/channel-registry.js

@@ -0,0 +1,48 @@
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('webchat');
+const channels = new Map();
+export function subscribe(chatId, sub) {
+    let set = channels.get(chatId);
+    if (!set) {
+        set = new Set();
+        channels.set(chatId, set);
+    }
+    set.add(sub);
+    return () => {
+        const current = channels.get(chatId);
+        if (!current)
+            return;
+        current.delete(sub);
+        if (current.size === 0)
+            channels.delete(chatId);
+    };
+}
+export function broadcast(chatId, event, data) {
+    const set = channels.get(chatId);
+    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 ${chatId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+export function evictWhere(chatId, drop) {
+    const set = channels.get(chatId);
+    if (!set)
+        return;
+    for (const sub of set) {
+        if (!drop(sub.viewerId))
+            continue;
+        set.delete(sub);
+        sub.close();
+    }
+    if (set.size === 0)
+        channels.delete(chatId);
+}
+export function subscriberCount(chatId) {
+    return channels.get(chatId)?.size ?? 0;
+}

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 { recordAssistant as storeAssistant, recordReasoning as storeReasoning, recordSuggestions as storeSuggestions, recordContext as storeContext, setSelection as storeSelection } from './chain-store.ts';
 import type { ReasoningDisplay } from './settings.ts';
 export interface StreamingConnector {
     connector: Connector;
@@ -9,10 +9,11 @@ export interface StreamingConnector {
 export interface StreamingConnectorOpts {
     chatId: string;
     botMsgId: string;
-    emit: (event: string, data: unknown) => void;
     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,71 +1,106 @@
-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 { recordAssistant as storeAssistant, recordReasoning as storeReasoning, recordSuggestions as storeSuggestions, recordContext as storeContext, setSelection as storeSelection, } from "./chain-store.js";
+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;
     const connector = {
         id: 'webchat',
-        reply(_chatId, _ctx) {
-            const ch = makeLiveChannel({
+        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) {
+            const inner = makeLiveSink({
                 ops: {
                     send: async (text) => {
-                        opts.emit('message', { msgId: opts.botMsgId, text });
+                        broadcast(opts.chatId, 'message', { msgId: opts.botMsgId, text });
                         return opts.botMsgId;
                     },
                     edit: async (msgId, text) => {
-                        opts.emit('delta', { msgId, text });
+                        broadcast(opts.chatId, 'delta', { msgId, 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 {
-                ...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(opts.chatId, 'reasoning', { msgId: opts.botMsgId, 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) => {
+                            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') {
+                        answerText = e.text;
+                        answerReasoning = e.reasoning;
+                        hasAnswer = true;
+                    }
+                    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 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 recordContext(m) {
+            await recordContextFn({ ...m, chatId: opts.chatId });
         },
     };
     return {

package/dist/runtime/index.d.ts

@@ -2,6 +2,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 { chatIdFor, recordUser, recordAssistant, buildChain, getSelection, setSelection } from './chain-store.ts';
 export { sendAction, pageContext } from './send.ts';
 export declare const serverHooks: PluginHooks;

package/dist/runtime/index.js

@@ -1,6 +1,6 @@
 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 { 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';
@@ -8,7 +8,7 @@ const THREAD_TTL_MS = Number(process.env['WEBCHAT_THREAD_TTL_MS'] ?? 30 * 86_400
 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 { chatIdFor, recordUser, recordAssistant, buildChain, getSelection, setSelection } from "./chain-store.js";
 export { sendAction, pageContext } from "./send.js";
 export const serverHooks = {
     init: () => {
@@ -23,9 +23,12 @@ export const serverHooks = {
         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: [
         {

package/dist/runtime/send.d.ts

@@ -1,12 +1,13 @@
 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 type { ConnectorCapabilities, ContextFact } from '@coffer-org/server/orchestrator';
+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>;