"sessions.compact",

]),

);

const sessionsHandlers = await getSessionsHandlers();

const directContext = {

broadcastToConnIds: vi.fn(),

getSessionEventSubscriberConnIds: () => new Set<string>(),

loadGatewayModelCatalog: async () => piSdkMock.models,

} as never;

async function directSessionReq<TPayload = unknown>(

method: keyof typeof sessionsHandlers,

params: Record<string, unknown>,

coercePayload?: (payload: unknown) => TPayload,

): Promise<{ ok: boolean; payload?: TPayload; error?: unknown }> {

let result:

| {

ok: boolean;

payload?: TPayload;

error?: unknown;

}

| undefined;

await sessionsHandlers[method]({

req: {} as never,

params,

respond: (ok, payload, error) => {

result = {

ok,

payload:

payload === undefined

? undefined

: coercePayload

? coercePayload(payload)

: (payload as TPayload),

error,

};

},

context: directContext,

client: null,

isWebchatConnect: () => false,

});

if (!result) {

throw new Error(`${method} did not respond`);

}

return result;

}

const resolvedByKey = await rpcReq<{ ok: true; key: string }>(ws, "sessions.resolve", {

key: "main",

});

expect(resolvedBySessionId.ok).toBe(true);

expect(resolvedBySessionId.payload?.key).toBe("agent:main:discord:group:dev");

ws.close();

const list1 = await rpcReq<{

const list1 = await directSessionReq<{

path: string;

defaults?: { model?: string | null; modelProvider?: string | null };

sessions: Array<{

lastAccountId?: string;

deliveryContext?: { channel?: string; to?: string; accountId?: string };

}>;

}>(ws, "sessions.list", { includeGlobal: false, includeUnknown: false });

}>("sessions.list", { includeGlobal: false, includeUnknown: false });

expect(list1.ok).toBe(true);

expect(list1.payload?.path).toBe(storePath);

threadId: "1737500000.123456",

});

