@love-moon/ai-sdk 0.13.1 → 0.13.3

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @love-moon/ai-sdk
 
+## 0.13.3
+
+### Patch Changes
+
+- 0859251: Show Codex progress notes as soon as Codex finishes writing them. The session
+  did not recognize the app-server's `agentMessage` items, so a commentary message
+  was held back until the next message started or the turn ended, often minutes
+  later during long tool runs.
+- c1b66d1: Fix Codex tasks that stopped mid-reply after the agent spawned sub-agents. In
+  multi-agent mode the Codex app-server also streams the sub-agent threads, and
+  the first sub-agent to finish ended the parent turn. The parent's later
+  messages and final answer were dropped, and a sub-agent's report could show up
+  as the AI reply. The session now ignores notifications from other threads.
+- f6dbd6b: Show completed Codex replies while subsequent tools are still running, and keep replies intact when their final text and completion arrive together.
+
+## 0.13.2
+
+### Patch Changes
+
+- 8c2833d: Support `/compact [focus instructions]` in task chats. Fire detects the command
+  per message (like `/goal`), runs the backend's native context compaction
+  instead of sending the text to the model, and posts one confirmation with the
+  token savings. Sessions advertise `capabilities.compact` and implement the new
+  optional `runCompact()`: claude (native `/compact`), codex app-server
+  (`thread/compact/start`), copilot (`session.history.compact`), kimi wire and
+  legacy print (built-in `/compact`), opencode (`session.summarize`) and dsh
+  (summary turn, then a fresh session seeded with the summary). Backends without
+  the capability (chat-web, codex exec, Kimi Code prompt mode) reply with a
+  not-supported notice. Opencode compaction summaries no longer surface as chat
+  replies, and dsh clears its "compacting context" status when automatic
+  compaction ends.
+- 8e3a4c3: Report how many model tokens each turn consumed. After every turn (or `/goal`)
+  `conductor fire` sends the turn's token count (fresh input + cache reads/writes +
+  output) over the new `task_turn_usage` websocket event, and the server adds it
+  to the task's running total shown in the task detail card. A persistent task's
+  total restarts with each round.
+
+  Failed or interrupted turns and `/compact` are counted too; when a turn's usage
+  is unknown the fire reports `null`, which clears the task's last-turn count.
+
+  - `@love-moon/conductor-sdk`: new `ConductorClient.sendTurnUsage(taskId, { tokens })`.
+  - `@love-moon/ai-sdk`: the Codex app-server provider's turn/goal `usage` now
+    carries `turnTotalTokens`, the turn's share of Codex's thread-cumulative total.
+    Claude and Codex turn errors carry the tokens spent before the failure as
+    `error.usage` (Claude sums streamed usage when an interrupted query ends
+    without a result).
+  - Claude and Codex backends are counted; other backends report nothing yet.
+
 ## 0.13.1
 
 ## 0.13.0

package/dist/client.d.ts

@@ -18,6 +18,7 @@ export class RemoteAiSession extends EventEmitter<[never]> {
         workerReady: boolean;
         capabilities: {
             goal?: boolean | undefined;
+            compact?: boolean | undefined;
         };
     };
     sessionMessageHandler: any;
@@ -51,6 +52,7 @@ export class RemoteAiSession extends EventEmitter<[never]> {
         workerReady: boolean;
         capabilities: {
             goal?: boolean | undefined;
+            compact?: boolean | undefined;
         };
     };
     usesSessionFileReplyStream(): boolean;
