@martian-engineering/lossless-claw 0.2.8 → 0.4.0

package/openclaw.plugin.json

@@ -17,13 +17,33 @@
       "label": "Database Path",
       "help": "Path to LCM SQLite database (default: ~/.openclaw/lcm.db)"
     },
+    "ignoreSessionPatterns": {
+      "label": "Ignored Sessions",
+      "help": "Glob patterns for session keys to exclude from LCM storage"
+    },
+    "statelessSessionPatterns": {
+      "label": "Stateless Sessions",
+      "help": "Glob patterns for session keys that can read from LCM but never write to it"
+    },
+    "skipStatelessSessions": {
+      "label": "Skip Stateless Sessions",
+      "help": "When enabled, matching stateless session keys skip LCM persistence and grant writes"
+    },
     "summaryModel": {
       "label": "Summary Model",
-      "help": "Model override for LCM summarization (e.g., 'gpt-5.4' or 'openai-resp/gpt-5.4')"
+      "help": "Model override for LCM summarization (e.g., 'gpt-5.4' to reuse the session provider, or 'openai-resp/gpt-5.4' for a full cross-provider ref)"
     },
     "summaryProvider": {
       "label": "Summary Provider",
-      "help": "Provider override for LCM summarization (e.g., 'openai-resp')"
+      "help": "Provider override used only when summaryModel is a bare model name (e.g., 'openai-resp')"
+    },
+    "expansionModel": {
+      "label": "Expansion Model",
+      "help": "Model override for lcm_expand_query sub-agent (e.g., 'anthropic/claude-haiku-4-5')"
+    },
+    "expansionProvider": {
+      "label": "Expansion Provider",
+      "help": "Provider override for lcm_expand_query sub-agent (e.g., 'anthropic')"
     }
   },
   "configSchema": {
@@ -61,6 +81,21 @@
       "dbPath": {
         "type": "string"
       },
+      "ignoreSessionPatterns": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      },
+      "statelessSessionPatterns": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      },
+      "skipStatelessSessions": {
+        "type": "boolean"
+      },
       "largeFileThresholdTokens": {
         "type": "integer",
         "minimum": 1000
@@ -70,6 +105,12 @@
       },
       "summaryProvider": {
         "type": "string"
+      },
+      "expansionModel": {
+        "type": "string"
+      },
+      "expansionProvider": {
+        "type": "string"
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martian-engineering/lossless-claw",
-  "version": "0.2.8",
+  "version": "0.4.0",
   "description": "Lossless Context Management plugin for OpenClaw — DAG-based conversation summarization with incremental compaction",
   "type": "module",
   "main": "index.ts",
@@ -15,6 +15,12 @@
     "conversation-memory",
     "dag"
   ],
