@coffer-org/plugin-orchestrator 1.4.0 → 2.0.0

package/dist/runtime/index.d.ts

@@ -2,5 +2,8 @@ import type { PluginHooks } from '@coffer-org/server/plugin-hooks';
 export { handleIncoming } from './pipeline.ts';
 export type { PipelineDeps, RunAgentFn } from './pipeline.ts';
 export { buildPolicy, loadGatePolicy } from './config.ts';
-export type { Connector, ConnectorCapabilities, IncomingConversation, GatePolicy, ConvMessage, SystemLayer, AgentRequest, AgentResult, } from './types.ts';
+export { makeLiveChannel, plainRender } from './live-message.ts';
+export type { LiveChannelOps, LiveChannelOpts, RenderFn } from './live-message.ts';
+export { chunk } from './format.ts';
+export type { Connector, IncomingConversation, GatePolicy, ReplyContext, ReplyPayload, ReplyChannel, ConvMessage, SystemLayer, AgentRequest, AgentResult, } from './types.ts';
 export declare const serverHooks: PluginHooks;

package/dist/runtime/index.js

@@ -2,6 +2,8 @@ import { openLogDb } from "./db.js";
 import { setLogDb } from "./pipeline.js";
 export { handleIncoming } from "./pipeline.js";
 export { buildPolicy, loadGatePolicy } from "./config.js";
