deepseek-agent-acp 0.2.1 → 0.2.3

package/dist/index.js

@@ -147,6 +147,7 @@ class Session {
     checkpoint;
     abortController = null;
     activePromptId = null;
+    activeTurnHandle = null;
     constructor(sessionId) {
         this.sessionId = sessionId;
         const sysPrompt = getSystemPrompt(MODEL);
@@ -218,6 +219,11 @@ async function handleRpcMessage(rpc) {
                         streaming: true,
                         tools: true,
                         sessionCancellation: true
+                    },
+                    _meta: {
+                        steering: {
+                            supported: true
+                        }
                     }
                 });
                 break;
@@ -244,6 +250,10 @@ async function handleRpcMessage(rpc) {
                 await handleSessionPrompt(id, params);
                 break;
             }
+            case '_session/steering': {
+                handleSessionSteering(id, params);
+                break;
+            }
             default: {
                 console.warn(`Unhandled method: ${method}`);
                 if (id !== undefined && id !== null) {
@@ -335,6 +345,7 @@ async function handleSessionPrompt(id, params) {
     session.messages.push({ role: 'user', content: promptText });
     const nostrMeta = parseNostrContext(promptText);
     const turnHandle = telemetryService?.startTurnSpan(sessionId, promptText, MODEL, nostrMeta);
+    session.activeTurnHandle = turnHandle ?? null;
     const maxIterations = getIterationLimit(MODEL);
     let iteration = 0;
     let lastToolError = null;
@@ -659,7 +670,41 @@ async function handleSessionPrompt(id, params) {
     finally {
         session.abortController = null;
         session.activePromptId = null;
+        session.activeTurnHandle = null;
+    }
+}
+/**
+ * Handle ACP _session/steering requests (mid-turn follow-up injection).
+ */
+function handleSessionSteering(id, params) {
+    const sessionId = params?.sessionId || '';
+    const session = sessionId ? sessions.get(sessionId) : undefined;
+    const promptText = extractPromptText(params);
+    if (!session || !session.activePromptId) {
+        // Session is idle or has no running turn
+        sendResponse(id, {
+            outcome: 'promptRequired',
+            reason: 'noRunningTurn'
+        });
+        return;
+    }
+    // Active turn in flight: parse nostr context and record steer child span
+    const nostrMeta = parseNostrContext(promptText);
+    if (session.activeTurnHandle) {
+        session.activeTurnHandle.recordSteerSpan({
+            eventId: nostrMeta.eventId,
+            text: promptText,
+            senderName: nostrMeta.senderName,
+            senderPubkey: nostrMeta.senderPubkey,
+            priority: 'now'
+        });
     }
+    // Inject into active turn messages for the model's next iteration
+    const steerHeader = '[New message — arrived while you were working]';
+    const steerFormatted = `${steerHeader}\n${promptText}`;
+    session.messages.push({ role: 'user', content: steerFormatted });
+    console.info(`[STEER] Injected steered message into active session ${sessionId} (event: ${nostrMeta.eventId ?? 'unknown'})`);
+    sendResponse(id, { outcome: 'injected' });
 }
 // ============================================================================
 // 6. PROCESS STDIN LISTENER

package/dist/telemetry.d.ts

@@ -44,18 +44,33 @@ export interface NostrMetadata {
  */
 export declare function parseNostrContext(rawText: unknown): NostrMetadata;
 /**
- * Extract the posted Buzz event ID from a reply tool result.
- * buzz-thread reply tools return `posted (N characters) · event_id <64 hex>`.
+ * Regex matching posted Nostr event ID across text, JSON, and escaped JSON formats:
+ * - buzz messages send / relay stdout: {"accepted":true,"event_id":"<64 hex>",...}
+ * - escaped JSON stdout: {\"accepted\":true,\"event_id\":\"<64 hex>\"}
+ * - reply tools: `posted (N characters) · event_id <64 hex>`
+ * - shell assignments: `event_id=<64 hex>` or `event_id: <64 hex>`
+ */
+export declare const POSTED_OUTPUT_PATTERN: RegExp;
+/**
+ * Extract the posted Buzz event ID from a reply tool result or shell output.
  */
 export declare function extractPostedEventId(output: unknown): string | undefined;
 export interface LlmSpanHandle {
     recordUsage(usage: DeepSeekUsage): void;
     end(outputValue?: string, errorMessage?: string): void;
 }
+export interface SteerSpanParams {
+    eventId?: string;
+    text: string;
+    senderName?: string;
+    senderPubkey?: string;
+    priority?: 'now' | 'later';
+}
 export interface TurnSpanHandle {
     startLlmSpan(modelName: string, iteration?: number): LlmSpanHandle;
     startToolSpan(toolCallId: string, toolName: string, toolParams: unknown): void;
     endToolSpan(toolCallId: string, output?: unknown, isError?: boolean, toolName?: string): void;
+    recordSteerSpan(params: SteerSpanParams): void;
     recordUsage(usage: DeepSeekUsage): void;
     end(status: 'OK' | 'ERROR' | 'CANCELLED', outputOrError?: string, failureKind?: string, errorMessage?: string): void;
 }

package/dist/telemetry.js

@@ -195,26 +195,43 @@ export function parseNostrContext(rawText) {
     return result;
 }
 /**
- * Extract the posted Buzz event ID from a reply tool result.
- * buzz-thread reply tools return `posted (N characters) · event_id <64 hex>`.
+ * Regex matching posted Nostr event ID across text, JSON, and escaped JSON formats:
+ * - buzz messages send / relay stdout: {"accepted":true,"event_id":"<64 hex>",...}
+ * - escaped JSON stdout: {\"accepted\":true,\"event_id\":\"<64 hex>\"}
+ * - reply tools: `posted (N characters) · event_id <64 hex>`
+ * - shell assignments: `event_id=<64 hex>` or `event_id: <64 hex>`
+ */
+export const POSTED_OUTPUT_PATTERN = /\bevent_id\\?["']?\s*[:=]?\s*\\?["']?([0-9a-f]{64})(?![0-9a-f])/i;
+/**
+ * Extract the posted Buzz event ID from a reply tool result or shell output.
  */
 export function extractPostedEventId(output) {
     let text = '';
     if (typeof output === 'string') {
         text = output;
+        try {
+            const parsed = JSON.parse(output);
+            if (parsed && typeof parsed.stdout === 'string') {
+                text += ` ${parsed.stdout}`;
+            }
+        }
+        catch {
+            // Ignored
+        }
     }
     else if (output && typeof output === 'object') {
+        const rec = output;
         text = JSON.stringify(output);
+        if (typeof rec.stdout === 'string') {
+            text += ` ${rec.stdout}`;
+        }
     }
     if (!text) {
         return undefined;
     }
-    const match = /\bevent_id\s+([0-9a-f]{64})\b/i.exec(text.slice(0, 4096));
+    const match = POSTED_OUTPUT_PATTERN.exec(text.slice(0, 8192));
     return match?.[1] ? match[1].toLowerCase() : undefined;
 }
-function isReplyTool(toolName) {
-    return toolName === 'mcp__buzz-thread__reply' || toolName === 'reply' || toolName.endsWith('reply');
-}
 // ============================================================================
 // 4. FLUSH COALESCING & ERROR THROTTLING
 // ============================================================================
@@ -309,7 +326,16 @@ export function initTelemetry(options) {
         const tracer = trace.getTracer('deepseek-agent-acp', getPackageVersion());
         return {
             startTurnSpan(sessionId, promptText, modelName, nostrMeta) {
-                const sanitizedPrompt = truncatePayload(redactSecrets(promptText), 8192);
+                // Extract the event message block if present for cleaner prompt preview in Phoenix & buzz-trace
+                let promptForSpan = promptText;
+                if (promptText.includes('\n') && promptText.includes('Event ID:')) {
+                    const blocks = promptText.split(/\n{2,}/);
+                    const eventBlock = blocks.find((b) => b.includes('Event ID:'));
+                    if (eventBlock) {
+                        promptForSpan = eventBlock;
+                    }
+                }
+                const sanitizedPrompt = truncatePayload(redactSecrets(promptForSpan), 8192);
                 const resolvedSessionId = nostrMeta?.threadRootId ?? sessionId;
                 const rootSpan = tracer.startSpan('agent_turn', {
                     attributes: {
@@ -429,18 +455,26 @@ export function initTelemetry(options) {
                             }
                             return;
                         }
-                        const { span: toolSpan, toolName: resolvedToolName } = entry;
+                        const { span: toolSpan } = entry;
                         const outputBytes = computeOutputBytes(output);
                         toolSpan.setAttribute('tool.output_bytes', outputBytes);
-                        // Extract posted_event_id for reply tools
-                        if (!isError && isReplyTool(resolvedToolName)) {
+                        // Extract posted_event_id for any posting tool (reply, buzz-thread__reply, shell, etc.)
+                        let hasPostedId = false;
+                        if (!isError) {
                             const postedId = extractPostedEventId(output);
                             if (postedId) {
+                                hasPostedId = true;
                                 toolSpan.setAttribute('nostr.posted_event_id', postedId);
                                 rootSpan.setAttribute('nostr.posted_event_id', postedId);
+                                // Ensure output.value and tool.output are captured on the posting span for trace fidelity
+                                const rawStr = typeof output === 'string' ? output : JSON.stringify(output);
+                                const sanitizedOut = truncatePayload(redactSecrets(rawStr), 8192);
+                                toolSpan.setAttribute('output.value', sanitizedOut);
+                                toolSpan.setAttribute('tool.output', sanitizedOut);
+                                toolSpan.setAttribute('output.mime_type', 'text/plain');
                             }
                         }
-                        if (process.env.OTEL_CAPTURE_TOOL_OUTPUT === 'true' && output !== undefined) {
+                        if (process.env.OTEL_CAPTURE_TOOL_OUTPUT === 'true' && output !== undefined && !hasPostedId) {
                             const sanitizedOut = truncatePayload(redactSecrets(output), 8192);
                             toolSpan.setAttribute('output.value', sanitizedOut);
                             toolSpan.setAttribute('output.mime_type', 'text/plain');
@@ -458,6 +492,32 @@ export function initTelemetry(options) {
                         toolSpan.end();
                         activeToolSpans.delete(toolCallId);
                     },
+                    recordSteerSpan(steerParams) {
+                        const sanitizedText = truncatePayload(redactSecrets(steerParams.text), 8192);
+                        const steerSpan = tracer.startSpan('steer', {
+                            attributes: {
+                                'openinference.span.kind': 'CHAIN',
+                                'session.id': resolvedSessionId,
+                                ...(steerParams.eventId ? { 'nostr.event_id': steerParams.eventId.toLowerCase() } : {}),
+                                'input.value': sanitizedText,
+                                'input.mime_type': 'text/plain',
+                                ...(steerParams.senderName ? { 'nostr.sender_name': steerParams.senderName } : {}),
+                                ...(steerParams.senderPubkey ? { 'nostr.sender_pubkey': steerParams.senderPubkey.toLowerCase() } : {}),
+                                'steer.priority': steerParams.priority ?? 'now',
+                                'steer.delivered': true,
+                                'steer.end_reason': 'echo'
+                            }
+                        }, rootContext);
+                        steerSpan.setStatus({ code: SpanStatusCode.OK });
+                        steerSpan.end();
+                        rootSpan.addEvent('steer', {
+                            ...(steerParams.eventId ? { 'nostr.event_id': steerParams.eventId.toLowerCase() } : {}),
+                            'input.value': sanitizedText,
+                            ...(steerParams.senderName ? { 'nostr.sender_name': steerParams.senderName } : {}),
+                            'steer.priority': steerParams.priority ?? 'now',
+                            'steer.delivered': true
+                        });
+                    },
                     recordUsage(usage) {
                         const promptTokens = usage.prompt_tokens || 0;
                         const completionTokens = usage.completion_tokens || 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepseek-agent-acp",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Agent Client Protocol (ACP) adapter for DeepSeek reasoning and chat models with Model Context Protocol (MCP) tool execution",
   "type": "module",
   "main": "dist/index.js",