@love-moon/ai-sdk 0.13.0 → 0.13.2

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

@@ -4,10 +4,15 @@ import { appendContextFilesToPrompt } from "../context-files.js";
 import { PROVIDER_MEDIA_CAPABILITIES, buildOpencodeParts } from "../media-adapters.js";
 import { assertMediaCapabilities, defaultPromptForMedia, resolveTurnMedia, } from "../media-input.js";
 import { OpencodeServerTransport } from "../transports/opencode-server-transport.js";
-import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, proxyToEnv, sanitizeForLog, } from "../shared.js";
+import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, noteToolFinished, noteToolStarted, proxyToEnv, sanitizeForLog, withActiveTool, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
 const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
+const SUMMARY_EVENT_GRACE_MS = 2000;
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function isHeadersTimeoutError(error) {
+    return [error?.code, error?.cause?.code].includes("UND_ERR_HEADERS_TIMEOUT");
+}
 function waitForever() {
     return new Promise(() => { });
 }
@@ -226,7 +231,7 @@ export class OpencodeSdkSession extends EventEmitter {
             resumeReady: Boolean(this.sessionId),
             manualResume: null,
             currentTurnStatus: this.getCurrentTurnStatus(),
-            capabilities: { media: PROVIDER_MEDIA_CAPABILITIES[OPENCODE_PROVIDER_VARIANT] },
+            capabilities: { compact: true, media: PROVIDER_MEDIA_CAPABILITIES[OPENCODE_PROVIDER_VARIANT] },
             pid: this.transport.pid || undefined,
         };
     }
@@ -234,7 +239,7 @@ export class OpencodeSdkSession extends EventEmitter {
         return this.sessionInfo ? { ...this.sessionInfo } : null;
     }
     getCurrentTurnStatus() {
-        return this.currentTurnStatus ? { ...this.currentTurnStatus } : null;
+        return withActiveTool(this.currentTurnStatus, this.currentTurn);
     }
     async ensureSessionInfo() {
         await this.boot();
@@ -729,7 +734,9 @@ export class OpencodeSdkSession extends EventEmitter {
                 phase: "message_aggregation",
                 reply_in_progress: true,
                 status_line: statusLineForPhase("message_aggregation"),
-                reply_preview: sanitizeSummary(this.collectAssistantText(messageState), 120),
+                reply_preview: currentTurn.suppressReply || messageState.info?.summary === true
+                    ? undefined
+                    : sanitizeSummary(this.collectAssistantText(messageState), 120),
             }, onProgress);
             return;
         }
@@ -742,6 +749,12 @@ export class OpencodeSdkSession extends EventEmitter {
             return;
         }
         if (part.type === "tool") {
+            if (part.state?.status === "completed" || part.state?.status === "error") {
+                noteToolFinished(currentTurn, part.callID || part.id);
+            }
+            else {
+                noteToolStarted(currentTurn, part.callID || part.id, part.tool, part.state?.input);
+            }
             const phase = toolPhaseForName(part.tool);
             const toolStatus = part.state?.status === "completed"
                 ? part.state?.title || part.state?.output || ""
@@ -791,7 +804,9 @@ export class OpencodeSdkSession extends EventEmitter {
                 phase: "message_aggregation",
                 reply_in_progress: true,
                 status_line: statusLineForPhase("message_aggregation"),
-                reply_preview: sanitizeSummary(this.collectAssistantText(messageState), 120),
+                reply_preview: currentTurn.suppressReply || messageState.info?.summary === true
+                    ? undefined
+                    : sanitizeSummary(this.collectAssistantText(messageState), 120),
             }, onProgress);
             return;
         }
