dsh-lark-agent 0.3.3 → 0.5.0

package/dist/onboarding/host.js

@@ -4,14 +4,18 @@ import { constants, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { delimiter, join, resolve } from 'node:path';
 import { createBotService, BotServiceStartError } from '../bot-service.js';
-import { checkRuntimeCompatibility, DshRuntime } from '../dsh-runtime.js';
+import { checkRuntimeCompatibility } from '../dsh-runtime.js';
 import { acquireLock, LockHeldError } from '../lock.js';
-import { ConnectionController, SetupError } from './controller.js';
-import { ConnectionStore } from './store.js';
+import { SetupError } from './controller.js';
 import { LarkPlatform } from './lark-platform.js';
+import { ConnectionManager, validConnectionId } from './manager.js';
+import { agentCatalog, parseAgentSettings, validateAgentSettings } from './agents.js';
 import { npmLatest, UpdateCheck } from './updates.js';
+import { checkConnectionModel } from './model-check.js';
 const endpoints = new Set(['status', 'profiles', 'create', 'use-profile', 'recheck', 'cancel',
-    'renew-pairing', 'confirm-owner', 'pause', 'resume', 'disconnect', 'enable-documents', 'cancel-documents']);
+    'renew-pairing', 'confirm-owner', 'pause', 'resume', 'disconnect', 'enable-documents', 'cancel-documents', 'enable-input', 'cancel-input', 'update-agent']);
+const managerEndpoints = ['connections', 'add-connection', 'remove-connection', 'agent-catalog'];
+const allEndpoints = [...endpoints, ...managerEndpoints];
 const failure = (message) => ({ ok: false, error: { code: 'internal', message, details: {} } });
 class ConnectionRegistrationCleanupError extends Error {
 }