@@ -69,6 +71,7 @@ export class RemoteAiSession extends EventEmitter<[never]> {
     interruptCurrentTurn(): Promise<any>;
     runTurn(promptText: any, options?: {}): Promise<any>;
     runGoal(goal: any, options?: {}): Promise<any>;
+    runCompact(request?: {}, options?: {}): Promise<any>;
     getGoal(): Promise<any>;
     clearGoal(): Promise<any>;
     close(): Promise<void>;
@@ -108,6 +111,7 @@ declare class LocalAiSessionProxy extends EventEmitter<[never]> {
         workerReady: boolean;
         capabilities: {
             goal?: boolean | undefined;
+            compact?: boolean | undefined;
         };
     };
     readyPromise: Promise<any>;
@@ -126,6 +130,7 @@ declare class LocalAiSessionProxy extends EventEmitter<[never]> {
     interruptCurrentTurn(): Promise<any>;
     runTurn(promptText: any, options?: {}): Promise<any>;
     runGoal(goal: any, options?: {}): Promise<any>;
+    runCompact(request?: {}, options?: {}): Promise<any>;
     getGoal(): Promise<any>;
     clearGoal(): Promise<any>;
     close(): Promise<void>;

package/dist/client.js

@@ -9,6 +9,11 @@ function createUnsupportedGoalError(name) {
     err.reason = "unsupported_goal";
     return err;
 }
+function createUnsupportedCompactError(name) {
+    const err = new Error(`runCompact() is not supported by backend session (${name || "unknown"}).`);
+    err.reason = "unsupported_compact";
+    return err;
+}
 const WORKER_PATH = fileURLToPath(new URL("./worker.js", import.meta.url));
 function sanitizeOptionsForWorker(options = {}) {
     const sanitized = {};
@@ -217,6 +222,16 @@ export class RemoteAiSession extends EventEmitter {
             progressHandler: typeof onProgress === "function" ? onProgress : null,
         });
     }
+    async runCompact(request = {}, options = {}) {
+        await this.readyPromise;
+        if (!this.snapshot?.capabilities || this.snapshot.capabilities.compact !== true) {
+            throw createUnsupportedCompactError(this.snapshot?.provider || this.snapshot?.backend);
+        }
+        const { onProgress, ...restOptions } = options || {};
+        return this.callWorker("runCompact", [request, restOptions], {
+            progressHandler: typeof onProgress === "function" ? onProgress : null,
+        });
+    }
     async getGoal() {
         // Propagate worker-creation errors instead of masking them as "no goal".
         // See N3 in the review.
@@ -675,6 +690,15 @@ class LocalAiSessionProxy extends EventEmitter {
         }
         return await session.runGoal(goal, options);
     }
+    async runCompact(request = {}, options = {}) {
+        const session = await this.readyPromise;
+        // Capabilities resolved at init (snapshot first) are authoritative; some
+        // providers only advertise them via getSnapshot().
+        if (this.snapshot?.capabilities?.compact !== true || typeof session.runCompact !== "function") {
+            throw createUnsupportedCompactError(session?.constructor?.name);
+        }
+        return await session.runCompact(request, options);
+    }
     async getGoal() {
         const session = await this.readyPromise;
         const capabilities = resolveSessionCapabilities(session);

package/dist/providers/claude-agent-sdk-session.d.ts

@@ -9,6 +9,7 @@ export function resolveClaudeCommandForRoot(commandLine: any, env?: NodeJS.Proce
 export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     static capabilities: Readonly<{
         goal: true;
+        compact: true;
         media: Readonly<{
             image: "native";
         }>;
@@ -16,6 +17,7 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     constructor(backend: any, options?: {});
     getCapabilities(): {
         goal: true;
+        compact: true;
         media: Readonly<{
             image: "native";
         }>;
@@ -42,12 +44,16 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     manualResumeReady: boolean;
     currentTurn: {
         abortController: AbortController;
+        suppressReply: boolean;
+        compactMetadata: null;
+        compactError: string;
         emittedAssistantMessage: boolean;
         fullText: string;
         items: never[];
         query: null;
         resultMessage: null;
         terminalWorkingStatusEmitted: boolean;
+        usageByMessageId: Map<any, any>;
     } | null;
     lastResult: any;
     rateLimitInfo: any;
@@ -88,6 +94,7 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
         currentTurnStatus: any;
         capabilities: {
             goal: true;
+            compact: true;
             media: Readonly<{
                 image: "native";
             }>;
@@ -154,10 +161,11 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
         onProgress: any;
     }): Promise<void>;
     interruptCurrentTurn(): Promise<boolean>;
-    runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema }?: {
+    runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema, suppressReply }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;
         jsonSchema?: null | undefined;
+        suppressReply?: boolean | undefined;
     }): Promise<{
         text: string;
         usage: null;
@@ -165,6 +173,8 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
         events: never[];
         provider?: undefined;
         metadata?: undefined;
+        compactMetadata?: undefined;
+        compactError?: undefined;
     } | {
         text: any;
         usage: any;
@@ -178,6 +188,8 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
             modelUsage: any;
             structuredOutput: any;
         };
+        compactMetadata: undefined;
+        compactError: string | undefined;
     }>;
     /**
      * Trigger Claude's native `/goal` slash command. Implemented by sending the
@@ -204,6 +216,18 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
      * @returns {Promise<import("../shared.js").GoalResult>}
      */
     runGoal(goal: import("../shared.js").GoalRequest, options?: object): Promise<import("../shared.js").GoalResult>;
