expect(warningSpy).toHaveBeenCalledTimes(1);

expect(String(warningSpy.mock.calls[0]?.[0])).toContain(`toolsBySender key "${legacyKey}"`);

expect(warningSpy.mock.calls[0]?.[1]).toMatchObject({

code: "OPENCLAW_TOOLS_BY_SENDER_UNTYPED_KEY",

});

const warningMeta = warningSpy.mock.calls[0]?.[1] as { code?: unknown } | undefined;

expect(warningMeta?.code).toBe("OPENCLAW_TOOLS_BY_SENDER_UNTYPED_KEY");

});

});

} catch (err) {

expect(err).toBeInstanceOf(CircularIncludeError);

const circular = err as CircularIncludeError;

expect(circular.chain).toEqual(expect.arrayContaining([DEFAULT_BASE_PATH, aPath, bPath]));

expect(circular.chain).toContain(DEFAULT_BASE_PATH);

expect(circular.chain).toContain(aPath);

expect(circular.chain).toContain(bPath);

expect(circular.message).toMatch(/Circular include detected/);

expect(circular.message).toContain("a.json");

expect(circular.message).toContain("b.json");

auth: { mode: "token" },

});

const channels = persisted.channels as Record<string, Record<string, unknown>> | undefined;

expect(channels?.imessage).toMatchObject({

cliPath: "/usr/local/bin/imsg",

});

expect(channels?.imessage?.cliPath).toBe("/usr/local/bin/imsg");

expect(channels?.imessage).not.toHaveProperty("runtimeOnlyDefault");

});

// The cache should detect the size change and reload from disk

const loaded2 = loadSessionStore(storePath);

expect(loaded2).toMatchObject({

"session:2": { displayName: "Added" },

});

expect(loaded2["session:2"]?.displayName).toBe("Added");

});

});

}

async function expectPathMissing(targetPath: string): Promise<void> {

await expect(fs.stat(targetPath)).rejects.toMatchObject({ code: "ENOENT" });

let error: { code?: unknown } | undefined;

try {

await fs.stat(targetPath);

} catch (err) {

error = err as { code?: unknown };

}

expect(error?.code).toBe("ENOENT");

}

const deriveSessionKeyCases = [

sessionKey,

update: async () => null,

});

expect(result).toEqual(expect.objectContaining({ sessionId: "sess-1", thinkingLevel: "low" }));

expect(result?.sessionId).toBe("sess-1");

expect(result?.thinkingLevel).toBe("low");

const store = loadSessionStore(storePath);

expect(store[sessionKey]?.thinkingLevel).toBe("low");

expect(readSessionStoreReadOnly(storePath)).toStrictEqual({});

await fs.writeFile(storePath, '{"session-1":{"sessionId":"s1","updatedAt":1}}\n', "utf8");

expect(readSessionStoreReadOnly(storePath)).toMatchObject({

"session-1": {

sessionId: "s1",

updatedAt: 1,

},

});

const store = readSessionStoreReadOnly(storePath);

expect(store["session-1"]?.sessionId).toBe("s1");

expect(store["session-1"]?.updatedAt).toBe(1);

});

});

});

message: { role: "user", content: "x".repeat(5 * 1024 * 1024) },

});

await expect(readLatestAssistantTextFromSessionTranscript(sessionFile)).resolves.toMatchObject({

id: exactResult.messageId,

text: "Hello before the large user entry",

});

const latestAssistantText = await readLatestAssistantTextFromSessionTranscript(sessionFile);

if (!latestAssistantText) {

throw new Error("expected latest assistant text");

}

expect(latestAssistantText.id).toBe(exactResult.messageId);

expect(latestAssistantText.text).toBe("Hello before the large user entry");

const mirrorResult = await appendAssistantMessageToSessionTranscript({

sessionKey,

describe("typing mode schema reuse", () => {

it("accepts supported typingMode values for session and agent defaults", () => {

expect(SessionSchema.parse({ typingMode: "thinking" })).toMatchObject({

typingMode: "thinking",

});

expect(AgentDefaultsSchema.parse({ typingMode: "message" })).toMatchObject({

typingMode: "message",

});

const session = SessionSchema.parse({ typingMode: "thinking" });

const agentDefaults = AgentDefaultsSchema.parse({ typingMode: "message" });

expect(session?.typingMode).toBe("thinking");

expect(agentDefaults?.typingMode).toBe("message");

});

it("rejects unsupported typingMode values for session and agent defaults", () => {