deepseek-agent-acp 0.2.2 → 0.3.0

package/README.md

@@ -81,8 +81,9 @@ It bridges headless orchestrators, team chat relays, and multi-agent harnesses w
 4. **Transactional State Management & Rollback**:
    * Takes atomic message snapshots before executing each turn.
    * Restores session state seamlessly to the last stable checkpoint upon client cancellation (`session/cancel`) or uncaught runtime exceptions.
-5. **Execution Circuit Breaker**:
+5. **Execution Circuit Breaker and Turn Limit**:
    * Detects stagnant loops (e.g., 2 consecutive identical tool failures).
+   * Caps the model calls per turn (`ACP_MAX_ITERATIONS`) and ends an exhausted turn with the ACP stop reason `max_turn_requests`.
    * Injects synthetic safeguards for remaining unexecuted tool calls to maintain strict OpenAI tool-call response invariants.
 6. **Full Model Context Protocol (MCP) Integration**:
    * Discovers tools dynamically from connected MCP servers and translates them to OpenAI function schemas.
@@ -115,15 +116,38 @@ deepseek-agent-acp
 | Variable | Default | Description |
 | :--- | :--- | :--- |
 | `DEEPSEEK_API_KEY` | *(Required)* | DeepSeek API key (or `DEEPSEEK_AUTH_TOKEN`). |
-| `DEEPSEEK_MODEL` | `deepseek-chat` | Target model (`deepseek-chat`, `deepseek-reasoner`). |
+| `DEEPSEEK_MODEL` | `deepseek-chat` | Target model (for example `deepseek-flash`, `deepseek-chat`, `deepseek-reasoner`). |
 | `DEEPSEEK_BASE_URL` | `https://api.deepseek.com` | Base endpoint URL for completions API. |
 | `DEEPSEEK_TEMPERATURE` | `0.0` | Sampling temperature. |
-| `DEEPSEEK_REQUEST_TIMEOUT_MS`| `90000` | HTTP fetch and chunk read timeout (ms). |
+| `DEEPSEEK_THINKING` | *(unset: API default)* | `enabled` or `disabled`, sent as `thinking.type`. DeepSeek models think by default, so set `disabled` for a zero-thinking agent. |
+| `DEEPSEEK_REASONING_EFFORT` | *(unset: API default)* | `none` (turns thinking off) or `minimal`, `low`, `medium`, `high`, `xhigh`, `max`, `ultra`, sent as `reasoning_effort`. `DEEPSEEK_THINKING=disabled` wins over any level. |
+| `DEEPSEEK_REQUEST_TIMEOUT_MS`| `90000` | HTTP fetch and chunk read timeout (ms). A positive integer. |
 | `ACP_MCP_COMMAND` | `buzz-dev-mcp` | Command to launch the Stdio MCP tool server. |
 | `ACP_SYSTEM_PROMPT_FILE` | `./system-prompt.md` | Path to custom system instructions. |
-| `ACP_MAX_ITERATIONS` | `15` (`25` for coder) | Maximum autonomous tool execution turn iterations. |
+| `ACP_MAX_ITERATIONS` | `15` (`25` for coder/builder) | Maximum model calls in one `session/prompt` turn, a positive integer (`BUZZ_MAX_ITERATIONS` is the fallback). Every tool call costs one iteration, so an agent that stays in one turn for minutes (a meeting call that loops on `meeting_wait`) must raise it. |
 | `MCP_TOOL_TIMEOUT_MS` | `60000` | Timeout for individual MCP tool calls (ms). |
 
+`thinking` and `reasoning_effort` are only added to the request when the matching variable is set, so endpoints
+that reject unknown fields keep working. Invalid values are ignored with a warning on stderr, and the effective
+settings are logged once at start-up:
+
+```text
+[config] model=deepseek-flash thinking=disabled max_iterations=10000 (ACP_MAX_ITERATIONS) request_timeout_ms=90000
+```
+
+Every `DEEPSEEK_*` variable that is not a setting listed above is treated as a secret and removed from the process
+environment at start-up (see In-Memory Secret Sanitization).
+
+### Stop reasons
+
+`session/prompt` always ends with an ACP stop reason, so clients such as buzz-acp never see a protocol error:
+
+| `stopReason` | When |
+| :--- | :--- |
+| `end_turn` | The model finished, or the circuit breaker stopped a loop of identical tool errors (the notice is streamed as text). |
+| `max_turn_requests` | The turn used all `ACP_MAX_ITERATIONS` model calls. A notice is streamed and the client may rotate the session. |
+| `error` | The turn failed (API error, timeout) and the session was rolled back. Not an ACP value: buzz-acp answers it by respawning the adapter and re-queueing the prompt. |
+
 ---
 
 ## 🛠 Supported ACP Methods

