@a1hvdy/cc-openclaw 0.30.0 → 0.32.0

package/dist/src/channels/telegram-mirror/card-renderer.js

@@ -30,8 +30,12 @@ function basename(p) {
  * Glyph picked per tool-call status. Mirrors terminal "running / done /
  * errored" iconography that A1 already reads in the live Claude Code TUI.
  */
-function toolGlyph(tc) {
-    if (tc.isError)
+function toolGlyph(tc, suppressToolErrors = false) {
+    // OpenClaw 2026.5.20 #81561 — when the user set messages.suppressToolErrors,
+    // an errored-but-completed tool reads as a normal "✓" rather than the "✗"
+    // error glyph. tc.result is set for an errored tool (it carries the error
+    // body), so the completed-✓ branch below picks it up once "✗" is skipped.
+    if (tc.isError && !suppressToolErrors)
         return '✗';
     if (tc.result !== undefined)
         return '✓';
@@ -260,8 +264,8 @@ export function toolIcon(name) {
         return '🔌';
     return '🔹';
 }
-export function renderToolLine(tc) {
-    const glyph = toolGlyph(tc);
+export function renderToolLine(tc, suppressToolErrors = false) {
+    const glyph = toolGlyph(tc, suppressToolErrors);
     const icon = toolIcon(tc.name);
     // Status glyph + emoji are HTML-safe; the tool name is HTML-escaped and the
     // input detail rides in a <code> span (v0.27.0 M1 HTML styling).
@@ -384,7 +388,7 @@ export function renderTurn(turn, meta) {
         let acc = 0;
         for (let i = turn.toolCalls.length - 1; i >= 0; i--) {
             const tc = turn.toolCalls[i];
-            const line = renderToolLine(tc);
+            const line = renderToolLine(tc, meta?.suppressToolErrors);
             // v0.27.4 M2 — for Edit/Write/MultiEdit show a diff (from input) instead of
             // the "File updated" result; other tools keep the result preview.
             const diffText = toolDiffBlock(tc);

package/dist/src/channels/telegram-mirror/commands.js

@@ -44,14 +44,6 @@ export function parseSlash(text) {
     return { cmd: cmd.toLowerCase(), args: tokens.slice(1) };
 }
 // ── /sessions ────────────────────────────────────────────────────────────
-function enrichRows(entries, stateLookup) {
-    return entries.map((e) => ({
-        slug: e.slug,
-        sessionName: e.sessionName,
-        state: stateLookup(e.slug),
-        lastUsedAt: e.lastUsedAt,
-    }));
-}
 /**
  * v0.28.0 — `/sessions` is now a `claude -r`-style picker over the REAL Claude
  * Code sessions. It mirrors `~/.claude/projects/**` (the store every `claude`

package/dist/src/channels/telegram-mirror/status-line.js

@@ -4,7 +4,7 @@
  * Builds the Claude-Code-CLI-style status line that sits at the top of the
  * Telegram live-mirror card, e.g.:
  *
- *   [Opus 4.7] · CC 2.1.145 · ⏱ 2h13m · 🔧 3 · bypass
+ *   [Opus 4.7] · CC 2.1.145 · GW 2026.5.20 · ⏱ 2h13m · 🔧 3 · bypass
  *
  * STRICT no-fake-data rule (per the v0.26.2 brief): every segment is rendered
  * ONLY when its value is genuinely available. Missing model / version / etc.
@@ -40,6 +40,33 @@ export function getCcVersion() {
 export function _resetCcVersionForTests() {
     _ccVersion = undefined;
 }
+// ── Gateway version (cached; resolved at most once per process) ──────────────
+// `openclaw --version` prints e.g. "OpenClaw 2026.5.20 (e510042)". Mirrors the
+// getCcVersion() resolve-once-and-cache contract (including a failed lookup as
+// `null`). Surfaced on the status line as "GW <ver>" so the card shows which
+// OpenClaw core is actually running alongside the CC CLI version.
+let _gatewayVersion;
+export function getGatewayVersion() {
+    if (_gatewayVersion !== undefined)
+        return _gatewayVersion;
+    try {
+        const out = execFileSync('openclaw', ['--version'], {
+            timeout: 5_000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            encoding: 'utf8',
+        });
+        const m = /(\d+\.\d+\.\d+)/.exec(out);
+        _gatewayVersion = m ? m[1] : null;
+    }
+    catch {
+        _gatewayVersion = null;
+    }
+    return _gatewayVersion;
+}
+/** Test-only — reset the cached gateway version. */
+export function _resetGatewayVersionForTests() {
+    _gatewayVersion = undefined;
+}
 // ── Model id → short label ─────────────────────────────────────────────────
 // "claude-opus-4-7" → "Opus 4.7"; "claude-sonnet-4-6" → "Sonnet 4.6". Unknown
 // shapes pass through unchanged (still real data, just not prettified).
@@ -69,7 +96,7 @@ export function fmtElapsed(ms) {
 /**
  * Render the status line for a turn. Returns `undefined` when NOTHING is
  * available to show (so callers omit the line entirely). Segments, in order:
- *   [model] · CC <ver> · ⏱ <elapsed> · 🔧 <toolCount> · bypass
+ *   [model] · CC <ver> · GW <ver> · ⏱ <elapsed> · 🔧 <toolCount> · bypass
  * Every segment is conditional on real data.
  */
 export function renderStatusLine(turn, meta, now = Date.now()) {
@@ -80,6 +107,9 @@ export function renderStatusLine(turn, meta, now = Date.now()) {
     const ver = getCcVersion();
     if (ver)
         segs.push(`CC ${ver}`);
+    const gwVer = getGatewayVersion();
+    if (gwVer)
+        segs.push(`GW ${gwVer}`);
     // Turn elapsed is always real (Turn.startedAt is set at card creation). Use
     // endedAt once the turn is done so the finalized card shows total duration.
     const elapsedMs = (turn.endedAt ?? now) - turn.startedAt;

package/dist/src/constants.js

@@ -28,14 +28,28 @@ export const SESSION_READY_FALLBACK_MS = 2_000;
  *
  *  v0.20.0: env-overridable via `CC_OPENCLAW_TURN_TIMEOUT_MS` (see
  *  src/lib/env-overrides.ts). Setting `=0` disables the per-turn timer
- *  entirely, matching direct-CLI behavior on long tool turns. */
+ *  entirely, matching direct-CLI behavior on long tool turns.
+ *
+ *  OpenClaw 2026.5.20 (#83979): core now HONORS
+ *  `models.providers.cc-openclaw.timeoutSeconds` above its idle watchdog —
+ *  previously the outer request was killed at ~120s regardless of that value,
+ *  so this 900_000 alignment was a workaround fighting a hidden ceiling. It is
+ *  now a genuine, end-to-end envelope. Keep it aligned to timeoutSeconds (do
+ *  NOT reduce below the configured outer bound). */
 export const TURN_TIMEOUT_MS = 900_000;
 /** Runtime watchdog threshold for "stuck" sessions. If a session is
  *  `isBusy === true` AND its stats.lastActivity hasn't moved in this many
  *  ms, the SessionManager watchdog aborts + disposes the session. Mirrors
  *  the boot-time orphan reaper in gateway-pm2-wrapper.sh:53-60, but runs
  *  continuously on a setInterval. Env-overridable via
- *  CC_OPENCLAW_STALLED_KILL_MS. v0.10.0. */
+ *  CC_OPENCLAW_STALLED_KILL_MS. v0.10.0.
+ *
+ *  NOTE (OpenClaw 2026.5.20 #83979): this is ORTHOGONAL to core's now-honored
+ *  provider idle watchdog — that bounds first-token / inter-token waits on the
+ *  request; this bounds a wedged Claude SUBPROCESS that emits no output at all.
+ *  The core fix does NOT make this redundant. Keep it. Raise (don't remove) via
+ *  CC_OPENCLAW_STALLED_KILL_MS only if legitimately long no-output tool runs
+ *  (e.g. a long Bash) trip it. */
 export const STALLED_SESSION_KILL_MS = 180_000;
 /** How often the stalled-session watchdog scans the sessions Map. */
 export const STALLED_WATCH_INTERVAL_MS = 30_000;

package/dist/src/engines/persistent-session.js

@@ -63,6 +63,7 @@ export class PersistentClaudeSession extends EventEmitter {
             history: [],
             retries: 0,
             lastRetryError: undefined,
+            lastStopReason: undefined,
             lastTurnContextTokens: 0,
         };
     }
@@ -624,6 +625,15 @@ export class PersistentClaudeSession extends EventEmitter {
                             (usage.cache_creation_input_tokens || 0);
                     this._updateCost();
                 }
+                // v0.32.0 — record the turn's stop_reason BEFORE TURN_COMPLETE is
+                // emitted (that emit resolves the streaming handler's await). The
+                // handler reads stats.lastStopReason to tell a hard rate_limit/error
+                // (→ non-200 so OpenClaw fails over to Sonnet) apart from an
+                // empty-but-successful turn (→ the "Done." backstop).
+                {
+                    const sr = event.stop_reason;
+                    this.stats.lastStopReason = typeof sr === 'string' ? sr : undefined;
+                }
                 this.emit(SESSION_EVENT.RESULT, event);
                 this.emit(SESSION_EVENT.TURN_COMPLETE, event);
                 // v0.27.6 — liveness watchdog (Killer #1): turn is over; clear any
@@ -826,6 +836,7 @@ export class PersistentClaudeSession extends EventEmitter {
                 100)),
             retries: this.stats.retries,
             lastRetryError: this.stats.lastRetryError,
+            lastStopReason: this.stats.lastStopReason,
             sessionId: this.sessionId,
             uptime: this.stats.startTime ? Math.round((Date.now() - new Date(this.stats.startTime).getTime()) / 1000) : 0,
         };

package/dist/src/lib/config.js

@@ -351,6 +351,46 @@ export function _resetTtsAutoModeCacheForTests() {
     _ttsAutoModeCache = null;
     _ttsAutoModeCacheChecked = false;
 }
+// ── Suppress tool errors (OpenClaw 2026.5.20 #81561) ────────────────────────
+// Reads `messages.suppressToolErrors` from `~/.openclaw/openclaw.json` once and
+// caches it. When true, the user has opted out of tool-failure noise, so the
+// Telegram live-card renders an errored-but-completed tool with its normal "✓"
+// glyph instead of the "✗" error glyph (the card-side equivalent of the core's
+// "no separate warning payloads" behavior). The TURN-level "❌ <reason>" header
+// is unaffected — that's terminal turn state, not a per-tool warning.
+//
+// Same custom-file-reader rationale as getTtsAutoMode(): openclaw.json is a
+// plugin-side decision that shouldn't reach through OpenClaw's typed runtime.
+// Tests override via the CC_OPENCLAW_SUPPRESS_TOOL_ERRORS env var.
+let _suppressToolErrorsCache = null;
+let _suppressToolErrorsCacheChecked = false;
+export function getSuppressToolErrors() {
+    // Test-time / explicit override takes precedence.
+    const envOverride = process.env.CC_OPENCLAW_SUPPRESS_TOOL_ERRORS?.trim().toLowerCase();
+    if (envOverride === '1' || envOverride === 'true' || envOverride === 'on')
+        return true;
+    if (envOverride === '0' || envOverride === 'false' || envOverride === 'off')
+        return false;
+    if (!_suppressToolErrorsCacheChecked) {
+        _suppressToolErrorsCacheChecked = true;
+        try {
+            const configPath = process.env.OPENCLAW_CONFIG_PATH || join(homedir(), '.openclaw', 'openclaw.json');
+            const raw = readFileSync(configPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            _suppressToolErrorsCache = parsed.messages?.suppressToolErrors ?? null;
+        }
+        catch {
+            // File missing / unreadable / invalid JSON — fall through to false.
+            _suppressToolErrorsCache = null;
+        }
+    }
+    return _suppressToolErrorsCache === true;
+}
+/** Test-only: reset the suppress-tool-errors cache so the next call re-reads. */
+export function _resetSuppressToolErrorsCacheForTests() {
+    _suppressToolErrorsCache = null;
+    _suppressToolErrorsCacheChecked = false;
+}
 export function getClaudeBin() {
     const cfg = getConfigService();
     if (cfg)

package/dist/src/openai-compat/non-streaming-handler.js

@@ -23,7 +23,7 @@
 import { reportStatus, getToolDescription } from './status-reporter.js';
 import { parseToolCallsFromText } from './tool-calls-parser.js';
 import { formatCompletionResponse } from './response-formatter.js';
-import { getSurfaceThinkingEnabled, getTtsAutoMode, getCardAnswerMirrorEnabled } from '../lib/config.js';
+import { getSurfaceThinkingEnabled, getTtsAutoMode, getCardAnswerMirrorEnabled, getSuppressToolErrors } from '../lib/config.js';
 import { emit as emitTrajectory, emitTurnTrace } from '../lib/trajectory.js';
 import { formatError, ERROR_CODES } from '../lib/error-formatter.js';
 import { applyVoiceRecovery, _logVoiceDebug, detectVoiceIntent, hasTtsMarkers } from './voice-recovery.js';
@@ -55,7 +55,7 @@ slashCommand) {
     // cards THIS module instance sees (see handleStreaming counterpart).
     process.stderr.write(`[cc-openclaw/openai-compat] handleNonStreaming pid=${process.pid} hasTools=${hasTools} ${mirrorCardStateDebug()} session=${sessionName}\n`);
     // v0.26.2 M1+M2 — feed the CC-CLI status line (model + bypass + quota; see streaming).
-    mirrorSetCardMeta({ model, bypassPermissions: true, ...mirrorReadQuotaMeta() });
+    mirrorSetCardMeta({ model, bypassPermissions: true, suppressToolErrors: getSuppressToolErrors(), ...mirrorReadQuotaMeta() });
     // v0.14.0 turn-trace probe: capture wall-clock duration of the turn.
     const turnStartMs = Date.now();
     // v0.15.0 Slice 1: hoist userText so the catch-path probe emit can reference

package/dist/src/openai-compat/streaming-handler.js

@@ -41,7 +41,7 @@ import { formatCompletionChunk } from './response-formatter.js';
 import { isToolStreamMode } from './mode-flags.js';
 import { emit as emitTrajectory, emitTurnTrace } from '../lib/trajectory.js';
 import { formatError, ERROR_CODES } from '../lib/error-formatter.js';
-import { getSurfaceThinkingEnabled, getTtsAutoMode, getCardAnswerMirrorEnabled } from '../lib/config.js';
+import { getSurfaceThinkingEnabled, getTtsAutoMode, getCardAnswerMirrorEnabled, getSuppressToolErrors } from '../lib/config.js';
 import { applyVoiceRecovery, detectVoiceIntent, hasTtsMarkers, _logVoiceDebug } from './voice-recovery.js';
 import { pushToolUse as mirrorPushToolUse, pushToolResult as mirrorPushToolResult, pushAssistantText as mirrorPushAssistantText, pushThinking as mirrorPushThinking, finalizeActiveCards as mirrorFinalizeActiveCards, extractInsightForCard as mirrorExtractInsightForCard, failActiveCards as mirrorFailActiveCards, classifyFailure, setCardMeta as mirrorSetCardMeta, readQuotaMeta as mirrorReadQuotaMeta, } from '../channels/telegram-mirror/turn-bridge.js';
 import { cardStateDebug as mirrorCardStateDebug } from '../channels/telegram-mirror/card-state.js';
@@ -83,16 +83,40 @@ onFinalText) {
     // v0.26.2 M1+M2 — feed the CC-CLI status line. The openai-compat path always
     // runs permissionMode 'bypassPermissions' (openai-compat.ts) so we assert it.
     // Quota is read once here (real status-tee snapshot or omitted).
-    mirrorSetCardMeta({ model, bypassPermissions: true, ...mirrorReadQuotaMeta() });
+    mirrorSetCardMeta({ model, bypassPermissions: true, suppressToolErrors: getSuppressToolErrors(), ...mirrorReadQuotaMeta() });
     // #4 dual-surface seam — hoist once per turn (read off the hot delta loop).
     // Default OFF: card is the activity pane, gateway draft is the answer pane.
     const mirrorAnswerToCard = getCardAnswerMirrorEnabled();
-    res.writeHead(200, {
+    // v0.32.0 — DEFERRED header commit. Previously res.writeHead(200) fired here
+    // eagerly (before any model output), permanently locking the status to 200.
+    // On an Anthropic weekly-cap rate_limit the turn then resolved as a 200-empty
+    // SSE stream that OpenClaw read as a successful (empty) turn — so its model
+    // fallback chain (opus → sonnet → haiku) never advanced. By holding the
+    // header until the first real SSE byte, a pre-stream rate_limit/error can
+    // instead return HTTP 429/5xx, which OpenClaw's status-code failover acts on.
+    // Once a byte has streamed the 200 is committed and we fall back to an in-band
+    // SSE error (can't retract a 200) — but a hard cap almost always trips before
+    // the first byte. For a normal turn the only change is that the role-opener
+    // chunk now flushes immediately before the first content delta (sub-second,
+    // immaterial to the SSE client) instead of at handler entry.
+    const SSE_HEADERS = {
         'Content-Type': 'text/event-stream',
         'Cache-Control': 'no-cache',
         Connection: 'keep-alive',
         'X-Accel-Buffering': 'no',
-    });
+    };
+    let streamOpened = false;
+    // Opens the SSE stream exactly once: commits the 200 header + the role-opener
+    // chunk. Called lazily from writeSSE on the first content write. Until it
+    // runs, the response status is still mutable (so a pre-stream failure can
+    // return a non-200).
+    const openStream = () => {
+        if (streamOpened)
+            return;
+        streamOpened = true;
+        res.writeHead(200, SSE_HEADERS);
+        res.write(`data: ${JSON.stringify(formatCompletionChunk(completionId, model, { role: 'assistant' }, null))}\n\n`);
+    };
     // v0.14.0 turn-trace probe: track wall-clock + accumulate streamed text
     // for the final per-turn diagnostic emit. accumulatedText mirrors what
     // the client actually received (text deltas only — tool_calls are tracked
@@ -123,6 +147,7 @@ onFinalText) {
     });
     const writeSSE = (data) => {
         if (!clientDisconnected) {
+            openStream(); // commit 200 + role opener on the first real byte
             try {
                 res.write(`data: ${data}\n\n`);
             }
@@ -131,8 +156,10 @@ onFinalText) {
             }
         }
     };
-    // Initial chunk with role
-    writeSSE(JSON.stringify(formatCompletionChunk(completionId, model, { role: 'assistant' }, null)));
+    // v0.32.0 — the role-opener chunk is now emitted by openStream() on the first
+    // content write (see the deferred-header note above), so the eager write that
+    // lived here is gone. This keeps the HTTP status mutable until real content
+    // exists, enabling the pre-stream 429/5xx failover path below.
     // SSE keepalive heartbeat. v0.27.5: 30s → 15s. A long quiet phase (Claude
     // CLI thinking, a slow Bash/tool step) with no SSE write can make OpenClaw's
     // HTTP client perceive the stream as dead and fire a RETRY — which the
@@ -142,7 +169,11 @@ onFinalText) {
     // retries at the source. (The request-coalescer is the second line of
     // defense for the retries that still slip through.)
     const heartbeatTimer = setInterval(() => {
-        if (!clientDisconnected) {
+        // v0.32.0 — only heartbeat once the stream is actually open. Before the
+        // first byte the response status is still mutable (so a pre-stream
+        // rate_limit can 429); a keepalive write here would implicitly commit a 200
+        // and lock that failover option out.
+        if (!clientDisconnected && streamOpened) {
             try {
                 res.write(': keepalive\n\n');
             }
@@ -376,6 +407,11 @@ onFinalText) {
         }
         // Get token usage for final chunk
         let usage;
+        // v0.32.0 — captured from the same getStatus() call to drive the no-output
+        // failover branch below. persistent-session sets stats.lastStopReason on the
+        // CLI `result` event BEFORE TURN_COMPLETE resolves this await, so it is
+        // populated by the time we read it here.
+        let lastStopReason;
         try {
             const status = manager.getStatus(sessionName);
             usage = {
@@ -383,6 +419,7 @@ onFinalText) {
                 completion_tokens: status.stats.tokensOut,
                 total_tokens: status.stats.tokensIn + status.stats.tokensOut,
             };
+            lastStopReason = status.stats.lastStopReason;
         }
         catch {
             /* best effort */
@@ -393,6 +430,68 @@ onFinalText) {
         // payload. Skip when tool_calls were emitted — those are openai-spec
         // valid as the only payload (multi-turn tool-use sessions).
         const noVisiblePayload = !streamedAnything && bufferedText.length === 0 && toolCallsEmitted === 0;
+        // v0.32.0 — quota/error fast-fail. A no-output turn whose stop_reason is a
+        // hard failure (rate_limit = Anthropic weekly cap reached; error = upstream
+        // fault) must NOT be masked as a "Done." 200 below — that is exactly what
+        // made OpenClaw accept a capped turn as an empty success and skip its
+        // opus → sonnet → haiku fallback chain. While no byte has streamed the HTTP
+        // status is still mutable, so return a non-200 (429 for rate_limit, 502 for
+        // error) with an OpenAI-shaped error body; OpenClaw's status-code failover
+        // then advances to the next model in the chain. Once a byte has streamed we
+        // cannot retract the 200 — fall through to the normal finalize in that rare
+        // partial-output case (the catch path / card ❌ still surface the failure).
+        const isFailureStop = lastStopReason === 'rate_limit' || lastStopReason === 'error';
+        if (noVisiblePayload && isFailureStop && !streamOpened && !clientDisconnected) {
+            clearInterval(heartbeatTimer);
+            const isRateLimit = lastStopReason === 'rate_limit';
+            const httpStatus = isRateLimit ? 429 : 502;
+            reportStatus('idle', isRateLimit ? 'Rate limited' : 'Upstream error');
+            // Flip the Telegram card to ❌ <reason> so it never finalizes a misleading
+            // "✓ Done" on a capped/failed turn. Mirrors the catch-path pattern; the
+            // finally block's finalize respects the already-failed card state.
+            try {
+                await mirrorFailActiveCards(isRateLimit ? 'rate limited — model quota reached' : 'upstream error');
+            }
+            catch {
+                /* card fail is cosmetic */
+            }
+            const errBody = {
+                error: {
+                    message: isRateLimit
+                        ? `Model ${model} is rate limited (quota reached).`
+                        : `Model ${model} returned an upstream error.`,
+                    type: isRateLimit ? 'rate_limit_error' : 'server_error',
+                    code: isRateLimit ? 'rate_limited' : 'upstream_error',
+                },
+            };
+            formatError(new Error(errBody.error.message), {
+                code: ERROR_CODES.SESSION_ERROR,
+                sessionId: sessionName,
+                details: { phase: 'handleStreaming', stopReason: lastStopReason, httpStatus },
+            });
+            emitTurnTrace({
+                path: 'streaming',
+                model,
+                userTextPreview: userText.slice(0, 500),
+                userTextLen: userText.length,
+                hasTools,
+                useToolStream,
+                toolCallCount: 0,
+                outputTextPreview: '',
+                outputTextLen: 0,
+                finishReason: 'error',
+                doneBackstopFired: false,
+                voiceIntent,
+                tokensIn: usage?.prompt_tokens ?? 0,
+                tokensOut: usage?.completion_tokens ?? 0,
+                durationMs: Date.now() - turnStartMs,
+                errorMessage: errBody.error.message,
+                errorName: isRateLimit ? 'RateLimitError' : 'UpstreamError',
+            }, sessionName);
+            res.writeHead(httpStatus, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(errBody));
+            return;
+        }
         if (noVisiblePayload) {
             markFirstByte();
             writeSSE(JSON.stringify(formatCompletionChunk(completionId, model, { content: 'Done.' }, null)));
@@ -580,8 +679,21 @@ onFinalText) {
         }
         // v0.4.3: route through formatError for errors_total + trajectory error.
         formatError(err, { code: ERROR_CODES.SESSION_ERROR, sessionId: sessionName, details: { phase: 'handleStreaming' } });
-        writeSSE(JSON.stringify({ error: { message: err.message, type: 'server_error' } }));
-        writeSSE('[DONE]');
+        // v0.32.0 — if nothing has streamed yet the status is still mutable: return
+        // a 502 so OpenClaw's failover advances the model chain. OpenClaw does not
+        // treat an in-band SSE error on a committed 200 as a provider failure, so
+        // the old SSE-error path (kept for the already-streaming case) could not
+        // trigger a fallback.
+        if (!streamOpened && !clientDisconnected) {
+            res.writeHead(502, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: { message: err.message, type: 'server_error', code: 'upstream_error' },
+            }));
+        }
+        else {
+            writeSSE(JSON.stringify({ error: { message: err.message, type: 'server_error' } }));
+            writeSSE('[DONE]');
+        }
         // v0.15.0 Slice 1: turn-trace probe now ALSO fires on error-exit so
         // broken turns (claude CLI crash, timeout, stalled session kill) get
         // captured in the same trajectory stream as successful turns. Without

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@a1hvdy/cc-openclaw",
-  "version": "0.30.0",
+  "version": "0.32.0",
   "description": "A1xAI's Anthropic CLI bridge plugin for OpenClaw",
   "author": "@a1cy",
   "license": "MIT",
   "type": "module",
   "main": "dist/src/index.js",
-  "types": "dist/src/index.d.ts",
   "homepage": "https://github.com/A1cy/cc-openclaw",
   "repository": "github:A1cy/cc-openclaw",
   "engines": {
@@ -23,6 +22,8 @@
   },
   "files": [
     "dist/",
+    "!dist/**/*.d.ts",
+    "!dist/**/*.d.ts.map",
     "configs/",
     "skills/",
     "openclaw.plugin.json",

package/dist/src/channels/adapter.d.ts

@@ -1,103 +0,0 @@
-/**
- * Channel Adapter — generic interface for delivering session UX
- * to chat channels (Telegram, Discord, Signal, etc.).
- *
- * Telegram is the first concrete implementation (src/channels/telegram/).
- * Discord and Signal are deferred to v1.1 (Nice-to-Have).
- *
- * Each adapter:
- *  - Renders live session cards (progress, tool calls, summaries)
- *  - Receives inbound channel messages and forwards them as session inputs
- *  - Sends session outputs back to the channel
- *  - Provides idempotent register() to wire OpenClaw plugin lifecycle hooks
- *
- * AUDIT — B2 (PRP_v3 §11 vs reality, 2026-04-28):
- *
- * PRP_v3 §11.1 documents an event vocabulary (`session.created`,
- * `session.turn.start`, `session.tool.start`, `plugin.heartbeat`, etc.)
- * that does NOT exist in the actual codebase. Every `api.on()` call
- * site in src/ uses the openclaw-claude-code hook-event vocabulary
- * documented in `ChannelHookEvent` below. Likewise §11.2's
- * `api.emit('session.result', ...)` is unimplemented — no `api.emit`
- * call sites exist.
- *
- * Resolution: this audit treats the *code* as canonical and the spec
- * as drifted. The `ChannelHookEvent` literal union captures the actual
- * contract any future channel adapter must speak. The §11.x doc
- * sections need a v3.1 revision to match — tracked as a docs-tier
- * follow-up (Tier 3 §24), not a code-tier blocker.
- */
-/**
- * Canonical hook event vocabulary — every event name passed to `api.on()`
- * across src/channels/, src/command-router/, and src/session-bootstrap/
- * (verified by `rg "api\\.on\\(" src/`).
- *
- * This is the contract: any channel/handler that wants to subscribe to
- * gateway events MUST use one of these names. Adding a new event name
- * here without a corresponding gateway emitter is dead-code-typing.
- */
-type ChannelHookEvent = 'before_dispatch' | 'before_prompt_build' | 'before_model_resolve' | 'before_tool_call' | 'after_tool_call' | 'reply_dispatch' | 'message_sending';
-/** Hook handler signature — gateway passes (event, ctx?) positional args. */
-type ChannelHookHandler = (...args: unknown[]) => unknown | Promise<unknown>;
-export interface PluginApi {
-    /**
-     * Subscribe to a gateway hook event.
-     *
-     * Accepts `ChannelHookEvent` for compile-time event-name checking, or
-     * `string` as an escape hatch for adapter-specific events not yet
-     * canonicalized into the union. Future tightening: drop the `| string`
-     * overload once all hook sites use the union.
-     */
-    on(event: ChannelHookEvent, handler: ChannelHookHandler): void;
-    on(event: string, handler: ChannelHookHandler): void;
-}
-/**
- * Outbound message from session → channel.
- */
-export interface ChannelMessage {
-    channel: string;
-    target: string;
-    text?: string;
-    buttons?: ChannelButton[];
-    metadata?: Record<string, unknown>;
-}
-export interface ChannelButton {
-    text: string;
-    callbackData?: string;
-    url?: string;
-}
-/**
- * Inbound envelope from channel → session.
- */
-export interface ChannelInbound {
-    channel: string;
-    fromUserId: string;
-    text: string;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Channel adapter contract. Each concrete adapter (e.g. Telegram) implements
- * this interface so cc-openclaw can route session events to any wired channel.
- */
-export interface ChannelAdapter {
-    /** Adapter identifier — must be unique across registered adapters. */
-    readonly id: string;
-    /**
-     * Idempotent registration of OpenClaw plugin lifecycle hooks.
-     * Multiple calls with the same api MUST NOT stack listeners.
-     */
-    register(api: PluginApi): void;
-    /** Send an outbound message to the channel. */
-    send(message: ChannelMessage): Promise<void>;
-    /** Update an existing live card in-place (rendering progress). */
-    updateCard?(target: string, message: ChannelMessage): Promise<void>;
-    /** Render a final completion summary to the channel. */
-    completionSummary?(target: string, summary: ChannelMessage): Promise<void>;
-}
-/**
- * Helper to wire any ChannelAdapter via the plugin's main register() flow.
- * Centralizes the per-adapter `register()` call so src/index.ts can
- * iterate a list of adapters without coupling to each adapter's internals.
- */
-export declare function registerChannelAdapter(api: PluginApi, adapter: ChannelAdapter): void;
-export {};