+export { makeLiveChannel, plainRender } from "./live-message.js";
+export { chunk } from "./format.js";
 let db;
 export const serverHooks = {
     init: () => { db = openLogDb(); setLogDb(db); },

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

@@ -0,0 +1,14 @@
+import type { ReplyChannel, ReplyPayload } 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 {
+    ops: LiveChannelOps;
+    throttleMs: number;
+    render: RenderFn;
+    maxLength: number;
+}
+export declare function plainRender(max: number): RenderFn;
+export declare function makeLiveChannel(o: LiveChannelOpts): ReplyChannel;

package/dist/runtime/live-message.js

@@ -0,0 +1,83 @@
+import { chunk } from "./format.js";
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('orchestrator');
+export function plainRender(max) {
+    return (r) => chunk((r.text ?? '').trim() || '⚠️ the agent returned no response', max);
+}
+async function swallow(fn, fallback, label) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        log.error(`live-message ${label}: ${err instanceof Error ? err.message : String(err)}`);
+        return fallback;
+    }
+}
+export function makeLiveChannel(o) {
+    let msgId = null;
+    let pending = '';
+    let lastSent = '';
+    let busy = false;
+    let closed = false;
+    let gen = 0;
+    let inFlight = Promise.resolve();
+    const timer = setInterval(() => {
+        if (closed || busy)
+            return;
+        const t = pending.slice(0, o.maxLength);
+        if (!t || t === lastSent)
+            return;
+        busy = true;
+        const myGen = gen;
+        if (!msgId) {
+            inFlight = o.ops.send(t)
+                .then((id) => { if (gen === myGen) {
+                msgId = id;
+                lastSent = t;
+            } })
+                .catch((err) => { log.error(`live-message send: ${err instanceof Error ? err.message : String(err)}`); })
+                .finally(() => { busy = false; });
+            return;
+        }
+        const id = msgId;
+        inFlight = o.ops.edit(id, t)
+            .then(() => { if (gen === myGen)
+            lastSent = t; })
+            .catch((err) => { log.error(`live-message edit: ${err instanceof Error ? err.message : String(err)}`); })
+            .finally(() => { busy = false; });
+    }, o.throttleMs);
+    if (typeof timer.unref === 'function')
+        timer.unref();
+    return {
+        update(text) {
+            pending = text;
+        },
+        segment() {
+            gen++;
+            msgId = null;
+            pending = '';
+            lastSent = '';
+        },
+        async finish(r) {
+            closed = true;
+            clearInterval(timer);
+            await inFlight;
+            const parts = o.render(r);
+            let last = null;
+            const [head, ...rest] = parts;
+            if (msgId && head !== undefined) {
+                const id = msgId;
+                await swallow(() => o.ops.edit(id, head), undefined, 'edit(final)');
+                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;
+        },
+    };
+}

package/dist/runtime/pipeline.d.ts

@@ -6,7 +6,6 @@ export type RunAgentFn = typeof runAgent;
 export interface PipelineDeps {
     runAgent?: RunAgentFn;
     logDb?: LogDb | null;
-    throttleMs?: number;
     policy?: GatePolicy;
     agentBase?: () => Promise<string>;
 }

package/dist/runtime/pipeline.js

@@ -1,12 +1,10 @@
 import { runAgent, agentSystemBase } from '@coffer-org/plugin-claude-agent/runtime';
-import { chunk } from "./format.js";
 import { join } from 'node:path';
 import { loadAllowed, saveAllowed, isAllowed, addAllowed, makeThrottle } from "./allow.js";
 import { loadGatePolicy } from "./config.js";
 import { buildSystem } from "./system-assembly.js";
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('orchestrator');
-const DEFAULT_STREAM_THROTTLE_MS = 2000;
 const stateDir = () => process.env['ORCHESTRATOR_STATE_DIR']
     ?? join(new URL('../../runtime/state', import.meta.url).pathname);
 let logDb;
@@ -22,6 +20,15 @@ function passThrottle(connectorId) {
 }
 let cachedBase;
 function cachedAgentBase() { return (cachedBase ??= agentSystemBase()); }
+function openChannel(connector, chatId, ctx) {
+    try {
+        return connector.reply(chatId, ctx);
+    }
+    catch (err) {
+        log.error(`connector error in reply: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
 async function safeCall(fn, fallback, label) {
     try {
         return await fn();
@@ -34,7 +41,6 @@ async function safeCall(fn, fallback, label) {
 export async function handleIncoming(connector, conversation, deps) {
     const agent = deps?.runAgent ?? runAgent;
     const db = deps && 'logDb' in deps ? deps.logDb : logDb;
-    const throttleMs = deps?.throttleMs ?? DEFAULT_STREAM_THROTTLE_MS;
     const policy = deps?.policy ?? await loadGatePolicy();
     const agentBase = deps?.agentBase ?? cachedAgentBase;
     const { connectorId, chatId, sender, messages } = conversation;
@@ -50,10 +56,14 @@ export async function handleIncoming(connector, conversation, deps) {
             if (last.content.trim() === policy.accessPassword) {
                 allow = addAllowed(allow, sender.id, Date.now());
                 saveAllowed(allowFile, allow);
-                await safeCall(() => connector.sendMessage(chatId, '✅ Access granted. Send your requests.'), null, 'sendMessage(enroll)');
+                const ch = openChannel(connector, chatId, { parentMsgId: incomingMsgId });
+                if (ch)
+                    await safeCall(() => ch.finish({ text: '✅ Access granted. Send your requests.', reasoning: null }), null, 'finish(enroll)');
             }
             else if (passThrottle(connectorId)(sender.id)) {
-                await safeCall(() => connector.sendMessage(chatId, '🔒 Access locked. Send the password to gain access.'), null, 'sendMessage(locked)');
+                const ch = openChannel(connector, chatId, { parentMsgId: incomingMsgId });
+                if (ch)
+                    await safeCall(() => ch.finish({ text: '🔒 Access locked. Send the password to gain access.', reasoning: null }), null, 'finish(locked)');
             }
             return;
         }
@@ -67,88 +77,46 @@ export async function handleIncoming(connector, conversation, deps) {
         ? messages.map((m, i) => (i === messages.length - 1 ? { ...m, content: queryText } : m))
         : messages;
     const base = await agentBase();
-    const system = buildSystem({ base, channelSystem: conversation.channelSystem });
+    const system = buildSystem({
+        base,
+        channelSystem: conversation.channelSystem,
+        volatileSystem: conversation.volatileSystem,
+    });
     db?.logTurn({ connector: connectorId, chatId, userId: sender.id, role: 'user', text: queryText, tokensIn: null, tokensOut: null, ms: null });
     const startedAt = Date.now();
-    const canStream = connector.capabilities.streaming && typeof connector.editMessage === 'function';
-    const max = connector.capabilities.maxMessageLength;
+    const ch = openChannel(connector, chatId, { parentMsgId: incomingMsgId });
+    if (!ch)
+        return;
     let result;
-    let placeholderId = null;
-    if (canStream) {
-        const stopTyping = connector.capabilities.typing && connector.startTyping
-            ? await safeCall(async () => connector.startTyping(chatId), undefined, 'startTyping')
-            : undefined;
-        let pending = '', lastEdited = '', editing = false, closed = false;
-        let editPromise = Promise.resolve();
-        const timer = setInterval(() => {
-            if (closed || editing)
-                return;
-            const t = pending.slice(0, max);
-            if (!t || t === lastEdited)
-                return;
-            editing = true;
-            if (!placeholderId) {
-                editPromise = safeCall(() => connector.sendMessage(chatId, t), null, 'sendMessage(stream-create)')
-                    .then((s) => { placeholderId = s?.msgId ?? null; lastEdited = t; })
-                    .finally(() => { editing = false; });
-                return;
+    try {
+        result = await agent({
+            system,
+            messages: agentMessages,
+            onDelta: (acc) => { try {
+                ch.update(acc);
             }
-            editPromise = safeCall(() => connector.editMessage(chatId, placeholderId, t), undefined, 'editMessage(stream)')
-                .then(() => { lastEdited = t; })
-                .finally(() => { editing = false; });
-        }, throttleMs);
-        try {
-            result = await agent({
-                system,
-                messages: agentMessages,
-                onDelta: (acc) => { pending = acc; },
-                onSegment: () => {
-                    const t = pending.slice(0, max);
-                    if (placeholderId && t && t !== lastEdited) {
-                        void safeCall(() => connector.editMessage(chatId, placeholderId, t), undefined, 'editMessage(segment)');
-                    }
-                    placeholderId = null;
-                    pending = '';
-                    lastEdited = '';
-                },
-            });
-        }
-        finally {
-            closed = true;
-            clearInterval(timer);
-            await editPromise;
-            stopTyping?.();
-        }
-    }
-    else {
-        const stopTyping = connector.capabilities.typing && connector.startTyping
-            ? await safeCall(async () => connector.startTyping(chatId), undefined, 'startTyping')
-            : undefined;
-        try {
-            result = await agent({ system, messages: agentMessages });
-        }
-        finally {
-            stopTyping?.();
-        }
-    }
-    let botMsgId = null;
-    const out = result.text ?? '⚠️ the agent returned no response';
-    const parts = chunk(out, max);
-    if (canStream && placeholderId) {
-        await safeCall(() => connector.editMessage(chatId, placeholderId, parts[0]), undefined, 'editMessage(final)');
-        botMsgId = placeholderId;
-        for (const p of parts.slice(1)) {
-            const s = await safeCall(() => connector.sendMessage(chatId, p), null, 'sendMessage(overflow)');
-            botMsgId = s?.msgId ?? botMsgId;
-        }
+            catch (err) {
+                log.error(`connector error in update: ${err instanceof Error ? err.message : String(err)}`);
+            } },
+            onReasoning: (acc) => { try {
+                ch.updateReasoning?.(acc);
+            }
+            catch (err) {
+                log.error(`connector error in updateReasoning: ${err instanceof Error ? err.message : String(err)}`);
+            } },
+            onSegment: () => { try {
+                ch.segment();
+            }
+            catch (err) {
+                log.error(`connector error in segment: ${err instanceof Error ? err.message : String(err)}`);
+            } },
+        });
     }
-    else {
-        for (const p of parts) {
-            const s = await safeCall(() => connector.sendMessage(chatId, p), null, 'sendMessage(deliver)');
-            botMsgId = s?.msgId ?? botMsgId;
-        }
+    catch (err) {
+        log.error(`agent error: ${err instanceof Error ? err.message : String(err)}`);
     }
-    if (result.text)
+    const botMsgId = await safeCall(() => ch.finish({ text: result?.text ?? null, reasoning: result?.reasoning ?? null }), null, 'finish');
+    if (result?.text)
         db?.logTurn({ connector: connectorId, chatId, userId: sender.id, role: 'assistant', text: result.text, tokensIn: result.tokensIn, tokensOut: result.tokensOut, ms: Date.now() - startedAt });
-    await safeCall(() => connector.recordAssistant({ parentMsgId: incomingMsgId, botMsgId, text: result.text ?? '' }), undefined, 'recordAssistant');
+    await safeCall(() => connector.recordAssistant({ parentMsgId: incomingMsgId, botMsgId, text: result?.text ?? '', reasoning: result?.reasoning ?? null }), undefined, 'recordAssistant');
 }

package/dist/runtime/system-assembly.d.ts

@@ -2,4 +2,5 @@ import type { SystemLayer } from './types.ts';
 export declare function buildSystem(input: {
     base: string;
     channelSystem?: string;
+    volatileSystem?: string;
 }): SystemLayer[];

package/dist/runtime/system-assembly.js

@@ -1,4 +1,7 @@
 export function buildSystem(input) {
     const text = [input.base, input.channelSystem].filter(Boolean).join('\n\n');
-    return [{ text, stable: true }];
+    const layers = [{ text, stable: true }];
+    if (input.volatileSystem?.trim())
+        layers.push({ text: input.volatileSystem, stable: false });
+    return layers;
 }

package/dist/runtime/types.d.ts

@@ -1,32 +1,37 @@
 export type { ConvMessage, SystemLayer, AgentRequest, AgentResult } from '@coffer-org/plugin-claude-agent/runtime';
 import type { ConvMessage } from '@coffer-org/plugin-claude-agent/runtime';
-export interface ConnectorCapabilities {
-    streaming: boolean;
-    typing: boolean;
-    maxMessageLength: number;
-}
 export interface IncomingConversation {
     connectorId: string;
     chatId: string;
     channelSystem?: string;
+    volatileSystem?: string;
     sender: {
         id: string;
         displayName?: string;
     };
     messages: ConvMessage[];
 }
+export interface ReplyContext {
+    parentMsgId: string | null;
+}
+export interface ReplyPayload {
+    text: string | null;
+    reasoning: string | null;
+}
+export interface ReplyChannel {
+    update(text: string): void;
+    updateReasoning?(acc: string): void;
+    segment(): void;
+    finish(r: ReplyPayload): Promise<string | null>;
+}
 export interface Connector {
     id: string;
-    capabilities: ConnectorCapabilities;
-    sendMessage(chatId: string, text: string): Promise<{
-        msgId: string;
-    } | null>;
-    editMessage?(chatId: string, msgId: string, text: string): Promise<void>;
-    startTyping?(chatId: string): () => void;
+    reply(chatId: string, ctx: ReplyContext): ReplyChannel;
     recordAssistant(m: {
         parentMsgId: string | null;
         botMsgId: string | null;
         text: string;
+        reasoning: string | null;
     }): Promise<void>;
 }
 export interface GatePolicy {

package/dist/schema.js

@@ -4609,6 +4609,25 @@ function internalApiToken(o) {
 		]
 	});
 }
+/**
+* Internal "connected apps" list — the OAuth clients (claude.ai & co) the user
+* has authorized for MCP access. Same "internal" caveat and custom-renderer
+* trick as internalApiToken(): read-only rows + a revoke action, never part of
+* the parent form's save.
+*/
+function internalOauthGrants(o) {
+	return group({
+		key: o.key,
+		label: o.label ?? o.key,
+		multiple: true,
+		view: { kind: "internalOauthGrants" },
+		fields: [
+			string({ key: "clientName" }),
+			string({ key: "createdAt" }),
+			string({ key: "lastUsedAt" })
+		]
+	});
+}
 var SLUG_RE = /^[a-z0-9-]+$/;
 function slug(raw) {
 	const o = normalizeOpts(raw);
@@ -5038,7 +5057,8 @@ var presets = {
 	weight,
 	dimensions,
 	country,
-	internalApiToken
+	internalApiToken,
+	internalOauthGrants
 };
 //#endregion
 //#region ../../node_modules/iso-639-1/src/data.js
@@ -5865,7 +5885,7 @@ function group(o) {
 		required: o.required,
 		unique: r.unique,
 		label: o.label,
-		icon: v.icon,
+		icon: o.icon,
 		display: v.display ?? "wrap",
 		kind: v.kind,
 		fixed: r.fixed,
@@ -5876,11 +5896,9 @@ function group(o) {
 function row(o) {
 	return group({
 		label: o.label,
+		icon: o.icon,
 		fields: o.fields,
-		view: {
-			...o.view,
-			display: "scroll"
-		}
+		view: { display: "scroll" }
 	});
 }
 /** Tabular collection (array of rows → <table>, aligned by columns). Sugar. */
@@ -5888,14 +5906,12 @@ function table(o) {
 	return group({
 		key: o.key,
 		label: o.label,
+		icon: o.icon,
 		fields: o.fields,
 		multiple: true,
 		required: o.required,
 		rules: o.rules,
-		view: {
-			...o.view,
-			display: "table"
-		}
+		view: { display: "table" }
 	});
 }
 /**
@@ -5911,11 +5927,9 @@ function sheet(o) {
 	});
 	return group({
 		label: o.label,
+		icon: o.icon,
 		fields: flat,
-		view: {
-			...o.view,
-			display: "sheet"
-		}
+		view: { display: "sheet" }
 	});
 }
 /**
@@ -5947,8 +5961,8 @@ function keyed(o) {
 	return {
 		...(o.container ?? group)({
 			label: o.label,
-			fields: [o.by, ...o.fields],
-			view: o.view
+			icon: o.icon,
+			fields: [o.by, ...o.fields]
 		}),
 		key: o.key,
 		multiple: true,
@@ -6384,7 +6398,7 @@ function relation(raw) {
 		},
 		relation: {
 			library: raw.options.library,
-			type: raw.options.shelf
+			shelf: raw.options.shelf
 		},
 		...multi && { json: true },
 		zod: optionalize(s, required)
@@ -6764,15 +6778,44 @@ function period(raw) {
 		zod: optionalize(s, required)
 	});
 }
+/** Keys a file entry may carry. Everything else is rejected — see fileEntryIssue. */
+var FILE_KEYS = /* @__PURE__ */ new Set([
+	"name",
+	"mime",
+	"size"
+]);
+/** Keys that mean "the author pasted a remote address" — the one mistake worth naming. */
+var FILE_URL_KEYS = [
+	"url",
+	"src",
+	"href",
+	"link"
+];
+/**
+* A file entry points at a file already uploaded to the server: `{ name }`, where
+* name is the bare filename returned by POST /api/upload. Anything else — a remote
+* URL, an extra key, a path — is refused here, so a record can never hold a
+* reference the server cannot serve. `mime`/`size` are accepted (legacy payloads
+* and the web uploader send them) but the server overwrites them from disk.
+* Returns a vmsg code, or null when the entry is well-formed.
+*/
+function fileEntryIssue(it) {
+	if (typeof it !== "object" || it === null || Array.isArray(it)) return "file_structure";
+	const rec = it;
+	if (FILE_URL_KEYS.some((k) => k in rec)) return "file_remote_url";
+	const name = rec["name"];
+	if (typeof name !== "string" || name === "") return "file_structure";
+	if (name.includes("://") || name.startsWith("//")) return "file_remote_url";
+	if (/[\\/]/.test(name) || name.includes("..")) return "file_name";
+	for (const k of Object.keys(rec)) if (!FILE_KEYS.has(k)) return "file_unknown_key";
+	if (rec["mime"] !== void 0 && typeof rec["mime"] !== "string") return "file_structure";
+	if (rec["size"] !== void 0 && typeof rec["size"] !== "number") return "file_structure";
+	return null;
+}
 function makeFile(kind, raw) {
 	const o = normalizeOpts(raw);
 	const required = o.required ?? false;
 	const multiple = o.multiple ?? false;
-	const rowSchema = object({
-		name: string$1().min(1),
-		mime: string$1().optional(),
-		size: number$1().optional()
-	});
 	const s = unknown().superRefine((raw, ctx) => {
 		if (typeof raw === "string") try {
 			JSON.parse(raw);
@@ -6785,12 +6828,15 @@ function makeFile(kind, raw) {
 		}
 		const parsed = jsonValue(raw);
 		const items = Array.isArray(parsed) ? parsed : [parsed];
-		for (const it of items) if (!rowSchema.safeParse(it).success) {
-			ctx.addIssue({
-				code: ZodIssueCode.custom,
-				message: vmsg("file_structure")
-			});
-			return;
+		for (const it of items) {
+			const code = fileEntryIssue(it);
+			if (code) {
+				ctx.addIssue({
+					code: ZodIssueCode.custom,
+					message: vmsg(code)
+				});
+				return;
+			}
 		}
 	});
 	return wrapKey(o, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/plugin-orchestrator",
-  "version": "1.4.0",
+  "version": "2.0.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -25,9 +25,9 @@
     "postpack": "node ../../scripts/swap-exports.mjs src"
   },
   "dependencies": {
-    "@coffer-org/sdk": "^1.5.0",
-    "@coffer-org/server": "^1.8.0",
-    "@coffer-org/plugin-claude-agent": "^1.4.0"
+    "@coffer-org/sdk": "^2.0.0",
+    "@coffer-org/server": "^2.0.1",
+    "@coffer-org/plugin-claude-agent": "^2.0.0"
   },
   "coffer": {
     "schema": "dist/schema.js"