+    /**
+     * Manually compact the conversation via Claude's native `/compact` slash
+     * command. Custom focus instructions are forwarded as the command argument.
+     * No assistant message is emitted; the caller renders the confirmation.
+     *
+     * @param {import("../shared.js").CompactRequest} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").CompactResult>}
+     */
+    runCompact(request?: import("../shared.js").CompactRequest, { onProgress }?: {
+        onProgress?: Function;
+    }): Promise<import("../shared.js").CompactResult>;
     close(): Promise<void>;
 }
 import { EventEmitter } from "node:events";

package/dist/providers/claude-agent-sdk-session.js

@@ -32,6 +32,22 @@ function createTurnError(message, extras = {}) {
     }
     return error;
 }
+/** Per-turn usage summed from streamed assistant messages (one entry per API response). */
+function sumStreamedUsage(usageByMessageId) {
+    if (!usageByMessageId.size) {
+        return null;
+    }
+    const total = {};
+    for (const usage of usageByMessageId.values()) {
+        for (const key of ["input_tokens", "cache_creation_input_tokens", "cache_read_input_tokens", "output_tokens"]) {
+            const value = Number(usage?.[key]);
+            if (Number.isFinite(value)) {
+                total[key] = (total[key] || 0) + value;
+            }
+        }
+    }
+    return total;
+}
 function normalizeClaudeBackend(backend) {
     const normalized = String(backend || "").trim().toLowerCase();
     if (normalized === "claude-code") {
@@ -214,9 +230,10 @@ function sanitizeSummary(value, maxLen = 180) {
 export class ClaudeAgentSdkSession extends EventEmitter {
     // Capability advertised via getSnapshot().capabilities so worker proxies
     // can short-circuit runGoal without an IPC round trip. Claude exposes
-    // native `/goal` slash command, so this is true.
+    // native `/goal` and `/compact` slash commands, so both are true.
     static capabilities = Object.freeze({
         goal: true,
+        compact: true,
         media: PROVIDER_MEDIA_CAPABILITIES[CLAUDE_PROVIDER_VARIANT],
     });
     getCapabilities() {
@@ -720,6 +737,16 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                     this.updateSessionInfo(message.session_id || message.sessionId);
                     return;
                 }
+                if (message.subtype === "compact_boundary") {
+                    currentTurn.compactMetadata =
+                        message.compact_metadata && typeof message.compact_metadata === "object"
+                            ? { ...message.compact_metadata }
+                            : {};
+                    return;
+                }
+                if (message.subtype === "status" && message.compact_result === "failed") {
+                    currentTurn.compactError = normalizeText(message.compact_error) || "compaction failed";
+                }
                 if (message.subtype === "status" && message.status === "compacting") {
                     await this.emitWorkingStatus({
                         phase: "context_compaction",
@@ -775,6 +802,9 @@ export class ClaudeAgentSdkSession extends EventEmitter {
             }
             case "assistant": {
                 this.updateSessionInfo(message.session_id || message.sessionId);
+                if (message.message?.id && message.message.usage) {
+                    currentTurn.usageByMessageId.set(message.message.id, message.message.usage);
+                }
                 for (const block of contentBlocks(message.message)) {
                     if (block?.type === "tool_use") {
                         noteToolStarted(currentTurn, block.id, block.name, block.input);
@@ -784,8 +814,11 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                 if (!text) {
                     return;
                 }
-                currentTurn.emittedAssistantMessage = true;
                 currentTurn.fullText = text;
+                if (currentTurn.suppressReply) {
+                    return;
+                }
+                currentTurn.emittedAssistantMessage = true;
                 await this.emitWorkingStatus({
                     phase: "message_aggregation",
                     reply_in_progress: true,
@@ -843,7 +876,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         }
         return true;
     }
-    async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null } = {}) {
+    async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null, suppressReply = false } = {}) {
         if (this.closeRequested) {
             throw this.createSessionClosedError();
         }
@@ -869,16 +902,22 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         if (!sdkModule || typeof sdkModule.query !== "function") {
             throw new Error("Claude Agent SDK is unavailable");
         }
-        this.history.push({ role: "user", content: promptText });
+        if (!suppressReply) {
+            this.history.push({ role: "user", content: promptText });
+        }
         const abortController = new AbortController();
         const currentTurn = {
             abortController,
+            suppressReply,
+            compactMetadata: null,
+            compactError: "",
             emittedAssistantMessage: false,
             fullText: "",
             items: [],
             query: null,
             resultMessage: null,
             terminalWorkingStatusEmitted: false,
+            usageByMessageId: new Map(),
         };
         this.currentTurn = currentTurn;
         this.markTurnStartedStatus();
@@ -934,6 +973,8 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                     permissionDenials: Array.isArray(resultMessage.permission_denials)
                         ? [...resultMessage.permission_denials]
                         : [],
+                    // A failed turn still spent tokens.
+                    usage: resultMessage.usage ? { ...resultMessage.usage } : null,
                 });
             }
             const structuredOutput = jsonSchema && resultMessage.structured_output && typeof resultMessage.structured_output === "object"
@@ -944,10 +985,10 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                 : normalizeText(resultMessage.result) ||
                     currentTurn.fullText ||
                     extractAssistantText(currentTurn.items.find((item) => item?.type === "assistant")?.message);
-            if (!currentTurn.emittedAssistantMessage && responseText) {
+            if (!suppressReply && !currentTurn.emittedAssistantMessage && responseText) {
                 await this.emitAssistantMessage(responseText);
             }
-            if (responseText) {
+            if (!suppressReply && responseText) {
                 this.history.push({ role: "assistant", content: responseText });
             }
             this.manualResumeReady = Boolean(this.sessionId);
@@ -971,9 +1012,14 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                     modelUsage: resultMessage.modelUsage ? { ...resultMessage.modelUsage } : undefined,
                     structuredOutput: structuredOutput !== null ? structuredOutput : undefined,
                 },
+                compactMetadata: currentTurn.compactMetadata || undefined,
+                compactError: currentTurn.compactError || undefined,
             };
         }
         catch (error) {
+            // A failed turn still spent tokens; an interrupted query ends without a
+            // result, so fall back to the usage streamed so far.
+            const usage = error?.usage ?? sumStreamedUsage(currentTurn.usageByMessageId);
             if (error?.reason === "turn_timeout") {
                 await this.interruptCurrentTurn();
             }
@@ -985,9 +1031,12 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                 }, onProgress);
             }
             if (this.closeRequested && error?.reason !== "session_closed") {
-                throw this.createSessionClosedError();
+                throw Object.assign(this.createSessionClosedError(), { usage });
             }
             this.maybeEmitAuthRequired(error?.message || "", error?.message || "");
+            if (error && typeof error === "object") {
+                error.usage = usage;
+            }
             throw error;
         }
         finally {
@@ -1113,6 +1162,46 @@ export class ClaudeAgentSdkSession extends EventEmitter {
             },
         };
     }
