anyclaude-sdk 0.6.0 → 0.6.2

package/dist/agent.js

@@ -480,7 +480,12 @@ export async function* runAgent(options) {
                     yield {
                         type: 'system',
                         subtype: 'compact_boundary',
-                        compact_metadata: { trigger: 'manual', pre_tokens: 0 },
+                        compact_metadata: {
+                            trigger: 'manual',
+                            pre_tokens: 0,
+                            status: 'end',
+                            post_tokens: Math.round(estimateTokens(history)),
+                        },
                         uuid: uuid(),
                         session_id: sessionId,
                     };
@@ -581,21 +586,38 @@ export async function* runAgent(options) {
             if (options.autoCompact && autoCompactCount < 3 && history.length > 3) {
                 const limit = options.contextLimit ?? (contextWindowFor(resultModel) || 200_000);
                 const threshold = (options.compactThreshold ?? 0.8) * limit;
-                if (estimateTokens(history) > threshold) {
+                const preTokens = estimateTokens(history);
+                if (preTokens > threshold) {
                     await runHooks('PreCompact', { hook_event_name: 'PreCompact', trigger: 'auto' });
+                    // Emit a START boundary BEFORE the (possibly slow) summarization so a UI
+                    // can show a live "compacting…" indicator while the LLM call is in flight.
+                    yield {
+                        type: 'system',
+                        subtype: 'compact_boundary',
+                        compact_metadata: { trigger: 'auto', pre_tokens: Math.round(preTokens), status: 'start' },
+                        uuid: uuid(),
+                        session_id: sessionId,
+                    };
                     const compacted = await summarizeHistory(history, llm, { model, signal });
                     if (compacted) {
                         history.splice(0, history.length, ...compacted);
                         autoCompactCount++;
-                        yield {
-                            type: 'system',
-                            subtype: 'compact_boundary',
-                            compact_metadata: { trigger: 'auto', pre_tokens: Math.round(threshold) },
-                            uuid: uuid(),
-                            session_id: sessionId,
-                        };
-                        await runHooks('PostCompact', { hook_event_name: 'PostCompact', trigger: 'auto' });
                     }
+                    // END boundary closes the live indicator either way (compacted or not).
+                    yield {
+                        type: 'system',
+                        subtype: 'compact_boundary',
+                        compact_metadata: {
+                            trigger: 'auto',
+                            pre_tokens: Math.round(preTokens),
+                            status: 'end',
+                            post_tokens: Math.round(estimateTokens(history)),
+                        },
+                        uuid: uuid(),
+                        session_id: sessionId,
+                    };
+                    if (compacted)
+                        await runHooks('PostCompact', { hook_event_name: 'PostCompact', trigger: 'auto' });
                 }
             }
             let streamedText = '';

package/dist/queue.d.ts

@@ -1,6 +1,8 @@
 import type { ContentBlockParam } from './types/index.js';
 export type QueuedContent = string | ContentBlockParam[];
 export interface QueuedMessage {
+    /** Stable id for this queued item — use it to `remove()` a single message. */
+    id: string;
     content: QueuedContent;
     /** Epoch ms when enqueued. */
     at: number;
@@ -8,10 +10,19 @@ export interface QueuedMessage {
 export declare class MessageQueue {
     private items;
     private listeners;
-    /** Enqueue a user message to be delivered at the next turn boundary. */
-    push(content: QueuedContent): void;
+    /**
+     * Enqueue a user message to be delivered at the next turn boundary.
+     * Returns the item's stable `id` (pass it to `remove()` to cancel just this one).
+     */
+    push(content: QueuedContent): string;
     /** Remove and return the oldest queued message (FIFO), or undefined if empty. */
     shift(): QueuedMessage | undefined;
+    /**
+     * Remove a single pending message by its `id` (e.g. a per-pill ✕ in the UI).
+     * Returns true if an item was removed. No-op if the id isn't pending — already
+     * drained (shifted) items can't be cancelled.
+     */
+    remove(id: string): boolean;
     peek(): QueuedMessage | undefined;
     get size(): number;
     /** Snapshot of pending messages (does not drain). */

package/dist/queue.js

@@ -1,12 +1,18 @@
+import { uuid } from './util/ids.js';
 export class MessageQueue {
     constructor() {
         this.items = [];
         this.listeners = new Set();
     }
-    /** Enqueue a user message to be delivered at the next turn boundary. */
+    /**
+     * Enqueue a user message to be delivered at the next turn boundary.
+     * Returns the item's stable `id` (pass it to `remove()` to cancel just this one).
+     */
     push(content) {
-        this.items.push({ content, at: Date.now() });
+        const id = uuid();
+        this.items.push({ id, content, at: Date.now() });
         this.emit();
+        return id;
     }
     /** Remove and return the oldest queued message (FIFO), or undefined if empty. */
     shift() {
@@ -15,6 +21,19 @@ export class MessageQueue {
             this.emit();
         return m;
     }
+    /**
+     * Remove a single pending message by its `id` (e.g. a per-pill ✕ in the UI).
+     * Returns true if an item was removed. No-op if the id isn't pending — already
+     * drained (shifted) items can't be cancelled.
+     */
+    remove(id) {
+        const i = this.items.findIndex((m) => m.id === id);
+        if (i < 0)
+            return false;
+        this.items.splice(i, 1);
+        this.emit();
+        return true;
+    }
     peek() {
         return this.items[0];
     }

package/dist/types/index.d.ts

@@ -162,7 +162,17 @@ export type SDKCompactBoundaryMessage = {
     subtype: 'compact_boundary';
     compact_metadata: {
         trigger: 'manual' | 'auto';
+        /** Transcript token estimate when compaction began. */
         pre_tokens: number;
+        /**
+         * Compaction phase: `'start'` is emitted BEFORE the (possibly slow)
+         * summarization so a UI can show a live "compacting…" indicator; `'end'`
+         * is emitted after, with `post_tokens` set. Absent ⇒ treat as `'end'`
+         * (back-compat: pre-0.6.2 only emitted the post-compaction boundary).
+         */
+        status?: 'start' | 'end';
+        /** Transcript token estimate after compaction (only on `status: 'end'`). */
+        post_tokens?: number;
     };
     uuid: string;
     session_id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyclaude-sdk",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Standalone, browser-compatible SDK providing Claude Code agent capabilities (tools, tool loop, multi-turn, MCP, sub-agents, sessions) against any OpenAI/Anthropic-compatible LLM endpoint. Runs in the browser (WebContainer), Node, and Bun — no backend required.",
   "type": "module",
   "main": "./dist/index.js",