deepseek-agent-acp 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -11,3 +11,7 @@
  * - Full Model Context Protocol (MCP) tool execution.
  */
 export declare function loadSecretKey(secretsPath?: string): string;
+/**
+ * Extract clean prompt text from ACP params supporting string, ContentBlock[], or nested structures.
+ */
+export declare function extractPromptText(params?: Record<string, unknown>): string;

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) {
@@ -267,12 +277,54 @@ async function handleRpcMessage(rpc) {
         }
     }
 }
+/**
+ * Extract clean prompt text from ACP params supporting string, ContentBlock[], or nested structures.
+ */
+export function extractPromptText(params) {
+    if (!params) {
+        return '';
+    }
+    const prompt = params.prompt ?? params.message ?? params.text;
+    if (typeof prompt === 'string') {
+        return prompt;
+    }
+    if (Array.isArray(prompt)) {
+        return prompt
+            .map((block) => {
+            if (typeof block === 'string') {
+                return block;
+            }
+            if (block && typeof block === 'object') {
+                const rec = block;
+                if (typeof rec.text === 'string') {
+                    return rec.text;
+                }
+                if (typeof rec.content === 'string') {
+                    return rec.content;
+                }
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (prompt && typeof prompt === 'object') {
+        const rec = prompt;
+        if (typeof rec.text === 'string') {
+            return rec.text;
+        }
+        if (typeof rec.content === 'string') {
+            return rec.content;
+        }
+    }
+    return '';
+}
 /**
  * Handle ACP session/prompt execution with multi-turn tool loops.
  */
 async function handleSessionPrompt(id, params) {
     const sessionId = params?.sessionId || `session-${Date.now().toString()}`;
-    const promptText = params?.prompt || params?.message || params?.text || '';
+    const promptText = extractPromptText(params);
     let session = sessions.get(sessionId);
     if (!session) {
         session = new Session(sessionId);
@@ -293,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;
@@ -617,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

@@ -42,20 +42,34 @@ export interface NostrMetadata {
  * Isolates the active envelope using lastIndexOf('Event ID:') to prevent
  * capturing cancelled or steered predecessor messages.
  */
-export declare function parseNostrContext(rawText: string): 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 and JSON formats:
+ * - buzz messages send / relay 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

@@ -153,7 +153,7 @@ export function computeOutputBytes(output) {
  */
 export function parseNostrContext(rawText) {
     const result = {};
-    if (!rawText) {
+    if (typeof rawText !== 'string' || !rawText) {
         return result;
     }
     const lastEventIdx = rawText.lastIndexOf('Event ID:');
@@ -195,8 +195,14 @@ 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 and JSON formats:
+ * - buzz messages send / relay 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 = '';
@@ -209,12 +215,9 @@ export function extractPostedEventId(output) {
     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
 // ============================================================================
@@ -429,11 +432,11 @@ 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.)
+                        if (!isError) {
                             const postedId = extractPostedEventId(output);
                             if (postedId) {
                                 toolSpan.setAttribute('nostr.posted_event_id', postedId);
@@ -458,6 +461,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.0",
+  "version": "0.2.2",
   "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",