@love-moon/ai-sdk 0.13.1 → 0.13.2

package/dist/providers/codex-app-server-session.js

@@ -56,6 +56,24 @@ ${schemaText}
 
 ${promptText}`;
 }
+function readTokenCount(breakdown) {
+    const value = Number(breakdown?.totalTokens);
+    return Number.isFinite(value) ? value : null;
+}
+/** Adds tokens spent outside the reported attempt (an overflowed first try) to a turn result or error. */
+function addTurnTokens(holder, extraTokens) {
+    if (extraTokens > 0 && holder && typeof holder === "object") {
+        const counted = Number(holder.usage?.turnTotalTokens);
+        holder.usage = { ...(holder.usage || {}), turnTotalTokens: (Number.isFinite(counted) ? counted : 0) + extraTokens };
+    }
+    return holder;
+}
+/** A failed or interrupted turn still spent tokens: expose them on the error. */
+function attachTurnUsage(error, usage) {
+    if (error && typeof error === "object" && error.usage === undefined) {
+        error.usage = usage;
+    }
+}
 function normalizeItemId(value) {
     return typeof value === "string" ? value.trim() : "";
 }
@@ -185,6 +203,7 @@ export class CodexAppServerSession extends EventEmitter {
      */
     static capabilities = Object.freeze({
         goal: true,
+        compact: true,
         media: PROVIDER_MEDIA_CAPABILITIES[CODEX_APP_SERVER_VARIANT],
     });
     /**
@@ -219,6 +238,10 @@ export class CodexAppServerSession extends EventEmitter {
         this.nativeSessionId = "";
         this.rateLimits = null;
         this.tokenUsage = null;
+        // Thread total when the current turn/goal/compaction started, and whether
+        // its own usage has arrived since; see snapshotTokenUsage().
+        this.turnTokenBaseline = null;
+        this.turnTokensSeen = false;
         this.currentTurnStatus = null;
         this.currentTurnActivityAt = 0;
         this.now = typeof options.now === "function" ? options.now : () => Date.now();
@@ -467,6 +490,29 @@ export class CodexAppServerSession extends EventEmitter {
             }
         }
     }
+    /** Start counting a turn's tokens from the thread total known right now. */
+    beginTurnTokenAccounting() {
+        this.turnTokenBaseline = readTokenCount(this.tokenUsage?.total);
+        this.turnTokensSeen = false;
+    }
+    /**
+     * 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() {
+        if (!this.tokenUsage) {
+            return null;
+        }
+        const total = readTokenCount(this.tokenUsage.total);
+        return {
+            ...this.tokenUsage,
+            ...(total !== null && this.turnTokenBaseline !== null && this.turnTokensSeen
+                ? { turnTotalTokens: Math.max(0, total - this.turnTokenBaseline) }
+                : {}),
+        };
+    }
     resolveContextUsagePercent() {
         const totalTokens = Number(this.tokenUsage?.total?.totalTokens);
         const contextWindow = Number(this.tokenUsage?.modelContextWindow);
@@ -527,6 +573,8 @@ export class CodexAppServerSession extends EventEmitter {
         this.manualResumeReady = false;
         this.sessionInfo = null;
         this.tokenUsage = null;
+        this.turnTokenBaseline = null;
+        this.turnTokensSeen = false;
         this.booted = false;
         this.bootPromise = null;
     }
@@ -602,7 +650,7 @@ export class CodexAppServerSession extends EventEmitter {
         if (!finalizedMessageId || !activeMessageId || activeMessageId === finalizedMessageId) {
             currentTurn.activeAssistantMessageId = "";
         }
-        if (!text) {
+        if (!text || currentTurn.suppressReply) {
             return false;
         }
         await this.emitAssistantMessage(text);
@@ -925,9 +973,28 @@ export class CodexAppServerSession extends EventEmitter {
                 await this.queueAssistantDelta(delta, { messageId });
                 return;
             }
-            case "thread/tokenUsage/updated":
-                this.tokenUsage = params?.tokenUsage && typeof params.tokenUsage === "object" ? { ...params.tokenUsage } : null;
+            case "thread/tokenUsage/updated": {
+                const tokenUsage = params?.tokenUsage && typeof params.tokenUsage === "object" ? { ...params.tokenUsage } : null;
+                if (this.currentTurn && tokenUsage) {
+                    // Codex replays a resumed thread's total right after thread/resume,
+                    // before this turn's own responses (no or another turn id).
+                    const turnId = this.currentTurn.turnId;
+                    const beforeTurn = !turnId || Boolean(params?.turnId && params.turnId !== turnId);
+                    if (this.turnTokenBaseline === null) {
+                        // No total was known when the turn started (fresh boot or resume):
+                        // a replayed total is the baseline; this turn's first response
+                        // has `total - last` before it.
+                        const total = readTokenCount(tokenUsage.total);
+                        const last = readTokenCount(tokenUsage.last);
+                        this.turnTokenBaseline = total === null ? null : beforeTurn ? total : last === null ? null : total - last;
+                    }
+                    if (!beforeTurn) {
+                        this.turnTokensSeen = true;
+                    }
+                }
+                this.tokenUsage = tokenUsage;
                 return;
+            }
             case "account/rateLimits/updated":
                 this.rateLimits = params?.rateLimits && typeof params.rateLimits === "object" ? { ...params.rateLimits } : null;
                 return;
@@ -1023,7 +1090,7 @@ export class CodexAppServerSession extends EventEmitter {
                 await this.emitTurnCompletedStatus(currentTurn);
                 currentTurn.resolve({
                     turn,
-                    usage: this.tokenUsage ? { ...this.tokenUsage } : null,
+                    usage: this.snapshotTokenUsage(),
                 });
                 this.currentTurn = null;
                 return;
@@ -1145,6 +1212,7 @@ export class CodexAppServerSession extends EventEmitter {
             resolve: resolveTurn,
             reject: rejectTurn,
         };
+        this.beginTurnTokenAccounting();
         this.currentTurn = currentTurn;
         try {
             const startPromise = this.transport.request("turn/start", {
@@ -1203,6 +1271,8 @@ export class CodexAppServerSession extends EventEmitter {
                 !this.closeRequested &&
                 !currentTurn.goalMode &&
                 this.isRecoverableContextOverflow(error)) {
+                // The overflowed attempt already spent tokens; the fresh thread's totals won't include them.
+                const failedAttemptTokens = this.snapshotTokenUsage()?.turnTotalTokens ?? 0;
                 // Drop the user message pushed for the failed attempt; the retry
                 // re-adds it (and folds prior history in as a preface via buildPrompt).
                 if (this.history.length > 0 &&
@@ -1227,12 +1297,15 @@ export class CodexAppServerSession extends EventEmitter {
                         status_line: "codex context full; retrying on a fresh thread",
                     });
                     this.emit("thread_recovered", { reason: "context_overflow", backend: this.backend });
-                    return await this.runTurn(promptText, {
+                    return addTurnTokens(await this.runTurn(promptText, {
                         useInitialImages,
                         media: mediaInput,
                         contextFiles,
                         jsonSchema,
-                    });
+                    }), failedAttemptTokens);
+                }
+                catch (retryError) {
+                    throw addTurnTokens(retryError, failedAttemptTokens);
                 }
                 finally {
                     this._contextRecoveryInFlight = false;
@@ -1246,6 +1319,97 @@ export class CodexAppServerSession extends EventEmitter {
                 });
             }
             this.maybeEmitAuthRequired(error);
+            attachTurnUsage(error, this.snapshotTokenUsage());
+            throw error;
+        }
+        finally {
+            if (this.currentTurn === currentTurn) {
+                this.currentTurn = null;
+            }
+            closeGuard.cleanup();
+            turnTimeoutGuard.cleanup();
+        }
+    }
+    /**
+     * 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>}
+     */
+    async runCompact(request = {}) {
+        if (this.closeRequested) {
+            throw this.createSessionClosedError();
+        }
+        if (this.currentTurn || this.currentGoalRun) {
+            throw createTurnError("Codex app-server turn already running", {
+                reason: "turn_already_running",
+            });
+        }
+        const instructions = typeof request?.instructions === "string" ? request.instructions.trim() : "";
+        if (instructions) {
+            this.trace("thread/compact/start takes no instructions; ignoring them");
+        }
+        if (this.pendingHistorySeed || (!this.resumeSessionId && this.history.length === 0)) {
+            return { compact: { status: "noop", instructionsApplied: false }, usage: null, metadata: {} };
+        }
+        this.markTurnStartedStatus();
+        try {
+            await this.boot();
+        }
+        catch (error) {
+            await this.failPendingTurnStart(error);
+            throw error;
+        }
+        const closeGuard = this.createCloseGuard();
+        const turnTimeoutGuard = this.createTurnTimeoutGuard();
+        let resolveTurn = null;
+        let rejectTurn = null;
+        const completion = new Promise((resolve, reject) => {
+            resolveTurn = resolve;
+            rejectTurn = reject;
+        });
+        const currentTurn = {
+            turnId: "",
+            fullText: "",
+            activeAssistantMessageId: "",
+            activeAssistantMessageText: "",
+            resolve: resolveTurn,
+            reject: rejectTurn,
+            suppressReply: true,
+        };
+        this.beginTurnTokenAccounting();
+        this.currentTurn = currentTurn;
+        const metadata = { source: CODEX_APP_SERVER_VARIANT, threadId: this.sessionId };
+        try {
+            const completionResult = await Promise.race([
+                (async () => {
+                    await this.transport.request("thread/compact/start", { threadId: this.sessionId });
+                    return await completion;
+                })(),
+                closeGuard.promise,
+                turnTimeoutGuard.promise,
+            ]);
+            await this.emitTurnCompletedStatus(currentTurn);
+            return {
+                compact: { status: "compacted", instructionsApplied: false },
+                usage: completionResult?.usage || null,
+                metadata,
+            };
+        }
+        catch (error) {
+            if (error?.reason === "turn_timeout") {
+                await this.interruptCurrentTurn();
+            }
+            if (!this.closeRequested && error?.reason !== "session_closed") {
+                await this.emitWorkingStatus({
+                    phase: "turn_failed",
+                    reply_in_progress: false,
+                    status_done_line: error instanceof Error ? error.message : String(error),
+                });
+            }
+            attachTurnUsage(error, this.snapshotTokenUsage());
             throw error;
         }
         finally {
@@ -1368,7 +1532,7 @@ export class CodexAppServerSession extends EventEmitter {
                 if (isTerminalGoalStatusLocal(payload.status)) {
                     resolveGoal?.({
                         goal: { ...goalRun.latestGoal },
-                        usage: this.tokenUsage ? { ...this.tokenUsage } : null,
+                        usage: this.snapshotTokenUsage(),
                         cleared: false,
                     });
                 }
@@ -1382,7 +1546,7 @@ export class CodexAppServerSession extends EventEmitter {
                 };
                 resolveGoal?.({
                     goal: { ...finalGoal, status: finalGoal.status || "complete" },
-                    usage: this.tokenUsage ? { ...this.tokenUsage } : null,
+                    usage: this.snapshotTokenUsage(),
                     cleared: true,
                 });
             },
@@ -1406,6 +1570,7 @@ export class CodexAppServerSession extends EventEmitter {
             },
             goalMode: true,
         };
+        this.beginTurnTokenAccounting();
         this.currentTurn = currentTurn;
         try {
             let setResult;
@@ -1440,7 +1605,7 @@ export class CodexAppServerSession extends EventEmitter {
                 if (isTerminalGoalStatusLocal(initialGoal.status)) {
                     resolveGoal?.({
                         goal: { ...initialGoal },
-                        usage: this.tokenUsage ? { ...this.tokenUsage } : null,
+                        usage: this.snapshotTokenUsage(),
                         cleared: false,
                     });
                 }
@@ -1480,7 +1645,8 @@ export class CodexAppServerSession extends EventEmitter {
                     status: goalState.status,
                     tokenBudget: goalState.tokenBudget !== undefined ? goalState.tokenBudget : tokenBudget,
                 },
-                usage: goalResult?.usage || (this.tokenUsage ? { ...this.tokenUsage } : null),
+                // Fresh snapshot: usage can still arrive after the terminal goal status.
+                usage: this.snapshotTokenUsage() || goalResult?.usage || null,
                 metadata: {
                     source: CODEX_APP_SERVER_VARIANT,
                     threadId: this.sessionId,
@@ -1502,6 +1668,7 @@ export class CodexAppServerSession extends EventEmitter {
                 });
             }
             this.maybeEmitAuthRequired(error);
+            attachTurnUsage(error, this.snapshotTokenUsage());
             throw error;
         }
         finally {

package/dist/providers/copilot-sdk-session.d.ts

@@ -41,7 +41,7 @@ export class CopilotSdkSession extends EventEmitter<[never]> {
         abortRequested: boolean;
         terminalWorkingStatusEmitted: boolean;
         error: null;
-        onProgress: null;
+        onProgress: any;
     } | null;
     lastUsage: any;
     currentTurnStatus: any;
@@ -84,6 +84,7 @@ export class CopilotSdkSession extends EventEmitter<[never]> {
         } | null;
         currentTurnStatus: any;
         capabilities: {
+            compact: boolean;
             media: Readonly<{
                 image: "native";
             }>;
@@ -170,6 +171,33 @@ export class CopilotSdkSession extends EventEmitter<[never]> {
     handleCopilotEventFailure(error: any): void;
     handleCopilotEvent(event: any): Promise<void>;
     interruptCurrentTurn(): Promise<void>;
+    createTurnState(onProgress: any): {
+        items: never[];
+        events: never[];
+        fullText: string;
+        messageOrder: never[];
+        messageText: Map<any, any>;
+        emittedMessageIds: Set<any>;
+        activeToolName: string;
+        activeToolPhase: string;
+        abortRequested: boolean;
+        terminalWorkingStatusEmitted: boolean;
+        error: null;
+        onProgress: any;
+    };
+    /**
+     * Manually compact the session via the CLI's `session.history.compact` RPC
+     * (the same call its interactive `/compact` makes). `customInstructions`
+     * is not in the SDK's typed wrapper, so the request goes through the raw
+     * connection.
+     *
+     * @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>;
     runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;

package/dist/providers/copilot-sdk-session.js

@@ -594,7 +594,7 @@ export class CopilotSdkSession extends EventEmitter {
                 }
                 : null,
             currentTurnStatus: this.getCurrentTurnStatus(),
-            capabilities: { media: PROVIDER_MEDIA_CAPABILITIES[COPILOT_PROVIDER_VARIANT] },
+            capabilities: { compact: true, media: PROVIDER_MEDIA_CAPABILITIES[COPILOT_PROVIDER_VARIANT] },
         };
     }
     getSessionInfo() {
@@ -709,7 +709,7 @@ export class CopilotSdkSession extends EventEmitter {
             return false;
         }
         const text = currentTurn.messageText.get(messageId) || "";
-        if (!text) {
+        if (!text || currentTurn.suppressReply) {
             return false;
         }
         currentTurn.emittedMessageIds.add(messageId);
@@ -1362,6 +1362,11 @@ export class CopilotSdkSession extends EventEmitter {
         }
     }
     async interruptCurrentTurn() {
+        if (this.currentTurn?.abortCompaction) {
+            this.currentTurn.abortRequested = true;
+            this.currentTurn.abortCompaction();
+            return;
+        }
         if (!this.currentTurn || !this.session || typeof this.session.abort !== "function") {
             return;
         }
@@ -1374,6 +1379,109 @@ export class CopilotSdkSession extends EventEmitter {
             }
         }
     }
+    createTurnState(onProgress) {
+        return {
+            items: [],
+            events: [],
+            fullText: "",
+            messageOrder: [],
+            messageText: new Map(),
+            emittedMessageIds: new Set(),
+            activeToolName: "",
+            activeToolPhase: "",
+            abortRequested: false,
+            terminalWorkingStatusEmitted: false,
+            error: null,
+            onProgress,
+        };
+    }
+    /**
+     * Manually compact the session via the CLI's `session.history.compact` RPC
+     * (the same call its interactive `/compact` makes). `customInstructions`
+     * is not in the SDK's typed wrapper, so the request goes through the raw
+     * connection.
+     *
+     * @param {import("../shared.js").CompactRequest} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").CompactResult>}
+     */
+    async runCompact(request = {}, { onProgress = null } = {}) {
+        if (this.currentTurn) {
+            throw this.createTurnAlreadyRunningError();
+        }
+        const instructions = typeof request?.instructions === "string" ? request.instructions.trim() : "";
+        const noop = { compact: { status: "noop", instructionsApplied: false }, usage: null, metadata: {} };
+        if (this.pendingHistorySeed) {
+            return noop;
+        }
+        const currentTurn = this.createTurnState(onProgress);
+        currentTurn.suppressReply = true;
+        this.currentTurn = currentTurn;
+        this.touchTurnActivity();
+        this.markTurnStartedStatus();
+        // `session.abort()` does not stop a manual compaction; it has its own abort RPC.
+        const abortCompaction = () => {
+            Promise.resolve()
+                .then(() => this.session?.connection?.sendRequest("session.history.abortManualCompaction", {
+                sessionId: this.session.sessionId,
+            }))
+                .catch(() => { });
+        };
+        currentTurn.abortCompaction = abortCompaction;
+        const closeGuard = this.createCloseGuard(abortCompaction);
+        const turnTimeoutGuard = this.createTurnTimeoutGuard(abortCompaction);
+        try {
+            await Promise.race([this.boot(), closeGuard.promise, turnTimeoutGuard.promise]);
+            this.applySessionInfo(this.session?.sessionId || this.sessionId);
+            await this.emitWorkingStatus({ phase: "context_compaction", reply_in_progress: true, status_line: "copilot compacting context" }, onProgress);
+            if (currentTurn.abortRequested) {
+                throw createTurnError("Copilot compaction interrupted", { reason: "turn_interrupted" });
+            }
+            const result = await Promise.race([
+                this.requestOrThrow(this.session.connection.sendRequest("session.history.compact", {
+                    sessionId: this.session.sessionId,
+                    // The CLI schema caps focus instructions at 4000 characters.
+                    ...(instructions ? { customInstructions: instructions.slice(0, 4000) } : {}),
+                })),
+                closeGuard.promise,
+                turnTimeoutGuard.promise,
+            ]);
+            if (result?.success === false) {
+                throw createTurnError("Copilot compaction failed", { reason: "compact_failed" });
+            }
+            await this.emitTerminalWorkingStatus(currentTurn, { phase: "turn_completed", status_done_line: "copilot compacted context" }, onProgress);
+            const tokensRemoved = Number(result?.tokensRemoved);
+            return {
+                compact: {
+                    status: "compacted",
+                    instructionsApplied: Boolean(instructions),
+                    tokensRemoved: Number.isFinite(tokensRemoved) ? tokensRemoved : undefined,
+                },
+                usage: null,
+                metadata: { source: COPILOT_PROVIDER_VARIANT, sessionId: this.sessionId || undefined },
+            };
+        }
+        catch (error) {
+            const message = extractErrorMessage(error);
+            // The CLI refuses when the session holds nothing it can summarize yet.
+            if (!currentTurn.abortRequested && /nothing to compact|no active agent context/i.test(message)) {
+                await this.emitTerminalWorkingStatus(currentTurn, { phase: "turn_completed", status_done_line: "copilot finished" }, onProgress);
+                return noop;
+            }
+            if (currentTurn.abortRequested && error?.reason !== "turn_timeout" && error?.reason !== "session_closed") {
+                await this.emitTerminalWorkingStatus(currentTurn, { phase: "turn_interrupted", status_done_line: "copilot interrupted" }, onProgress);
+                throw createTurnError("Copilot compaction interrupted", { reason: "turn_interrupted" });
+            }
+            await this.emitTerminalWorkingStatus(currentTurn, { phase: "turn_failed", status_done_line: message }, onProgress);
+            throw error;
+        }
+        finally {
+            closeGuard.cleanup();
+            turnTimeoutGuard.cleanup();
+            this.activeReplyTarget = "";
+            this.currentTurn = null;
+        }
+    }
     async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null } = {}) {
         if (this.currentTurn) {
             throw this.createTurnAlreadyRunningError();
@@ -1394,20 +1502,7 @@ export class CopilotSdkSession extends EventEmitter {
                 },
             };
         }
-        const currentTurn = {
-            items: [],
-            events: [],
-            fullText: "",
-            messageOrder: [],
-            messageText: new Map(),
-            emittedMessageIds: new Set(),
-            activeToolName: "",
-            activeToolPhase: "",
-            abortRequested: false,
-            terminalWorkingStatusEmitted: false,
-            error: null,
-            onProgress,
-        };
+        const currentTurn = this.createTurnState(onProgress);
         this.currentTurn = currentTurn;
         this.touchTurnActivity();
         this.markTurnStartedStatus();

package/dist/providers/dsh-sdk-session.d.ts

@@ -1,4 +1,5 @@
 export function defaultDshSessionRoot(): string;
+export const COMPACT_SUMMARY_PROMPT: string;
 /**
  * DeepSeek Harness (dsh) backend session.
  *
@@ -17,10 +18,12 @@ export function defaultDshSessionRoot(): string;
 export class DshSdkSession extends EventEmitter<[never]> {
     static capabilities: Readonly<{
         goal: false;
+        compact: true;
     }>;
     constructor(backend: any, options?: {});
     getCapabilities(): {
         goal: false;
+        compact: true;
     };
     backend: string;
     options: {};
@@ -52,6 +55,7 @@ export class DshSdkSession extends EventEmitter<[never]> {
     manualResumeReady: boolean;
     sessionAnnounced: boolean;
     currentTurn: {
+        suppressReply: boolean;
         emittedAssistantMessage: boolean;
         fullText: string;
         interrupted: boolean;
@@ -87,6 +91,7 @@ export class DshSdkSession extends EventEmitter<[never]> {
         currentTurnStatus: any;
         capabilities: {
             goal: false;
+            compact: true;
         };
     };
     getSessionInfo(): {
@@ -165,9 +170,23 @@ export class DshSdkSession extends EventEmitter<[never]> {
         onProgress: any;
     }): Promise<void>;
     interruptCurrentTurn(): Promise<boolean>;
-    runTurn(promptText: any, { useInitialImages, onProgress }?: {
+    /**
+     * Manually compact the conversation. The dsh SDK wire exposes no compaction
+     * request (its engine's `compactNow` is internal), so the model summarizes
+     * the conversation in one silent turn and the chat continues on a fresh
+     * wire session seeded with only that summary.
+     *
+     * @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>;
+    runTurn(promptText: any, { useInitialImages, onProgress, suppressReply }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;
+        suppressReply?: boolean | undefined;
     }): Promise<{
         text: string;
         usage: null;