nexus-agentd 0.1.8 → 0.1.9

package/dist/a2a/runtime.d.ts

@@ -1,5 +1,5 @@
 import type { AgentSessionRuntime, AgentSessionSink } from '../session-contract.js';
-import type { AgentdA2AConfig, AgentdAgentView, AgentdInputAttachment } from '../types.js';
+import type { AgentdA2AConfig, AgentdAgentView, AgentdInputAttachment, AgentdPendingResponse } from '../types.js';
 export declare function probeA2AAgent(id: string, config: AgentdA2AConfig): Promise<AgentdAgentView>;
 export declare class A2AClientRuntime implements AgentSessionRuntime {
     private readonly config;
@@ -10,8 +10,6 @@ export declare class A2AClientRuntime implements AgentSessionRuntime {
     private taskId;
     private contextId;
     private prompting;
-    private firstPrompt;
-    private readonly instructions;
     private disposed;
     private activeController?;
     private readonly artifactCache;
@@ -19,7 +17,7 @@ export declare class A2AClientRuntime implements AgentSessionRuntime {
     constructor(config: AgentdA2AConfig, sink: AgentSessionSink, promptTimeoutMs: number);
     start(): Promise<void>;
     prompt(message: string, attachments?: AgentdInputAttachment[]): Promise<void>;
-    respondPending(message: string, attachments?: AgentdInputAttachment[]): Promise<void>;
+    respondPending(response: AgentdPendingResponse | string, attachments?: AgentdInputAttachment[]): Promise<void>;
     cancel(): Promise<void>;
     dispose(): Promise<void>;
     private messageRequest;

package/dist/a2a/runtime.js

@@ -1,7 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { Role, TaskState } from '@a2a-js/sdk';
 import { ClientFactory, DefaultAgentCardResolver, JsonRpcTransportFactory, RestTransportFactory } from '@a2a-js/sdk/client';
-import { buildAgentInstructions, composeInitialAgentPrompt } from '../agent-instructions.js';
 export async function probeA2AAgent(id, config) {
     const startedAt = Date.now();
     if (config.enabled === false)
@@ -44,8 +43,6 @@ export class A2AClientRuntime {
     taskId = '';
     contextId = '';
     prompting = false;
-    firstPrompt = true;
-    instructions;
     disposed = false;
     activeController;
     artifactCache = new Map();
@@ -54,7 +51,6 @@ export class A2AClientRuntime {
         this.config = config;
         this.sink = sink;
         this.promptTimeoutMs = promptTimeoutMs;
-        this.instructions = buildAgentInstructions(config.instructions);
     }
     async start() {
         const resolver = createResolver(this.config);
@@ -82,16 +78,12 @@ export class A2AClientRuntime {
         this.prompting = true;
         this.sink.clearPending();
         this.sink.setState('running');
-        const promptMessage = this.firstPrompt
-            ? composeInitialAgentPrompt(this.instructions, message)
-            : message;
-        this.firstPrompt = false;
         const controller = new AbortController();
         this.activeController = controller;
         const timer = setTimeout(() => controller.abort(new Error('A2A message timed out')), Math.min(this.promptTimeoutMs, this.config.timeoutMs || this.promptTimeoutMs));
         timer.unref?.();
         try {
-            const request = this.messageRequest(promptMessage, attachments);
+            const request = this.messageRequest(message, attachments);
             for await (const response of this.client.sendMessageStream(request, {
                 signal: controller.signal
             })) {
@@ -112,10 +104,19 @@ export class A2AClientRuntime {
             this.prompting = false;
         }
     }
-    async respondPending(message, attachments = []) {
+    async respondPending(response, attachments = []) {
         if (this.sink.state !== 'input_required') {
             throw new Error('A2A session is not waiting for input');
         }
+        const message = typeof response === 'string'
+            ? response
+            : response.action === 'cancel'
+                ? 'cancel'
+                : response.action === 'decline'
+                    ? 'decline'
+                    : response.message ?? response.optionId ?? '';
+        if (!message.trim())
+            throw new Error('A2A pending response is empty');
         this.sink.clearPending();
         await this.prompt(message, attachments);
     }

package/dist/acp/runtime.d.ts

@@ -1,9 +1,6 @@
 import type { AgentDriver } from '../drivers/index.js';
 import type { AcpSessionSink } from '../session-contract.js';
-import type { AgentdInputAttachment } from '../types.js';
-export declare class InvalidPermissionAnswerError extends Error {
-    constructor(message: string);
-}
+import type { AgentdInputAttachment, AgentdPendingResponse } from '../types.js';
 export declare class AcpProcessRuntime {
     private readonly driver;
     private readonly sink;
@@ -15,14 +12,12 @@ export declare class AcpProcessRuntime {
     private prompting;
     private readonly maxStderrChunkChars;
     private readonly promptTimeoutMs;
-    private readonly instructions;
-    private firstPrompt;
     private promptCapabilities;
     private inputDirectory?;
-    constructor(driver: AgentDriver, sink: AcpSessionSink, maxStderrChunkChars?: number, promptTimeoutMs?: number, customInstructions?: string);
+    constructor(driver: AgentDriver, sink: AcpSessionSink, maxStderrChunkChars?: number, promptTimeoutMs?: number);
     start(workspace: string): Promise<void>;
     prompt(message: string, attachments?: AgentdInputAttachment[]): Promise<void>;
-    respondPending(message: string, _attachments?: AgentdInputAttachment[]): Promise<void>;
+    respondPending(input: AgentdPendingResponse | string, _attachments?: AgentdInputAttachment[]): Promise<void>;
     cancel(): Promise<void>;
     dispose(): Promise<void>;
     private requestPermission;

package/dist/acp/runtime.js

@@ -4,13 +4,6 @@ import path from 'node:path';
 import { Readable, Writable } from 'node:stream';
 import { pathToFileURL } from 'node:url';
 import * as acp from '@agentclientprotocol/sdk';
-import { buildAgentInstructions, composeInitialAgentPrompt } from '../agent-instructions.js';
-export class InvalidPermissionAnswerError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'InvalidPermissionAnswerError';
-    }
-}
 export class AcpProcessRuntime {
     driver;
     sink;
@@ -22,11 +15,9 @@ export class AcpProcessRuntime {
     prompting = false;
     maxStderrChunkChars;
     promptTimeoutMs;
-    instructions;
-    firstPrompt = true;
     promptCapabilities = {};
     inputDirectory;
-    constructor(driver, sink, maxStderrChunkChars = 16 * 1024, promptTimeoutMs = 30 * 60 * 1000, customInstructions) {
+    constructor(driver, sink, maxStderrChunkChars = 16 * 1024, promptTimeoutMs = 30 * 60 * 1000) {
         this.driver = driver;
         this.sink = sink;
         const limit = Number.isFinite(maxStderrChunkChars)
@@ -34,7 +25,6 @@ export class AcpProcessRuntime {
             : 16 * 1024;
         this.maxStderrChunkChars = Math.max(1, Math.min(16 * 1024, limit));
         this.promptTimeoutMs = Math.max(10_000, Math.trunc(promptTimeoutMs));
-        this.instructions = buildAgentInstructions(customInstructions);
     }
     async start(workspace) {
         if (this.process)
@@ -96,14 +86,10 @@ export class AcpProcessRuntime {
         this.prompting = true;
         this.sink.clearPending();
         this.sink.setState('running');
-        const promptMessage = this.firstPrompt
-            ? composeInitialAgentPrompt(this.instructions, message)
-            : message;
-        this.firstPrompt = false;
         try {
             const response = await withTimeout(this.connection.agent.request(acp.methods.agent.session.prompt, {
                 sessionId,
-                prompt: await this.promptBlocks(promptMessage, attachments)
+                prompt: await this.promptBlocks(message, attachments)
             }), this.promptTimeoutMs, 'ACP prompt timed out');
             if (this.sink.state === 'canceled' || this.sink.state === 'failed') {
                 return;
@@ -129,16 +115,47 @@ export class AcpProcessRuntime {
             this.prompting = false;
         }
     }
-    async respondPending(message, _attachments = []) {
+    async respondPending(input, _attachments = []) {
+        const response = typeof input === 'string'
+            ? {
+                requestId: this.pendingInput?.request.id ??
+                    this.pending?.request.id ??
+                    '',
+                message: input
+            }
+            : input;
         if (this.pendingInput) {
-            this.finishInput(message);
+            if (response.requestId !== this.pendingInput.request.id) {
+                throw new Error(`ACP pending request no longer matches: ${response.requestId}`);
+            }
+            this.finishInput(response.message ?? response.optionId ?? '', response.action);
             return;
         }
         const pending = this.pending;
         if (!pending)
             throw new Error('ACP session is not waiting for input');
-        const normalized = message.trim().toLowerCase();
+        if (response.requestId !== pending.request.id) {
+            throw new Error(`ACP pending request no longer matches: ${response.requestId}`);
+        }
         const options = pending.request.options || [];
+        if (response.action === 'cancel' || response.action === 'decline') {
+            this.finishPermission({ outcome: { outcome: 'cancelled' } });
+            return;
+        }
+        if (response.action === 'accept') {
+            const option = options.find((item) => item.kind?.startsWith('allow')) ||
+                options.find((item) => !(item.kind?.startsWith('reject') ?? false));
+            if (!option) {
+                throw new Error('Permission request does not provide an allow option');
+            }
+            this.finishPermission({
+                outcome: { outcome: 'selected', optionId: option.id }
+            });
+            return;
+        }
+        const normalized = (response.optionId ?? response.message ?? '')
+            .trim()
+            .toLowerCase();
         if (['cancel', 'deny', 'reject', '拒绝', '取消', '不同意'].includes(normalized)) {
             this.finishPermission({ outcome: { outcome: 'cancelled' } });
             return;
@@ -147,9 +164,9 @@ export class AcpProcessRuntime {
         const option = Number.isInteger(numeric) && numeric >= 1
             ? options[numeric - 1]
             : options.find((item) => item.id.toLowerCase() === normalized ||
-                item.name.toLowerCase() === normalized) || permissionApprovalOption(normalized, options);
+                item.name.toLowerCase() === normalized);
         if (!option) {
-            throw new InvalidPermissionAnswerError(`Permission answer must be an option id/name or index: ${options
+            throw new Error(`Permission answer must be an option id/name or index: ${options
                 .map((item, index) => `${index + 1}. ${item.name} (${item.id})`)
                 .join('; ')}`);
         }
@@ -221,18 +238,6 @@ export class AcpProcessRuntime {
                 }
                 : { outcome: { outcome: 'cancelled' } };
         }
-        if (this.driver.permissionPolicy === 'allow') {
-            const allow = params.options.find((option) => option.kind.toLowerCase() === 'allow_once') ||
-                params.options.find((option) => option.kind.toLowerCase().startsWith('allow'));
-            return allow
-                ? {
-                    outcome: {
-                        outcome: 'selected',
-                        optionId: allow.optionId
-                    }
-                }
-                : { outcome: { outcome: 'cancelled' } };
-        }
         if (this.pending) {
             return { outcome: { outcome: 'cancelled' } };
         }
@@ -295,16 +300,17 @@ export class AcpProcessRuntime {
             this.pendingInput = { request, params, resolve, timer };
         });
     }
-    finishInput(message) {
+    finishInput(message, requestedAction) {
         const pending = this.pendingInput;
         if (!pending)
             return;
         const normalized = message.trim().toLowerCase();
         let response;
-        if (['cancel', '取消'].includes(normalized)) {
+        if (requestedAction === 'cancel' || ['cancel', '取消'].includes(normalized)) {
             response = { action: 'cancel' };
         }
-        else if (['decline', '拒绝', '不同意'].includes(normalized)) {
+        else if (requestedAction === 'decline' ||
+            ['decline', '拒绝', '不同意'].includes(normalized)) {
             response = { action: 'decline' };
         }
         else if (!isFormElicitation(pending.params)) {
@@ -477,39 +483,6 @@ export class AcpProcessRuntime {
         };
     }
 }
-function permissionApprovalOption(answer, options) {
-    const approvals = new Set([
-        'yes',
-        'y',
-        'ok',
-        'okay',
-        'approve',
-        'approved',
-        'accept',
-        'allow',
-        'proceed',
-        '同意',
-        '允许',
-        '允许一次',
-        '确认',
-        '好的',
-        '可以',
-        '继续',
-        '是',
-        '是的'
-    ]);
-    if (!approvals.has(answer))
-        return undefined;
-    return (options.find((item) => item.kind?.toLowerCase() === 'allow_once') ||
-        options.find((item) => isApprovalOption(item)));
-}
-function isApprovalOption(option) {
-    const kind = option.kind?.toLowerCase() || '';
-    if (kind.startsWith('allow'))
-        return true;
-    const values = [option.id, option.name].map((value) => value.trim().toLowerCase());
-    return values.some((value) => ['allow', 'approve', 'accept', 'permit', '允许', '同意'].some((word) => value === word || value.startsWith(`${word} `) || value.startsWith(`${word}_`)));
-}
 class PromptTimeoutError extends Error {
 }
 function safeFilename(value) {

package/dist/config.js

@@ -1,6 +1,5 @@
 import { mkdir, open, readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { normalizeAgentInstructions } from './agent-instructions.js';
 import { agentdDriverKinds } from './types.js';
 export async function ensureAgentdConfig(filePath, options = {}) {
     const absolute = path.resolve(filePath);
@@ -98,12 +97,6 @@ export async function loadAgentdConfig(filePath) {
         workspaceRoots,
         maxRequestBytes: integerValue(value.maxRequestBytes, 'maxRequestBytes', 1024 * 1024, 1024, 16 * 1024 * 1024),
         maxAttachmentBytes: integerValue(value.maxAttachmentBytes, 'maxAttachmentBytes', 32 * 1024 * 1024, 1024, 64 * 1024 * 1024),
-        artifactStoragePath: resolveConfigPath(absolute, optionalString(value.artifactStoragePath, 'artifactStoragePath') || './artifacts'),
-        maxArtifactBytes: integerValue(value.maxArtifactBytes, 'maxArtifactBytes', 512 * 1024 * 1024, 1024, 16 * 1024 * 1024 * 1024),
-        maxArtifactStorageBytes: integerValue(value.maxArtifactStorageBytes, 'maxArtifactStorageBytes', 4 * 1024 * 1024 * 1024, 1024 * 1024, Number.MAX_SAFE_INTEGER),
-        maxPublishedArtifacts: integerValue(value.maxPublishedArtifacts, 'maxPublishedArtifacts', 4096, 1, 1_000_000),
-        maxConcurrentArtifactPublishes: integerValue(value.maxConcurrentArtifactPublishes, 'maxConcurrentArtifactPublishes', 4, 1, 128),
-        artifactTtlMs: integerValue(value.artifactTtlMs, 'artifactTtlMs', 24 * 60 * 60 * 1000, 60_000, 30 * 24 * 60 * 60 * 1000),
         maxEventsPerSession: integerValue(value.maxEventsPerSession, 'maxEventsPerSession', 2048, 64, 100_000),
         maxOutputChars: integerValue(value.maxOutputChars, 'maxOutputChars', 512 * 1024, 16 * 1024, 16 * 1024 * 1024),
         sessionTtlMs: integerValue(value.sessionTtlMs, 'sessionTtlMs', 24 * 60 * 60 * 1000, 60_000, 30 * 24 * 60 * 60 * 1000),
@@ -141,9 +134,7 @@ function parseAgent(id, value) {
         throw new Error(`Unsupported nexus-agentd driver: ${driver || id}`);
     }
     const permissionPolicy = optionalString(input.permissionPolicy, `agents.${id}.permissionPolicy`) || 'ask';
-    if (permissionPolicy !== 'ask' &&
-        permissionPolicy !== 'allow' &&
-        permissionPolicy !== 'deny') {
+    if (permissionPolicy !== 'ask' && permissionPolicy !== 'deny') {
         throw new Error(`Invalid permissionPolicy for ${id}`);
     }
     const result = {
@@ -151,7 +142,6 @@ function parseAgent(id, value) {
         driver,
         name: optionalString(input.name, `agents.${id}.name`),
         description: optionalString(input.description, `agents.${id}.description`),
-        instructions: normalizeAgentInstructions(input.instructions, `agents.${id}.instructions`),
         enabled: optionalBoolean(input.enabled, `agents.${id}.enabled`) ?? true,
         workspace: optionalString(input.workspace, `agents.${id}.workspace`),
         command: optionalString(input.command, `agents.${id}.command`),
@@ -207,7 +197,6 @@ function parseA2AAgent(id, input) {
         protocol: 'a2a',
         name: optionalString(input.name, `agents.${id}.name`),
         description: optionalString(input.description, `agents.${id}.description`),
-        instructions: normalizeAgentInstructions(input.instructions, `agents.${id}.instructions`),
         enabled: optionalBoolean(input.enabled, `agents.${id}.enabled`) ?? true,
         agentCardUrl,
         agentUrl,
@@ -340,9 +329,6 @@ function validateHttpUrl(value, name) {
         throw new Error(`nexus-agentd ${name} must be an http(s) URL without credentials or a fragment`);
     }
 }
-function resolveConfigPath(configPath, value) {
-    return path.resolve(path.dirname(configPath), value);
-}
 function secretsEqual(left, right) {
     return left.length === right.length && left === right;
 }

package/dist/control-plane.d.ts

@@ -5,7 +5,6 @@ export interface AgentdAgentUpdate {
     driver?: AgentdDriverKind;
     name?: string;
     description?: string;
-    instructions?: string;
     enabled?: boolean;
     workspace?: string;
     permissionPolicy?: PermissionPolicy;

package/dist/control-plane.js

@@ -2,7 +2,6 @@ import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { chmod, open, readFile, rename, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { hashAdminPassword, validateAdminPassword, verifyAdminPassword } from './auth.js';
-import { normalizeAgentInstructions } from './agent-instructions.js';
 import { loadAgentdConfig } from './config.js';
 import { createDriverRegistry } from './drivers/index.js';
 import { agentdDriverKinds } from './types.js';
@@ -312,7 +311,6 @@ export class AgentdControlPlane {
                 next.name = cleanString(update.name) || cleanString(previous.name);
             }
         }
-        setOptionalInstructions(next, update.instructions ?? cleanString(previous.instructions));
         setOptionalString(next, 'description', update.description ?? cleanString(previous.description));
         agents[id] = next;
         raw.agents = agents;
@@ -450,7 +448,6 @@ export class AgentdControlPlane {
                 protocol: 'a2a',
                 name: config.name || id,
                 description: config.description,
-                instructions: config.instructions,
                 enabled: config.enabled !== false,
                 agentCardUrl: config.agentCardUrl || defaultAgentCardUrl(config.agentUrl),
                 agentUrl: config.agentUrl,
@@ -469,7 +466,6 @@ export class AgentdControlPlane {
             driver: config.driver,
             name: config.name || id,
             description: config.description,
-            instructions: config.instructions,
             enabled: config.enabled !== false,
             workspace: config.workspace || this.config.workspaceRoots[0] || '',
             permissionPolicy: config.permissionPolicy || 'ask',
@@ -505,9 +501,8 @@ function validateUpdate(update) {
     }
     if (update.permissionPolicy !== undefined &&
         update.permissionPolicy !== 'ask' &&
-        update.permissionPolicy !== 'allow' &&
         update.permissionPolicy !== 'deny') {
-        throw new ControlPlaneError(400, 'permissionPolicy must be ask, allow, or deny');
+        throw new ControlPlaneError(400, 'permissionPolicy must be ask or deny');
     }
     if (update.preferredTransport !== undefined &&
         !['auto', 'jsonrpc', 'http-json'].includes(update.preferredTransport)) {
@@ -612,19 +607,6 @@ function setOptionalString(target, key, value) {
     else
         delete target[key];
 }
-function setOptionalInstructions(target, value) {
-    let text;
-    try {
-        text = normalizeAgentInstructions(value);
-    }
-    catch (error) {
-        throw new ControlPlaneError(400, errorMessage(error));
-    }
-    if (text)
-        target.instructions = text;
-    else
-        delete target.instructions;
-}
 function validHeaderName(value) {
     return /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(value);
 }