From dc02a90700b23ac48752d21fc73f2b6763b7d3a3 Mon Sep 17 00:00:00 2001 From: zhangcheng Date: Wed, 26 Aug 2026 16:50:22 +0800 Subject: [PATCH 1/3] fix: ignore unknown session end events --- src/triggers/api.ts | 43 ++++++-- test/session-lifecycle-api.test.ts | 153 +++++++++++++++++++++++++++++ 2 files changed, 189 insertions(+), 7 deletions(-) create mode 100644 test/session-lifecycle-api.test.ts diff --git a/src/triggers/api.ts b/src/triggers/api.ts index 56fad4f0de..81aeec2753 100644 --- a/src/triggers/api.ts +++ b/src/triggers/api.ts @@ -665,10 +665,28 @@ export function registerApiTriggers( body: { error: "sessionId is required and must be a non-empty string" }, }; } - await kv.update(KV.sessions, sessionId, [ - { type: "set", path: "endedAt", value: new Date().toISOString() }, - { type: "set", path: "status", value: "completed" }, - ]); + // state::update has upsert semantics. A lifecycle adapter can emit an + // end event before its first observation has created the corresponding + // agentmemory session (for example, OpenClaw's /new command). Updating + // that missing key would create a partial row with only status/endedAt, + // which later breaks consumers that require Session.id. + const endResult = await withKeyedLock(`obs:${sessionId}`, async () => { + const session = await kv.get(KV.sessions, sessionId); + if (!session || session.id !== sessionId) return "not_found" as const; + if (session.status === "completed") return "already_completed" as const; + + await kv.update(KV.sessions, sessionId, [ + { type: "set", path: "endedAt", value: new Date().toISOString() }, + { type: "set", path: "status", value: "completed" }, + ]); + return "ended" as const; + }); + if (endResult !== "ended") { + return { + status_code: 200, + body: { success: true, ended: false, reason: endResult }, + }; + } // Fan out session-stopped lifecycle (non-blocking). try { sdk.trigger({ @@ -682,7 +700,7 @@ export function registerApiTriggers( error: err instanceof Error ? err.message : String(err), }); } - return { status_code: 200, body: { success: true } }; + return { status_code: 200, body: { success: true, ended: true } }; }, ); sdk.registerTrigger({ @@ -851,6 +869,17 @@ export function registerApiTriggers( const authErr = checkAuth(req, secret); if (authErr) return authErr; const sessions = await kv.list(KV.sessions); + // Be tolerant of legacy partial rows created by state::update before + // the session existed. In particular, never issue state::get with an + // undefined summary key: iii-engine can leave that invocation pending + // until the caller times out, making the viewer look empty. + const validSessions = sessions.filter( + (session): session is Session => + !!session && + typeof session === "object" && + typeof session.id === "string" && + session.id.length > 0, + ); const normalizedAgentId = typeof req.query_params?.["agentId"] === "string" ? req.query_params["agentId"].trim() @@ -863,8 +892,8 @@ export function registerApiTriggers( : explicitAgentId ?? (isAgentScopeIsolated() ? getAgentId() : undefined); const filtered = filterAgentId - ? sessions.filter((s) => s.agentId === filterAgentId) - : sessions; + ? validSessions.filter((s) => s.agentId === filterAgentId) + : validSessions; // Bounded fan-out: each kv.get is a full engine invocation, so // Promise.all over hundreds of sessions saturates the invocation // pool. Batch in chunks of 10 (parallel within a chunk, sequential diff --git a/test/session-lifecycle-api.test.ts b/test/session-lifecycle-api.test.ts new file mode 100644 index 0000000000..037f720436 --- /dev/null +++ b/test/session-lifecycle-api.test.ts @@ -0,0 +1,153 @@ +import { describe, expect, it, vi } from "vitest"; + +import { registerApiTriggers } from "../src/triggers/api.js"; +import { KV } from "../src/state/schema.js"; +import type { Session } from "../src/types.js"; + +type ApiResponse = { + status_code: number; + body: Record; +}; + +function makeHarness(sessionRows: Array<[string, unknown]> = []) { + const store = new Map>([ + [KV.sessions, new Map(sessionRows)], + [KV.summaries, new Map()], + ]); + const functions = new Map(); + const trigger = vi.fn(async () => undefined); + const update = vi.fn( + async ( + scope: string, + key: string, + ops: Array<{ type: "set" | "remove"; path: string; value?: unknown }>, + ) => { + const values = store.get(scope) ?? new Map(); + store.set(scope, values); + const existing = values.get(key); + const next = + existing && typeof existing === "object" + ? { ...(existing as Record) } + : {}; + for (const op of ops) { + if (op.type === "remove") delete next[op.path]; + else next[op.path] = op.value; + } + values.set(key, next); + return next; + }, + ); + const kv = { + get: vi.fn(async (scope: string, key: string) => { + if (typeof key !== "string" || key.length === 0) { + throw new Error("state::get requires a non-empty key"); + } + return store.get(scope)?.get(key) ?? null; + }), + set: vi.fn(), + update, + delete: vi.fn(), + list: vi.fn(async (scope: string) => + Array.from(store.get(scope)?.values() ?? []), + ), + }; + const sdk = { + registerFunction: (id: string, handler: Function) => functions.set(id, handler), + registerTrigger: vi.fn(), + trigger, + }; + + registerApiTriggers(sdk as never, kv as never); + + return { functions, kv, store, trigger, update }; +} + +function session(id: string, status: Session["status"] = "active"): Session { + return { + id, + project: "test-project", + cwd: "/tmp/test-project", + startedAt: "2026-08-26T00:00:00.000Z", + status, + observationCount: 1, + }; +} + +describe("session lifecycle API", () => { + it("treats ending an unknown session as a no-op without creating a partial row", async () => { + const harness = makeHarness(); + const handler = harness.functions.get("api::session::end")!; + + const response = (await handler({ + body: { sessionId: "agent:dmp-pm:direct:test" }, + })) as ApiResponse; + + expect(response).toEqual({ + status_code: 200, + body: { success: true, ended: false, reason: "not_found" }, + }); + expect(harness.update).not.toHaveBeenCalled(); + expect(harness.store.get(KV.sessions)).toEqual(new Map()); + expect(harness.trigger).not.toHaveBeenCalledWith( + expect.objectContaining({ function_id: "event::session::stopped" }), + ); + }); + + it("does not treat an existing partial row as a valid session", async () => { + const sessionId = "agent:dmp-pm:direct:partial"; + const harness = makeHarness([ + [sessionId, { status: "completed", endedAt: "2026-08-26T00:00:00.000Z" }], + ]); + const handler = harness.functions.get("api::session::end")!; + + const response = (await handler({ body: { sessionId } })) as ApiResponse; + + expect(response.body).toEqual({ + success: true, + ended: false, + reason: "not_found", + }); + expect(harness.update).not.toHaveBeenCalled(); + }); + + it("ends an existing session and publishes the stopped lifecycle once", async () => { + const sessionId = "agent:dmp-pm:direct:existing"; + const harness = makeHarness([[sessionId, session(sessionId)]]); + const handler = harness.functions.get("api::session::end")!; + + const response = (await handler({ body: { sessionId } })) as ApiResponse; + + expect(response.body).toEqual({ success: true, ended: true }); + expect(harness.store.get(KV.sessions)?.get(sessionId)).toMatchObject({ + id: sessionId, + status: "completed", + endedAt: expect.any(String), + }); + expect(harness.trigger).toHaveBeenCalledTimes(1); + expect(harness.trigger).toHaveBeenCalledWith( + expect.objectContaining({ + function_id: "event::session::stopped", + payload: { sessionId }, + }), + ); + }); + + it("skips malformed rows when listing sessions and never reads an undefined summary key", async () => { + const valid = session("ses_valid", "completed"); + const harness = makeHarness([ + [valid.id, valid], + ["agent:dmp-pm:direct:partial", { status: "completed", endedAt: "2026-08-26T00:00:00.000Z" }], + ]); + const handler = harness.functions.get("api::sessions")!; + + const response = (await handler({ + headers: {}, + query_params: { agentId: "*" }, + })) as ApiResponse; + + expect(response.status_code).toBe(200); + expect(response.body.sessions).toEqual([valid]); + expect(harness.kv.get).toHaveBeenCalledWith(KV.summaries, valid.id); + expect(harness.kv.get).not.toHaveBeenCalledWith(KV.summaries, undefined); + }); +}); From 5f5a94954cf8e60e92a2e51c73f13e844085fa85 Mon Sep 17 00:00:00 2001 From: zhangcheng Date: Thu, 27 Aug 2026 10:49:44 +0800 Subject: [PATCH 2/3] test: cover completed session end no-op --- test/session-lifecycle-api.test.ts | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/test/session-lifecycle-api.test.ts b/test/session-lifecycle-api.test.ts index 037f720436..eb6a483eda 100644 --- a/test/session-lifecycle-api.test.ts +++ b/test/session-lifecycle-api.test.ts @@ -1,5 +1,16 @@ import { describe, expect, it, vi } from "vitest"; +vi.mock("iii-sdk", async (importOriginal) => { + const actual = await importOriginal(); + return { + ...actual, + TriggerAction: { + ...actual.TriggerAction, + Void: vi.fn(() => ({ type: "void" })), + }, + }; +}); + import { registerApiTriggers } from "../src/triggers/api.js"; import { KV } from "../src/state/schema.js"; import type { Session } from "../src/types.js"; @@ -110,6 +121,21 @@ describe("session lifecycle API", () => { expect(harness.update).not.toHaveBeenCalled(); }); + it("treats ending an already-completed session as a no-op", async () => { + const sessionId = "agent:dmp-pm:direct:completed"; + const harness = makeHarness([[sessionId, session(sessionId, "completed")]]); + const handler = harness.functions.get("api::session::end")!; + + const response = (await handler({ body: { sessionId } })) as ApiResponse; + + expect(response).toEqual({ + status_code: 200, + body: { success: true, ended: false, reason: "already_completed" }, + }); + expect(harness.update).not.toHaveBeenCalled(); + expect(harness.trigger).not.toHaveBeenCalled(); + }); + it("ends an existing session and publishes the stopped lifecycle once", async () => { const sessionId = "agent:dmp-pm:direct:existing"; const harness = makeHarness([[sessionId, session(sessionId)]]); From 8d6e8233193f485f23670355174273c16603515c Mon Sep 17 00:00:00 2001 From: Rohit Ghumare Date: Thu, 1 Oct 2026 13:25:46 +0530 Subject: [PATCH 3/3] fix(events): ignore session ended events for unknown sessions event::session::ended used state::update directly, which upserts and can create a partial session row for an unknown id. Apply the same check as api::session::end under the obs:${sessionId} lock: missing, malformed, or partial rows return not_found, completed sessions return already_completed, and only active sessions are updated. --- src/triggers/events.ts | 21 +++++++--- test/session-lifecycle-api.test.ts | 67 ++++++++++++++++++++++++++++++ 2 files changed, 83 insertions(+), 5 deletions(-) diff --git a/src/triggers/events.ts b/src/triggers/events.ts index 42c058c869..9a271ce31c 100644 --- a/src/triggers/events.ts +++ b/src/triggers/events.ts @@ -184,13 +184,24 @@ export function registerEventTriggers(sdk: IIIClient, kv: StateKV): void { sdk.registerFunction( "event::session::ended", async (data: { sessionId: string }) => { - await withKeyedLock(`obs:${data.sessionId}`, () => - kv.update(KV.sessions, data.sessionId, [ + const sessionId = data?.sessionId; + if (typeof sessionId !== "string" || sessionId.length === 0) { + return { success: true, ended: false, reason: "not_found" as const }; + } + const endResult = await withKeyedLock(`obs:${sessionId}`, async () => { + const session = await kv.get(KV.sessions, sessionId); + if (!session || session.id !== sessionId) return "not_found" as const; + if (session.status === "completed") return "already_completed" as const; + await kv.update(KV.sessions, sessionId, [ { type: "set", path: "endedAt", value: new Date().toISOString() }, { type: "set", path: "status", value: "completed" }, - ]), - ); - return { success: true }; + ]); + return "ended" as const; + }); + if (endResult !== "ended") { + return { success: true, ended: false, reason: endResult }; + } + return { success: true, ended: true }; }, ); sdk.registerTrigger({ diff --git a/test/session-lifecycle-api.test.ts b/test/session-lifecycle-api.test.ts index eb6a483eda..0fe7081fc4 100644 --- a/test/session-lifecycle-api.test.ts +++ b/test/session-lifecycle-api.test.ts @@ -12,6 +12,7 @@ vi.mock("iii-sdk", async (importOriginal) => { }); import { registerApiTriggers } from "../src/triggers/api.js"; +import { registerEventTriggers } from "../src/triggers/events.js"; import { KV } from "../src/state/schema.js"; import type { Session } from "../src/types.js"; @@ -69,6 +70,7 @@ function makeHarness(sessionRows: Array<[string, unknown]> = []) { }; registerApiTriggers(sdk as never, kv as never); + registerEventTriggers(sdk as never, kv as never); return { functions, kv, store, trigger, update }; } @@ -177,3 +179,68 @@ describe("session lifecycle API", () => { expect(harness.kv.get).not.toHaveBeenCalledWith(KV.summaries, undefined); }); }); + +describe("event::session::ended", () => { + it("ignores an unknown session without creating a partial row", async () => { + const harness = makeHarness(); + const handler = harness.functions.get("event::session::ended")!; + + const result = await handler({ sessionId: "agent:dmp-pm:direct:test" }); + + expect(result).toEqual({ success: true, ended: false, reason: "not_found" }); + expect(harness.update).not.toHaveBeenCalled(); + expect(harness.store.get(KV.sessions)).toEqual(new Map()); + }); + + it("ignores a malformed session id", async () => { + const harness = makeHarness(); + const handler = harness.functions.get("event::session::ended")!; + + const result = await handler({}); + + expect(result).toEqual({ success: true, ended: false, reason: "not_found" }); + expect(harness.kv.get).not.toHaveBeenCalled(); + expect(harness.update).not.toHaveBeenCalled(); + }); + + it("does not treat an existing partial row as a valid session", async () => { + const sessionId = "agent:dmp-pm:direct:partial"; + const harness = makeHarness([[sessionId, { status: "active" }]]); + const handler = harness.functions.get("event::session::ended")!; + + const result = await handler({ sessionId }); + + expect(result).toEqual({ success: true, ended: false, reason: "not_found" }); + expect(harness.update).not.toHaveBeenCalled(); + }); + + it("leaves an already-completed session untouched", async () => { + const sessionId = "agent:dmp-pm:direct:completed"; + const harness = makeHarness([[sessionId, session(sessionId, "completed")]]); + const handler = harness.functions.get("event::session::ended")!; + + const result = await handler({ sessionId }); + + expect(result).toEqual({ + success: true, + ended: false, + reason: "already_completed", + }); + expect(harness.update).not.toHaveBeenCalled(); + }); + + it("completes an existing active session", async () => { + const sessionId = "agent:dmp-pm:direct:existing"; + const harness = makeHarness([[sessionId, session(sessionId)]]); + const handler = harness.functions.get("event::session::ended")!; + + const result = await handler({ sessionId }); + + expect(result).toEqual({ success: true, ended: true }); + expect(harness.store.get(KV.sessions)?.get(sessionId)).toMatchObject({ + id: sessionId, + status: "completed", + endedAt: expect.any(String), + }); + }); +});