+  "scripts": {
+    "changeset": "changeset",
+    "release:verify": "npm test && npm pack --dry-run",
+    "test": "vitest run --dir test",
+    "version-packages": "changeset version"
+  },
   "files": [
     "index.ts",
     "src/**/*.ts",
@@ -23,21 +29,22 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "test": "vitest run --dir test"
-  },
   "dependencies": {
     "@mariozechner/pi-agent-core": "*",
     "@mariozechner/pi-ai": "*",
     "@sinclair/typebox": "0.34.48"
   },
   "devDependencies": {
+    "@changesets/cli": "^2.30.0",
     "typescript": "^5.7.0",
     "vitest": "^3.0.0"
   },
   "peerDependencies": {
     "openclaw": "*"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "openclaw": {
     "extensions": [
       "./index.ts"

package/src/assembler.ts

@@ -65,7 +65,7 @@ function buildSystemPromptAddition(summarySignals: SummaryPromptSignal[]): strin
     "",
     "Summaries above are compressed context — maps to details, not the details themselves.",
     "",
-    "**Recall priority:** LCM tools first, then qmd (for Granola/Limitless/pre-LCM data), then memory_search as last resort.",
+    "**Recall priority:** Use LCM tools first for compacted conversation history. If LCM does not cover the needed data, prefer any available memory/recall tool before falling back to raw text search.",
     "",
     "**Tool escalation:**",
     "1. `lcm_grep` — search by regex or full-text across messages and summaries",
@@ -211,7 +211,8 @@ function tryRestoreOpenAIReasoning(raw: Record<string, unknown>): Record<string,
   return null;
 }
 
-function toolCallBlockFromPart(part: MessagePartRecord, rawType?: string): unknown {
+/** @internal Exported for testing only. */
+export function toolCallBlockFromPart(part: MessagePartRecord, rawType?: string): unknown {
   const type =
     rawType === "function_call" ||
     rawType === "functionCall" ||
@@ -245,7 +246,10 @@ function toolCallBlockFromPart(part: MessagePartRecord, rawType?: string): unkno
   }
 
   if (input !== undefined) {
-    if (type === "functionCall") {
+    // toolCall and functionCall use "arguments" (consumed by OpenAI/xAI Chat
+    // Completions extractToolCalls and Responses API paths in OpenClaw).
+    // tool_use and variants use "input" (Anthropic native format).
+    if (type === "functionCall" || type === "toolCall") {
       block.arguments = input;
     } else {
       block.input = input;
@@ -254,13 +258,40 @@ function toolCallBlockFromPart(part: MessagePartRecord, rawType?: string): unkno
   return block;
 }
 
-function toolResultBlockFromPart(part: MessagePartRecord, rawType?: string): unknown {
+/** @internal Exported for testing only. */
+export function toolResultBlockFromPart(
+  part: MessagePartRecord,
+  rawType?: string,
+  raw?: Record<string, unknown>,
+): unknown {
   const type =
     rawType === "function_call_output" || rawType === "toolResult" || rawType === "tool_result"
       ? rawType
       : "tool_result";
-  const output = parseStoredValue(part.toolOutput) ?? part.textContent ?? "";
-  const block: Record<string, unknown> = { type, output };
+  const output = parseStoredValue(part.toolOutput);
+  const block: Record<string, unknown> = { type };
+
+  if (typeof part.toolName === "string" && part.toolName.length > 0) {
+    block.name = part.toolName;
+  }
+
+  if (output !== undefined) {
+    block.output = output;
+  } else if (typeof part.textContent === "string") {
+    block.output = part.textContent;
+  } else if (raw && raw.output !== undefined) {
+    block.output = raw.output;
+  } else if (raw && raw.content !== undefined) {
+    block.content = raw.content;
+  } else {
+    block.output = "";
+  }
+
+  if (raw && typeof raw.is_error === "boolean") {
+    block.is_error = raw.is_error;
+  } else if (raw && typeof raw.isError === "boolean") {
+    block.isError = raw.isError;
+  }
 
   if (type === "function_call_output") {
     if (typeof part.toolCallId === "string" && part.toolCallId.length > 0) {
@@ -303,14 +334,34 @@ function toRuntimeRole(
   return "user"; // user | system
 }
 
-function blockFromPart(part: MessagePartRecord): unknown {
+/** @internal Exported for testing only. */
+export function blockFromPart(part: MessagePartRecord): unknown {
   const metadata = getPartMetadata(part);
   if (metadata.raw && typeof metadata.raw === "object") {
     // If this is an OpenClaw-normalised OpenAI reasoning block, restore the original
     // OpenAI format so the Responses API gets the {type:"reasoning", id:"rs_…"} it expects.
     const restored = tryRestoreOpenAIReasoning(metadata.raw as Record<string, unknown>);
     if (restored) return restored;
-    return metadata.raw;
+
+    // Don't return raw for tool call/result blocks — they need to go through
+    // toolCallBlockFromPart/toolResultBlockFromPart which properly normalize
+    // arguments (stringify if object) and format for the target provider.
+    // Returning raw here causes arguments to be passed as a JS object instead
+    // of a JSON string, which breaks xAI/OpenAI Chat Completions API (422).
+    const rawType = (metadata.raw as Record<string, unknown>).type as string | undefined;
+    const isToolBlock =
+      rawType === "toolCall" ||
+      rawType === "tool_use" ||
+      rawType === "tool-use" ||
+      rawType === "toolUse" ||
+      rawType === "functionCall" ||
+      rawType === "function_call" ||
+      rawType === "function_call_output" ||
+      rawType === "toolResult" ||
+      rawType === "tool_result";
+    if (!isToolBlock) {
+      return metadata.raw;
+    }
   }
 
   if (part.partType === "reasoning") {
@@ -318,7 +369,13 @@ function blockFromPart(part: MessagePartRecord): unknown {
   }
   if (part.partType === "tool") {
     if (metadata.originalRole === "toolResult" || metadata.rawType === "function_call_output") {
-      return toolResultBlockFromPart(part, metadata.rawType);
+      return toolResultBlockFromPart(
+        part,
+        metadata.rawType,
+        metadata.raw && typeof metadata.raw === "object"
+          ? (metadata.raw as Record<string, unknown>)
+          : undefined,
+      );
     }
     return toolCallBlockFromPart(part, metadata.rawType);
   }
@@ -337,7 +394,13 @@ function blockFromPart(part: MessagePartRecord): unknown {
     metadata.rawType === "tool_result" ||
     metadata.rawType === "toolResult"
   ) {
-    return toolResultBlockFromPart(part, metadata.rawType);
+    return toolResultBlockFromPart(
+      part,
+      metadata.rawType,
+      metadata.raw && typeof metadata.raw === "object"
+        ? (metadata.raw as Record<string, unknown>)
+        : undefined,
+    );
   }
   if (part.partType === "text") {
     return { type: "text", text: part.textContent ?? "" };
@@ -395,6 +458,10 @@ function pickToolCallId(parts: MessagePartRecord[]): string | undefined {
     if (!decoded || typeof decoded !== "object") {
       continue;
     }
+    const metadataToolCallId = (decoded as { toolCallId?: unknown }).toolCallId;
+    if (typeof metadataToolCallId === "string" && metadataToolCallId.length > 0) {
+      return metadataToolCallId;
+    }
     const raw = (decoded as { raw?: unknown }).raw;
     if (!raw || typeof raw !== "object") {
       continue;
@@ -411,6 +478,49 @@ function pickToolCallId(parts: MessagePartRecord[]): string | undefined {
   return undefined;
 }
 
+function pickToolName(parts: MessagePartRecord[]): string | undefined {
+  for (const part of parts) {
+    if (typeof part.toolName === "string" && part.toolName.length > 0) {
+      return part.toolName;
+    }
+    const decoded = parseJson(part.metadata);
+    if (!decoded || typeof decoded !== "object") {
+      continue;
+    }
+    const metadataToolName = (decoded as { toolName?: unknown }).toolName;
+    if (typeof metadataToolName === "string" && metadataToolName.length > 0) {
+      return metadataToolName;
+    }
+    const raw = (decoded as { raw?: unknown }).raw;
+    if (!raw || typeof raw !== "object") {
+      continue;
+    }
+    const maybe = (raw as { name?: unknown }).name;
+    if (typeof maybe === "string" && maybe.length > 0) {
+      return maybe;
+    }
+    const maybeCamel = (raw as { toolName?: unknown }).toolName;
+    if (typeof maybeCamel === "string" && maybeCamel.length > 0) {
+      return maybeCamel;
+    }
+  }
+  return undefined;
+}
+
+function pickToolIsError(parts: MessagePartRecord[]): boolean | undefined {
+  for (const part of parts) {
+    const decoded = parseJson(part.metadata);
+    if (!decoded || typeof decoded !== "object") {
+      continue;
+    }
+    const metadataIsError = (decoded as { isError?: unknown }).isError;
+    if (typeof metadataIsError === "boolean") {
+      return metadataIsError;
+    }
+  }
+  return undefined;
+}
+
 /** Format a Date for XML attributes in the agent's timezone. */
 function formatDateForAttribute(date: Date, timezone?: string): string {
   const tz = timezone ?? "UTC";
@@ -674,16 +784,19 @@ export class ContextAssembler {
 
     const parts = await this.conversationStore.getMessageParts(msg.messageId);
     const roleFromStore = toRuntimeRole(msg.role, parts);
-    const toolCallId = roleFromStore === "toolResult" ? pickToolCallId(parts) : undefined;
+    const isToolResult = roleFromStore === "toolResult";
+    const toolCallId = isToolResult ? pickToolCallId(parts) : undefined;
+    const toolName = isToolResult ? (pickToolName(parts) ?? "unknown") : undefined;
+    const toolIsError = isToolResult ? pickToolIsError(parts) : undefined;
     // Tool results without a call id cannot be serialized for Anthropic-compatible APIs.
     // This happens for legacy/bootstrap rows that have role=tool but no message_parts.
     // Preserve the text by degrading to assistant content instead of emitting invalid toolResult.
     const role: "user" | "assistant" | "toolResult" =
-      roleFromStore === "toolResult" && !toolCallId ? "assistant" : roleFromStore;
+      isToolResult && !toolCallId ? "assistant" : roleFromStore;
     const content = contentFromParts(parts, role, msg.content);
     const contentText =
       typeof content === "string" ? content : (JSON.stringify(content) ?? msg.content);
-    const tokenCount = msg.tokenCount > 0 ? msg.tokenCount : estimateTokens(contentText);
+    const tokenCount = estimateTokens(contentText);
 
     // Cast: these are reconstructed from DB storage, not live agent messages,
     // so they won't carry the full AgentMessage metadata (timestamp, usage, etc.)
@@ -713,6 +826,8 @@ export class ContextAssembler {
               role,
               content,
               ...(toolCallId ? { toolCallId } : {}),
+              ...(toolName ? { toolName } : {}),
+              ...(role === "toolResult" && toolIsError !== undefined ? { isError: toolIsError } : {}),
             } as AgentMessage),
       tokens: tokenCount,
       isMessage: true,

package/src/compaction.ts

@@ -86,7 +86,7 @@ function estimateTokens(content: string): number {
 }
 
 /** Format a timestamp as `YYYY-MM-DD HH:mm TZ` for prompt source text. */
-function formatTimestamp(value: Date, timezone: string = "UTC"): string {
+export function formatTimestamp(value: Date, timezone: string = "UTC"): string {
   try {
     const fmt = new Intl.DateTimeFormat("en-CA", {
       timeZone: timezone,
@@ -282,6 +282,14 @@ export class CompactionEngine {
       summarize,
       previousSummaryContent,
     );
+    if (!leafResult) {
+      return {
+        actionTaken: false,
+        tokensBefore,
+        tokensAfter: tokensBefore,
+        condensed: false,
+      };
+    }
     const tokensAfterLeaf = await this.summaryStore.getContextTokenCount(conversationId);
 
     await this.persistCompactionEvents({
@@ -315,6 +323,9 @@ export class CompactionEngine {
           targetDepth,
           summarize,
         );
+        if (!condenseResult) {
+          break;
+        }
         const passTokensAfter = await this.summaryStore.getContextTokenCount(conversationId);
         await this.persistCompactionEvents({
           conversationId,
@@ -406,6 +417,9 @@ export class CompactionEngine {
         summarize,
         previousSummaryContent,
       );
+      if (!leafResult) {
+        break;
+      }
       const passTokensAfter = await this.summaryStore.getContextTokenCount(conversationId);
       await this.persistCompactionEvents({
         conversationId,
@@ -421,6 +435,10 @@ export class CompactionEngine {
       level = leafResult.level;
       previousSummaryContent = leafResult.content;
 
+      if (!force && passTokensAfter <= threshold) {
+        previousTokens = passTokensAfter;
+        break;
+      }
       if (passTokensAfter >= passTokensBefore || passTokensAfter >= previousTokens) {
         break;
       }
@@ -428,7 +446,7 @@ export class CompactionEngine {
     }
 
     // Phase 2: depth-aware condensed passes, always processing shallowest depth first.
-    while (true) {
+    while (force || previousTokens > threshold) {
       const candidate = await this.selectShallowestCondensationCandidate({
         conversationId,
         hardTrigger: hardTrigger === true,
@@ -444,6 +462,9 @@ export class CompactionEngine {
         candidate.targetDepth,
         summarize,
       );
+      if (!condenseResult) {
+        break;
+      }
       const passTokensAfter = await this.summaryStore.getContextTokenCount(conversationId);
       await this.persistCompactionEvents({
         conversationId,
@@ -459,6 +480,10 @@ export class CompactionEngine {
       createdSummaryId = condenseResult.summaryId;
       level = condenseResult.level;
 
+      if (!force && passTokensAfter <= threshold) {
+        previousTokens = passTokensAfter;
+        break;
+      }
       if (passTokensAfter >= passTokensBefore || passTokensAfter >= previousTokens) {
         break;
       }
@@ -964,7 +989,7 @@ export class CompactionEngine {
     sourceText: string;
     summarize: CompactionSummarizeFn;
     options?: CompactionSummarizeOptions;
-  }): Promise<{ content: string; level: CompactionLevel }> {
+  }): Promise<{ content: string; level: CompactionLevel } | null> {
     const sourceText = params.sourceText.trim();
     if (!sourceText) {
       return {
@@ -974,11 +999,25 @@ export class CompactionEngine {
     }
     const inputTokens = Math.max(1, estimateTokens(sourceText));
 
-    let summaryText = await params.summarize(sourceText, false, params.options);
+    const runSummarizer = async (aggressiveMode: boolean): Promise<string | null> => {
+      const output = await params.summarize(sourceText, aggressiveMode, params.options);
+      const trimmed = output.trim();
+      return trimmed || null;
+    };
+
+    const initialSummary = await runSummarizer(false);
+    if (initialSummary === null) {
+      return null;
+    }
+    let summaryText = initialSummary;
     let level: CompactionLevel = "normal";
 
     if (estimateTokens(summaryText) >= inputTokens) {
-      summaryText = await params.summarize(sourceText, true, params.options);
+      const aggressiveSummary = await runSummarizer(true);
+      if (aggressiveSummary === null) {
+        return null;
+      }
+      summaryText = aggressiveSummary;
       level = "aggressive";
 
       if (estimateTokens(summaryText) >= inputTokens) {
@@ -986,7 +1025,8 @@ export class CompactionEngine {
           sourceText.length > FALLBACK_MAX_CHARS
             ? sourceText.slice(0, FALLBACK_MAX_CHARS)
             : sourceText;
-        summaryText = `${truncated}\n[Truncated from ${inputTokens} tokens]`;
+        summaryText = `${truncated}
+[Truncated from ${inputTokens} tokens]`;
         level = "fallback";
       }
     }
@@ -1004,7 +1044,7 @@ export class CompactionEngine {
     messageItems: ContextItemRecord[],
     summarize: CompactionSummarizeFn,
     previousSummaryContent?: string,
-  ): Promise<{ summaryId: string; level: CompactionLevel; content: string }> {
+  ): Promise<{ summaryId: string; level: CompactionLevel; content: string } | null> {
     // Fetch full message content for each context item
     const messageContents: { messageId: number; content: string; createdAt: Date; tokenCount: number }[] =
       [];
@@ -1037,6 +1077,12 @@ export class CompactionEngine {
         isCondensed: false,
       },
     });
+    if (!summary) {
+      console.warn(
+        `[lcm] leaf summarizer returned empty content; conversationId=${conversationId}; chunkMessages=${messageContents.length}; skipping leaf chunk`,
+      );
+      return null;
+    }
 
     // Persist the leaf summary
     const summaryId = generateSummaryId(summary.content);
@@ -1095,7 +1141,7 @@ export class CompactionEngine {
     summaryItems: ContextItemRecord[],
     targetDepth: number,
     summarize: CompactionSummarizeFn,
-  ): Promise<PassResult> {
+  ): Promise<PassResult | null> {
     // Fetch full summary records
     const summaryRecords: SummaryRecord[] = [];
     for (const item of summaryItems) {
@@ -1136,6 +1182,12 @@ export class CompactionEngine {
         depth: targetDepth + 1,
       },
     });
+    if (!condensed) {
+      console.warn(
+        `[lcm] condensed summarizer returned empty content; conversationId=${conversationId}; depth=${targetDepth}; chunkSummaries=${summaryRecords.length}; skipping condensed chunk`,
+      );
+      return null;
+    }
 
     // Persist the condensed summary
     const summaryId = generateSummaryId(condensed.content);

package/src/db/config.ts

@@ -4,6 +4,12 @@ import { join } from "path";
 export type LcmConfig = {
   enabled: boolean;
   databasePath: string;
+  /** Glob patterns for session keys to exclude from LCM storage entirely. */
+  ignoreSessionPatterns: string[];
+  /** Glob patterns for session keys that may read from LCM but never write to it. */
+  statelessSessionPatterns: string[];
+  /** When true, stateless session pattern matching is enforced. */
+  skipStatelessSessions: boolean;
   contextThreshold: number;
   freshTailCount: number;
   leafMinFanout: number;
@@ -15,10 +21,22 @@ export type LcmConfig = {
   condensedTargetTokens: number;
   maxExpandTokens: number;
   largeFileTokenThreshold: number;
+  /** Provider override for compaction summarization. */
+  summaryProvider: string;
+  /** Model override for compaction summarization. */
+  summaryModel: string;
   /** Provider override for large-file text summarization. */
   largeFileSummaryProvider: string;
   /** Model override for large-file text summarization. */
   largeFileSummaryModel: string;
+  /** Model override for conversation summarization. */
+  summaryModel: string;
+  /** Provider override for conversation summarization. */
+  summaryProvider: string;
+  /** Provider override for lcm_expand_query sub-agent. */
+  expansionProvider: string;
+  /** Model override for lcm_expand_query sub-agent. */
+  expansionModel: string;
   autocompactDisabled: boolean;
   /** IANA timezone for timestamps in summaries (from TZ env or system default) */
   timezone: string;
@@ -53,6 +71,24 @@ function toStr(value: unknown): string | undefined {
   return undefined;
 }
 
+/** Coerce a plugin config value into a trimmed string array when possible. */
+function toStrArray(value: unknown): string[] | undefined {
+  if (Array.isArray(value)) {
+    const normalized = value
+      .map((entry) => toStr(entry))
+      .filter((entry): entry is string => typeof entry === "string");
+    return normalized.length > 0 ? normalized : [];
+  }
+  const single = toStr(value);
+  if (!single) {
+    return undefined;
+  }
+  return single
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
 /**
  * Resolve LCM configuration with three-tier precedence:
  *   1. Environment variables (highest — backward compat)
@@ -75,6 +111,24 @@ export function resolveLcmConfig(
       ?? toStr(pc.dbPath)
       ?? toStr(pc.databasePath)
       ?? join(homedir(), ".openclaw", "lcm.db"),
+    ignoreSessionPatterns:
+      env.LCM_IGNORE_SESSION_PATTERNS !== undefined
+        ? env.LCM_IGNORE_SESSION_PATTERNS
+          .split(",")
+          .map((entry) => entry.trim())
+          .filter(Boolean)
+        : toStrArray(pc.ignoreSessionPatterns) ?? [],
+    statelessSessionPatterns:
+      env.LCM_STATELESS_SESSION_PATTERNS !== undefined
+        ? env.LCM_STATELESS_SESSION_PATTERNS
+          .split(",")
+          .map((entry) => entry.trim())
+          .filter(Boolean)
+        : toStrArray(pc.statelessSessionPatterns) ?? [],
+    skipStatelessSessions:
+      env.LCM_SKIP_STATELESS_SESSIONS !== undefined
+        ? env.LCM_SKIP_STATELESS_SESSIONS === "true"
+        : toBool(pc.skipStatelessSessions) ?? true,
     contextThreshold:
       (env.LCM_CONTEXT_THRESHOLD !== undefined ? parseFloat(env.LCM_CONTEXT_THRESHOLD) : undefined)
         ?? toNumber(pc.contextThreshold) ?? 0.75,
@@ -110,10 +164,18 @@ export function resolveLcmConfig(
         ?? toNumber(pc.largeFileThresholdTokens)
         ?? toNumber(pc.largeFileTokenThreshold)
         ?? 25000,
+    summaryProvider:
+      env.LCM_SUMMARY_PROVIDER?.trim() ?? toStr(pc.summaryProvider) ?? "",
+    summaryModel:
+      env.LCM_SUMMARY_MODEL?.trim() ?? toStr(pc.summaryModel) ?? "",
     largeFileSummaryProvider:
       env.LCM_LARGE_FILE_SUMMARY_PROVIDER?.trim() ?? toStr(pc.largeFileSummaryProvider) ?? "",
     largeFileSummaryModel:
       env.LCM_LARGE_FILE_SUMMARY_MODEL?.trim() ?? toStr(pc.largeFileSummaryModel) ?? "",
+    expansionProvider:
+      env.LCM_EXPANSION_PROVIDER?.trim() ?? toStr(pc.expansionProvider) ?? "",
+    expansionModel:
+      env.LCM_EXPANSION_MODEL?.trim() ?? toStr(pc.expansionModel) ?? "",
     autocompactDisabled:
       env.LCM_AUTOCOMPACT_DISABLED !== undefined
         ? env.LCM_AUTOCOMPACT_DISABLED === "true"