+    /**
+     * Manually compact the conversation via Claude's native `/compact` slash
+     * command. Custom focus instructions are forwarded as the command argument.
+     * No assistant message is emitted; the caller renders the confirmation.
+     *
+     * @param {import("../shared.js").CompactRequest} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").CompactResult>}
+     */
+    async runCompact(request = {}, { onProgress = null } = {}) {
+        const instructions = normalizeText(request?.instructions).trim();
+        if (!this.sessionId || this.pendingHistorySeed) {
+            return { compact: { status: "noop", instructionsApplied: false }, usage: null, metadata: {} };
+        }
+        const turnResult = await this.runTurn(instructions ? `/compact ${instructions}` : "/compact", {
+            onProgress,
+            suppressReply: true,
+        });
+        if (/not enough messages/i.test(turnResult.compactError || "")) {
+            return { compact: { status: "noop", instructionsApplied: false }, usage: turnResult.usage, metadata: turnResult.metadata };
+        }
+        if (turnResult.compactError) {
+            throw createTurnError(`Claude compaction failed: ${turnResult.compactError}`, {
+                reason: "compact_failed",
+            });
+        }
+        const boundary = turnResult.compactMetadata;
+        const preTokens = Number(boundary?.pre_tokens);
+        const postTokens = Number(boundary?.post_tokens);
+        return {
+            compact: {
+                status: boundary ? "compacted" : "noop",
+                instructionsApplied: Boolean(boundary && instructions),
+                preTokens: Number.isFinite(preTokens) ? preTokens : undefined,
+                postTokens: Number.isFinite(postTokens) ? postTokens : undefined,
+            },
+            usage: turnResult.usage,
+            metadata: turnResult.metadata,
+        };
+    }
     async close() {
         if (this.closed) {
             return;

package/dist/providers/codex-app-server-session.d.ts

@@ -31,6 +31,8 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
     nativeSessionId: string;
     rateLimits: any;
     tokenUsage: any;
+    turnTokenBaseline: number | null;
+    turnTokensSeen: boolean;
     currentTurnStatus: any;
     currentTurnActivityAt: number;
     now: any;
@@ -42,6 +44,14 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
         activeAssistantMessageText: string;
         resolve: null;
         reject: null;
+    } | {
+        turnId: string;
+        fullText: string;
+        activeAssistantMessageId: string;
+        activeAssistantMessageText: string;
+        resolve: null;
+        reject: null;
+        suppressReply: boolean;
     } | {
         turnId: string;
         fullText: string;
@@ -127,6 +137,15 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
         resumeReady?: boolean | undefined;
     }): void;
     applySessionConfigured(params: any): void;
