nexus-agentd 0.1.8 → 0.2.0

package/dist/server.js

@@ -1,21 +1,14 @@
 import { randomUUID, timingSafeEqual } from 'node:crypto';
 import http from 'node:http';
-import path from 'node:path';
-import { pipeline } from 'node:stream/promises';
-import { ArtifactStoreError, contentDisposition, GatewayArtifactStore, mediaTypeForName } from './artifact-store.js';
 import { AdminSessionStore } from './auth.js';
 import { ControlPlaneError } from './control-plane.js';
 import { RunNotFoundError, SessionNotFoundError, SessionRequestError } from './session.js';
 import { redirectToAgentdWebUi, writeAgentdWebUi } from './webui/index.js';
-import { WorkspaceFileError, WorkspaceFiles } from './workspace-files.js';
 const ADMIN_COOKIE = 'agent_nexus_admin';
 export function createAgentdServer(config, sessions, controlPlane) {
     const adminSessions = new AdminSessionStore(config.adminSessionTtlMs || 12 * 60 * 60 * 1000);
     const loginLimiter = new FailureRateLimiter(8, 60_000, 5 * 60_000);
     const apiLimiter = new FailureRateLimiter(30, 60_000, 60_000);
-    const artifactStore = new GatewayArtifactStore(config.artifactStoragePath || path.resolve('.nexus-agentd-artifacts'), config.artifactTtlMs || 24 * 60 * 60 * 1000, config.maxArtifactBytes || 512 * 1024 * 1024, config.maxArtifactStorageBytes || 4 * 1024 * 1024 * 1024, config.maxPublishedArtifacts || 4096, config.maxConcurrentArtifactPublishes || 4);
-    const workspaceFiles = new WorkspaceFiles(() => controlPlane?.snapshot().workspaceRoots || config.workspaceRoots, config.maxArtifactBytes || 512 * 1024 * 1024);
-    artifactStore.startCleanup(config.cleanupIntervalMs);
     let sseConnections = 0;
     const server = http.createServer((request, response) => {
         const requestId = randomUUID();
@@ -27,8 +20,6 @@ export function createAgentdServer(config, sessions, controlPlane) {
             adminSessions,
             loginLimiter,
             apiLimiter,
-            artifactStore,
-            workspaceFiles,
             request,
             response,
             acquireSse() {
@@ -67,14 +58,11 @@ export function createAgentdServer(config, sessions, controlPlane) {
     server.headersTimeout = Math.min(server.requestTimeout, 20_000);
     server.keepAliveTimeout = 5_000;
     server.maxConnections = config.maxConnections || 256;
-    server.once('close', () => {
-        adminSessions.clear();
-        artifactStore.stopCleanup();
-    });
+    server.once('close', () => adminSessions.clear());
     return server;
 }
 async function handleRequest(context) {
-    const { config, sessions, controlPlane, adminSessions, loginLimiter, apiLimiter, artifactStore, workspaceFiles, request, response } = context;
+    const { config, sessions, controlPlane, adminSessions, loginLimiter, apiLimiter, request, response } = context;
     const url = new URL(request.url || '/', 'http://localhost');
     if (url.pathname === '/' && request.method === 'GET') {
         redirectToAgentdWebUi(response);
@@ -84,12 +72,6 @@ async function handleRequest(context) {
         writeAgentdWebUi(response);
         return;
     }
-    const artifactMatch = url.pathname.match(/^\/v1\/artifacts\/([a-f0-9]{64})\/(\d+)\/([^/]+)$/);
-    if (artifactMatch && request.method === 'GET') {
-        const artifact = await artifactStore.open(artifactMatch[1], artifactMatch[2], decodePathSegment(artifactMatch[3]));
-        await streamDownload(response, artifact.handle, artifact.name, artifact.size, artifact.mediaType);
-        return;
-    }
     if (url.pathname === '/health' && request.method === 'GET') {
         writeJson(response, 200, {
             ok: true,
@@ -168,6 +150,10 @@ async function handleRequest(context) {
         return;
     }
     const principal = authenticateApiKey(request, config, controlPlane, apiLimiter);
+    if (url.pathname === '/v1/meta' && request.method === 'GET') {
+        writeJson(response, 200, { instanceId: sessions.instanceId });
+        return;
+    }
     if (url.pathname === '/v1/agents' && request.method === 'GET') {
         const ids = principal.scope.allAgents
             ? undefined
@@ -183,37 +169,9 @@ async function handleRequest(context) {
         assertOnlyKeys(body, ['agentId', 'workspace']);
         const agentId = requiredString(body.agentId, 'agentId');
         assertAgentScope(principal, agentId);
-        writeJson(response, 201, await materializeSessionArtifacts(await sessions.create(agentId, optionalString(body.workspace), principal.id), artifactStore));
+        writeJson(response, 201, await sessions.create(agentId, optionalString(body.workspace), principal.id));
         return;
     }
-    const filesMatch = url.pathname.match(/^\/v1\/sessions\/([^/]+)\/files(?:\/(content|publish))?$/);
-    if (filesMatch) {
-        const sessionId = decodePathSegment(filesMatch[1]);
-        const session = ownedSession(sessions, sessionId, principal);
-        const root = await workspaceFiles.sessionRoot(session.workspace);
-        const action = filesMatch[2];
-        if (!action && request.method === 'GET') {
-            writeJson(response, 200, await workspaceFiles.list(root, url.searchParams.get('path') || ''));
-            return;
-        }
-        if (action === 'content' && request.method === 'GET') {
-            const file = await workspaceFiles.open(root, requiredQuery(url, 'path'));
-            await streamDownload(response, file.handle, file.name, file.size, mediaTypeForName(file.name));
-            return;
-        }
-        if (action === 'publish' && request.method === 'POST') {
-            assertJsonContentType(request);
-            const body = await readJsonBody(request, config.maxRequestBytes);
-            assertOnlyKeys(body, ['paths']);
-            const paths = requiredStringArray(body.paths, 'paths');
-            if (paths.length > 32)
-                throw new RequestError(400, 'paths must contain at most 32 values');
-            const result = await publishWorkspaceFiles(workspaceFiles, artifactStore, root, paths);
-            writeJson(response, result.errors.length ? 207 : 201, result);
-            return;
-        }
-        throw new RequestError(405, 'Method not allowed');
-    }
     const attachmentMatch = url.pathname.match(/^\/v1\/sessions\/([^/]+)\/attachments$/);
     if (attachmentMatch && request.method === 'POST') {
         const sessionId = decodeURIComponent(attachmentMatch[1]);
@@ -226,6 +184,46 @@ async function handleRequest(context) {
         writeJson(response, 201, sessions.addInputAttachment(sessionId, decodeHeader(request.headers['x-nexus-file-name']) || 'attachment', normalizedMediaType(request.headers['content-type']), bytes));
         return;
     }
+    const resolveMatch = url.pathname.match(/^\/v1\/sessions\/([^/]+)\/requests\/([^/]+)\/resolve$/);
+    if (resolveMatch && request.method === 'POST') {
+        const sessionId = decodeURIComponent(resolveMatch[1]);
+        const requestId = decodeURIComponent(resolveMatch[2]);
+        const session = sessions.get(sessionId);
+        if (!sessions.owns(sessionId, principal.id)) {
+            throw new RequestError(404, 'Session not found');
+        }
+        assertAgentScope(principal, session.agentId);
+        assertJsonContentType(request);
+        const body = await readJsonBody(request, config.maxRequestBytes);
+        assertOnlyKeys(body, ['message', 'optionId', 'action', 'attachments']);
+        const resolution = {
+            requestId,
+            message: optionalString(body.message),
+            optionId: optionalString(body.optionId),
+            action: optionalPendingAction(body.action)
+        };
+        if (!resolution.message &&
+            !resolution.optionId &&
+            !resolution.action) {
+            throw new RequestError(400, 'A pending response is required');
+        }
+        writeJson(response, 202, await sessions.resolvePending(sessionId, resolution, optionalAttachmentIds(body.attachments)));
+        return;
+    }
+    const publishMatch = url.pathname.match(/^\/v1\/sessions\/([^/]+)\/artifacts\/publish$/);
+    if (publishMatch && request.method === 'POST') {
+        const sessionId = decodeURIComponent(publishMatch[1]);
+        const session = sessions.get(sessionId);
+        if (!sessions.owns(sessionId, principal.id)) {
+            throw new RequestError(404, 'Session not found');
+        }
+        assertAgentScope(principal, session.agentId);
+        assertJsonContentType(request);
+        const body = await readJsonBody(request, config.maxRequestBytes);
+        assertOnlyKeys(body, ['path']);
+        writeJson(response, 201, await sessions.publishFile(sessionId, requiredString(body.path, 'path')));
+        return;
+    }
     const match = url.pathname.match(/^\/v1\/sessions\/([^/]+)(?:\/(message|cancel|events))?$/);
     if (!match)
         throw new RequestError(404, 'Route not found');
@@ -237,19 +235,23 @@ async function handleRequest(context) {
     }
     assertAgentScope(principal, session.agentId);
     if (!action && request.method === 'GET') {
-        writeJson(response, 200, await materializeSessionArtifacts(session, artifactStore));
+        writeJson(response, 200, session);
+        return;
+    }
+    if (!action && request.method === 'DELETE') {
+        writeJson(response, 200, await sessions.close(sessionId));
         return;
     }
     if (action === 'message' && request.method === 'POST') {
         assertJsonContentType(request);
         const body = await readJsonBody(request, config.maxRequestBytes);
         assertOnlyKeys(body, ['message', 'attachments']);
-        writeJson(response, 202, await materializeSessionArtifacts(await sessions.message(sessionId, requiredMessage(body.message), optionalAttachmentIds(body.attachments)), artifactStore));
+        writeJson(response, 202, await sessions.message(sessionId, requiredMessage(body.message), optionalAttachmentIds(body.attachments)));
         return;
     }
     if (action === 'cancel' && request.method === 'POST') {
         await assertEmptyJsonBody(request, config.maxRequestBytes);
-        writeJson(response, 200, await materializeSessionArtifacts(await sessions.cancel(sessionId), artifactStore));
+        writeJson(response, 200, await sessions.cancel(sessionId));
         return;
     }
     if (action === 'events' && request.method === 'GET') {
@@ -262,66 +264,9 @@ async function handleRequest(context) {
     throw new RequestError(405, 'Method not allowed');
 }
 async function handleAdminRoute(context, url) {
-    const { config, sessions, controlPlane, adminSessions, artifactStore, workspaceFiles, request, response } = context;
+    const { config, sessions, controlPlane, adminSessions, request, response } = context;
     if (!controlPlane)
         throw new RequestError(404, 'Control plane is unavailable');
-    if (url.pathname === '/v1/admin/files/roots' && request.method === 'GET') {
-        writeJson(response, 200, { roots: await workspaceFiles.roots() });
-        return;
-    }
-    if (url.pathname === '/v1/admin/files' && request.method === 'GET') {
-        const root = await workspaceFiles.adminRoot(requiredQuery(url, 'root'));
-        writeJson(response, 200, await workspaceFiles.list(root, url.searchParams.get('path') || ''));
-        return;
-    }
-    if (url.pathname === '/v1/admin/files/content') {
-        const root = await workspaceFiles.adminRoot(requiredQuery(url, 'root'));
-        const filePath = requiredQuery(url, 'path');
-        if (request.method === 'GET') {
-            const file = await workspaceFiles.open(root, filePath);
-            await streamDownload(response, file.handle, file.name, file.size, mediaTypeForName(file.name));
-            return;
-        }
-        if (request.method === 'PUT') {
-            const declared = optionalContentLength(request);
-            writeJson(response, 201, await workspaceFiles.write(root, filePath, request, declared));
-            return;
-        }
-        if (request.method === 'DELETE') {
-            await assertEmptyJsonBody(request, config.maxRequestBytes);
-            writeJson(response, 200, await workspaceFiles.remove(root, filePath));
-            return;
-        }
-        throw new RequestError(405, 'Method not allowed');
-    }
-    if (url.pathname === '/v1/admin/files/directory' && request.method === 'POST') {
-        assertJsonContentType(request);
-        const body = await readJsonBody(request, config.maxRequestBytes);
-        assertOnlyKeys(body, ['root', 'path']);
-        const root = await workspaceFiles.adminRoot(requiredString(body.root, 'root'));
-        writeJson(response, 201, await workspaceFiles.createDirectory(root, requiredString(body.path, 'path')));
-        return;
-    }
-    if (url.pathname === '/v1/admin/files/move' && request.method === 'POST') {
-        assertJsonContentType(request);
-        const body = await readJsonBody(request, config.maxRequestBytes);
-        assertOnlyKeys(body, ['root', 'path', 'destination']);
-        const root = await workspaceFiles.adminRoot(requiredString(body.root, 'root'));
-        writeJson(response, 200, await workspaceFiles.move(root, requiredString(body.path, 'path'), requiredString(body.destination, 'destination')));
-        return;
-    }
-    if (url.pathname === '/v1/admin/files/publish' && request.method === 'POST') {
-        assertJsonContentType(request);
-        const body = await readJsonBody(request, config.maxRequestBytes);
-        assertOnlyKeys(body, ['root', 'paths']);
-        const root = await workspaceFiles.adminRoot(requiredString(body.root, 'root'));
-        const paths = requiredStringArray(body.paths, 'paths');
-        if (paths.length > 32)
-            throw new RequestError(400, 'paths must contain at most 32 values');
-        const result = await publishWorkspaceFiles(workspaceFiles, artifactStore, root, paths);
-        writeJson(response, result.errors.length ? 207 : 201, result);
-        return;
-    }
     if (url.pathname === '/v1/admin/overview' && request.method === 'GET') {
         const agents = await sessions.listAgents(undefined, url.searchParams.get('refresh') === '1');
         writeJson(response, 200, { agents, sessions: sessions.count() });
@@ -441,7 +386,6 @@ function readAgentUpdate(body) {
         'driver',
         'name',
         'description',
-        'instructions',
         'enabled',
         'workspace',
         'permissionPolicy',
@@ -459,7 +403,6 @@ function readAgentUpdate(body) {
         driver: optionalString(body.driver),
         name: optionalString(body.name),
         description: optionalString(body.description),
-        instructions: optionalString(body.instructions),
         enabled: optionalBoolean(body.enabled, 'enabled'),
         workspace: optionalString(body.workspace),
         permissionPolicy: optionalString(body.permissionPolicy),
@@ -759,6 +702,14 @@ function optionalString(value) {
         throw new RequestError(400, 'Expected a string');
     return value.trim() || undefined;
 }
+function optionalPendingAction(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (value === 'accept' || value === 'decline' || value === 'cancel') {
+        return value;
+    }
+    throw new RequestError(400, 'action must be accept, decline, or cancel');
+}
 function optionalBoolean(value, name) {
     if (value === undefined)
         return undefined;
@@ -788,22 +739,6 @@ function requiredStringArray(value, name, allowEmpty = false) {
     }
     return result;
 }
-function requiredQuery(url, name) {
-    const value = url.searchParams.get(name)?.trim();
-    if (!value)
-        throw new RequestError(400, `${name} is required`);
-    return value;
-}
-function optionalContentLength(request) {
-    const raw = stringHeader(request.headers['content-length']);
-    if (!raw)
-        return undefined;
-    const value = Number(raw);
-    if (!Number.isSafeInteger(value) || value < 0) {
-        throw new RequestError(400, 'Content-Length is invalid');
-    }
-    return value;
-}
 function cookieValue(request, name) {
     const cookie = stringHeader(request.headers.cookie);
     for (const part of cookie.split(';')) {
@@ -856,122 +791,6 @@ function safePath(value) {
         return '/invalid-url';
     }
 }
-function decodePathSegment(value) {
-    try {
-        return decodeURIComponent(value);
-    }
-    catch {
-        throw new RequestError(400, 'URL path is invalid');
-    }
-}
-function ownedSession(sessions, sessionId, principal) {
-    const session = sessions.get(sessionId);
-    if (!sessions.owns(sessionId, principal.id)) {
-        throw new RequestError(404, 'Session not found');
-    }
-    assertAgentScope(principal, session.agentId);
-    return session;
-}
-async function streamDownload(response, handle, name, size, mediaType) {
-    try {
-        response.writeHead(200, {
-            'Content-Type': mediaType,
-            'Content-Length': size,
-            'Content-Disposition': contentDisposition(name),
-            'Cache-Control': 'no-store',
-            'X-Content-Type-Options': 'nosniff'
-        });
-        await pipeline(handle.createReadStream({ autoClose: false }), response);
-    }
-    finally {
-        await handle.close().catch(() => undefined);
-    }
-}
-async function publishWorkspaceFiles(workspaceFiles, artifactStore, root, paths) {
-    const files = [];
-    const errors = [];
-    let firstFailure;
-    for (const value of paths) {
-        let file;
-        try {
-            file = await workspaceFiles.publishable(root, value);
-            files.push(await artifactStore.publishHandle(file.handle, file.name));
-        }
-        catch (error) {
-            if (!(error instanceof WorkspaceFileError) && !(error instanceof ArtifactStoreError)) {
-                throw error;
-            }
-            firstFailure ||= { status: error.status, message: error.message };
-            errors.push({ path: value, error: error.message });
-        }
-        finally {
-            await file?.handle.close().catch(() => undefined);
-        }
-    }
-    if (!files.length && firstFailure) {
-        throw new RequestError(firstFailure.status, firstFailure.message);
-    }
-    return { files, errors };
-}
-async function materializeSessionArtifacts(session, store) {
-    const artifacts = await Promise.all(session.artifacts.map(async (artifact, index) => {
-        if (!artifact.bytesBase64)
-            return artifact;
-        let bytes;
-        try {
-            bytes = decodeArtifactBase64(artifact.bytesBase64);
-        }
-        catch (error) {
-            return omittedArtifact(artifact, errorMessage(error));
-        }
-        try {
-            const published = await store.publishBytes(bytes, artifact.filename || artifact.name || `artifact-${artifact.id || randomUUID()}`, artifact.mediaType, `${session.id}:${artifact.id || index}`);
-            return {
-                ...artifact,
-                name: artifact.name || published.name,
-                filename: artifact.filename || published.name,
-                url: published.url,
-                bytesBase64: undefined,
-                metadata: {
-                    ...artifact.metadata,
-                    publishedArtifactId: published.id,
-                    size: published.size,
-                    sha256: published.sha256,
-                    expiresAt: published.expiresAt
-                }
-            };
-        }
-        catch (error) {
-            if (error instanceof ArtifactStoreError && error.status === 413) {
-                return omittedArtifact(artifact, error.message);
-            }
-            throw error;
-        }
-    }));
-    return { ...session, artifacts };
-}
-function decodeArtifactBase64(value) {
-    const normalized = value.replace(/\s/g, '');
-    if (!normalized ||
-        normalized.length % 4 === 1 ||
-        !/^[A-Za-z0-9+/]*={0,2}$/.test(normalized)) {
-        throw new Error('Artifact contains invalid Base64 data');
-    }
-    const bytes = Buffer.from(normalized, 'base64');
-    if (bytes.toString('base64').replace(/=+$/, '') !== normalized.replace(/=+$/, '')) {
-        throw new Error('Artifact contains invalid Base64 data');
-    }
-    return bytes;
-}
-function omittedArtifact(artifact, reason) {
-    return {
-        ...artifact,
-        bytesBase64: undefined,
-        description: [artifact.description, `[binary artifact omitted: ${reason}]`]
-            .filter(Boolean)
-            .join('\n')
-    };
-}
 function errorStatus(error) {
     if (error instanceof RunNotFoundError)
         return 404;
@@ -981,10 +800,6 @@ function errorStatus(error) {
         return error.status;
     if (error instanceof ControlPlaneError)
         return error.status;
-    if (error instanceof ArtifactStoreError)
-        return error.status;
-    if (error instanceof WorkspaceFileError)
-        return error.status;
     if (error instanceof RequestError)
         return error.status;
     return 500;

package/dist/session-contract.d.ts

@@ -1,10 +1,11 @@
-import type { AgentdArtifact, AgentdEventType, AgentdInputAttachment, AgentdPendingRequest, AgentdSessionState } from './types.js';
+import type { AgentdArtifact, AgentdEventType, AgentdInputAttachment, AgentdPendingRequest, AgentdPendingResponse, AgentdSessionState, AgentdTurnCompletionProof } from './types.js';
 export interface AgentSessionSink {
     readonly id: string;
     readonly state: AgentdSessionState;
     readonly protocolSessionId?: string;
     setProtocolSessionId(id: string): void;
     setState(state: AgentdSessionState, error?: string): void;
+    completeTurn(proof: AgentdTurnCompletionProof): boolean;
     appendOutput(text: string): void;
     addArtifact(artifact: AgentdArtifact): void;
     setPending(request: AgentdPendingRequest): void;
@@ -18,7 +19,7 @@ export interface AcpSessionSink extends AgentSessionSink {
 export interface AgentSessionRuntime {
     start(workspace?: string): 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>;
 }

package/dist/session.d.ts

@@ -2,7 +2,7 @@ import type { AgentDriver } from './drivers/index.js';
 import { SessionEventLog } from './events.js';
 import { RunStore, type RunListQuery } from './run-store.js';
 import type { AcpSessionSink, AgentSessionRuntime, AgentSessionSink } from './session-contract.js';
-import type { AgentdAgentView, AgentdArtifact, AgentdConfig, AgentdEvent, AgentdEventType, AgentdInputAttachmentView, AgentdPendingRequest, AgentdProtocol, AgentdSessionState, AgentdSessionView } from './types.js';
+import type { AgentdAgentView, AgentdArtifact, AgentdConfig, AgentdEvent, AgentdEventType, AgentdInputAttachmentView, AgentdPendingRequest, AgentdPendingResponse, AgentdProtocol, AgentdSessionState, AgentdSessionView, AgentdTurnCompletionProof } from './types.js';
 import type { WorkspacePolicy } from './workspace.js';
 export declare class ManagedSession implements AgentSessionSink, AcpSessionSink {
     readonly agentId: string;
@@ -12,6 +12,7 @@ export declare class ManagedSession implements AgentSessionSink, AcpSessionSink
     private readonly maxOutputChars;
     private readonly agentName;
     private readonly runStore?;
+    readonly instanceId: string;
     readonly id: `${string}-${string}-${string}-${string}-${string}`;
     readonly createdAt: number;
     readonly events: SessionEventLog;
@@ -22,21 +23,25 @@ export declare class ManagedSession implements AgentSessionSink, AcpSessionSink
     output: string;
     error?: string;
     pendingRequest?: AgentdPendingRequest;
+    private completion?;
     private artifacts;
     private inputAttachments;
     private runtime?;
-    constructor(agentId: string, protocol: AgentdProtocol, workspace: string | undefined, ownerKeyId: string, maxEvents: number, maxOutputChars: number, agentName: string, runStore?: RunStore | undefined);
+    constructor(agentId: string, protocol: AgentdProtocol, workspace: string | undefined, ownerKeyId: string, maxEvents: number, maxOutputChars: number, agentName: string, runStore?: RunStore | undefined, instanceId?: string);
     attach(runtime: AgentSessionRuntime): void;
     setProtocolSessionId(id: string): void;
     setAcpSessionId(id: string): void;
     setState(state: AgentdSessionState, error?: string): void;
+    completeTurn(proof: AgentdTurnCompletionProof): boolean;
     appendOutput(text: string): void;
     addArtifact(artifact: AgentdArtifact): void;
+    publishFile(filePath: string): Promise<AgentdArtifact>;
     setPending(request: AgentdPendingRequest): void;
     clearPending(): void;
     emit(type: AgentdEventType, data?: unknown): void;
     addInputAttachment(name: string, mediaType: string | undefined, bytes: Buffer): AgentdInputAttachmentView;
     message(message: string, attachmentIds?: string[]): Promise<void>;
+    resolvePending(response: AgentdPendingResponse, attachmentIds?: string[]): Promise<void>;
     cancel(): Promise<void>;
     dispose(): Promise<void>;
     snapshot(): AgentdSessionView;
@@ -50,6 +55,7 @@ export declare class SessionManager {
     private workspacePolicy;
     private drivers;
     private readonly runStore?;
+    readonly instanceId: `${string}-${string}-${string}-${string}-${string}`;
     private sessions;
     private cleanupTimer?;
     private readinessCache?;
@@ -67,8 +73,11 @@ export declare class SessionManager {
     };
     getRun(id: string): import("./types.js").AgentdRunDetail;
     message(id: string, message: string, attachmentIds?: string[]): Promise<AgentdSessionView>;
+    resolvePending(id: string, response: AgentdPendingResponse, attachmentIds?: string[]): Promise<AgentdSessionView>;
     addInputAttachment(id: string, name: string, mediaType: string | undefined, bytes: Buffer): AgentdInputAttachmentView;
+    publishFile(id: string, path: string): Promise<AgentdSessionView>;
     cancel(id: string): Promise<AgentdSessionView>;
+    close(id: string): Promise<AgentdSessionView>;
     eventsAfter(id: string, after?: string): AgentdEvent[];
     subscribe(id: string, listener: (event: AgentdEvent) => void): () => boolean;
     shutdown(): Promise<void>;