nexus-agentd 0.2.2 → 0.2.3

package/dist/acp/runtime.d.ts

@@ -14,6 +14,8 @@ export declare class AcpProcessRuntime {
     private readonly promptTimeoutMs;
     private promptCapabilities;
     private inputDirectory?;
+    private workspace?;
+    private promptOutput;
     constructor(driver: AgentDriver, sink: AcpSessionSink, maxStderrChunkChars?: number, promptTimeoutMs?: number);
     start(workspace: string): Promise<void>;
     prompt(message: string, attachments?: AgentdInputAttachment[]): Promise<void>;
@@ -27,6 +29,7 @@ export declare class AcpProcessRuntime {
     private sessionUpdate;
     private captureToolArtifacts;
     private captureArtifact;
+    private captureMediaMarkers;
     private captureStderr;
     private onProcessFailure;
     private requireSessionId;

package/dist/acp/runtime.js

@@ -1,11 +1,12 @@
 import { randomUUID } from 'node:crypto';
-import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, realpath, rm, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { Readable, Writable } from 'node:stream';
-import { pathToFileURL } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import * as acp from '@agentclientprotocol/sdk';
 import { terminateProcessTree } from '../process-tree.js';
 import { TURN_COMPLETION_CONTRACT } from '../completion-contract.js';
+const MAX_MEDIA_MARKER_FILE_BYTES = 32 * 1024 * 1024;
 export class AcpProcessRuntime {
     driver;
     sink;
@@ -19,6 +20,8 @@ export class AcpProcessRuntime {
     promptTimeoutMs;
     promptCapabilities = {};
     inputDirectory;
+    workspace;
+    promptOutput = '';
     constructor(driver, sink, maxStderrChunkChars = 16 * 1024, promptTimeoutMs = 30 * 60 * 1000) {
         this.driver = driver;
         this.sink = sink;
@@ -31,6 +34,7 @@ export class AcpProcessRuntime {
     async start(workspace) {
         if (this.process)
             throw new Error('ACP runtime is already started');
+        this.workspace = workspace;
         this.inputDirectory = path.join(workspace, '.nexus-inputs', this.sink.id);
         const child = this.driver.spawn(workspace);
         this.process = child;
@@ -86,6 +90,7 @@ export class AcpProcessRuntime {
             throw new Error('ACP session is already processing a prompt');
         const sessionId = this.requireSessionId();
         this.prompting = true;
+        this.promptOutput = '';
         this.sink.clearPending();
         this.sink.setState('running');
         try {
@@ -98,6 +103,7 @@ export class AcpProcessRuntime {
             }
             switch (response.stopReason) {
                 case 'end_turn':
+                    await this.captureMediaMarkers();
                     this.sink.completeTurn({
                         source: 'acp_prompt_response',
                         stopReason: response.stopReason
@@ -356,6 +362,7 @@ export class AcpProcessRuntime {
         switch (update.sessionUpdate) {
             case 'agent_message_chunk':
                 if (update.content.type === 'text') {
+                    this.promptOutput += update.content.text;
                     this.sink.appendOutput(update.content.text);
                     this.sink.emit('assistant_chunk', {
                         messageId: update.messageId,
@@ -410,6 +417,29 @@ export class AcpProcessRuntime {
         if (artifact)
             this.sink.addArtifact(artifact);
     }
+    async captureMediaMarkers() {
+        const markers = mediaMarkers(this.promptOutput);
+        if (!markers.length)
+            return;
+        this.sink.replaceOutput(withoutMediaMarkers(this.promptOutput));
+        const seen = new Set();
+        for (const marker of markers) {
+            if (seen.has(marker))
+                continue;
+            seen.add(marker);
+            try {
+                const artifact = await artifactFromMediaMarker(marker, `media:${randomUUID()}`, this.workspace);
+                this.sink.addArtifact(artifact);
+                this.sink.emit('artifact', artifact);
+            }
+            catch (error) {
+                this.sink.emit('terminal_output', {
+                    stream: 'system',
+                    text: `Could not attach MEDIA artifact ${safeMarkerName(marker)}: ${error instanceof Error ? error.message : String(error)}`
+                });
+            }
+        }
+    }
     captureStderr(child) {
         let buffer = '';
         let flushed = false;
@@ -619,6 +649,93 @@ function filenameFromValue(value) {
 function usableUrl(value) {
     return value && /^(?:https?|file):/i.test(value) ? value : undefined;
 }
+function mediaMarkers(output) {
+    return output
+        .split(/\r?\n/)
+        .map((line) => line.match(/^\s*MEDIA:\s*(.+?)\s*$/i)?.[1]?.trim())
+        .filter((value) => Boolean(value));
+}
+function withoutMediaMarkers(output) {
+    return output
+        .split(/\r?\n/)
+        .filter((line) => !/^\s*MEDIA:\s*(.+?)\s*$/i.test(line))
+        .join('\n')
+        .trim();
+}
+async function artifactFromMediaMarker(marker, id, workspace) {
+    if (/^https?:\/\//i.test(marker)) {
+        const filename = artifactFilename(marker, undefined, 'resource', undefined);
+        return {
+            id,
+            name: filename,
+            filename,
+            url: marker,
+            metadata: { source: 'acp_media_marker' }
+        };
+    }
+    const localPath = marker.startsWith('file:')
+        ? fileURLToPath(marker)
+        : marker;
+    const resolved = await realpath(path.isAbsolute(localPath)
+        ? localPath
+        : path.resolve(workspace || process.cwd(), localPath));
+    const details = await stat(resolved);
+    if (!details.isFile()) {
+        throw new Error('declared path is not a regular file');
+    }
+    if (details.size > MAX_MEDIA_MARKER_FILE_BYTES) {
+        throw new Error(`declared file exceeds the ${MAX_MEDIA_MARKER_FILE_BYTES} byte limit`);
+    }
+    const filename = path.basename(resolved);
+    return {
+        id,
+        name: filename,
+        filename,
+        mediaType: mediaTypeForPath(filename),
+        bytesBase64: (await readFile(resolved)).toString('base64'),
+        metadata: {
+            source: 'acp_media_marker',
+            size: details.size
+        }
+    };
+}
+function safeMarkerName(marker) {
+    try {
+        return path.basename(marker.startsWith('file:') ? fileURLToPath(marker) : marker);
+    }
+    catch {
+        return 'declared artifact';
+    }
+}
+function mediaTypeForPath(value) {
+    switch (path.extname(value).toLowerCase()) {
+        case '.pptx':
+            return 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
+        case '.docx':
+            return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+        case '.xlsx':
+            return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+        case '.pdf':
+            return 'application/pdf';
+        case '.png':
+            return 'image/png';
+        case '.jpg':
+        case '.jpeg':
+            return 'image/jpeg';
+        case '.gif':
+            return 'image/gif';
+        case '.webp':
+            return 'image/webp';
+        case '.mp3':
+            return 'audio/mpeg';
+        case '.wav':
+            return 'audio/wav';
+        case '.mp4':
+            return 'video/mp4';
+        default:
+            return 'application/octet-stream';
+    }
+}
 function artifactIndex(id) {
     return id.split(':').pop() || 'output';
 }

package/dist/completion-contract.js

@@ -4,6 +4,6 @@ export const TURN_COMPLETION_CONTRACT = [
     'If you need user input or permission, use the protocol input/permission request and wait for the response.',
     'Before ending the turn, verify the requested work and provide a non-empty final response.',
     'The final response must summarize the outcome, verification performed, and workspace-relative paths for generated files.',
-    'Attach generated resources or artifacts through the protocol when supported.',
+    'Attach generated resources or artifacts through the protocol when supported. If the runtime only reports a local deliverable path, put each requested file on its own final line as MEDIA:<path>; Agent Nexus will snapshot that explicitly declared file as an artifact before the turn completes.',
     '</agent_nexus_completion_contract>'
 ].join('\n');

package/dist/session-contract.d.ts

@@ -7,6 +7,7 @@ export interface AgentSessionSink {
     setState(state: AgentdSessionState, error?: string): void;
     completeTurn(proof: AgentdTurnCompletionProof): boolean;
     appendOutput(text: string): void;
+    replaceOutput(text: string): void;
     addArtifact(artifact: AgentdArtifact): void;
     setPending(request: AgentdPendingRequest): void;
     clearPending(): void;

package/dist/session.d.ts

@@ -34,6 +34,7 @@ export declare class ManagedSession implements AgentSessionSink, AcpSessionSink
     setState(state: AgentdSessionState, error?: string): void;
     completeTurn(proof: AgentdTurnCompletionProof): boolean;
     appendOutput(text: string): void;
+    replaceOutput(text: string): void;
     addArtifact(artifact: AgentdArtifact): void;
     publishFile(filePath: string): Promise<AgentdArtifact>;
     setPending(request: AgentdPendingRequest): void;

package/dist/session.js

@@ -130,6 +130,11 @@ export class ManagedSession {
         this.updatedAt = Date.now();
         this.syncRun({ output: this.output });
     }
+    replaceOutput(text) {
+        this.output = String(text || '').slice(0, this.maxOutputChars);
+        this.updatedAt = Date.now();
+        this.syncRun({ output: this.output || undefined });
+    }
     addArtifact(artifact) {
         const next = structuredClone(artifact);
         const existingIndex = next.id

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-agentd",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Local Nexus Gateway daemon that exposes allowlisted Coding Agents through HTTP/SSE and ACP",
   "type": "module",
   "main": "dist/index.js",