package/dist/config.d.ts

@@ -0,0 +1,61 @@
+/**
+ * config.ts — Pure, side-effect-free resolution of the adapter's non-secret settings from the environment.
+ *
+ * Every function takes the environment as an argument and returns the resolved value together with the
+ * warnings the caller should log, so the rules are unit-testable without spawning the adapter.
+ * Invalid input never throws: it falls back to the documented default and produces a warning that names
+ * the offending variable (a silently ignored setting is how a "zero thinking" agent kept thinking).
+ */
+export type Env = Readonly<Record<string, string | undefined>>;
+/**
+ * DEEPSEEK_* variables that are settings, not secrets. loadSecretKey() purges every other DEEPSEEK_* variable
+ * from process.env (default-deny, so an unknown variable is never exposed to child processes); a new setting
+ * must be listed here to survive that purge.
+ */
+export declare const PRESERVED_DEEPSEEK_CONFIG: ReadonlySet<string>;
+declare const REASONING_EFFORTS: readonly ["minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+export type ReasoningEffort = (typeof REASONING_EFFORTS)[number];
+/** Fields merged into the chat-completions request body. Empty means "leave the API default". */
+export interface ReasoningRequestParams {
+    thinking?: {
+        type: 'enabled' | 'disabled';
+    };
+    reasoning_effort?: ReasoningEffort;
+}
+export interface ReasoningResolution {
+    params: ReasoningRequestParams;
+    warnings: string[];
+}
+/**
+ * DEEPSEEK_THINKING        `enabled` | `disabled`          → thinking: { type }
+ * DEEPSEEK_REASONING_EFFORT `none` | minimal … max | ultra  → `none` disables thinking, any other level is
+ *                                                            sent as reasoning_effort
+ *
+ * Nothing is sent unless it is configured, so endpoints that reject unknown fields keep working. Disabling
+ * thinking always wins over an effort level (a disabled model has no effort to set).
+ */
+export declare function resolveReasoningParams(env: Env): ReasoningResolution;
+/** Short, log-friendly summary of what the request will say about thinking, e.g. `disabled` or `api-default`. */
+export declare function describeReasoning(params: ReasoningRequestParams): string;
+export declare const DEFAULT_ITERATION_LIMIT = 15;
+export declare const CODER_ITERATION_LIMIT = 25;
+export interface IterationLimitResolution {
+    limit: number;
+    source: 'ACP_MAX_ITERATIONS' | 'BUZZ_MAX_ITERATIONS' | 'default';
+    warnings: string[];
+}
+/**
+ * Maximum model calls (tool-loop iterations) in one session/prompt turn.
+ * ACP_MAX_ITERATIONS wins over BUZZ_MAX_ITERATIONS; without either the default is 25 for coder/builder
+ * agents and 15 otherwise. A long-lived loop such as a meeting call spends one iteration per tool call, so
+ * agents that stay in one turn for minutes must raise it.
+ */
+export declare function resolveIterationLimit(env: Env, model: string): IterationLimitResolution;
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 90000;
+export interface RequestTimeoutResolution {
+    timeoutMs: number;
+    warnings: string[];
+}
+/** HTTP request and stream-read timeout (ms) for one chat-completions call. */
+export declare function resolveRequestTimeoutMs(env: Env): RequestTimeoutResolution;
+export {};

package/dist/config.js

@@ -0,0 +1,139 @@
+/**
+ * config.ts — Pure, side-effect-free resolution of the adapter's non-secret settings from the environment.
+ *
+ * Every function takes the environment as an argument and returns the resolved value together with the
+ * warnings the caller should log, so the rules are unit-testable without spawning the adapter.
+ * Invalid input never throws: it falls back to the documented default and produces a warning that names
+ * the offending variable (a silently ignored setting is how a "zero thinking" agent kept thinking).
+ */
+/**
+ * DEEPSEEK_* variables that are settings, not secrets. loadSecretKey() purges every other DEEPSEEK_* variable
+ * from process.env (default-deny, so an unknown variable is never exposed to child processes); a new setting
+ * must be listed here to survive that purge.
+ */
+export const PRESERVED_DEEPSEEK_CONFIG = new Set([
+    'DEEPSEEK_BASE_URL',
+    'DEEPSEEK_MODEL',
+    'DEEPSEEK_TEMPERATURE',
+    'DEEPSEEK_THINKING',
+    'DEEPSEEK_REASONING_EFFORT',
+    'DEEPSEEK_REQUEST_TIMEOUT_MS'
+]);
+// ============================================================================
+// Thinking / reasoning effort
+// ============================================================================
+const REASONING_EFFORTS = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+function normalized(value) {
+    return (value ?? '').trim().toLowerCase();
+}
+function isReasoningEffort(value) {
+    return REASONING_EFFORTS.includes(value);
+}
+/**
+ * DEEPSEEK_THINKING        `enabled` | `disabled`          → thinking: { type }
+ * DEEPSEEK_REASONING_EFFORT `none` | minimal … max | ultra  → `none` disables thinking, any other level is
+ *                                                            sent as reasoning_effort
+ *
+ * Nothing is sent unless it is configured, so endpoints that reject unknown fields keep working. Disabling
+ * thinking always wins over an effort level (a disabled model has no effort to set).
+ */
+export function resolveReasoningParams(env) {
+    const warnings = [];
+    const thinkingRaw = normalized(env.DEEPSEEK_THINKING);
+    const effortRaw = normalized(env.DEEPSEEK_REASONING_EFFORT);
+    let thinking;
+    if (thinkingRaw === 'enabled' || thinkingRaw === 'disabled') {
+        thinking = thinkingRaw;
+    }
+    else if (thinkingRaw !== '') {
+        warnings.push(`Ignoring DEEPSEEK_THINKING="${thinkingRaw}": expected "enabled" or "disabled"; the API default applies.`);
+    }
+    let effort;
+    if (effortRaw === 'none' || isReasoningEffort(effortRaw)) {
+        effort = effortRaw;
+    }
+    else if (effortRaw !== '') {
+        warnings.push(`Ignoring DEEPSEEK_REASONING_EFFORT="${effortRaw}": expected "none" or one of ${REASONING_EFFORTS.join(', ')}; the API default applies.`);
+    }
+    if (thinking === 'disabled' || effort === 'none') {
+        if (thinking === 'enabled' && effort === 'none') {
+            warnings.push('DEEPSEEK_THINKING=enabled conflicts with DEEPSEEK_REASONING_EFFORT=none; thinking stays disabled.');
+        }
+        if (thinking === 'disabled' && effort !== undefined && effort !== 'none') {
+            warnings.push(`DEEPSEEK_REASONING_EFFORT=${effort} is ignored because DEEPSEEK_THINKING=disabled.`);
+        }
+        return { params: { thinking: { type: 'disabled' } }, warnings };
+    }
+    const params = {};
+    if (thinking === 'enabled') {
+        params.thinking = { type: 'enabled' };
+    }
+    if (effort !== undefined) {
+        params.reasoning_effort = effort;
+    }
+    return { params, warnings };
+}
+/** Short, log-friendly summary of what the request will say about thinking, e.g. `disabled` or `api-default`. */
+export function describeReasoning(params) {
+    const parts = [];
+    if (params.thinking) {
+        parts.push(params.thinking.type);
+    }
+    if (params.reasoning_effort) {
+        parts.push(`effort:${params.reasoning_effort}`);
+    }
+    return parts.length > 0 ? parts.join('+') : 'api-default';
+}
+// ============================================================================
+// Positive-integer settings
+// ============================================================================
+/** Strict positive decimal integer; rejects "10abc", "1.5", "1e3", "0" and "-5" that parseInt would half-accept. */
+function parsePositiveInt(raw) {
+    if (!/^[1-9]\d*$/.test(raw)) {
+        return null;
+    }
+    const value = Number(raw);
+    return Number.isSafeInteger(value) ? value : null;
+}
+export const DEFAULT_ITERATION_LIMIT = 15;
+export const CODER_ITERATION_LIMIT = 25;
+/**
+ * Maximum model calls (tool-loop iterations) in one session/prompt turn.
+ * ACP_MAX_ITERATIONS wins over BUZZ_MAX_ITERATIONS; without either the default is 25 for coder/builder
+ * agents and 15 otherwise. A long-lived loop such as a meeting call spends one iteration per tool call, so
+ * agents that stay in one turn for minutes must raise it.
+ */
+export function resolveIterationLimit(env, model) {
+    const warnings = [];
+    for (const name of ['ACP_MAX_ITERATIONS', 'BUZZ_MAX_ITERATIONS']) {
+        const raw = (env[name] ?? '').trim();
+        if (raw === '') {
+            continue;
+        }
+        const value = parsePositiveInt(raw);
+        if (value !== null) {
+            return { limit: value, source: name, warnings };
+        }
+        warnings.push(`Ignoring ${name}="${raw}": expected a positive integer.`);
+    }
+    const isCoder = model.includes('coder') || env.AGENT_ROLE === 'coder' || env.AGENT_ROLE === 'builder';
+    return { limit: isCoder ? CODER_ITERATION_LIMIT : DEFAULT_ITERATION_LIMIT, source: 'default', warnings };
+}
+export const DEFAULT_REQUEST_TIMEOUT_MS = 90_000;
+/** HTTP request and stream-read timeout (ms) for one chat-completions call. */
+export function resolveRequestTimeoutMs(env) {
+    const raw = (env.DEEPSEEK_REQUEST_TIMEOUT_MS ?? '').trim();
+    if (raw === '') {
+        return { timeoutMs: DEFAULT_REQUEST_TIMEOUT_MS, warnings: [] };
+    }
+    const value = parsePositiveInt(raw);
+    if (value === null) {
+        return {
+            timeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+            warnings: [
+                `Ignoring DEEPSEEK_REQUEST_TIMEOUT_MS="${raw}": expected a positive integer; using ${DEFAULT_REQUEST_TIMEOUT_MS.toString()} ms.`
+            ]
+        };
+    }
+    return { timeoutMs: value, warnings: [] };
+}

package/dist/index.js

@@ -15,6 +15,7 @@ import readline from 'node:readline';
 import { format } from 'node:util';
 import { StreamAccumulator, parseSSEStream } from './sse-parser.js';
 import { McpClient } from './mcp-client.js';
+import { PRESERVED_DEEPSEEK_CONFIG, describeReasoning, resolveIterationLimit, resolveReasoningParams, resolveRequestTimeoutMs } from './config.js';
 import { initTelemetry, registerSecret, parseNostrContext } from './telemetry.js';
 // ============================================================================
 // 1. STDIO HYGIENE
@@ -69,9 +70,9 @@ export function loadSecretKey(secretsPath = '/run/agent-secrets/env') {
     delete process.env.DEEPSEEK_AUTH_TOKEN;
     delete process.env.DEEPSEEK_TOKEN;
     delete process.env.DEEPSEEK_SECRET;
-    const preservedDeepseekConfig = new Set(['DEEPSEEK_BASE_URL', 'DEEPSEEK_MODEL', 'DEEPSEEK_TEMPERATURE']);
+    // Default-deny: any DEEPSEEK_* variable that is not a documented setting could be a secret.
     for (const envKey of Object.keys(process.env)) {
-        if (/^DEEPSEEK_/i.test(envKey) && !preservedDeepseekConfig.has(envKey)) {
+        if (/^DEEPSEEK_/i.test(envKey) && !PRESERVED_DEEPSEEK_CONFIG.has(envKey)) {
             delete process.env[envKey];
         }
     }
@@ -91,6 +92,16 @@ const BASE_URL = (process.env.DEEPSEEK_BASE_URL ?? 'https://api.deepseek.com').r
 const MODEL = process.env.DEEPSEEK_MODEL ?? 'deepseek-chat';
 const TEMPERATURE = parseFloat(process.env.DEEPSEEK_TEMPERATURE ?? '0.0');
 const MCP_COMMAND = process.env.ACP_MCP_COMMAND ?? process.env.BUZZ_ACP_MCP_COMMAND ?? 'buzz-dev-mcp';
+// Resolved once at start-up (after the secret purge, so every setting listed in PRESERVED_DEEPSEEK_CONFIG is intact).
+const REASONING = resolveReasoningParams(process.env);
+const ITERATION_LIMIT = resolveIterationLimit(process.env, MODEL);
+const REQUEST_TIMEOUT = resolveRequestTimeoutMs(process.env);
+for (const warning of [...REASONING.warnings, ...ITERATION_LIMIT.warnings, ...REQUEST_TIMEOUT.warnings]) {
+    console.warn(warning);
+}
+console.info(`[config] model=${MODEL} thinking=${describeReasoning(REASONING.params)} ` +
+    `max_iterations=${ITERATION_LIMIT.limit.toString()} (${ITERATION_LIMIT.source}) ` +
+    `request_timeout_ms=${REQUEST_TIMEOUT.timeoutMs.toString()}`);
 // ============================================================================
 // 3. PROMPT ADAPTATION LAYER
 // ============================================================================
@@ -125,19 +136,6 @@ function getSystemPrompt(model) {
     }
     return adaptSystemPrompt(raw, model);
 }
-function getIterationLimit(model) {
-    const maxIterEnv = process.env.ACP_MAX_ITERATIONS ?? process.env.BUZZ_MAX_ITERATIONS;
-    if (maxIterEnv) {
-        const val = parseInt(maxIterEnv, 10);
-        if (!isNaN(val) && val > 0) {
-            return val;
-        }
-    }
-    const isCoder = model.includes('coder') ||
-        process.env.AGENT_ROLE === 'coder' ||
-        process.env.AGENT_ROLE === 'builder';
-    return isCoder ? 25 : 15;
-}
 // ============================================================================
 // 4. SESSION & TRANSACTIONAL STATE MANAGER
 // ============================================================================
@@ -346,11 +344,13 @@ async function handleSessionPrompt(id, params) {
     const nostrMeta = parseNostrContext(promptText);
     const turnHandle = telemetryService?.startTurnSpan(sessionId, promptText, MODEL, nostrMeta);
     session.activeTurnHandle = turnHandle ?? null;
-    const maxIterations = getIterationLimit(MODEL);
+    const maxIterations = ITERATION_LIMIT.limit;
     let iteration = 0;
     let lastToolError = null;
     let consecutiveErrorCount = 0;
     let turnCompleted = false;
+    // Why the loop ended when the model did not finish by itself: the while condition (iteration limit) unless the breaker fires.
+    let stoppedBy = 'iteration_limit';
     try {
         const tools = await mcpClient.getTools();
         while (iteration < maxIterations) {
@@ -380,8 +380,8 @@ async function handleSessionPrompt(id, params) {
             if (!DEEPSEEK_API_KEY) {
                 throw new Error('DEEPSEEK_API_KEY is missing or empty. Cannot authenticate with DeepSeek API.');
             }
-            // Call DeepSeek Chat Completions with Streaming with 90s request timeout
-            const requestTimeoutMs = parseInt(process.env.DEEPSEEK_REQUEST_TIMEOUT_MS ?? '90000', 10);
+            // Call DeepSeek Chat Completions with Streaming (request timeout: DEEPSEEK_REQUEST_TIMEOUT_MS, default 90s)
+            const requestTimeoutMs = REQUEST_TIMEOUT.timeoutMs;
             const timeoutSignal = AbortSignal.timeout(requestTimeoutMs);
             const combinedSignal = session.abortController
                 ? AbortSignal.any([session.abortController.signal, timeoutSignal])
@@ -397,6 +397,8 @@ async function handleSessionPrompt(id, params) {
                     messages: messagesPayload,
                     tools: tools && tools.length > 0 ? tools : undefined,
                     temperature: TEMPERATURE,
+                    // thinking / reasoning_effort: only present when DEEPSEEK_THINKING / DEEPSEEK_REASONING_EFFORT are set.
+                    ...REASONING.params,
                     stream: true,
                     stream_options: { include_usage: true }
                 }),
@@ -615,23 +617,39 @@ async function handleSessionPrompt(id, params) {
                     }
                 }
                 console.warn(`Circuit breaker triggered for session ${sessionId}. Ending turn.`);
+                stoppedBy = 'circuit_breaker';
                 break;
             }
         }
         if (!turnCompleted) {
             session.commit();
-            const finalContent = iteration >= maxIterations
-                ? (session.messages[session.messages.length - 1]?.content ?? 'Turn reached maximum iteration limit.')
+            const hitIterationLimit = stoppedBy === 'iteration_limit';
+            const finalContent = hitIterationLimit
+                ? `Turn stopped after ${maxIterations.toString()} model iterations (ACP_MAX_ITERATIONS). Send a new message to continue.`
                 : 'Turn execution stopped because repetitive tool errors occurred.';
+            if (hitIterationLimit) {
+                console.warn(`[ITERATION LIMIT] Session ${sessionId} used all ${maxIterations.toString()} iterations of the turn. ` +
+                    'Ending it with stopReason max_turn_requests.');
+                sendNotification('session/update', {
+                    sessionId,
+                    delta: {
+                        type: 'text',
+                        text: `\n\n*(Notice: iteration limit of ${maxIterations.toString()} reached; the turn was stopped.)*`
+                    }
+                });
+            }
             turnHandle?.end('OK', finalContent);
             void telemetryService?.backgroundFlush();
+            // Only ACP stop reasons are valid here: buzz-acp answers any other value ("unknown stopReason") with a
+            // protocol error that kills and respawns this process. An exhausted iteration budget is `max_turn_requests`;
+            // a circuit-breaker stop is a normal, committed end of turn.
             sendResponse(id, {
                 sessionId,
                 message: {
                     role: 'assistant',
                     content: finalContent
                 },
-                stopReason: iteration >= maxIterations ? 'max_iterations' : 'loop_aborted'
+                stopReason: hitIterationLimit ? 'max_turn_requests' : 'end_turn'
             });
             sendNotification('session/turnComplete', { sessionId });
         }
@@ -657,6 +675,9 @@ async function handleSessionPrompt(id, params) {
                 text: `⚠️ **DeepSeek Agent Notice:** Encountered an error during processing: ${msg}. Conversation state has been restored to last stable checkpoint.`
             }
         });