const active = await rpcReq<{

const active = await directSessionReq<{

sessions: Array<{ key: string }>;

}>(ws, "sessions.list", {

}>("sessions.list", {

includeGlobal: false,

includeUnknown: false,

activeMinutes: 5,

});

expect(active.ok).toBe(true);

expect(active.payload?.sessions.map((s) => s.key)).toEqual(["agent:main:main"]);

const limited = await rpcReq<{

const limited = await directSessionReq<{

sessions: Array<{ key: string }>;

}>(ws, "sessions.list", {

}>("sessions.list", {

includeGlobal: true,

includeUnknown: false,

limit: 1,

expect(limited.payload?.sessions).toHaveLength(1);

expect(limited.payload?.sessions[0]?.key).toBe("global");

const patched = await rpcReq<{ ok: true; key: string }>(ws, "sessions.patch", {

const patched = await directSessionReq<{ ok: true; key: string }>("sessions.patch", {

key: "agent:main:main",

thinkingLevel: "medium",

verboseLevel: "off",

expect(patched.payload?.ok).toBe(true);

expect(patched.payload?.key).toBe("agent:main:main");

const sendPolicyPatched = await rpcReq<{

const sendPolicyPatched = await directSessionReq<{

ok: true;

entry: { sendPolicy?: string };

}>(ws, "sessions.patch", { key: "agent:main:main", sendPolicy: "deny" });

}>("sessions.patch", { key: "agent:main:main", sendPolicy: "deny" });

expect(sendPolicyPatched.ok).toBe(true);

expect(sendPolicyPatched.payload?.entry.sendPolicy).toBe("deny");

const labelPatched = await rpcReq<{

const labelPatched = await directSessionReq<{

ok: true;

entry: { label?: string };

}>(ws, "sessions.patch", {

}>("sessions.patch", {

key: "agent:main:subagent:one",

label: "Briefing",

});

expect(labelPatched.ok).toBe(true);

expect(labelPatched.payload?.entry.label).toBe("Briefing");

const labelPatchedDuplicate = await rpcReq(ws, "sessions.patch", {

const labelPatchedDuplicate = await directSessionReq("sessions.patch", {

key: "agent:main:discord:group:dev",

label: "Briefing",

});

expect(labelPatchedDuplicate.ok).toBe(false);

const list2 = await rpcReq<{

const list2 = await directSessionReq<{

sessions: Array<{

key: string;

thinkingLevel?: string;

label?: string;

displayName?: string;

}>;

}>(ws, "sessions.list", {});

}>("sessions.list", {});

expect(list2.ok).toBe(true);

const main2 = list2.payload?.sessions.find((s) => s.key === "agent:main:main");

expect(main2?.thinkingLevel).toBe("medium");

expect(subagent?.label).toBe("Briefing");

expect(subagent?.displayName).toBe("Briefing");

const clearedVerbose = await rpcReq<{ ok: true; key: string }>(ws, "sessions.patch", {

const clearedVerbose = await directSessionReq<{ ok: true; key: string }>("sessions.patch", {

key: "agent:main:main",

verboseLevel: null,

});

expect(clearedVerbose.ok).toBe(true);

const list3 = await rpcReq<{

const list3 = await directSessionReq<{

sessions: Array<{

key: string;

verboseLevel?: string;

}>;

}>(ws, "sessions.list", {});

}>("sessions.list", {});

expect(list3.ok).toBe(true);

const main3 = list3.payload?.sessions.find((s) => s.key === "agent:main:main");

expect(main3?.verboseLevel).toBeUndefined();

const listByLabel = await rpcReq<{

const listByLabel = await directSessionReq<{

sessions: Array<{ key: string }>;

}>(ws, "sessions.list", {

}>("sessions.list", {

includeGlobal: false,

includeUnknown: false,

label: "Briefing",

});

expect(listByLabel.ok).toBe(true);

expect(listByLabel.payload?.sessions.map((s) => s.key)).toEqual(["agent:main:subagent:one"]);

const resolvedByLabel = await rpcReq<{ ok: true; key: string }>(ws, "sessions.resolve", {

const resolvedByLabel = await directSessionReq<{ ok: true; key: string }>("sessions.resolve", {

label: "Briefing",

agentId: "main",

});

expect(resolvedByLabel.ok).toBe(true);

expect(resolvedByLabel.payload?.key).toBe("agent:main:subagent:one");

const spawnedOnly = await rpcReq<{

const spawnedOnly = await directSessionReq<{

sessions: Array<{ key: string }>;

}>(ws, "sessions.list", {

}>("sessions.list", {

includeGlobal: true,

includeUnknown: true,

spawnedBy: "agent:main:main",

});

expect(spawnedOnly.ok).toBe(true);

expect(spawnedOnly.payload?.sessions.map((s) => s.key)).toEqual(["agent:main:subagent:one"]);

const spawnedPatched = await rpcReq<{

const spawnedPatched = await directSessionReq<{

ok: true;

entry: { spawnedBy?: string };

}>(ws, "sessions.patch", {

}>("sessions.patch", {

key: "agent:main:subagent:two",

spawnedBy: "agent:main:main",

});

expect(spawnedPatched.ok).toBe(true);

expect(spawnedPatched.payload?.entry.spawnedBy).toBe("agent:main:main");

const acpPatched = await rpcReq<{

const acpPatched = await directSessionReq<{

ok: true;

entry: { spawnedBy?: string; spawnDepth?: number };

}>(ws, "sessions.patch", {

}>("sessions.patch", {

key: "agent:main:acp:child",

spawnedBy: "agent:main:main",

spawnDepth: 1,

expect(acpPatched.payload?.entry.spawnedBy).toBe("agent:main:main");

expect(acpPatched.payload?.entry.spawnDepth).toBe(1);

const spawnedPatchedInvalidKey = await rpcReq(ws, "sessions.patch", {

const spawnedPatchedInvalidKey = await directSessionReq("sessions.patch", {

key: "agent:main:main",

spawnedBy: "agent:main:main",

});

expect(spawnedPatchedInvalidKey.ok).toBe(false);

piSdkMock.enabled = true;

piSdkMock.models = [{ id: "gpt-test-a", name: "A", provider: "openai" }];

const modelPatched = await rpcReq<{

const modelPatched = await directSessionReq<{

ok: true;

entry: {

modelOverride?: string;

modelProvider?: string;

};

resolved?: { model?: string; modelProvider?: string };

}>(ws, "sessions.patch", {

}>("sessions.patch", {

key: "agent:main:main",

model: "openai/gpt-test-a",

});

expect(modelPatched.payload?.resolved?.modelProvider).toBe("openai");

expect(modelPatched.payload?.resolved?.model).toBe("gpt-test-a");

const listAfterModelPatch = await rpcReq<{

const listAfterModelPatch = await directSessionReq<{

sessions: Array<{ key: string; modelProvider?: string; model?: string }>;

}>(ws, "sessions.list", {});

}>("sessions.list", {});

expect(listAfterModelPatch.ok).toBe(true);

const mainAfterModelPatch = listAfterModelPatch.payload?.sessions.find(

(session) => session.key === "agent:main:main",

);

expect(mainAfterModelPatch?.modelProvider).toBe("openai");

expect(mainAfterModelPatch?.model).toBe("gpt-test-a");

const compacted = await rpcReq<{ ok: true; compacted: boolean }>(ws, "sessions.compact", {

const compacted = await directSessionReq<{ ok: true; compacted: boolean }>("sessions.compact", {

key: "agent:main:main",

maxLines: 3,

});

const filesAfterCompact = await fs.readdir(dir);

expect(filesAfterCompact.some((f) => f.startsWith("sess-main.jsonl.bak."))).toBe(true);

const deleted = await rpcReq<{ ok: true; deleted: boolean }>(ws, "sessions.delete", {

const deleted = await directSessionReq<{ ok: true; deleted: boolean }>("sessions.delete", {

key: "agent:main:discord:group:dev",

});

expect(deleted.ok).toBe(true);

expect(deleted.payload?.deleted).toBe(true);

const listAfterDelete = await rpcReq<{

const listAfterDelete = await directSessionReq<{

sessions: Array<{ key: string }>;

}>(ws, "sessions.list", {});

}>("sessions.list", {});

expect(listAfterDelete.ok).toBe(true);

expect(

listAfterDelete.payload?.sessions.some((s) => s.key === "agent:main:discord:group:dev"),

).toBe(false);

const filesAfterDelete = await fs.readdir(dir);

expect(filesAfterDelete.some((f) => f.startsWith("sess-group.jsonl.deleted."))).toBe(true);

const reset = await rpcReq<{

const reset = await directSessionReq<{

ok: true;

key: string;

entry: {

lastAccountId?: string;

lastThreadId?: string | number;

};

}>(ws, "sessions.reset", { key: "agent:main:main" });

}>("sessions.reset", { key: "agent:main:main" });

expect(reset.ok).toBe(true);

expect(reset.payload?.key).toBe("agent:main:main");

expect(reset.payload?.entry.sessionId).not.toBe("sess-main");

const filesAfterReset = await fs.readdir(dir);

expect(filesAfterReset.some((f) => f.startsWith("sess-main.jsonl.reset."))).toBe(true);

const badThinking = await rpcReq(ws, "sessions.patch", {

const badThinking = await directSessionReq("sessions.patch", {

key: "agent:main:main",

thinkingLevel: "banana",

});

expect(badThinking.ok).toBe(false);

expect((badThinking.error as { message?: unknown } | undefined)?.message ?? "").toMatch(

/invalid thinkinglevel/i,

);

ws.close();

});

test("sessions.compaction.* lists checkpoints and branches or restores from pre-compaction snapshots", async () => {