@coffer-org/server 7.2.0 → 7.3.0

package/dist/media/image.js

@@ -0,0 +1,103 @@
+import sharp from 'sharp';
+export class ImageNormalizeError extends Error {
+}
+const MIME_BY_FORMAT = {
+    jpeg: 'image/jpeg',
+    jpg: 'image/jpeg',
+    png: 'image/png',
+    webp: 'image/webp',
+    gif: 'image/gif',
+    avif: 'image/avif',
+    tiff: 'image/tiff',
+    heif: 'image/heif',
+};
+const QUALITY_LADDER = [85, 72, 58, 44];
+const MAX_ATTEMPTS = 6;
+const QUALITY_CAN_CLOSE = 2;
+function fit(width, height, maxEdge, maxPixels) {
+    let scale = Math.min(1, maxEdge / Math.max(width, height));
+    if (maxPixels)
+        scale = Math.min(scale, Math.sqrt(maxPixels / (width * height)));
+    return scaleTo(width, height, scale);
+}
+function scaleTo(width, height, scale) {
+    return {
+        width: Math.max(1, Math.floor(width * scale)),
+        height: Math.max(1, Math.floor(height * scale)),
+    };
+}
+function pickEncoding(target, hasAlpha) {
+    const accepts = (mime) => target.encode.includes(mime);
+    const order = hasAlpha ? ['image/webp', 'image/png', 'image/jpeg'] : ['image/jpeg', 'image/webp', 'image/png'];
+    for (const mime of order)
+        if (accepts(mime))
+            return mime;
+    throw new ImageNormalizeError(`the agent takes back none of the encodings this image could be produced in: ${target.encode.join(', ') || '(none declared)'}`);
+}
+function encode(pipeline, mime, quality) {
+    switch (mime) {
+        case 'image/jpeg':
+            return pipeline.jpeg({ quality, mozjpeg: true }).toBuffer();
+        case 'image/webp':
+            return pipeline.webp({ quality }).toBuffer();
+        case 'image/png':
+            return pipeline.png({ compressionLevel: 9, palette: true, quality }).toBuffer();
+        default:
+            throw new ImageNormalizeError(`Unsupported target encoding: ${mime}`);
+    }
+}
+export async function normalizeImage(bytes, target) {
+    let meta;
+    try {
+        meta = await sharp(bytes).metadata();
+    }
+    catch (err) {
+        throw new ImageNormalizeError(`Not a decodable image: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const format = meta.format ? MIME_BY_FORMAT[meta.format] : undefined;
+    const swap = (meta.orientation ?? 0) >= 5;
+    const width = swap ? meta.height : meta.width;
+    const height = swap ? meta.width : meta.height;
+    if (!format || !width || !height)
+        throw new ImageNormalizeError('Image has no readable format or dimensions.');
+    const source = { mime: format, width, height, bytes: bytes.length };
+    const target1 = fit(width, height, target.maxEdge, target.maxPixels);
+    const fitsNow = target.encode.includes(format) &&
+        bytes.length <= target.maxBytes &&
+        target1.width === width &&
+        target1.height === height;
+    if (fitsNow)
+        return { bytes, mime: format, width, height, source, changed: false };
+    const mime = pickEncoding(target, meta.hasAlpha === true);
+    const flatten = meta.hasAlpha === true && mime === 'image/jpeg';
+    let dims = target1;
+    let qualityStep = 0;
+    let last;
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        let pipeline = sharp(bytes).rotate();
+        if (flatten)
+            pipeline = pipeline.flatten({ background: '#ffffff' });
+        pipeline = pipeline.resize({ ...dims, fit: 'inside', withoutEnlargement: true });
+        const quality = QUALITY_LADDER[Math.min(qualityStep, QUALITY_LADDER.length - 1)];
+        last = await encode(pipeline, mime, quality);
+        if (last.length <= target.maxBytes) {
+            const out = await sharp(last).metadata();
+            return {
+                bytes: last,
+                mime,
+                width: out.width ?? dims.width,
+                height: out.height ?? dims.height,
+                source,
+                changed: true,
+            };
+        }
+        if (last.length <= target.maxBytes * QUALITY_CAN_CLOSE && qualityStep < QUALITY_LADDER.length - 1) {
+            qualityStep += 1;
+        }
+        else {
+            const shrink = Math.sqrt(target.maxBytes / last.length) * 0.9;
+            dims = scaleTo(dims.width, dims.height, Math.min(0.9, shrink));
+        }
+    }
+    throw new ImageNormalizeError(`Could not bring the image within ${target.maxBytes} bytes: ${last?.length ?? source.bytes} bytes after ${MAX_ATTEMPTS} attempts.`);
+}

package/dist/media/index.d.ts

@@ -0,0 +1 @@
+export { normalizeImage, ImageNormalizeError, type ImageTarget, type ImageFacts, type NormalizedImage, } from './image.ts';

package/dist/media/index.js

@@ -0,0 +1 @@
+export { normalizeImage, ImageNormalizeError, } from "./image.js";

package/dist/migrations.js

@@ -394,7 +394,7 @@ export function makeTable(em, table, record) {
 export async function renameSystemShelfKey(em) {
     await makeTable(em, '_embeddings').renameColumn('type', 'shelf_key');
 }
-const LEGACY_ORCHESTRATOR_FIELDS = ['agent_id', 'access_password', 'trigger_prefix', 'reply_window'];
+const LEGACY_ORCHESTRATOR_FIELDS = ['agent_id', 'trigger_prefix', 'reply_window'];
 export const SYSTEM_MIGRATIONS = [
     {
         name: 'embeddings-shelf-key',

package/dist/orchestrator/agent-capabilities.d.ts

@@ -1,2 +1,2 @@
-import type { AgentToolProvider, AttachmentRef } from './types.ts';
-export declare function makeAttachmentCapabilities(attachments: AttachmentRef[]): Promise<AgentToolProvider>;
+import type { AgentMediaLimits, AgentToolProvider, AttachmentRef } from './types.ts';
+export declare function makeAttachmentCapabilities(attachments: AttachmentRef[], limits: AgentMediaLimits): Promise<AgentToolProvider>;

package/dist/orchestrator/agent-capabilities.js

@@ -57,8 +57,8 @@ function fileItems(value) {
 function findTool(defs, name) {
     return defs.find((def) => def.server === 'coffer' && def.bareName === name);
 }
-export async function makeAttachmentCapabilities(attachments) {
-    const defs = await collectMcpTools();
+export async function makeAttachmentCapabilities(attachments, limits) {
+    const defs = await collectMcpTools({ role: 'member' });
     const getRecord = findTool(defs, 'get_record');
     const updateRecord = findTool(defs, 'update_record');
     const tools = [];
@@ -115,7 +115,7 @@ export async function makeAttachmentCapabilities(attachments) {
                 return inspectUpload(item['name'], {
                     ...(typeof item['mime'] === 'string' ? { mime: item['mime'] } : {}),
                     ...(typeof item['size'] === 'number' ? { size: item['size'] } : {}),
-                });
+                }, limits);
             },
         });
     }

package/dist/orchestrator/allow.d.ts

@@ -1,16 +1 @@
-import type { GatePolicy } from './types.ts';
-export declare const stateDir: () => string;
-export declare function carryLegacyState(): void;
-export declare function allowFileFor(connectorId: string): string;
-export interface AllowState {
-    ids: Record<string, number>;
-}
-export declare function emptyAllowed(): AllowState;
-export declare function loadAllowed(file: string): AllowState;
-export declare function saveAllowed(file: string, state: AllowState): void;
-export declare function isAllowed(state: AllowState, id: string | number | null | undefined): boolean;
-export declare function addAllowed(state: AllowState, id: string | number, now: number): AllowState;
-export declare function isSenderAllowed(connectorId: string, senderId: string, deps?: {
-    policy?: GatePolicy;
-}): Promise<boolean>;
-export declare function makeThrottle(maxAttempts?: number, windowMs?: number): (id: string | number, now?: number) => boolean;
+export declare function makeThrottle(maxNotices?: number, windowMs?: number): (id: string | number, now?: number) => boolean;

package/dist/orchestrator/allow.js

@@ -1,63 +1,13 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { loadGatePolicy } from "./config.js";
-import { carryInto, dataDir } from "../data-dir.js";
-export const stateDir = () => process.env['ORCHESTRATOR_STATE_DIR'] ?? path.join(dataDir(), 'state');
-function legacyStateDirs() {
-    return [
-        path.join(process.cwd(), 'packages', 'plugin-orchestrator', 'runtime', 'state'),
-        path.join(process.cwd(), 'node_modules', '@coffer-org', 'plugin-orchestrator', 'runtime', 'state'),
-    ];
-}
-export function carryLegacyState() {
-    carryInto(stateDir(), ...legacyStateDirs());
-}
-export function allowFileFor(connectorId) {
-    return path.join(stateDir(), `${connectorId}.allowed.json`);
-}
-export function emptyAllowed() {
-    return { ids: {} };
-}
-export function loadAllowed(file) {
-    try {
-        const obj = JSON.parse(fs.readFileSync(file, 'utf-8'));
-        if (obj && typeof obj === 'object' && 'ids' in obj && typeof obj.ids === 'object') {
-            return obj;
-        }
-        return emptyAllowed();
-    }
-    catch {
-        return emptyAllowed();
-    }
-}
-export function saveAllowed(file, state) {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    const tmp = `${file}.${process.pid}.tmp`;
-    fs.writeFileSync(tmp, JSON.stringify(state), 'utf-8');
-    fs.renameSync(tmp, file);
-}
-export function isAllowed(state, id) {
-    return id != null && Object.prototype.hasOwnProperty.call(state.ids, String(id));
-}
-export function addAllowed(state, id, now) {
-    return { ids: { ...state.ids, [String(id)]: now } };
-}
-export async function isSenderAllowed(connectorId, senderId, deps) {
-    const policy = deps?.policy ?? (await loadGatePolicy());
-    if (!policy.accessPassword)
-        return true;
-    return isAllowed(loadAllowed(allowFileFor(connectorId)), senderId);
-}
-export function makeThrottle(maxAttempts = 5, windowMs = 60_000) {
+export function makeThrottle(maxNotices = 5, windowMs = 60_000) {
     const hits = new Map();
-    return function allowAttempt(id, now = Date.now()) {
+    return function allowNotice(id, now = Date.now()) {
         const key = String(id);
         const rec = hits.get(key);
         if (!rec || now - rec.start >= windowMs) {
             hits.set(key, { start: now, count: 1 });
             return true;
         }
-        if (rec.count >= maxAttempts)
+        if (rec.count >= maxNotices)
             return false;
         rec.count += 1;
         return true;

package/dist/orchestrator/config.js

@@ -3,7 +3,6 @@ export function buildPolicy(dbSettings = {}) {
     const db = dbSettings;
     return {
         ...(typeof db.agent_id === 'string' && db.agent_id ? { agentId: db.agent_id } : {}),
-        accessPassword: db.access_password ?? '',
         triggerPrefix: db.trigger_prefix ?? '',
         replyWindow: Number(db.reply_window ?? 1800) || 1800,
     };

package/dist/orchestrator/context-facts.d.ts

@@ -0,0 +1,27 @@
+import type { AuthRole } from '../plugin-hooks.ts';
+export interface ContextFact {
+    name: string;
+    value: string;
+    attrs?: Record<string, string>;
+}
+export declare const CONNECTOR_FACT_NAME: RegExp;
+export declare const CONTEXT_GAP_MS: number;
+export declare const MAX_SPEAKER_NAME = 80;
+export declare const MAX_FACT_VALUE = 200;
+export declare const MAX_CONNECTOR_FACTS = 12;
+export declare function oneLine(value: string, maxLen?: number): string;
+export interface ContextSpeaker {
+    id: string;
+    name: string;
+    role: AuthRole;
+}
+export interface ContextInput {
+    connectorFacts: readonly ContextFact[];
+    speaker: ContextSpeaker;
+    now: Date;
+    timeZone: string;
+    previous: readonly ContextFact[] | null;
+    previousAt: Date | null;
+}
+export declare function humanizeGap(ms: number): string;
+export declare function buildContextFacts(input: ContextInput): ContextFact[];

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/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,27 +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 { 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, 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,19 +6,21 @@ 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;
@@ -27,7 +29,6 @@ function runStartersRefresh() {
     return refreshSystemStarters().catch((err) => log.warn(`system starters: ${String(err)}`));
 }
 export function startOrchestrator() {
-    carryLegacyState();
     db = openLogDb();
     setLogDb(db);
     void runStartersRefresh();
@@ -46,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;