@coffer-org/server 7.1.0 → 7.3.0

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,26 +1,33 @@
 import type { BackgroundTask } from '../background-scheduler.ts';
 import { listRecentMessageMetrics } from '../msg-log.ts';
 import { listDiagnostics } from './diagnostics.ts';
-export { handleIncoming } from './pipeline.ts';
-export { registerAgent, resolveAgent, registerConnector, isConnectorRegistered, clearRuntimeRegistries, listRegisteredAgents, listRegisteredConnectors, listAgentCatalog, getDefaultAgentId, liveAgentId, } from './registry.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, listLinkableConnectors, connectorLinkUrl, 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 { resolveSpeaker } from './pipeline.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 { chunk } from './format.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 { DEFAULT_TASK_TIMEOUT_MS } from '../background-scheduler.ts';
+export type { Connector, TurnEnvelope, ConnectorCapabilities, TurnBody, TurnRequest, SenderIdKind, 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;
+export declare const linkCodePruneTask: BackgroundTask;
 export declare function orchestratorDiagnostics(): Promise<{
     generatedAt: string;
     agents: string[];

package/dist/orchestrator/index.js

@@ -6,27 +6,29 @@ 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";
-export { registerAgent, resolveAgent, registerConnector, isConnectorRegistered, clearRuntimeRegistries, listRegisteredAgents, listRegisteredConnectors, listAgentCatalog, getDefaultAgentId, liveAgentId, } from "./registry.js";
+import { pruneLinkCodes } from "../identity-link.js";
+import { handleIncoming as handleIncomingImpl } from "./pipeline.js";
+export const handleIncoming = handleIncomingImpl;
+export { registerAgent, resolveAgent, registerConnector, isConnectorRegistered, clearRuntimeRegistries, listRegisteredAgents, listRegisteredConnectors, listLinkableConnectors, connectorLinkUrl, 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 { resolveSpeaker } from "./pipeline.js";
+export { mayRead, mayWrite, mayBePrivate } from "./conversation-access.js";
+export { makeLiveSink, plainRender } from "./live-message.js";
 export { chunk } from "./format.js";
+export { DEFAULT_TASK_TIMEOUT_MS } from "../background-scheduler.js";
 let db;
 const STARTERS_CHECK_INTERVAL_MS = 10 * 60_000;
 function runStartersRefresh() {
     return refreshSystemStarters().catch((err) => log.warn(`system starters: ${String(err)}`));
 }
 export function startOrchestrator() {
-    carryLegacyState();
     db = openLogDb();
     setLogDb(db);
     void runStartersRefresh();
@@ -45,6 +47,11 @@ export const orchestratorStartersTask = {
     intervalMs: STARTERS_CHECK_INTERVAL_MS,
     run: runStartersRefresh,
 };
+export const linkCodePruneTask = {
+    name: 'core:link-code-prune',
+    intervalMs: 86_400_000,
+    run: pruneLinkCodes,
+};
 export async function orchestratorDiagnostics() {
     return {
         generatedAt: new Date().toISOString(),

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

@@ -13,7 +13,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 +62,56 @@ 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 === 'notice')
+                deliverTerminal('notice', { text: e.text, reasoning: null });
+            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,32 @@
-import type { Connector, IncomingConversation, GatePolicy, AgentRuntime } from './types.ts';
+import type { AgentMediaLimits, Connector, 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';
 export declare function setLogDb(db: LogDb | undefined): void;
+export declare const NOTICE_THROTTLE: {
+    readonly max: 5;
+    readonly windowMs: 60000;
+};
 export type RunAgentFn = AgentRuntime['run'];
-export interface PipelineDeps {
+export declare function liveWorld(): Promise<AreaWorld>;
+export type UserLookup = (id: number) => Promise<AuthUser | null>;
+export declare function defaultResolveUser(id: string, lookup?: UserLookup): Promise<AuthUser | null>;
+export declare function defaultResolveLinkedUser(connectorId: string, externalId: string, lookup?: UserLookup): Promise<AuthUser | null>;
+export declare function resolveSpeaker(connectorId: string, sender: TurnRequest['sender'], deps?: Pick<PipelineDeps, 'resolveUser' | 'resolveLinkedUser'>): 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;
+    resolveUser?: (id: string) => Promise<AuthUser | null>;
+    resolveLinkedUser?: (connectorId: string, externalId: string) => 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>;