nexus-agentd 0.1.0 → 0.1.6

package/dist/session.js

@@ -1,35 +1,61 @@
 import { randomUUID } from 'node:crypto';
-import { SessionEventLog } from './events.js';
 import { AcpProcessRuntime } from './acp/runtime.js';
-class ManagedSession {
+import { A2AClientRuntime, probeA2AAgent } from './a2a/runtime.js';
+import { SessionEventLog } from './events.js';
+const MAX_SESSION_ARTIFACTS = 64;
+const MAX_ARTIFACT_BASE64_CHARS = 16 * 1024 * 1024;
+const MAX_SESSION_BASE64_CHARS = 32 * 1024 * 1024;
+const READINESS_CACHE_MS = 20_000;
+const MAX_INPUT_ATTACHMENTS = 16;
+const MAX_INPUT_ATTACHMENT_BYTES = 16 * 1024 * 1024;
+const MAX_SESSION_INPUT_BYTES = 32 * 1024 * 1024;
+export class ManagedSession {
     agentId;
+    protocol;
     workspace;
+    ownerKeyId;
     maxOutputChars;
+    agentName;
+    runStore;
     id = randomUUID();
     createdAt = Date.now();
     events;
     state = 'created';
     updatedAt = this.createdAt;
+    protocolSessionId;
     acpSessionId;
     output = '';
     error;
     pendingRequest;
+    artifacts = [];
+    inputAttachments = new Map();
     runtime;
-    constructor(agentId, workspace, maxEvents, maxOutputChars) {
+    constructor(agentId, protocol, workspace, ownerKeyId, maxEvents, maxOutputChars, agentName, runStore) {
         this.agentId = agentId;
+        this.protocol = protocol;
         this.workspace = workspace;
+        this.ownerKeyId = ownerKeyId;
         this.maxOutputChars = maxOutputChars;
+        this.agentName = agentName;
+        this.runStore = runStore;
         this.events = new SessionEventLog(this.id, maxEvents);
-        this.events.append('session_state', { state: this.state });
+        this.events.append('session_state', { state: this.state, protocol });
     }
     attach(runtime) {
         this.runtime = runtime;
     }
+    setProtocolSessionId(id) {
+        this.protocolSessionId = id;
+        this.updatedAt = Date.now();
+        this.syncRun({ protocolSessionId: id });
+    }
     setAcpSessionId(id) {
         this.acpSessionId = id;
-        this.updatedAt = Date.now();
+        this.setProtocolSessionId(id);
     }
     setState(state, error) {
+        if (this.state === state && this.error === error)
+            return;
         this.state = state;
         this.error = error;
         this.updatedAt = Date.now();
@@ -41,23 +67,67 @@ class ManagedSession {
                     ? 'canceled'
                     : 'session_state';
         this.events.append(type, { state, ...(error ? { error } : {}) });
+        const endedAt = isTerminal(state) ? this.updatedAt : undefined;
+        this.syncRun({
+            state,
+            error,
+            progress: progressForState(state, error),
+            ...(endedAt ? { endedAt } : {})
+        });
     }
     appendOutput(text) {
         if (!text)
             return;
         this.output = `${this.output}${text}`;
         if (this.output.length > this.maxOutputChars) {
-            this.output = `…[truncated by nexus-agentd]\n${this.output.slice(-this.maxOutputChars)}`;
+            this.output = `…[truncated by Agent Nexus]\n${this.output.slice(-this.maxOutputChars)}`;
         }
         this.updatedAt = Date.now();
+        this.syncRun({ output: this.output });
+    }
+    addArtifact(artifact) {
+        const next = structuredClone(artifact);
+        const existingIndex = next.id
+            ? this.artifacts.findIndex((item) => item.id === next.id)
+            : -1;
+        const retainedBase64Chars = this.artifacts.reduce((total, item, index) => index === existingIndex
+            ? total
+            : total + (item.bytesBase64?.length || 0), 0);
+        const binaryChars = next.bytesBase64?.length || 0;
+        if (binaryChars > MAX_ARTIFACT_BASE64_CHARS ||
+            retainedBase64Chars + binaryChars > MAX_SESSION_BASE64_CHARS) {
+            next.bytesBase64 = undefined;
+            next.description = [
+                next.description,
+                `[binary payload omitted: ${binaryChars} base64 characters exceed the session limit]`
+            ]
+                .filter(Boolean)
+                .join('\n');
+        }
+        if (existingIndex >= 0) {
+            this.artifacts[existingIndex] = next;
+        }
+        else if (this.artifacts.length < MAX_SESSION_ARTIFACTS) {
+            this.artifacts.push(next);
+        }
+        this.updatedAt = Date.now();
+        this.syncRun({
+            artifacts: this.artifacts.map(runArtifact),
+            artifactCount: this.artifacts.length
+        });
     }
     setPending(request) {
         this.pendingRequest = structuredClone(request);
         this.state = request.kind === 'permission' ? 'permission_required' : 'input_required';
         this.updatedAt = Date.now();
-        this.events.append(request.kind === 'permission'
-            ? 'permission_required'
-            : 'input_required', request);
+        this.events.append(request.kind === 'permission' ? 'permission_required' : 'input_required', request);
+        this.syncRun({
+            state: this.state,
+            progress: {
+                phase: request.kind === 'permission' ? '等待授权' : '等待输入',
+                message: clipProgress(request.prompt)
+            }
+        });
     }
     clearPending() {
         this.pendingRequest = undefined;
@@ -66,21 +136,62 @@ class ManagedSession {
     emit(type, data) {
         this.updatedAt = Date.now();
         this.events.append(type, data);
+        const progress = progressForEvent(type, data);
+        if (progress)
+            this.syncRun({ progress });
+    }
+    addInputAttachment(name, mediaType, bytes) {
+        if (bytes.length > MAX_INPUT_ATTACHMENT_BYTES) {
+            throw new SessionRequestError(413, 'Input attachment is too large');
+        }
+        const retained = Array.from(this.inputAttachments.values()).reduce((total, attachment) => total + attachment.bytes.length, 0);
+        if (this.inputAttachments.size >= MAX_INPUT_ATTACHMENTS) {
+            throw new SessionRequestError(413, 'Too many input attachments');
+        }
+        if (retained + bytes.length > MAX_SESSION_INPUT_BYTES) {
+            throw new SessionRequestError(413, 'Session input attachments are too large');
+        }
+        const id = randomUUID();
+        const attachment = {
+            id,
+            name: safeAttachmentName(name) || `attachment-${id.slice(0, 8)}`,
+            mediaType: mediaType || undefined,
+            bytes: Buffer.from(bytes)
+        };
+        this.inputAttachments.set(id, attachment);
+        this.updatedAt = Date.now();
+        return attachmentView(attachment);
     }
-    async message(message) {
+    async message(message, attachmentIds = []) {
         if (!this.runtime)
-            throw new Error('ACP runtime is unavailable');
+            throw new SessionRequestError(409, 'Agent runtime is unavailable');
+        const attachments = this.inputAttachmentsFor(attachmentIds);
         if (this.pendingRequest) {
-            await this.runtime.respondPending(message);
+            this.syncRun({
+                progress: { phase: '继续执行', message: '已提交补充信息' }
+            });
+            await this.runtime.respondPending(message, attachments);
             return;
         }
         if (this.state === 'running') {
-            throw new Error('ACP session is already processing a prompt');
+            throw new SessionRequestError(409, 'Session is already processing a message');
         }
         this.output = '';
+        this.artifacts = [];
         this.error = undefined;
         this.updatedAt = Date.now();
-        void this.runtime.prompt(message).catch((error) => {
+        this.currentRunId = this.runStore?.create({
+            sessionId: this.id,
+            agentId: this.agentId,
+            agentName: this.agentName,
+            protocol: this.protocol,
+            workspace: this.workspace,
+            protocolSessionId: this.protocolSessionId,
+            ownerKeyId: this.ownerKeyId,
+            task: message,
+            inputAttachmentCount: attachments.length
+        }).id;
+        void this.runtime.prompt(message, attachments).catch((error) => {
             if (this.state !== 'canceled')
                 this.setState('failed', errorMessage(error));
         });
@@ -90,17 +201,22 @@ class ManagedSession {
     }
     async dispose() {
         await this.runtime?.dispose();
+        this.inputAttachments.clear();
     }
     snapshot() {
         return {
             id: this.id,
-            acpSessionId: this.acpSessionId,
+            runId: this.currentRunId,
+            protocol: this.protocol,
+            protocolSessionId: this.protocolSessionId,
+            acpSessionId: this.protocol === 'acp' ? this.acpSessionId : undefined,
             agentId: this.agentId,
             workspace: this.workspace,
             state: this.state,
             output: this.output || undefined,
             error: this.error,
-            artifacts: [],
+            artifacts: structuredClone(this.artifacts),
+            inputAttachments: Array.from(this.inputAttachments.values()).map(attachmentView),
             pendingRequest: this.pendingRequest
                 ? structuredClone(this.pendingRequest)
                 : undefined,
@@ -109,35 +225,157 @@ class ManagedSession {
             updatedAt: this.updatedAt
         };
     }
+    interruptForShutdown() {
+        if (isActive(this.state)) {
+            this.setState('failed', 'Gateway stopped before the task finished');
+        }
+    }
+    currentRunId;
+    syncRun(patch) {
+        if (!this.runStore || !this.currentRunId)
+            return;
+        this.runStore.update(this.currentRunId, {
+            protocolSessionId: this.protocolSessionId,
+            output: this.output || undefined,
+            artifacts: this.artifacts.map(runArtifact),
+            artifactCount: this.artifacts.length,
+            updatedAt: this.updatedAt,
+            ...patch
+        });
+    }
+    inputAttachmentsFor(ids) {
+        const unique = Array.from(new Set(ids));
+        const attachments = unique.map((id) => this.inputAttachments.get(id));
+        if (attachments.some((attachment) => !attachment)) {
+            throw new SessionRequestError(400, 'Unknown input attachment');
+        }
+        return attachments;
+    }
 }
 export class SessionManager {
     config;
     workspacePolicy;
     drivers;
+    runStore;
     sessions = new Map();
     cleanupTimer;
-    constructor(config, workspacePolicy, drivers) {
+    readinessCache;
+    constructor(config, workspacePolicy, drivers, runStore) {
         this.config = config;
         this.workspacePolicy = workspacePolicy;
         this.drivers = drivers;
+        this.runStore = runStore;
+    }
+    reconfigure(config, workspacePolicy, drivers) {
+        this.config = config;
+        this.workspacePolicy = workspacePolicy;
+        this.drivers = drivers;
+        this.readinessCache = undefined;
+        if (this.cleanupTimer)
+            this.restartCleanup();
     }
     startCleanup() {
         if (this.cleanupTimer)
             return;
-        this.cleanupTimer = setInterval(() => void this.cleanup(), 60_000);
-        this.cleanupTimer.unref?.();
+        this.restartCleanup();
     }
-    async listAgents() {
-        return Promise.all(Array.from(this.drivers.values()).map((driver) => driver.probe()));
+    async listAgents(agentIds, force = false) {
+        const now = Date.now();
+        if (!force && this.readinessCache && this.readinessCache.expiresAt > now) {
+            return filterAgents(this.readinessCache.agents, agentIds);
+        }
+        const agents = await Promise.all(Object.entries(this.config.agents).map(async ([id, config]) => {
+            if (config.protocol === 'a2a')
+                return probeA2AAgent(id, config);
+            if (config.enabled === false) {
+                return {
+                    id,
+                    name: config.name || id,
+                    description: config.description,
+                    protocol: 'acp',
+                    driver: config.driver,
+                    ready: false,
+                    enabled: false,
+                    workspace: this.defaultWorkspace(id),
+                    error: 'Agent is disabled',
+                    checkedAt: Date.now()
+                };
+            }
+            const driver = this.drivers.get(id);
+            if (!driver) {
+                return {
+                    id,
+                    name: config.name || id,
+                    description: config.description,
+                    protocol: 'acp',
+                    driver: config.driver,
+                    ready: false,
+                    enabled: true,
+                    workspace: this.defaultWorkspace(id),
+                    error: 'ACP driver is unavailable',
+                    checkedAt: Date.now()
+                };
+            }
+            const startedAt = Date.now();
+            try {
+                const probe = await driver.probe();
+                return {
+                    ...probe,
+                    protocol: 'acp',
+                    driver: config.driver,
+                    enabled: true,
+                    workspace: this.defaultWorkspace(id),
+                    checkedAt: Date.now(),
+                    responseMs: Date.now() - startedAt
+                };
+            }
+            catch (error) {
+                return {
+                    id,
+                    name: config.name || id,
+                    description: config.description,
+                    protocol: 'acp',
+                    driver: config.driver,
+                    ready: false,
+                    enabled: true,
+                    workspace: this.defaultWorkspace(id),
+                    error: errorMessage(error),
+                    checkedAt: Date.now(),
+                    responseMs: Date.now() - startedAt
+                };
+            }
+        }));
+        agents.sort((left, right) => left.name.localeCompare(right.name));
+        this.readinessCache = {
+            expiresAt: Date.now() + READINESS_CACHE_MS,
+            agents: structuredClone(agents)
+        };
+        return filterAgents(agents, agentIds);
     }
-    async create(agentId, workspaceInput) {
-        const driver = this.drivers.get(agentId);
-        if (!driver)
-            throw new Error(`Configured ACP agent not found: ${agentId}`);
-        const workspace = await this.workspacePolicy.resolve(workspaceInput);
-        const session = new ManagedSession(agentId, workspace, this.config.maxEventsPerSession, this.config.maxOutputChars);
+    async create(agentId, workspaceInput, ownerKeyId) {
+        await this.ensureCapacity();
+        const config = this.config.agents[agentId];
+        if (!config || config.enabled === false) {
+            throw new SessionRequestError(404, `Configured agent not found: ${agentId}`);
+        }
+        let workspace;
+        let driver;
+        if (config.protocol !== 'a2a') {
+            driver = this.drivers.get(agentId);
+            if (!driver) {
+                throw new SessionRequestError(404, `Configured ACP agent not found: ${agentId}`);
+            }
+            const requestedWorkspace = String(workspaceInput || '').trim() || this.defaultWorkspace(agentId);
+            if (!requestedWorkspace) {
+                throw new SessionRequestError(400, `Configured ACP agent has no workspace: ${agentId}`);
+            }
+            workspace = await this.workspacePolicy.resolve(requestedWorkspace);
+        }
+        const session = new ManagedSession(agentId, config.protocol === 'a2a' ? 'a2a' : 'acp', workspace, ownerKeyId, this.config.maxEventsPerSession, this.config.maxOutputChars, config.name || agentId, this.runStore);
+        const runtime = config.protocol === 'a2a'
+            ? new A2AClientRuntime(config, session, this.config.promptTimeoutMs || 30 * 60_000)
+            : new AcpProcessRuntime(driver, session, this.config.maxOutputChars, this.config.promptTimeoutMs || 30 * 60_000);
         this.sessions.set(session.id, session);
-        const runtime = new AcpProcessRuntime(driver, session);
         session.attach(runtime);
         try {
             await runtime.start(workspace);
@@ -146,20 +384,40 @@ export class SessionManager {
         catch (error) {
             session.setState('failed', errorMessage(error));
             await session.dispose();
-            throw error;
+            this.sessions.delete(session.id);
+            throw new SessionRequestError(502, `Agent failed to start: ${errorMessage(error)}`);
         }
     }
     get(id) {
         return this.require(id).snapshot();
     }
-    async message(id, message) {
+    owns(id, keyId) {
+        return this.require(id).ownerKeyId === keyId;
+    }
+    count() {
+        return this.sessions.size;
+    }
+    listRuns(query = {}) {
+        return this.runStore?.list(query) || { runs: [], total: 0 };
+    }
+    getRun(id) {
+        const run = this.runStore?.get(id);
+        if (!run)
+            throw new RunNotFoundError(id);
+        return run;
+    }
+    async message(id, message, attachmentIds = []) {
         const text = String(message || '');
         if (!text.trim())
-            throw new Error('message is required');
+            throw new SessionRequestError(400, 'message is required');
         const session = this.require(id);
-        await session.message(text);
+        await session.message(text, attachmentIds);
         return session.snapshot();
     }
+    addInputAttachment(id, name, mediaType, bytes) {
+        const session = this.require(id);
+        return session.addInputAttachment(name, mediaType, bytes);
+    }
     async cancel(id) {
         const session = this.require(id);
         await session.cancel();
@@ -175,7 +433,10 @@ export class SessionManager {
         if (this.cleanupTimer)
             clearInterval(this.cleanupTimer);
         this.cleanupTimer = undefined;
-        await Promise.allSettled(Array.from(this.sessions.values()).map((session) => session.dispose()));
+        await Promise.allSettled(Array.from(this.sessions.values()).map(async (session) => {
+            session.interruptForShutdown();
+            await session.dispose();
+        }));
         this.sessions.clear();
     }
     require(id) {
@@ -184,27 +445,161 @@ export class SessionManager {
             throw new SessionNotFoundError(id);
         return session;
     }
+    async ensureCapacity() {
+        const limit = this.config.maxSessions || 64;
+        if (this.sessions.size < limit)
+            return;
+        const terminal = Array.from(this.sessions.values())
+            .filter((session) => isTerminal(session.state))
+            .sort((left, right) => left.updatedAt - right.updatedAt);
+        while (this.sessions.size >= limit && terminal.length) {
+            const session = terminal.shift();
+            await session.dispose();
+            this.sessions.delete(session.id);
+        }
+        if (this.sessions.size >= limit) {
+            throw new SessionRequestError(429, 'Session capacity has been reached');
+        }
+    }
     async cleanup() {
         const cutoff = Date.now() - this.config.sessionTtlMs;
         for (const [id, session] of this.sessions) {
-            if (session.updatedAt > cutoff ||
-                session.state === 'running' ||
-                session.state === 'permission_required' ||
-                session.state === 'input_required') {
+            if (session.updatedAt > cutoff)
                 continue;
+            if (!isTerminal(session.state)) {
+                session.setState('failed', 'Session expired after exceeding its lifetime');
             }
             await session.dispose();
             this.sessions.delete(id);
         }
     }
+    restartCleanup() {
+        if (this.cleanupTimer)
+            clearInterval(this.cleanupTimer);
+        this.cleanupTimer = setInterval(() => void this.cleanup(), this.config.cleanupIntervalMs || 60_000);
+        this.cleanupTimer.unref?.();
+    }
+    defaultWorkspace(agentId) {
+        const config = this.config.agents[agentId];
+        if (config?.protocol === 'a2a')
+            return '';
+        return config?.workspace || this.config.workspaceRoots[0] || '';
+    }
+}
+function progressForState(state, error) {
+    const phases = {
+        created: '已创建',
+        running: '运行中',
+        input_required: '等待输入',
+        permission_required: '等待授权',
+        completed: '已完成',
+        failed: '失败',
+        canceled: '已取消'
+    };
+    return { phase: phases[state], message: error ? clipProgress(error) : undefined };
+}
+function progressForEvent(type, data) {
+    const record = isRecord(data) ? data : undefined;
+    const message = clipProgress(firstString(record?.title, record?.name, record?.status, record?.toolCallId));
+    const percent = finitePercent(record?.percent);
+    switch (type) {
+        case 'assistant_chunk':
+            return { phase: '生成回复' };
+        case 'thought_chunk':
+            return { phase: '分析任务' };
+        case 'plan':
+            return { phase: '制定计划', message, percent };
+        case 'tool_call':
+            return { phase: '调用工具', message, percent };
+        case 'tool_update':
+            return { phase: '执行工具', message, percent };
+        case 'terminal_output':
+            return { phase: '执行命令', message };
+        case 'file_activity':
+            return { phase: '处理文件', message };
+        case 'artifact':
+            return { phase: '生成产物', message };
+        default:
+            return undefined;
+    }
+}
+function runArtifact(artifact) {
+    return {
+        id: artifact.id,
+        name: artifact.name,
+        description: artifact.description,
+        url: artifact.url,
+        filename: artifact.filename,
+        mediaType: artifact.mediaType,
+        metadata: artifact.metadata ? structuredClone(artifact.metadata) : undefined
+    };
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function clipProgress(value) {
+    if (!value)
+        return undefined;
+    return value.length > 500 ? `${value.slice(0, 500)}…` : value;
+}
+function finitePercent(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 100
+        ? value
+        : undefined;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
 export class SessionNotFoundError extends Error {
     sessionId;
     constructor(sessionId) {
-        super(`Nexus Gateway session not found: ${sessionId}`);
+        super(`Agent Nexus session not found: ${sessionId}`);
         this.sessionId = sessionId;
     }
 }
+export class SessionRequestError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export class RunNotFoundError extends Error {
+    runId;
+    constructor(runId) {
+        super(`Agent Nexus run not found: ${runId}`);
+        this.runId = runId;
+    }
+}
+function filterAgents(agents, ids) {
+    return agents
+        .filter((agent) => !ids || ids.has(agent.id))
+        .map((agent) => structuredClone(agent));
+}
+function isTerminal(state) {
+    return state === 'completed' || state === 'failed' || state === 'canceled';
+}
+function isActive(state) {
+    return state === 'running' || state === 'input_required' || state === 'permission_required';
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function attachmentView(attachment) {
+    return {
+        id: attachment.id,
+        name: attachment.name,
+        mediaType: attachment.mediaType,
+        size: attachment.bytes.length
+    };
+}
+function safeAttachmentName(value) {
+    return String(value || '')
+        .replace(/[<>:"/\\|?*\u0000-\u001f]/g, '_')
+        .trim()
+        .slice(0, 180);
+}