Channels: add thread-aware model overrides

src/cron/isolated-agent/session.test.ts

@@ -4,9 +4,11 @@ import type { OpenClawConfig } from "../../config/config.js";
 vi.mock("../../config/sessions.js", () => ({
   loadSessionStore: vi.fn(),
   resolveStorePath: vi.fn().mockReturnValue("/tmp/test-store.json"),
+  evaluateSessionFreshness: vi.fn().mockReturnValue({ fresh: true }),
+  resolveSessionResetPolicy: vi.fn().mockReturnValue({ mode: "idle", idleMinutes: 60 }),
 }));
 
-import { loadSessionStore } from "../../config/sessions.js";
+import { loadSessionStore, evaluateSessionFreshness } from "../../config/sessions.js";
 import { resolveCronSession } from "./session.js";
 
 const NOW_MS = 1_737_600_000_000;
@@ -15,18 +17,25 @@ type SessionStore = ReturnType<typeof loadSessionStore>;
 type SessionStoreEntry = SessionStore[string];
 type MockSessionStoreEntry = Partial<SessionStoreEntry>;
 
-function resolveWithStoredEntry(params?: { sessionKey?: string; entry?: MockSessionStoreEntry }) {
+function resolveWithStoredEntry(params?: {
+  sessionKey?: string;
+  entry?: MockSessionStoreEntry;
+  forceNew?: boolean;
+  fresh?: boolean;
+}) {
   const sessionKey = params?.sessionKey ?? "webhook:stable-key";
   const store: SessionStore = params?.entry
     ? ({ [sessionKey]: params.entry as SessionStoreEntry } as SessionStore)
     : {};
   vi.mocked(loadSessionStore).mockReturnValue(store);
+  vi.mocked(evaluateSessionFreshness).mockReturnValue({ fresh: params?.fresh ?? true });
 
   return resolveCronSession({
     cfg: {} as OpenClawConfig,
     sessionKey,
     agentId: "main",
     nowMs: NOW_MS,
+    forceNew: params?.forceNew,
   });
 }
 
@@ -76,51 +85,76 @@ describe("resolveCronSession", () => {
     expect(result.isNewSession).toBe(true);
   });
 
-  it("always creates a new sessionId for cron/webhook runs", () => {
-    const result = resolveWithStoredEntry({
-      entry: {
-        sessionId: "existing-session-id-123",
-        updatedAt: NOW_MS - 1000,
-        systemSent: true,
-      },
+  // New tests for session reuse behavior (#18027)
+  describe("session reuse for webhooks/cron", () => {
+    it("reuses existing sessionId when session is fresh", () => {
+      const result = resolveWithStoredEntry({
+        entry: {
+          sessionId: "existing-session-id-123",
+          updatedAt: NOW_MS - 1000,
+          systemSent: true,
+        },
+        fresh: true,
+      });
+
+      expect(result.sessionEntry.sessionId).toBe("existing-session-id-123");
+      expect(result.isNewSession).toBe(false);
+      expect(result.systemSent).toBe(true);
     });
 
-    expect(result.sessionEntry.sessionId).not.toBe("existing-session-id-123");
-    expect(result.isNewSession).toBe(true);
-    expect(result.systemSent).toBe(false);
-  });
+    it("creates new sessionId when session is stale", () => {
+      const result = resolveWithStoredEntry({
+        entry: {
+          sessionId: "old-session-id",
+          updatedAt: NOW_MS - 86_400_000, // 1 day ago
+          systemSent: true,
+          modelOverride: "gpt-4.1-mini",
+          providerOverride: "openai",
+          sendPolicy: "allow",
+        },
+        fresh: false,
+      });
 
-  it("preserves overrides while rolling a new sessionId", () => {
-    const result = resolveWithStoredEntry({
-      entry: {
-        sessionId: "old-session-id",
-        updatedAt: NOW_MS - 86_400_000,
-        systemSent: true,
-        modelOverride: "gpt-4.1-mini",
-        providerOverride: "openai",
-        sendPolicy: "allow",
-      },
+      expect(result.sessionEntry.sessionId).not.toBe("old-session-id");
+      expect(result.isNewSession).toBe(true);
+      expect(result.systemSent).toBe(false);
+      expect(result.sessionEntry.modelOverride).toBe("gpt-4.1-mini");
+      expect(result.sessionEntry.providerOverride).toBe("openai");
+      expect(result.sessionEntry.sendPolicy).toBe("allow");
     });
 
-    expect(result.sessionEntry.sessionId).not.toBe("old-session-id");
-    expect(result.isNewSession).toBe(true);
-    expect(result.systemSent).toBe(false);
-    expect(result.sessionEntry.modelOverride).toBe("gpt-4.1-mini");
-    expect(result.sessionEntry.providerOverride).toBe("openai");
-    expect(result.sessionEntry.sendPolicy).toBe("allow");
-  });
+    it("creates new sessionId when forceNew is true", () => {
+      const result = resolveWithStoredEntry({
+        entry: {
+          sessionId: "existing-session-id-456",
+          updatedAt: NOW_MS - 1000,
+          systemSent: true,
+          modelOverride: "sonnet-4",
+          providerOverride: "anthropic",
+        },
+        fresh: true,
+        forceNew: true,
+      });
 
-  it("creates new sessionId when entry exists but has no sessionId", () => {
-    const result = resolveWithStoredEntry({
-      entry: {
-        updatedAt: NOW_MS - 1000,
-        modelOverride: "some-model",
-      },
+      expect(result.sessionEntry.sessionId).not.toBe("existing-session-id-456");
+      expect(result.isNewSession).toBe(true);
+      expect(result.systemSent).toBe(false);
+      expect(result.sessionEntry.modelOverride).toBe("sonnet-4");
+      expect(result.sessionEntry.providerOverride).toBe("anthropic");
     });
 
-    expect(result.sessionEntry.sessionId).toBeDefined();
-    expect(result.isNewSession).toBe(true);
-    // Should still preserve other fields from entry
-    expect(result.sessionEntry.modelOverride).toBe("some-model");
+    it("creates new sessionId when entry exists but has no sessionId", () => {
+      const result = resolveWithStoredEntry({
+        entry: {
+          updatedAt: NOW_MS - 1000,
+          modelOverride: "some-model",
+        },
+      });
+
+      expect(result.sessionEntry.sessionId).toBeDefined();
+      expect(result.isNewSession).toBe(true);
+      // Should still preserve other fields from entry
+      expect(result.sessionEntry.modelOverride).toBe("some-model");
+    });
   });
 });