@@ -832,7 +847,8 @@ export class OpencodeSdkSession extends EventEmitter {
         if (currentTurn.activeAssistantMessageId === targetId) {
             currentTurn.activeAssistantMessageId = "";
         }
-        if (!text) {
+        // Compaction summaries (manual or automatic) are context, not a reply.
+        if (!text || currentTurn.suppressReply || messageState.info?.summary === true) {
             return false;
         }
         currentTurn.fullText += text;
@@ -1140,6 +1156,160 @@ export class OpencodeSdkSession extends EventEmitter {
         }
         return true;
     }
+    createTurnState(abortController, onProgress) {
+        const currentTurn = {
+            abortController,
+            assistantMessages: new Map(),
+            assistantMessageOrder: [],
+            activeAssistantMessageId: "",
+            messageRoles: new Map(),
+            pendingMessageEvents: new Map(),
+            fullText: "",
+            items: [],
+            lastAssistantInfo: null,
+            onProgress,
+            resolve: null,
+            reject: null,
+            settled: false,
+            terminalWorkingStatusEmitted: false,
+        };
+        const completionPromise = new Promise((resolve, reject) => {
+            currentTurn.resolve = resolve;
+            currentTurn.reject = reject;
+        });
+        return { currentTurn, completionPromise };
+    }
+    /**
+     * Model to summarize with: `session.summarize` requires one explicitly.
+     * Prefer what the session actually ran on (last turn, then its recent
+     * messages); the configured model is only a fallback.
+     */
+    async resolveCompactionModel() {
+        const fromInfo = (info) => {
+            const providerID = info?.providerID || info?.model?.providerID;
+            const modelID = info?.modelID || info?.model?.modelID;
+            return typeof providerID === "string" && providerID && typeof modelID === "string" && modelID
+                ? { providerID, modelID }
+                : null;
+        };
+        const lastModel = fromInfo(this.lastAssistantInfo);
+        if (lastModel) {
+            return lastModel;
+        }
+        if (typeof this.client?.session?.messages === "function") {
+            const messages = await this.requestOrThrow(this.client.session.messages({ sessionID: this.sessionId, limit: 20 }, { throwOnError: true, responseStyle: "data" })).catch((error) => {
+                this.trace(`compaction model lookup failed: ${extractErrorMessage(error)}`);
+                return [];
+            });
+            for (const entry of [...(Array.isArray(messages) ? messages : [])].reverse()) {
+                const model = fromInfo(entry?.info);
+                if (model) {
+                    return model;
+                }
+            }
+        }
+        const configured = typeof this.options.model === "string" ? this.options.model.trim() : "";
+        const slash = configured.indexOf("/");
+        if (slash > 0 && slash < configured.length - 1) {
+            return { providerID: configured.slice(0, slash), modelID: configured.slice(slash + 1) };
+        }
+        throw createTurnError("Opencode compaction needs a model, but none could be resolved for this session", {
+            reason: "compact_failed",
+        });
+    }
+    /**
+     * Manually compact via the server's `session.summarize` (what the TUI's
+     * `/compact` calls). It takes no focus instructions and answers `true`
+     * even when summarizing fails, so success is judged from the summary
+     * message itself.
+     *
+     * @param {import("../shared.js").CompactRequest} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").CompactResult>}
+     */
+    async runCompact(request = {}, { onProgress = null } = {}) {
+        if (this.closeRequested) {
+            throw this.createSessionClosedError();
+        }
+        if (this.currentTurn) {
+            throw createTurnError("Opencode turn already running", {
+                reason: "turn_already_running",
+            });
+        }
+        if (this.pendingHistorySeed || (!this.resumeSessionId && this.history.length === 0)) {
+            return { compact: { status: "noop", instructionsApplied: false }, usage: null, metadata: {} };
+        }
+        this.markTurnStartedStatus();
+        let model;
+        try {
+            await this.boot();
+            if (typeof this.client?.session?.summarize !== "function") {
+                throw new Error("Opencode summarize API is unavailable");
+            }
+            model = await this.resolveCompactionModel();
+        }
+        catch (error) {
+            await this.failPendingTurnStart(error, onProgress);
+            throw error;
+        }
+        const abortController = new AbortController();
+        const { currentTurn, completionPromise } = this.createTurnState(abortController, onProgress);
+        currentTurn.suppressReply = true;
+        this.currentTurn = currentTurn;
+        const closeGuard = this.createCloseGuard(() => {
+            abortController.abort();
+            void this.interruptCurrentTurn();
+        });
+        const turnTimeoutGuard = this.createTurnTimeoutGuard(() => {
+            abortController.abort();
+            void this.interruptCurrentTurn();
+        });
+        try {
+            await this.emitWorkingStatus({
+                phase: "context_compaction",
+                reply_in_progress: true,
+                status_line: statusLineForPhase("context_compaction"),
+            }, onProgress);
+            // The response only arrives once summarizing finishes, which can outlive
+            // fetch's header timeout; `session.idle` marks completion either way.
+            const summarize = this.requestOrThrow(this.client.session.summarize({ sessionID: this.sessionId, ...model, auto: false }, { throwOnError: true, responseStyle: "data", signal: abortController.signal })).catch((error) => (isHeadersTimeoutError(error) ? completionPromise : Promise.reject(error)));
+            await Promise.race([Promise.race([summarize, completionPromise]), closeGuard.promise, turnTimeoutGuard.promise]);
+            // Events trail the HTTP response on a separate stream; let idle land.
+            await Promise.race([completionPromise, delay(SUMMARY_EVENT_GRACE_MS)]);
+            const summaryInfo = currentTurn.lastAssistantInfo?.summary === true ? currentTurn.lastAssistantInfo : null;
+            if (summaryInfo?.error || summaryInfo?.finish === "error") {
+                throw createTurnError(`Opencode compaction failed: ${extractErrorMessage(summaryInfo.error?.data || summaryInfo.error) || "unknown error"}`, { reason: "compact_failed" });
+            }
+            await this.emitTerminalWorkingStatus(currentTurn, { phase: "turn_completed", status_done_line: "opencode compacted context" }, onProgress);
+            return {
+                // An empty session never gets here, so a summary whose events are
+                // still in flight counts as compacted.
+                compact: { status: "compacted", instructionsApplied: false },
+                usage: this.buildUsageFromAssistantInfo(summaryInfo),
+                metadata: { source: OPENCODE_PROVIDER_VARIANT, sessionId: this.sessionId || undefined, ...model },
+            };
+        }
+        catch (error) {
+            if (error?.reason === "turn_timeout") {
+                await this.interruptCurrentTurn();
+            }
+            if (!this.closeRequested && error?.reason !== "session_closed") {
+                await this.emitTerminalWorkingStatus(currentTurn, { phase: "turn_failed", status_done_line: extractErrorMessage(error) }, onProgress);
+            }
+            if (this.closeRequested && error?.reason !== "session_closed") {
+                throw this.createSessionClosedError();
+            }
+            throw error;
+        }
+        finally {
+            this.activeReplyTarget = "";
+            if (this.currentTurn === currentTurn) {
+                this.currentTurn = null;
+            }
+            closeGuard.cleanup();
+            turnTimeoutGuard.cleanup();
+        }
+    }
     async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null } = {}) {
         if (this.closeRequested) {
             throw this.createSessionClosedError();
@@ -1169,26 +1339,7 @@ export class OpencodeSdkSession extends EventEmitter {
         }
         this.history.push({ role: "user", content: promptText });
         const abortController = new AbortController();
-        const currentTurn = {
-            abortController,
-            assistantMessages: new Map(),
-            assistantMessageOrder: [],
-            activeAssistantMessageId: "",
-            messageRoles: new Map(),
-            pendingMessageEvents: new Map(),
-            fullText: "",
-            items: [],
-            lastAssistantInfo: null,
-            onProgress,
-            resolve: null,
-            reject: null,
-            settled: false,
-            terminalWorkingStatusEmitted: false,
-        };
-        const completionPromise = new Promise((resolve, reject) => {
-            currentTurn.resolve = resolve;
-            currentTurn.reject = reject;
-        });
+        const { currentTurn, completionPromise } = this.createTurnState(abortController, onProgress);
         this.currentTurn = currentTurn;
         const closeGuard = this.createCloseGuard(() => {
             abortController.abort();

package/dist/shared.d.ts

@@ -20,6 +20,18 @@ export function normalizeLogger(logger: any): any;
 export function emitLog(logger: any, message: any): void;
 export function truncateText(value: any, maxLen?: number): string;
 export function sanitizeForLog(value: any, maxLen?: number): string;
+/**
+ * Track tool calls that started but have not finished on a turn object, so
+ * `getCurrentTurnStatus()` can report what a long silent turn is running.
+ */
+export function noteToolStarted(turn: any, id: any, name: any, input: any): void;
+export function noteToolFinished(turn: any, id: any): void;
+/** Map a codex app-server (camelCase) or exec (snake_case) tool item to `{ name, input }`. */
+export function describeCodexToolItem(item: any): {
+    name: any;
+    input: any;
+} | null;
+export function withActiveTool(status: any, turn: any): any;
 export function isTruthyEnv(value: any): boolean;
 export function getBoundedEnvInt(envName: any, fallback: any, min: any, max: any): any;
 export function parseCommandParts(commandLine: any): {
@@ -87,6 +99,30 @@ export const TERMINAL_GOAL_STATUSES: ReadonlyArray<GoalStatus>;
  *
  * @typedef {Object} SessionCapabilities
  * @property {boolean} [goal]
+ * @property {boolean} [compact]
+ */
+/**
+ * Manual context compaction (`/compact`) contract for providers that
+ * implement the optional `runCompact` method and advertise
+ * `capabilities.compact === true`. Providers must NOT emit assistant messages
+ * while compacting; the caller renders the user-facing confirmation.
+ *
+ * @typedef {Object} CompactRequest
+ * @property {string} [instructions] Optional focus instructions; providers
+ *   whose backend cannot take them ignore them and report
+ *   `instructionsApplied: false`.
+ *
+ * @typedef {Object} CompactState
+ * @property {"compacted"|"noop"} status `noop` = nothing to compact.
+ * @property {boolean} instructionsApplied
+ * @property {number} [preTokens]
+ * @property {number} [postTokens]
+ * @property {number} [tokensRemoved]
+ *
+ * @typedef {Object} CompactResult
+ * @property {CompactState} compact
+ * @property {unknown} [usage]
+ * @property {Record<string, unknown>} [metadata]
  */
 /**
  * Default capabilities assigned to providers that do not opt into any optional
@@ -175,4 +211,46 @@ export type GoalResult = {
  */
 export type SessionCapabilities = {
     goal?: boolean | undefined;
+    compact?: boolean | undefined;
+};
+/**
+ * Manual context compaction (`/compact`) contract for providers that
+ * implement the optional `runCompact` method and advertise
+ * `capabilities.compact === true`. Providers must NOT emit assistant messages
+ * while compacting; the caller renders the user-facing confirmation.
+ */
+export type CompactRequest = {
+    /**
+     * Optional focus instructions; providers
+     * whose backend cannot take them ignore them and report
+     * `instructionsApplied: false`.
+     */
+    instructions?: string | undefined;
+};
+/**
+ * Manual context compaction (`/compact`) contract for providers that
+ * implement the optional `runCompact` method and advertise
+ * `capabilities.compact === true`. Providers must NOT emit assistant messages
+ * while compacting; the caller renders the user-facing confirmation.
+ */
+export type CompactState = {
+    /**
+     * `noop` = nothing to compact.
+     */
+    status: "compacted" | "noop";
+    instructionsApplied: boolean;
+    preTokens?: number | undefined;
+    postTokens?: number | undefined;
+    tokensRemoved?: number | undefined;
+};
+/**
+ * Manual context compaction (`/compact`) contract for providers that
+ * implement the optional `runCompact` method and advertise
+ * `capabilities.compact === true`. Providers must NOT emit assistant messages
+ * while compacting; the caller renders the user-facing confirmation.
+ */
+export type CompactResult = {
+    compact: CompactState;
+    usage?: unknown;
+    metadata?: Record<string, unknown> | undefined;
 };

package/dist/shared.js

@@ -80,6 +80,30 @@ export function isTerminalGoalStatus(value) {
  *
  * @typedef {Object} SessionCapabilities
  * @property {boolean} [goal]
+ * @property {boolean} [compact]
+ */
+/**
+ * Manual context compaction (`/compact`) contract for providers that
+ * implement the optional `runCompact` method and advertise
+ * `capabilities.compact === true`. Providers must NOT emit assistant messages
+ * while compacting; the caller renders the user-facing confirmation.
+ *
+ * @typedef {Object} CompactRequest
+ * @property {string} [instructions] Optional focus instructions; providers
+ *   whose backend cannot take them ignore them and report
+ *   `instructionsApplied: false`.
+ *
+ * @typedef {Object} CompactState
+ * @property {"compacted"|"noop"} status `noop` = nothing to compact.
+ * @property {boolean} instructionsApplied
+ * @property {number} [preTokens]
+ * @property {number} [postTokens]
+ * @property {number} [tokensRemoved]
+ *
+ * @typedef {Object} CompactResult
+ * @property {CompactState} compact
+ * @property {unknown} [usage]
+ * @property {Record<string, unknown>} [metadata]
  */
 /**
  * Default capabilities assigned to providers that do not opt into any optional
@@ -87,7 +111,7 @@ export function isTerminalGoalStatus(value) {
  *
  * @type {Readonly<SessionCapabilities>}
  */
-export const DEFAULT_SESSION_CAPABILITIES = Object.freeze({ goal: false });
+export const DEFAULT_SESSION_CAPABILITIES = Object.freeze({ goal: false, compact: false });
 /**
  * Resolve a session's capability snapshot, falling back to
  * {@link DEFAULT_SESSION_CAPABILITIES}.
@@ -146,6 +170,76 @@ export function sanitizeForLog(value, maxLen = 180) {
         return "";
     return truncateText(String(value).replace(/\s+/g, " ").trim(), maxLen);
 }
+const TOOL_INPUT_SUMMARY_KEYS = ["command", "cmd", "file_path", "filePath", "path", "pattern", "query", "url", "description", "prompt"];
+function summarizeToolInput(input) {
+    let value = input;
+    if (typeof value === "string" && /^\s*[[{]/.test(value)) {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            // keep the raw string
+        }
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const key = TOOL_INPUT_SUMMARY_KEYS.find((candidate) => value[candidate]);
+        value = key ? value[key] : JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        value = value.join(" ");
+    }
+    return sanitizeForLog(value, 200) || undefined;
+}
+/**
+ * Track tool calls that started but have not finished on a turn object, so
+ * `getCurrentTurnStatus()` can report what a long silent turn is running.
+ */
+export function noteToolStarted(turn, id, name, input) {
+    if (!turn || !id || !name) {
+        return;
+    }
+    turn.activeTools ||= new Map();
+    const key = String(id);
+    if (turn.activeTools.has(key)) {
+        return;
+    }
+    turn.activeTools.set(key, {
+        name: String(name),
+        summary: summarizeToolInput(input),
+        started_at: new Date().toISOString(),
+    });
+}
+export function noteToolFinished(turn, id) {
+    if (id) {
+        turn?.activeTools?.delete(String(id));
+    }
+}
+/** Map a codex app-server (camelCase) or exec (snake_case) tool item to `{ name, input }`. */
+export function describeCodexToolItem(item) {
+    switch (String(item?.type || "").replace(/_/g, "").toLowerCase()) {
+        case "commandexecution":
+            return { name: "command", input: item.command };
+        case "filechange":
+            return { name: "apply_patch", input: (item.changes || []).map((change) => change?.path).join(" ") };
+        case "mcptoolcall":
+            return { name: [item.server, item.tool].filter(Boolean).join("."), input: item.arguments };
+        case "dynamictoolcall":
+        case "collabagenttoolcall":
+            return { name: item.tool, input: item.arguments ?? item.prompt };
+        case "websearch":
+            return { name: "web_search", input: item.query };
+        default:
+            return null;
+    }
+}
+export function withActiveTool(status, turn) {
+    if (!status) {
+        return null;
+    }
+    const tools = turn?.activeTools ? [...turn.activeTools.values()] : [];
+    const activeTool = tools[tools.length - 1];
+    return activeTool ? { ...status, active_tool: { ...activeTool } } : { ...status };
+}
 export function isTruthyEnv(value) {
     if (value === undefined || value === null)
         return false;

package/dist/worker.js

@@ -76,7 +76,7 @@ async function handleRequest(message) {
         throw new Error(`Unsupported worker method: ${method}`);
     }
     const args = Array.isArray(message.args) ? [...message.args] : [];
-    if (method === "runTurn" || method === "runGoal") {
+    if (method === "runTurn" || method === "runGoal" || method === "runCompact") {
         const firstArg = args[0];
         const options = args[1] && typeof args[1] === "object" ? { ...args[1] } : {};
         options.onProgress = (payload) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -53,12 +53,12 @@
     "zod": "^4.1.5"
   },
   "optionalDependencies": {
-    "@love-moon/chat-web": "^0.13.0"
+    "@love-moon/chat-web": "^0.13.2"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "e1e507f"
+  "gitCommitId": "d60a6a2"
 }