@coffer-org/server 7.2.0 → 7.4.0

package/dist/orchestrator/context-facts.js

@@ -0,0 +1,89 @@
+import { currentMoment } from "./environment.js";
+export const CONNECTOR_FACT_NAME = /^[a-z][a-z0-9-]*$/;
+export const CONTEXT_GAP_MS = 60 * 60_000;
+export const MAX_SPEAKER_NAME = 80;
+export const MAX_FACT_VALUE = 200;
+export const MAX_CONNECTOR_FACTS = 12;
+const FORGERY_CHARS = /[\p{Cc}\p{Zl}\p{Zp}\p{Bidi_Control}]+/gu;
+export function oneLine(value, maxLen) {
+    const flat = value.replace(FORGERY_CHARS, ' ').replace(/\s+/g, ' ').trim();
+    return maxLen !== undefined && flat.length > maxLen ? `${flat.slice(0, maxLen - 1).trimEnd()}…` : flat;
+}
+const ORCHESTRATOR_FACT_NAMES = new Set(['at', 'gap', 'speaker', 'cleared']);
+function sameFact(a, b) {
+    if (a.value !== b.value)
+        return false;
+    const ka = Object.keys(a.attrs ?? {}).sort();
+    const kb = Object.keys(b.attrs ?? {}).sort();
+    if (ka.length !== kb.length || ka.some((k, i) => k !== kb[i]))
+        return false;
+    return ka.every((k) => a.attrs[k] === b.attrs[k]);
+}
+function dayAndZone(atValue) {
+    const [date, , ...zone] = atValue.split(' ');
+    return `${date} ${zone.join(' ')}`;
+}
+export function humanizeGap(ms) {
+    const minutes = Math.round(ms / 60_000);
+    if (minutes < 90)
+        return `about ${minutes} minutes`;
+    const hours = Math.round(ms / 3_600_000);
+    if (hours < 48)
+        return `about ${hours} hours`;
+    return `about ${Math.round(ms / 86_400_000)} days`;
+}
+export function buildContextFacts(input) {
+    const prev = input.previous;
+    const stated = (name) => prev?.find((f) => f.name === name);
+    const moment = currentMoment(input.now, input.timeZone);
+    const at = { name: 'at', value: `${moment} ${input.timeZone}` };
+    const speakerName = oneLine(input.speaker.name, MAX_SPEAKER_NAME) || 'unknown';
+    const speaker = {
+        name: 'speaker',
+        value: speakerName,
+        attrs: { id: oneLine(input.speaker.id, MAX_SPEAKER_NAME), role: input.speaker.role },
+    };
+    const facts = [];
+    const gapMs = input.previousAt ? input.now.getTime() - input.previousAt.getTime() : null;
+    const prevAt = stated('at');
+    const dayChanged = prevAt !== undefined && dayAndZone(prevAt.value) !== dayAndZone(at.value);
+    const stale = gapMs !== null && gapMs >= CONTEXT_GAP_MS;
+    if (!prevAt || dayChanged || stale) {
+        facts.push(at);
+        if (stale && gapMs !== null)
+            facts.push({ name: 'gap', value: humanizeGap(gapMs) });
+    }
+    const prevSpeaker = stated('speaker');
+    if (!prevSpeaker || !sameFact(prevSpeaker, speaker))
+        facts.push(speaker);
+    const validConnectorFacts = input.connectorFacts
+        .filter((f) => typeof f?.name === 'string' &&
+        CONNECTOR_FACT_NAME.test(f.name) &&
+        !ORCHESTRATOR_FACT_NAMES.has(f.name) &&
+        typeof f.value === 'string' &&
+        Object.entries(f.attrs ?? {}).every(([k, v]) => CONNECTOR_FACT_NAME.test(k) && typeof v === 'string'))
+        .slice(0, MAX_CONNECTOR_FACTS);
+    const currentConnectorNames = new Set(validConnectorFacts.map((f) => f.name));
+    for (const raw of validConnectorFacts) {
+        const fact = {
+            name: raw.name,
+            value: oneLine(raw.value, MAX_FACT_VALUE),
+            ...(raw.attrs
+                ? { attrs: Object.fromEntries(Object.entries(raw.attrs).map(([k, v]) => [k, oneLine(v, MAX_FACT_VALUE)])) }
+                : {}),
+        };
+        const before = stated(fact.name);
+        if (!before || !sameFact(before, fact))
+            facts.push(fact);
+    }
+    if (prev) {
+        for (const priorFact of prev) {
+            if (ORCHESTRATOR_FACT_NAMES.has(priorFact.name))
+                continue;
+            if (currentConnectorNames.has(priorFact.name))
+                continue;
+            facts.push({ name: 'cleared', value: oneLine(priorFact.name) });
+        }
+    }
+    return facts;
+}