@@ -29,24 +33,48 @@ export function registerConnectionRpc(rpc, controller, ownerRoutes) {
     if (!legacy && rpc.handle.length !== 2)
         throw new SetupError('此 dsh 版本的连接接口尚未验证，请更新到支持的版本。');
     const dispatch = async (endpoint, payload, signal) => {
-        if (!endpoints.has(endpoint))
+        if (!allEndpoints.includes(endpoint))
             return failure('不支持的连接操作。');
         if (!payload || typeof payload !== 'object' || Array.isArray(payload))
             return failure('连接请求格式不正确。');
-        const allowed = endpoint === 'create' ? ['cards', 'loading'] : endpoint === 'use-profile' ? ['name'] : endpoint === 'confirm-owner' ? ['id'] : [];
+        const manager = managerEndpoints.includes(endpoint);
+        const allowed = [...(manager && endpoint !== 'remove-connection' ? [] : ['connectionId']), ...(endpoint === 'create' ? ['cards', 'loading'] : endpoint === 'use-profile' ? ['name'] : endpoint === 'confirm-owner' ? ['id']
+                : endpoint === 'update-agent' ? ['label', 'agentPreset', 'workspace', 'imageInput', 'voiceInput'] : endpoint === 'enable-input' ? ['kind'] : [])];
         const data = payload;
-        if (Object.keys(data).some(key => !allowed.includes(key)) || Object.values(data).some(value => !['boolean', 'string'].includes(typeof value) || (typeof value === 'string' && value.length > 200)))
+        if (Object.keys(data).some(key => !allowed.includes(key)) || Object.values(data).some(value => !['boolean', 'string'].includes(typeof value)) || Object.entries(data).some(([key, value]) => typeof value === 'string' && value.length > (key === 'workspace' ? 4096 : 200))
+            || (data.connectionId !== undefined && !validConnectionId(data.connectionId)))
             return failure('连接请求格式不正确。');
         if ((endpoint === 'create' && ['cards', 'loading'].some(key => data[key] !== undefined && typeof data[key] !== 'boolean'))
             || (endpoint === 'use-profile' && typeof data.name !== 'string')
-            || (endpoint === 'confirm-owner' && typeof data.id !== 'string'))
+            || (endpoint === 'confirm-owner' && typeof data.id !== 'string')
+            || (endpoint === 'enable-input' && data.kind !== 'images' && data.kind !== 'voice'))
             return failure('连接请求格式不正确。');
+        if (endpoint === 'update-agent') {
+            try {
+                parseAgentSettings(data);
+            }
+            catch {
+                return failure('Agent 设置格式不正确。');
+            }
+        }
         try {
+            if (endpoint === 'connections' && controller.list)
+                return { ok: true, value: controller.list() };
+            if (endpoint === 'add-connection' && controller.add)
+                return { ok: true, value: await controller.add() };
+            if (endpoint === 'remove-connection' && controller.remove && typeof data.connectionId === 'string')
+                return { ok: true, value: await controller.remove(data.connectionId) };
+            if (endpoint === 'agent-catalog' && controller.catalog)
+                return { ok: true, value: await controller.catalog() };
+            if (manager)
+                return failure('当前连接服务不支持机器人管理，请检查插件版本。');
+            const { connectionId, ...fields } = data;
             if (endpoint === 'status')
-                return { ok: true, value: controller.snapshot() };
+                return { ok: true, value: connectionId === undefined ? controller.snapshot() : controller.snapshot(connectionId) };
             if (endpoint === 'profiles')
-                return { ok: true, value: await controller.profiles(signal) };
-            return { ok: true, value: await controller.command(endpoint, payload) };
+                return { ok: true, value: await (connectionId === undefined ? controller.profiles(signal) : controller.profiles(signal, connectionId)) };
+            const command = endpoint;
+            return { ok: true, value: await (connectionId === undefined ? controller.command(command, fields) : controller.command(command, fields, connectionId)) };
         }
         catch (error) {
             return failure(error instanceof SetupError ? error.message : '连接操作暂时失败，请检查本机服务后重试。');
@@ -72,7 +100,7 @@ export function registerConnectionRpc(rpc, controller, ownerRoutes) {
                     throw new ConnectionRegistrationCleanupError('Connection routes could not be removed.');
             };
             try {
-                for (const endpoint of endpoints) {
+                for (const endpoint of allEndpoints) {
                     disposers.push(ownerRoutes.register({ path: `/api/larkbot/${endpoint}`, methods: ['POST'], requestBody: 'buffered',
                         async fetch(request) {
                             const envelope = await readConnectionEnvelope(request, `larkbot/${endpoint}`);
@@ -227,23 +255,10 @@ export async function applyOnboarding(ctx, options = {}) {
         return;
     }
     const executable = await findLarkExecutable(options.executable);
-    const controller = new ConnectionController({ store: new ConnectionStore(directory), platform: new LarkPlatform({ executable }), executable,
+    const controller = new ConnectionManager(directory, () => ({ platform: new LarkPlatform({ executable }), executable,
+        validateAgent: settings => validateAgentSettings(ctx, settings),
         checkRuntime: () => requireRuntime(ctx),
-        preflight: async (config, signal) => {
-            const policy = config.users[0];
-            const timeout = AbortSignal.timeout(45_000);
-            const combined = AbortSignal.any([signal, timeout]);
-            const session = await new DshRuntime(ctx).create({ ...policy, provider: config.provider, model: config.model });
-            try {
-                const result = await session.run('这是飞书连接测试，请只回复“连接成功”。', combined);
-                if (!(typeof result === 'string' ? result : result.text).trim())
-                    throw new SetupError('模型没有返回内容，请检查模型设置后重试。');
-                await session.checkpoint();
-            }
-            finally {
-                await session.dispose();
-            }
-        },
+        preflight: (config, signal) => checkConnectionModel(ctx, config, signal),
         start: async (config, signal, health, pairedChat) => {
             signal.throwIfAborted();
             const service = await createBotService(ctx, config, health, { directChat: pairedChat });
@@ -258,14 +273,16 @@ export async function applyOnboarding(ctx, options = {}) {
                     throw new BotServiceStartError(service);
                 throw error;
             }
-        }, });
+        },
+    }), () => agentCatalog(ctx));
     const installed = installedPackage();
     const updates = new UpdateCheck(installed?.version, options.latestRelease
         ?? (signal => installed ? npmLatest(installed.name, signal) : Promise.resolve(undefined)));
     const control = {
-        snapshot: () => withUpdate(controller.snapshot(), updates),
-        profiles: signal => controller.profiles(signal),
-        command: async (endpoint, payload) => withUpdate(await controller.command(endpoint, payload), updates),
+        snapshot: id => withUpdate(controller.snapshot(id), updates),
+        profiles: (signal, id) => controller.profiles(signal, id),
+        command: async (endpoint, payload, id) => withUpdate(await controller.command(endpoint, payload, id), updates),
+        list: () => controller.list(), add: () => controller.add(), remove: id => controller.remove(id), catalog: () => controller.catalog(),
     };
     let remove;
     try {

package/dist/onboarding/lark-platform.d.ts

@@ -1,4 +1,5 @@
 import type { registerApp as sdkRegisterApp } from '@larksuiteoapi/node-sdk';
+import { type MediaInputKind } from '../media-scopes.js';
 type RegisterAppOptions = Parameters<typeof sdkRegisterApp>[0];
 type RegisterAppResult = Awaited<ReturnType<typeof sdkRegisterApp>>;
 export type LarkBrand = 'feishu' | 'lark';
@@ -92,6 +93,11 @@ export declare class LarkPlatform {
         url: string;
         expireIn: number;
     }) => void, signal: AbortSignal): Promise<void>;
+    enableInput(profile: string, kind: MediaInputKind, onQRCode: (info: {
+        url: string;
+        expireIn: number;
+    }) => void, signal: AbortSignal, expectedAppId: string): Promise<void>;
+    private authorizeScopes;
     saveNewProfile(profile: string, app: RegisteredApp, signal?: AbortSignal): Promise<ProfileSummary>;
     private profile;
     private api;

package/dist/onboarding/lark-platform.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { BOT_MENU_EVENT } from '../bot-menu.js';
-import { DOCUMENT_SCOPES, STREAMING_SCOPE, defaultScopesReady } from '../rich-scopes.js';
+import { DOCUMENT_SCOPES, STREAMING_SCOPE } from '../rich-scopes.js';
+import { mediaScopes } from '../media-scopes.js';
 export class LarkPlatformError extends Error {
     code;
     constructor(code) {
@@ -244,16 +245,26 @@ export class LarkPlatform {
     }
     /** Incremental, owner-confirmed authorization; returned credentials never leave this method. */
     async enableDocuments(profile, onQRCode, signal) {
+        return this.authorizeScopes(profile, [...DOCUMENT_SCOPES, STREAMING_SCOPE], onQRCode, signal);
+    }
+    async enableInput(profile, kind, onQRCode, signal, expectedAppId) {
+        if ((kind !== 'images' && kind !== 'voice') || !validId(expectedAppId, 'cli'))
+            fail('INVALID_INPUT');
+        return this.authorizeScopes(profile, mediaScopes(kind), onQRCode, signal, expectedAppId);
+    }
+    async authorizeScopes(profile, scopes, onQRCode, signal, expectedAppId) {
         const selected = await this.profile(profile, signal);
+        if (expectedAppId !== undefined && selected.appId !== expectedAppId)
+            fail('APP_MISMATCH');
         try {
             const current = await this.inspect(profile, signal);
             if (current.appId !== selected.appId)
                 fail('APP_MISMATCH');
             // Another host may already have completed the upgrade; never ask for another scan just to refresh UI state.
-            if (current.scopeStatus === 'verified' && defaultScopesReady(current.grantedScopes))
+            if (current.scopeStatus === 'verified' && scopes.every(scope => current.grantedScopes.includes(scope)))
                 return;
             const result = await this.registrar({ source: 'dsh-larkbot', appId: selected.appId, signal,
-                addons: { preset: false, scopes: { tenant: [...DOCUMENT_SCOPES, STREAMING_SCOPE] } },
+                addons: { preset: false, scopes: { tenant: [...scopes] } },
                 onQRCodeReady: info => {
                     checkSignal(signal);
                     let url;
@@ -274,7 +285,7 @@ export class LarkPlatform {
             if (result.client_id !== selected.appId || (result.user_info?.tenant_brand && result.user_info.tenant_brand !== selected.brand))
                 fail('APP_MISMATCH');
             const inspection = await this.inspect(profile, signal);
-            if (inspection.appId !== selected.appId || inspection.scopeStatus !== 'verified' || !defaultScopesReady(inspection.grantedScopes))
+            if (inspection.appId !== selected.appId || inspection.scopeStatus !== 'verified' || !scopes.every(scope => inspection.grantedScopes.includes(scope)))
                 fail('MISSING_SCOPE');
         }
         catch (error) {

package/dist/onboarding/manager.d.ts

@@ -0,0 +1,32 @@
+import { type OnboardingDependencies } from './controller.js';
+import { ConnectionStore } from './store.js';
+import type { AgentCatalog, ConnectionEndpoint, ConnectionList, ConnectionSnapshot } from './protocol.js';
+export declare const MAX_CONNECTIONS = 10;
+export declare const validConnectionId: (id: unknown) => id is string;
+/** Owns independent controllers; the legacy controller and its native logs never move. */
+export declare class ConnectionManager {
+    private readonly directory;
+    private readonly dependencies;
+    private readonly readCatalog;
+    private readonly controllers;
+    private readonly registry;
+    private readonly claims;
+    private tail;
+    private closed;
+    constructor(directory: string, dependencies: (store: ConnectionStore) => Omit<OnboardingDependencies, 'store'>, readCatalog: () => Promise<AgentCatalog>);
+    private make;
+    initialize(): Promise<void>;
+    private get;
+    snapshot(id?: string): ConnectionSnapshot;
+    list(): ConnectionList;
+    catalog(): Promise<AgentCatalog>;
+    profiles(signal?: AbortSignal, id?: string): Promise<import("./protocol.js").ConnectionProfile[]>;
+    command(endpoint: Exclude<ConnectionEndpoint, 'profiles' | 'status'>, payload: unknown, id?: string): Promise<ConnectionSnapshot>;
+    add(): Promise<ConnectionList & {
+        selectedId: string;
+    }>;
+    remove(id: string): Promise<ConnectionList & {
+        selectedId: string;
+    }>;
+    dispose(): Promise<boolean>;
+}

package/dist/onboarding/manager.js

@@ -0,0 +1,129 @@
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { ConnectionController, SetupError } from './controller.js';
+import { ConnectionStore } from './store.js';
+import { SettingsStore } from './settings-store.js';
+export const MAX_CONNECTIONS = 10;
+export const validConnectionId = (id) => typeof id === 'string' && (id === 'default' || /^[a-f0-9]{32}$/.test(id));
+function ids(raw) {
+    const value = raw;
+    if (value?.version !== 1 || !Array.isArray(value.ids) || !value.ids.length || value.ids.length > MAX_CONNECTIONS
+        || value.ids[0] !== 'default' || !value.ids.every(validConnectionId) || new Set(value.ids).size !== value.ids.length)
+        throw new Error('Invalid connection registry');
+    return { version: 1, ids: [...value.ids] };
+}
+/** Owns independent controllers; the legacy controller and its native logs never move. */
+export class ConnectionManager {
+    directory;
+    dependencies;
+    readCatalog;
+    controllers = new Map();
+    registry;
+    claims = new Map();
+    tail = Promise.resolve();
+    closed = false;
+    constructor(directory, dependencies, readCatalog) {
+        this.directory = directory;
+        this.dependencies = dependencies;
+        this.readCatalog = readCatalog;
+        this.registry = new SettingsStore(directory, 'connections.json', ids);
+    }
+    make(id) {
+        const directory = id === 'default' ? this.directory : join(this.directory, 'connections', id);
+        const store = new ConnectionStore(directory);
+        return new ConnectionController({ ...this.dependencies(store), store, reserveApp: appId => {
+                const owner = this.claims.get(appId);
+                if (owner && owner !== id)
+                    throw new SetupError('这个机器人已在列表中，请直接打开对应的机器人。', false);
+                this.claims.set(appId, id);
+            }, commitApp: appId => {
+                for (const [reserved, owner] of this.claims)
+                    if (owner === id && reserved !== appId)
+                        this.claims.delete(reserved);
+            } });
+    }
+    async initialize() {
+        const registry = await this.registry.read() ?? { version: 1, ids: ['default'] };
+        // Reserve all saved identities before any enabled controller starts receiving.
+        for (const id of registry.ids) {
+            const store = new ConnectionStore(id === 'default' ? this.directory : join(this.directory, 'connections', id));
+            const record = await store.read();
+            if (record) {
+                if (this.claims.has(record.appId))
+                    throw new SetupError('机器人列表有重复身份，请检查本地连接状态。', false);
+                this.claims.set(record.appId, id);
+            }
+            this.controllers.set(id, this.make(id));
+        }
+        for (const controller of this.controllers.values())
+            await controller.initialize();
+    }
+    get(id = 'default') {
+        if (this.closed || !validConnectionId(id))
+            throw new SetupError('机器人入口不可用，请刷新列表。');
+        const controller = this.controllers.get(id);
+        if (!controller)
+            throw new SetupError('没有找到这个机器人，请刷新列表。');
+        return controller;
+    }
+    snapshot(id) { return this.get(id).snapshot(); }
+    list() {
+        return { limit: MAX_CONNECTIONS, connections: [...this.controllers].map(([id, controller], index) => {
+                const snapshot = controller.snapshot();
+                return { id, label: snapshot.agent?.label || snapshot.bot?.name || `飞书助手 ${index + 1}`,
+                    phase: snapshot.phase, busy: snapshot.busy, agentPreset: snapshot.agent?.agentPreset ?? '' };
+            }) };
+    }
+    catalog() { return this.readCatalog(); }
+    profiles(signal, id) { return this.get(id).profiles(signal); }
+    command(endpoint, payload, id) {
+        // Serialize roster changes with command admission, before a controller can acquire a service.
+        const result = this.tail.then(() => this.get(id).command(endpoint, payload));
+        this.tail = result.catch(() => undefined);
+        return result;
+    }
+    add() {
+        const result = this.tail.then(async () => {
+            if (this.closed)
+                throw new SetupError('连接设置已关闭。');
+            if (this.controllers.size >= MAX_CONNECTIONS)
+                throw new SetupError(`最多管理 ${MAX_CONNECTIONS} 个机器人。`);
+            const id = randomUUID().replaceAll('-', '');
+            const controller = this.make(id);
+            await controller.initialize();
+            // Publish the new controller only after its roster entry is durable.
+            await this.registry.write({ version: 1, ids: [...this.controllers.keys(), id] });
+            this.controllers.set(id, controller);
+            return { ...this.list(), selectedId: id };
+        });
+        this.tail = result.catch(() => undefined);
+        return result;
+    }
+    remove(id) {
+        const result = this.tail.then(async () => {
+            const controller = this.get(id), snapshot = controller.snapshot();
+            if (id === 'default')
+                throw new SetupError('首个机器人入口会保留，可以断开后复用。');
+            if (!snapshot.agent?.editable || snapshot.documentSetup || snapshot.inputSetup)
+                throw new SetupError('请先暂停或取消这个机器人的连接和授权，再从列表移除。');
+            if (!await controller.dispose())
+                throw new SetupError('连接尚未安全停止，机器人入口已保留。');
+            await this.registry.write({ version: 1, ids: [...this.controllers.keys()].filter(key => key !== id) });
+            this.controllers.delete(id);
+            for (const [appId, owner] of this.claims)
+                if (owner === id)
+                    this.claims.delete(appId);
+            // Its durable folder and CLI credentials are retained for manual recovery.
+            return { ...this.list(), selectedId: 'default' };
+        });
+        this.tail = result.catch(() => undefined);
+        return result;
+    }
+    async dispose() {
+        this.closed = true;
+        await this.tail;
+        const results = await Promise.allSettled([...this.controllers.values()].map(controller => controller.dispose()));
+        return results.every(result => result.status === 'fulfilled' && result.value);
+    }
+}
+//# sourceMappingURL=manager.js.map

package/dist/onboarding/model-check.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { BotConfig } from '../config.js';
+export declare const CONNECTION_TEST_PROMPT = "\u8FD9\u662F\u98DE\u4E66\u8FDE\u63A5\u6D4B\u8BD5\uFF0C\u8BF7\u53EA\u56DE\u590D\u201C\u8FDE\u63A5\u6210\u529F\u201D\u3002";
+/** One model call, without an Agent or a durable conversation to clean up. */
+export declare function checkConnectionModel(ctx: Context, config: Pick<BotConfig, 'provider' | 'model'>, signal: AbortSignal): Promise<void>;

package/dist/onboarding/model-check.js

@@ -0,0 +1,51 @@
+import { createUserMessage, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { SetupError } from './controller.js';
+export const CONNECTION_TEST_PROMPT = '这是飞书连接测试，请只回复“连接成功”。';
+/** One model call, without an Agent or a durable conversation to clean up. */
+export async function checkConnectionModel(ctx, config, signal) {
+    const timeout = AbortSignal.timeout(45_000);
+    const combined = AbortSignal.any([signal, timeout]);
+    try {
+        combined.throwIfAborted();
+        const selection = config.provider && config.model ? { provider: config.provider, model: config.model }
+            : ctx.get('agentDefaultModel')?.currentSelection?.();
+        const llm = ctx.get('llm');
+        if (!selection?.provider || !selection.model || typeof llm?.stream !== 'function') {
+            throw new SetupError('请先在 dsh 的模型设置中选择可用模型，然后回来继续连接飞书。');
+        }
+        let text = false, finished = false;
+        for await (const chunk of llm.stream({
+            provider: selection.provider, model: selection.model,
+            ...(selection.reasoningEffort === undefined ? {} : { reasoningEffort: ReasoningEffortId(selection.reasoningEffort) }),
+            messages: [createUserMessage({ source: { kind: 'user' }, content: [{ type: 'text', text: CONNECTION_TEST_PROMPT }] })],
+            tools: [], signal: combined,
+        })) {
+            combined.throwIfAborted();
+            if (chunk.type === 'text-delta')
+                text ||= Boolean(chunk.text.trim());
+            if (chunk.type === 'block-end' && chunk.block.type === 'text')
+                text ||= Boolean(chunk.block.text.trim());
+            if (chunk.type === 'finish') {
+                if (chunk.reason.kind === 'error' || chunk.reason.kind === 'aborted' || chunk.reason.kind === 'tool-calls') {
+                    throw new SetupError('模型连接测试失败，请检查模型设置后重试。');
+                }
+                finished = true;
+            }
+        }
+        combined.throwIfAborted();
+        if (!finished)
+            throw new SetupError('模型连接测试未完成，请检查模型设置后重试。');
+        if (!text)
+            throw new SetupError('模型没有返回内容，请检查模型设置后重试。');
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw new SetupError('连接已取消。');
+        if (timeout.aborted)
+            throw new SetupError('模型连接测试超时，请检查模型设置后重试。');
+        if (error instanceof SetupError)
+            throw error;
+        throw new SetupError('模型连接测试失败，请检查模型设置后重试。');
+    }
+}
+//# sourceMappingURL=model-check.js.map

package/dist/onboarding/protocol.d.ts

@@ -1,3 +1,4 @@
+import type { MediaInputKind } from '../media-scopes.js';
 /** Owner-only UI contract. Credentials and raw platform errors never belong here. */
 export type ConnectionPhase = 'idle' | 'creating' | 'waiting_scan' | 'configuring' | 'action_required' | 'pairing' | 'confirming_owner' | 'starting' | 'connected' | 'paused' | 'error';
 export interface ConnectionSnapshot {
@@ -30,6 +31,8 @@ export interface ConnectionSnapshot {
         cards: boolean;
         loading: boolean;
         documents?: boolean;
+        images?: boolean;
+        voice?: boolean;
     };
     documentSetup?: {
         phase: 'preparing' | 'scanning' | 'error';
@@ -40,6 +43,16 @@ export interface ConnectionSnapshot {
             expiresAt: number;
         };
     };
+    inputSetup?: {
+        kind: MediaInputKind;
+        phase: 'preparing' | 'scanning' | 'error';
+        message: string;
+        qr?: {
+            url: string;
+            image: string;
+            expiresAt: number;
+        };
+    };
     /** Bottom-menu entries the published app lacks, and where its owner adds them. */
     menu?: {
         missing: Array<{
@@ -54,13 +67,50 @@ export interface ConnectionSnapshot {
         current: string;
         latest: string;
     };
+    agent?: AgentSettings & {
+        workspaceDisplay: string;
+        editable: boolean;
+    };
+}
+/** Per-robot choices. Empty preset/workspace follows the host/default workspace. */
+export interface AgentSettings {
+    label: string;
+    agentPreset: string;
+    workspace: string;
+    imageInput: boolean;
+    voiceInput: boolean;
+}
+export interface AgentCatalog {
+    presets: Array<{
+        id: string;
+        name: string;
+        description?: string;
+        available: boolean;
+    }>;
+    presetsAvailable: boolean;
+    defaultPreset?: string;
+    model: string;
+    imagesAvailable: boolean;
+    voiceAvailable: boolean;
+    modelImages?: 'supported' | 'unsupported' | 'unknown';
+}
+export interface ConnectionList {
+    connections: Array<{
+        id: string;
+        label: string;
+        phase: ConnectionPhase;
+        busy: boolean;
+        agentPreset: string;
+    }>;
+    limit: number;
 }
+export type ManagerEndpoint = 'connections' | 'add-connection' | 'remove-connection' | 'agent-catalog';
 export interface ConnectionProfile {
     name: string;
     appId: string;
     label: string;
 }
-export type ConnectionEndpoint = 'status' | 'profiles' | 'create' | 'use-profile' | 'recheck' | 'cancel' | 'renew-pairing' | 'confirm-owner' | 'pause' | 'resume' | 'disconnect' | 'enable-documents' | 'cancel-documents';
+export type ConnectionEndpoint = 'status' | 'profiles' | 'create' | 'use-profile' | 'recheck' | 'cancel' | 'renew-pairing' | 'confirm-owner' | 'pause' | 'resume' | 'disconnect' | 'enable-documents' | 'cancel-documents' | 'enable-input' | 'cancel-input' | 'update-agent';
 export type ConnectionResult<T> = {
     ok: true;
     value: T;

package/dist/onboarding/settings-store.d.ts

@@ -0,0 +1,11 @@
+/** A failed publication poisons this writer until the owner reloads from disk. */
+export declare class SettingsStore<T> {
+    private readonly directory;
+    private readonly filename;
+    private readonly parse;
+    private unavailable;
+    private tail;
+    constructor(directory: string, filename: string, parse: (raw: unknown) => T);
+    read(): Promise<T | undefined>;
+    write(value: T): Promise<void>;
+}

package/dist/onboarding/settings-store.js

@@ -0,0 +1,67 @@
+import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+/** A failed publication poisons this writer until the owner reloads from disk. */
+export class SettingsStore {
+    directory;
+    filename;
+    parse;
+    unavailable = false;
+    tail = Promise.resolve();
+    constructor(directory, filename, parse) {
+        this.directory = directory;
+        this.filename = filename;
+        this.parse = parse;
+    }
+    async read() {
+        await this.tail;
+        if (this.unavailable)
+            throw new Error('Settings publication is uncertain');
+        try {
+            return this.parse(JSON.parse(await readFile(join(this.directory, this.filename), 'utf8')));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+    }
+    write(value) {
+        const safe = this.parse(value);
+        const job = this.tail.then(async () => {
+            if (this.unavailable)
+                throw new Error('Settings publication is uncertain');
+            await mkdir(this.directory, { recursive: true, mode: 0o700 });
+            const temp = join(this.directory, `${this.filename}.${randomUUID()}.tmp`);
+            let publishing = false;
+            try {
+                const file = await open(temp, 'wx', 0o600);
+                try {
+                    await file.writeFile(JSON.stringify(safe) + '\n');
+                    await file.sync();
+                }
+                finally {
+                    await file.close();
+                }
+                publishing = true;
+                await rename(temp, join(this.directory, this.filename));
+                const directory = await open(this.directory, 'r');
+                try {
+                    await directory.sync();
+                }
+                finally {
+                    await directory.close();
+                }
+            }
+            catch (error) {
+                if (publishing)
+                    this.unavailable = true;
+                await unlink(temp).catch(() => undefined);
+                throw error;
+            }
+        });
+        this.tail = job.catch(() => undefined);
+        return job;
+    }
+}
+//# sourceMappingURL=settings-store.js.map

package/dist/replies.d.ts

@@ -44,6 +44,22 @@ export interface ReplyPanel {
     }[];
     actions?: ReplyAction[];
     actionColumns?: 1 | 2 | 3;
+    /** Trusted catalog controls; option values and callbacks are supplied by the application. */
+    select?: {
+        placeholder: string;
+        options: {
+            label: string;
+            value: string;
+        }[];
+        value: Record<string, string>;
+        initialOption?: string;
+        disabled?: boolean;
+    };
+    search?: {
+        query: string;
+        value: Record<string, string>;
+        disabled?: boolean;
+    };
     note?: string;
 }
 /**