+        // Known deviation, left as is: `error` is not an ACP stop reason. buzz-acp treats it as a protocol error and
+        // answers by respawning this process and re-queueing the prompt with backoff, which is the retry that transient
+        // API failures (HTTP 429/5xx, timeouts) currently get. Moving to a JSON-RPC error needs that retry decided first.
         sendResponse(id, {
             sessionId,
             message: {

package/dist/telemetry.d.ts

@@ -44,8 +44,9 @@ export interface NostrMetadata {
  */
 export declare function parseNostrContext(rawText: unknown): NostrMetadata;
 /**
- * Regex matching posted Nostr event ID across text and JSON formats:
+ * 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>`
  */

package/dist/telemetry.js

@@ -195,12 +195,13 @@ export function parseNostrContext(rawText) {
     return result;
 }
 /**
- * Regex matching posted Nostr event ID across text and JSON formats:
+ * 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;
+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.
  */
@@ -208,9 +209,22 @@ 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;
@@ -312,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: {
@@ -436,14 +459,22 @@ export function initTelemetry(options) {
                         const outputBytes = computeOutputBytes(output);
                         toolSpan.setAttribute('tool.output_bytes', outputBytes);
                         // 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');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepseek-agent-acp",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "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",
@@ -24,7 +24,7 @@
     "typecheck": "tsc --noEmit",
     "lint": "eslint src tests",
     "lint:fix": "eslint src tests --fix",
-    "test": "node --test tests/test_sse_parser.test.mjs tests/test_deepseek_acp.test.mjs tests/test_telemetry.test.mjs",
+    "test": "node --test tests/test_config.test.mjs tests/test_sse_parser.test.mjs tests/test_deepseek_acp.test.mjs tests/test_telemetry.test.mjs",
     "start": "node dist/index.js",
     "prepare": "husky",
     "prepublishOnly": "npm run typecheck && npm run lint && npm run test && npm run build"