package/dist/orchestrator/conversation-access.d.ts

@@ -0,0 +1,9 @@
+export interface ConversationAccess {
+    owner: string | null;
+    visibility: 'private' | null;
+}
+export declare function mayRead(access: ConversationAccess, viewerId: string): boolean;
+export declare function mayWrite(access: ConversationAccess, viewerId: string): boolean;
+export declare function mayBePrivate(capabilities: {
+    privateChats: boolean;
+}): boolean;

package/dist/orchestrator/conversation-access.js

@@ -0,0 +1,12 @@
+function isOwner(access, viewerId) {
+    return access.owner !== null && access.owner === viewerId;
+}
+export function mayRead(access, viewerId) {
+    return access.visibility !== 'private' || isOwner(access, viewerId);
+}
+export function mayWrite(access, viewerId) {
+    return access.visibility !== 'private' || isOwner(access, viewerId);
+}
+export function mayBePrivate(capabilities) {
+    return capabilities.privateChats;
+}

package/dist/orchestrator/draft-message.d.ts

@@ -0,0 +1,18 @@
+import type { TurnSink } from './types.ts';
+import type { RenderFn } from './live-message.ts';
+export interface DraftChannelOps {
+    draft(text: string): Promise<void>;
+    send(text: string): Promise<string | null>;
+}
+export interface DraftSinkOpts {
+    ops: DraftChannelOps;
+    throttleMs: number;
+    keepAliveMs: number;
+    render: RenderFn;
+    preview: (r: {
+        text: string | null;
+        reasoning: string | null;
+    }) => string;
+    maxLength: number;
+}
+export declare function makeDraftSink(o: DraftSinkOpts): TurnSink;

package/dist/orchestrator/draft-message.js

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

package/dist/orchestrator/environment.d.ts

@@ -1,2 +1,3 @@
 export declare function systemTimeZone(): string;
 export declare function todayDateString(now?: Date, timeZone?: string): string;
+export declare function currentMoment(now?: Date, timeZone?: string): string;

package/dist/orchestrator/environment.js

@@ -12,3 +12,13 @@ function part(now, timeZone, locale, options) {
 export function todayDateString(now = new Date(), timeZone = systemTimeZone()) {
     return part(now, timeZone, 'en-CA', { year: 'numeric', month: '2-digit', day: '2-digit' });
 }
+export function currentMoment(now = new Date(), timeZone = systemTimeZone()) {
+    return part(now, timeZone, 'en-CA', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hourCycle: 'h23',
+    }).replace(', ', ' ');
+}

package/dist/orchestrator/file-inspection.d.ts

@@ -1,3 +1,3 @@
-import type { AgentToolContentResult, AttachmentRef } from './types.ts';
-export declare function inspectUpload(name: string, ref?: Pick<AttachmentRef, 'mime' | 'size' | 'label'>): Promise<AgentToolContentResult>;
+import type { AgentMediaLimits, AgentToolContentResult, AttachmentRef } from './types.ts';
+export declare function inspectUpload(name: string, ref: Pick<AttachmentRef, 'mime' | 'size' | 'label'>, limits: AgentMediaLimits): Promise<AgentToolContentResult>;
 export declare function isAgentToolContentResult(value: unknown): value is AgentToolContentResult;

package/dist/orchestrator/file-inspection.js

@@ -2,15 +2,25 @@ import { readFile, stat } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { mimeForName } from "../file-fields.js";
 import { uploadsDir } from "../uploads.js";
