@martian-engineering/lossless-claw 0.5.2 → 0.5.3

package/src/plugin/index.ts

@@ -228,6 +228,30 @@ function readDefaultModelFromConfig(config: unknown): string {
   return typeof primary === "string" ? primary.trim() : "";
 }
 
+/** Read OpenClaw's configured compaction model from the validated runtime config. */
+function readCompactionModelFromConfig(config: unknown): string {
+  if (!config || typeof config !== "object") {
+    return "";
+  }
+
+  const compaction = (config as {
+    agents?: {
+      defaults?: {
+        compaction?: {
+          model?: unknown;
+        };
+      };
+    };
+  }).agents?.defaults?.compaction;
+  const model = compaction?.model;
+  if (typeof model === "string") {
+    return model.trim();
+  }
+
+  const primary = (model as { primary?: unknown } | undefined)?.primary;
+  return typeof primary === "string" ? primary.trim() : "";
+}
+
 /** Format a provider/model pair for logs. */
 function formatProviderModel(params: { provider: string; model: string }): string {
   return `${params.provider}/${params.model}`;
@@ -236,11 +260,28 @@ function formatProviderModel(params: { provider: string; model: string }): strin
 /** Build a startup log showing which compaction model LCM will use. */
 function buildCompactionModelLog(params: {
   config: LcmConfig;
-  defaultModelRef: string;
+  openClawConfig: unknown;
   defaultProvider: string;
 }): string {
-  const usingOverride = Boolean(params.config.summaryModel || params.config.summaryProvider);
-  const raw = (params.config.summaryModel || params.defaultModelRef).trim();
+  const envSummaryModel = process.env.LCM_SUMMARY_MODEL?.trim() ?? "";
+  const envSummaryProvider = process.env.LCM_SUMMARY_PROVIDER?.trim() ?? "";
+  const pluginSummaryModel = params.config.summaryModel.trim();
+  const pluginSummaryProvider = params.config.summaryProvider.trim();
+  const compactionModelRef = readCompactionModelFromConfig(params.openClawConfig);
+  const defaultModelRef = readDefaultModelFromConfig(params.openClawConfig);
+  const selected =
+    envSummaryModel
+      ? { raw: envSummaryModel, source: "override" as const }
+      : pluginSummaryModel
+        ? { raw: pluginSummaryModel, source: "override" as const }
+        : compactionModelRef
+          ? { raw: compactionModelRef, source: "override" as const }
+          : defaultModelRef
+            ? { raw: defaultModelRef, source: "default" as const }
+            : undefined;
+  const usingOverride =
+    selected?.source === "override" || Boolean(envSummaryProvider || pluginSummaryProvider);
+  const raw = selected?.raw.trim() ?? "";
   if (!raw) {
     return "[lcm] Compaction summarization model: (unconfigured)";
   }
@@ -256,7 +297,12 @@ function buildCompactionModelLog(params: {
     }
   }
 
-  const provider = (params.config.summaryProvider || params.defaultProvider || "openai").trim();
+  const provider = (
+    envSummaryProvider ||
+    pluginSummaryProvider ||
+    params.defaultProvider ||
+    "openai"
+  ).trim();
   return `[lcm] Compaction summarization model: ${formatProviderModel({
     provider,
     model: raw,
@@ -1037,6 +1083,64 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
     api.logger.warn(buildLegacyAuthFallbackWarning());
   }
 
+  /** Resolve the best config object to hand to runtime.modelAuth for this lookup. */
+  const resolveModelAuthConfig = (runtimeConfig: unknown): OpenClawPluginApi["config"] => {
+    if (runtimeConfig && typeof runtimeConfig === "object") {
+      return runtimeConfig as OpenClawPluginApi["config"];
+    }
+    return api.config;
+  };
+
+  /** Resolve an API key without throwing so summarizer auth fallback can retry safely. */
+  const lookupApiKey = async (
+    provider: string,
+    model: string,
+    options?: {
+      profileId?: string;
+      preferredProfile?: string;
+      agentDir?: string;
+      runtimeConfig?: unknown;
+      skipModelAuth?: boolean;
+    },
+  ): Promise<string | undefined> => {
+    const modelAuthConfig = resolveModelAuthConfig(options?.runtimeConfig);
+
+    if (modelAuth && options?.skipModelAuth !== true) {
+      try {
+        const modelAuthKey = resolveApiKeyFromAuthResult(
+          await modelAuth.getApiKeyForModel({
+            model: buildModelAuthLookupModel({ provider, model }),
+            cfg: modelAuthConfig,
+            ...(options?.profileId ? { profileId: options.profileId } : {}),
+            ...(options?.preferredProfile ? { preferredProfile: options.preferredProfile } : {}),
+          }),
+        );
+        if (modelAuthKey) {
+          return modelAuthKey;
+        }
+      } catch {
+        // Fall through to env/auth-profile lookup for older or scope-limited runtimes.
+      }
+    }
+
+    const envKey = resolveApiKey(provider, readEnv);
+    if (envKey) {
+      return envKey;
+    }
+
+    const piAiModuleId = "@mariozechner/pi-ai";
+    const mod = (await import(piAiModuleId)) as PiAiModule;
+    return resolveApiKeyFromAuthProfiles({
+      provider,
+      authProfileId: options?.profileId,
+      agentDir: options?.agentDir ?? api.resolvePath("."),
+      runtimeConfig: options?.runtimeConfig,
+      appConfig: api.config,
+      piAiModule: mod,
+      envSnapshot,
+    });
+  };
+
   return {
     config,
     complete: async ({
@@ -1349,76 +1453,10 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
       return { provider, model: raw };
     },
     getApiKey: async (provider, model, options) => {
-      if (modelAuth) {
-        try {
-          const modelAuthKey = resolveApiKeyFromAuthResult(
-            await modelAuth.getApiKeyForModel({
-              model: buildModelAuthLookupModel({ provider, model }),
-              cfg: api.config,
-              ...(options?.profileId ? { profileId: options.profileId } : {}),
-              ...(options?.preferredProfile ? { preferredProfile: options.preferredProfile } : {}),
-            }),
-          );
-          if (modelAuthKey) {
-            return modelAuthKey;
-          }
-        } catch {
-          // Fall through to auth-profile lookup for older OpenClaw runtimes.
-        }
-      }
-
-      const envKey = resolveApiKey(provider, readEnv);
-      if (envKey) {
-        return envKey;
-      }
-
-      const piAiModuleId = "@mariozechner/pi-ai";
-      const mod = (await import(piAiModuleId)) as PiAiModule;
-      return resolveApiKeyFromAuthProfiles({
-        provider,
-        authProfileId: options?.profileId,
-        agentDir: api.resolvePath("."),
-        runtimeConfig: api.config,
-        piAiModule: mod,
-        envSnapshot,
-      });
+      return lookupApiKey(provider, model, options);
     },
     requireApiKey: async (provider, model, options) => {
-      const key = await (async () => {
-        if (modelAuth) {
-          try {
-            const modelAuthKey = resolveApiKeyFromAuthResult(
-              await modelAuth.getApiKeyForModel({
-                model: buildModelAuthLookupModel({ provider, model }),
-                cfg: api.config,
-                ...(options?.profileId ? { profileId: options.profileId } : {}),
-                ...(options?.preferredProfile ? { preferredProfile: options.preferredProfile } : {}),
-              }),
-            );
-            if (modelAuthKey) {
-              return modelAuthKey;
-            }
-          } catch {
-            // Fall through to auth-profile lookup for older OpenClaw runtimes.
-          }
-        }
-
-        const envKey = resolveApiKey(provider, readEnv);
-        if (envKey) {
-          return envKey;
-        }
-
-        const piAiModuleId = "@mariozechner/pi-ai";
-        const mod = (await import(piAiModuleId)) as PiAiModule;
-        return resolveApiKeyFromAuthProfiles({
-          provider,
-          authProfileId: options?.profileId,
-          agentDir: api.resolvePath("."),
-          runtimeConfig: api.config,
-          piAiModule: mod,
-          envSnapshot,
-        });
-      })();
+      const key = await lookupApiKey(provider, model, options);
       if (!key) {
         throw new Error(`Missing API key for provider '${provider}' (model '${model}').`);
       }
@@ -1527,7 +1565,7 @@ const lcmPlugin = {
       log: (message) => api.logger.info(message),
       message: buildCompactionModelLog({
         config: deps.config,
-        defaultModelRef: readDefaultModelFromConfig(api.config),
+        openClawConfig: api.config,
         defaultProvider: process.env.OPENCLAW_PROVIDER?.trim() ?? "",
       }),
     });

package/src/store/summary-store.ts

@@ -45,6 +45,11 @@ export type SummarySubtreeNodeRecord = SummaryRecord & {
   childCount: number;
 };
 
+export type MessageLeafSummaryLinkRecord = {
+  messageId: number;
+  summaryId: string;
+};
+
 export type ContextItemRecord = {
   conversationId: number;
   ordinal: number;
@@ -172,6 +177,15 @@ interface MessageIdRow {
   message_id: number;
 }
 
+interface MaxDepthRow {
+  max_depth: number | null;
+}
+
+interface MessageLeafSummaryLinkRow {
+  message_id: number;
+  summary_id: string;
+}
+
 interface LargeFileRow {
   file_id: string;
   conversation_id: number;
@@ -460,6 +474,72 @@ export class SummaryStore {
     return rows.map((r) => r.message_id);
   }
 
+  /**
+   * Return the deepest persisted summary depth for a conversation.
+   */
+  async getConversationMaxSummaryDepth(conversationId: number): Promise<number | null> {
+    const row = this.db
+      .prepare(
+        `SELECT MAX(depth) AS max_depth
+         FROM summaries
+         WHERE conversation_id = ?`,
+      )
+      .get(conversationId) as unknown as MaxDepthRow | undefined;
+    return typeof row?.max_depth === "number" ? row.max_depth : null;
+  }
+
+  /**
+   * Resolve raw message hits back to their linked leaf summaries.
+   */
+  async getLeafSummaryLinksForMessageIds(
+    conversationId: number,
+    messageIds: number[],
+  ): Promise<MessageLeafSummaryLinkRecord[]> {
+    const normalizedMessageIds = Array.from(
+      new Set(
+        messageIds.filter(
+          (messageId): messageId is number => Number.isInteger(messageId) && messageId > 0,
+        ),
+      ),
+    );
+    if (normalizedMessageIds.length === 0) {
+      return [];
+    }
+
+    const placeholders = normalizedMessageIds.map(() => "?").join(", ");
+    const rows = this.db
+      .prepare(
+        `SELECT sm.message_id, sm.summary_id
+         FROM summary_messages sm
+         JOIN summaries s ON s.summary_id = sm.summary_id
+         WHERE s.conversation_id = ?
+           AND s.kind = 'leaf'
+           AND sm.message_id IN (${placeholders})
+         ORDER BY sm.ordinal ASC, s.created_at ASC`,
+      )
+      .all(conversationId, ...normalizedMessageIds) as unknown as MessageLeafSummaryLinkRow[];
+
+    const summaryIdsByMessageId = new Map<number, string[]>();
+    for (const row of rows) {
+      const existing = summaryIdsByMessageId.get(row.message_id) ?? [];
+      if (!existing.includes(row.summary_id)) {
+        existing.push(row.summary_id);
+        summaryIdsByMessageId.set(row.message_id, existing);
+      }
+    }
+
+    const orderedLinks: MessageLeafSummaryLinkRecord[] = [];
+    for (const messageId of normalizedMessageIds) {
+      for (const summaryId of summaryIdsByMessageId.get(messageId) ?? []) {
+        orderedLinks.push({
+          messageId,
+          summaryId,
+        });
+      }
+    }
+    return orderedLinks;
+  }
+
   async getSummaryChildren(parentSummaryId: string): Promise<SummaryRecord[]> {
     const rows = this.db
       .prepare(