+    /** Start counting a turn's tokens from the thread total known right now. */
+    beginTurnTokenAccounting(): void;
+    /**
+     * Thread token usage plus `turnTotalTokens`: tokens spent since the current
+     * turn (or goal) started. Codex only reports thread-cumulative totals, and
+     * only when a response completes, so a turn that ended before any response
+     * did has unknown usage.
+     */
+    snapshotTokenUsage(): any;
     resolveContextUsagePercent(): number | undefined;
     /**
      * Whether a turn failure was caused by the provider thread outgrowing the
@@ -175,6 +194,14 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
         activeAssistantMessageText: string;
         resolve: null;
         reject: null;
+    } | {
+        turnId: string;
+        fullText: string;
+        activeAssistantMessageId: string;
+        activeAssistantMessageText: string;
+        resolve: null;
+        reject: null;
+        suppressReply: boolean;
     } | {
         turnId: string;
         fullText: string;
@@ -207,6 +234,14 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
         activeAssistantMessageText: string;
         resolve: null;
         reject: null;
+    } | {
+        turnId: string;
+        fullText: string;
+        activeAssistantMessageId: string;
+        activeAssistantMessageText: string;
+        resolve: null;
+        reject: null;
+        suppressReply: boolean;
     } | {
         turnId: string;
         fullText: string;
@@ -244,6 +279,15 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
         useInitialImages?: boolean | undefined;
         jsonSchema?: null | undefined;
     }): any;
+    /**
+     * Manually compact the thread via `thread/compact/start`. The app-server
+     * runs compaction as a regular turn, so completion is the usual
+     * `turn/completed`. The protocol takes no focus instructions.
+     *
+     * @param {import("../shared.js").CompactRequest} [request]
+     * @returns {Promise<import("../shared.js").CompactResult>}
+     */
+    runCompact(request?: import("../shared.js").CompactRequest): Promise<import("../shared.js").CompactResult>;
     /**
      * Normalize a goal payload from a codex `thread/goal/*` notification into
      * the cross-layer {@link GoalState} shape.