-const MAX_VISION_BYTES = 5 * 1024 * 1024;
-const MAX_DOCUMENT_BYTES = 10 * 1024 * 1024;
-const MAX_TEXT_BYTES = 512 * 1024;
+import { normalizeImage, ImageNormalizeError } from "../media/index.js";
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('orchestrator');
 const textResult = (text, isError = false) => ({
     __cofferToolContent: true,
     content: [{ type: 'text', text }],
     ...(isError ? { isError: true } : {}),
 });
-export async function inspectUpload(name, ref = {}) {
+function accepts(mime, patterns) {
+    return patterns.some((p) => (p.endsWith('/*') ? mime.startsWith(p.slice(0, -1)) : p === mime));
+}
+function human(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${Math.round(bytes / 1024)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export async function inspectUpload(name, ref, limits) {
     if (!name || basename(name) !== name)
         return textResult('Invalid upload name.', true);
     const file = join(uploadsDir(), name);
@@ -22,34 +32,46 @@ export async function inspectUpload(name, ref = {}) {
         return textResult(`File is no longer present on the server: ${name}`, true);
     }
     const mime = ref.mime ?? mimeForName(name);
-    if (mime === 'image/jpeg' || mime === 'image/png' || mime === 'image/gif' || mime === 'image/webp') {
-        if (size > MAX_VISION_BYTES)
-            return textResult(`Image is ${size} bytes, above the ${MAX_VISION_BYTES}-byte inspection limit.`, true);
+    const label = ref.label ?? name;
+    if (mime && accepts(mime, limits.image.accepts)) {
         const bytes = await readFile(file);
+        let image;
+        try {
+            image = await normalizeImage(bytes, limits.image);
+        }
+        catch (err) {
+            if (err instanceof ImageNormalizeError)
+                return textResult(`Image could not be prepared for the agent: ${err.message}`, true);
+            throw err;
+        }
+        const shape = image.changed
+            ? `${image.source.width}×${image.source.height} ${human(image.source.bytes)} → ${image.width}×${image.height} ${human(image.bytes.length)}, ${image.mime}`
+            : `${image.width}×${image.height}, ${image.mime}, ${human(image.bytes.length)}`;
+        if (image.changed)
+            log.debug(`normalized ${name}: ${image.source.bytes} → ${image.bytes.length} bytes for the agent`);
         return {
             __cofferToolContent: true,
             content: [
-                { type: 'text', text: `Image: ${ref.label ?? name} (${mime}, ${size} bytes).` },
-                { type: 'image', mime, data: bytes.toString('base64') },
+                { type: 'text', text: `Image: ${label} (${shape}).` },
+                { type: 'image', mime: image.mime, data: image.bytes.toString('base64') },
             ],
         };
     }
-    if (mime === 'application/pdf') {
-        if (size > MAX_DOCUMENT_BYTES)
-            return textResult(`PDF is ${size} bytes, above the ${MAX_DOCUMENT_BYTES}-byte inspection limit.`, true);
-        const bytes = await readFile(file);
+    if (mime && accepts(mime, limits.document.accepts)) {
+        if (size > limits.document.maxBytes)
+            return textResult(`Document is ${human(size)}, above the ${human(limits.document.maxBytes)} the agent accepts.`, true);
         return {
             __cofferToolContent: true,
             content: [
-                { type: 'text', text: `PDF: ${ref.label ?? name} (${size} bytes).` },
-                { type: 'document', mime: 'application/pdf', data: bytes.toString('base64') },
+                { type: 'text', text: `PDF: ${label} (${human(size)}).` },
+                { type: 'document', mime: 'application/pdf', data: (await readFile(file)).toString('base64') },
             ],
         };
     }
-    if (mime?.startsWith('text/') || mime === 'application/json' || mime === 'text/csv') {
-        if (size > MAX_TEXT_BYTES)
-            return textResult(`Text file is too large to inspect: ${size} bytes.`, true);
-        return textResult(`Text file: ${ref.label ?? name}\n\n${(await readFile(file)).toString('utf8')}`);
+    if (mime && accepts(mime, limits.text.accepts)) {
+        if (size > limits.text.maxBytes)
+            return textResult(`Text file is ${human(size)}, above the ${human(limits.text.maxBytes)} the agent accepts.`, true);
+        return textResult(`Text file: ${label}\n\n${(await readFile(file)).toString('utf8')}`);
     }
     return textResult(`This file type cannot be inspected by the agent (${mime ?? 'unknown'}). ` +
         'It can still be attached to a record.', true);

package/dist/orchestrator/index.d.ts

@@ -1,24 +1,29 @@
 import type { BackgroundTask } from '../background-scheduler.ts';
 import { listRecentMessageMetrics } from '../msg-log.ts';
 import { listDiagnostics } from './diagnostics.ts';
-export { handleIncoming } from './pipeline.ts';
+import { type PipelineOptions } from './pipeline.ts';
+import type { Connector, TurnRequest } from './types.ts';
+export declare const handleIncoming: (connector: Connector, turn: TurnRequest, options?: PipelineOptions) => Promise<void>;
 export { registerAgent, resolveAgent, registerConnector, isConnectorRegistered, clearRuntimeRegistries, listRegisteredAgents, listRegisteredConnectors, listAgentCatalog, getDefaultAgentId, liveAgentId, } from './registry.ts';
 export { attachmentMaterializer } from './attachments.ts';
 export { makeAttachmentCapabilities } from './agent-capabilities.ts';
 export { makeSystemCapabilities } from './system-capabilities.ts';
-export { makeSuggestionCapabilities } from './suggestion-capabilities.ts';
-export type { SuggestionCapability } from './suggestion-capabilities.ts';
 export { systemTimeZone } from './environment.ts';
+export type { ContextFact } from './context-facts.ts';
+export { CONNECTOR_FACT_NAME } from './context-facts.ts';
 export { inspectUpload, isAgentToolContentResult } from './file-inspection.ts';
-export type { PipelineDeps, RunAgentFn } from './pipeline.ts';
+export type { PipelineOptions, RunAgentFn } from './pipeline.ts';
 export { buildPolicy, loadGatePolicy, loadAgentId } from './config.ts';
 export { getConversationStarters, refreshSystemStarters } from './starters.ts';
-export { isSenderAllowed } from './allow.ts';
-export { makeLiveChannel, plainRender } from './live-message.ts';
-export type { LiveChannelOps, LiveChannelOpts, RenderFn } from './live-message.ts';
-export { chunk } from './format.ts';
+export { mayRead, mayWrite, mayBePrivate } from './conversation-access.ts';
+export type { ConversationAccess } from './conversation-access.ts';
+export { makeLiveSink, plainRender } from './live-message.ts';
+export type { LiveChannelOps, LiveSinkOpts, RenderFn } from './live-message.ts';
+export { makeDraftSink } from './draft-message.ts';
+export type { DraftChannelOps, DraftSinkOpts } from './draft-message.ts';
 export { DEFAULT_TASK_TIMEOUT_MS } from '../background-scheduler.ts';
-export type { Connector, IncomingConversation, GatePolicy, ReplyContext, ReplyPayload, ReplyChannel, AttachmentRef, AttachmentMaterializer, AgentToolDefinition, AgentToolProvider, ConvMessage, AgentRequest, AgentResult, AgentRuntime, AgentCapabilities, AgentPreset, AgentDescriptor, ConnectorRegistration, AgentToolContentBlock, AgentToolContentResult, } from './types.ts';
+export type { Connector, TurnEnvelope, ConnectorCapabilities, TurnBody, TurnRequest, GatePolicy, TurnEvent, TurnSink, AttachmentRef, AttachmentMaterializer, AgentToolDefinition, AgentToolProvider, ConvMessage, AgentTurn, AgentRuntime, AgentCapabilities, AgentMediaKind, AgentMediaLimits, AgentPreset, AgentDescriptor, AgentCatalogEntry, ConnectorRegistration, AgentToolContentBlock, AgentToolContentResult, } from './types.ts';
+export type { AuthRole } from '../plugin-hooks.ts';
 export declare function startOrchestrator(): void;
 export declare function stopOrchestrator(): void;
 export declare const orchestratorStartersTask: BackgroundTask;

package/dist/orchestrator/index.js

@@ -6,20 +6,20 @@ import { setLogDb } from "./pipeline.js";
 import { refreshSystemStarters } from "./starters.js";
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('orchestrator');
-export { handleIncoming } from "./pipeline.js";
+import { handleIncoming as handleIncomingImpl } from "./pipeline.js";
+export const handleIncoming = handleIncomingImpl;
 export { registerAgent, resolveAgent, registerConnector, isConnectorRegistered, clearRuntimeRegistries, listRegisteredAgents, listRegisteredConnectors, listAgentCatalog, getDefaultAgentId, liveAgentId, } from "./registry.js";
 export { attachmentMaterializer } from "./attachments.js";
 export { makeAttachmentCapabilities } from "./agent-capabilities.js";
 export { makeSystemCapabilities } from "./system-capabilities.js";
-export { makeSuggestionCapabilities } from "./suggestion-capabilities.js";
 export { systemTimeZone } from "./environment.js";
+export { CONNECTOR_FACT_NAME } from "./context-facts.js";
 export { inspectUpload, isAgentToolContentResult } from "./file-inspection.js";
 export { buildPolicy, loadGatePolicy, loadAgentId } from "./config.js";
 export { getConversationStarters, refreshSystemStarters } from "./starters.js";
-export { isSenderAllowed } from "./allow.js";
-import { carryLegacyState } from "./allow.js";
-export { makeLiveChannel, plainRender } from "./live-message.js";
-export { chunk } from "./format.js";
+export { mayRead, mayWrite, mayBePrivate } from "./conversation-access.js";
+export { makeLiveSink, plainRender } from "./live-message.js";
+export { makeDraftSink } from "./draft-message.js";
 export { DEFAULT_TASK_TIMEOUT_MS } from "../background-scheduler.js";
 let db;
 const STARTERS_CHECK_INTERVAL_MS = 10 * 60_000;
@@ -27,7 +27,6 @@ function runStartersRefresh() {
     return refreshSystemStarters().catch((err) => log.warn(`system starters: ${String(err)}`));
 }
 export function startOrchestrator() {
-    carryLegacyState();
     db = openLogDb();
     setLogDb(db);
     void runStartersRefresh();

package/dist/orchestrator/live-message.d.ts

@@ -1,14 +1,17 @@
-import type { ReplyChannel, ReplyPayload } from './types.ts';
+import type { TurnSink } from './types.ts';
 export interface LiveChannelOps {
     send(text: string): Promise<string | null>;
     edit(msgId: string, text: string): Promise<void>;
 }
-export type RenderFn = (r: ReplyPayload) => string[];
-export interface LiveChannelOpts {
+export type RenderFn = (r: {
+    text: string | null;
+    reasoning: string | null;
+}) => string[];
+export interface LiveSinkOpts {
     ops: LiveChannelOps;
     throttleMs: number;
     render: RenderFn;
     maxLength: number;
 }
 export declare function plainRender(max: number): RenderFn;
-export declare function makeLiveChannel(o: LiveChannelOpts): ReplyChannel;
+export declare function makeLiveSink(o: LiveSinkOpts): TurnSink;

package/dist/orchestrator/live-message.js

@@ -1,6 +1,11 @@
-import { chunk } from "./format.js";
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('orchestrator');
+function chunk(text, max) {
+    const out = [];
+    for (let i = 0; i < text.length; i += max)
+        out.push(text.slice(i, i + max));
+    return out.length ? out : [''];
+}
 export function plainRender(max) {
     return (r) => chunk((r.text ?? '').trim() || '⚠️ the agent returned no response', max);
 }
@@ -13,7 +18,7 @@ async function swallow(fn, fallback, label) {
         return fallback;
     }
 }
-export function makeLiveChannel(o) {
+export function makeLiveSink(o) {
     let msgId = null;
     let pending = '';
     let lastSent = '';
@@ -62,39 +67,54 @@ export function makeLiveChannel(o) {
     }, o.throttleMs);
     if (typeof timer.unref === 'function')
         timer.unref();
+    async function deliver(r) {
+        closed = true;
+        clearInterval(timer);
+        await inFlight;
+        const parts = o.render(r);
+        const [head, ...rest] = parts;
+        if (msgId && head !== undefined) {
+            const id = msgId;
+            if (head !== lastSent) {
+                await swallow(() => o.ops.edit(id, head), undefined, 'edit(final)');
+                lastSent = head;
+            }
+        }
+        else if (head !== undefined) {
+            await swallow(() => o.ops.send(head), null, 'send(final)');
+        }
+        for (const p of rest) {
+            await swallow(() => o.ops.send(p), null, 'send(overflow)');
+        }
+    }
+    let finished = Promise.resolve();
+    let terminalDelivered = false;
+    function deliverTerminal(kind, r) {
+        if (terminalDelivered) {
+            log.warn(`live-message: a second terminal event (${kind}) after the turn already finished — dropped`);
+            return;
+        }
+        terminalDelivered = true;
+        finished = deliver(r);
+    }
     return {
-        update(text) {
-            pending = text;
-        },
-        segment() {
-            gen++;
-            msgId = null;
-            pending = '';
-            lastSent = '';
+        emit(e) {
+            if (e.kind === 'delta')
+                pending = e.text;
+            else if (e.kind === 'segment') {
+                gen++;
+                msgId = null;
+                pending = '';
+                lastSent = '';
+            }
+            else if (e.kind === 'answer')
+                deliverTerminal('answer', { text: e.text, reasoning: e.reasoning });
+            else if (e.kind === 'error')
+                deliverTerminal('error', { text: null, reasoning: null });
         },
-        async finish(r) {
-            closed = true;
+        done: () => {
             clearInterval(timer);
-            await inFlight;
-            const parts = o.render(r);
-            let last = null;
-            const [head, ...rest] = parts;
-            if (msgId && head !== undefined) {
-                const id = msgId;
-                if (head !== lastSent) {
-                    await swallow(() => o.ops.edit(id, head), undefined, 'edit(final)');
-                    lastSent = head;
-                }
-                last = id;
-            }
-            else if (head !== undefined) {
-                last = await swallow(() => o.ops.send(head), null, 'send(final)');
-            }
-            for (const p of rest) {
-                const id = await swallow(() => o.ops.send(p), null, 'send(overflow)');
-                last = id ?? last;
-            }
-            return last;
+            return finished;
         },
     };
 }

package/dist/orchestrator/pipeline.d.ts

@@ -1,11 +1,29 @@
-import type { Connector, IncomingConversation, GatePolicy, AgentRuntime } from './types.ts';
+import type { AgentMediaLimits, Connector, ConvMessage, TurnRequest, GatePolicy, AgentRuntime } from './types.ts';
 import type { LogDb } from './db.ts';
+import { type AreaWorld, type SystemAreas } from './system-areas.ts';
+import type { AuthUser } from '../auth-store.ts';
+import { type ContextFact } from './context-facts.ts';
+import { type StoredMsg } from '../conversation-store.ts';
 export declare function setLogDb(db: LogDb | undefined): void;
 export type RunAgentFn = AgentRuntime['run'];
-export interface PipelineDeps {
+export declare function liveWorld(): Promise<AreaWorld>;
+export declare function foldContextFacts(messages: readonly (StoredMsg | ConvMessage)[]): ContextFact[];
+export declare function lastContextAt(messages: readonly (StoredMsg | ConvMessage)[]): Date | null;
+export declare function toConvMessages(stored: readonly StoredMsg[], facts: ContextFact[], userMsgId: string, queryText: string, contextSource?: readonly StoredMsg[]): ConvMessage[];
+export type UserLookup = (id: number) => Promise<AuthUser | null>;
+export interface PipelineOptions {
+    policy?: GatePolicy;
+}
+export interface PipelineDeps extends PipelineOptions {
     runAgent?: RunAgentFn;
+    afterword?: AgentRuntime['afterword'];
     logDb?: LogDb | null;
-    policy?: GatePolicy;
     agentBase?: () => Promise<string>;
+    media?: AgentMediaLimits;
+    lookupUser?: (id: number) => Promise<AuthUser | null>;
+    now?: () => Date;
+    timeZone?: string;
+    world?: AreaWorld;
+    domainAreas?: () => Promise<SystemAreas>;
 }
-export declare function handleIncoming(connector: Connector, conversation: IncomingConversation, deps?: PipelineDeps): Promise<void>;
+export declare function handleIncoming(connector: Connector, turn: TurnRequest, deps?: PipelineDeps): Promise<void>;