refactor(voice-call): centralize persisted status lookup

steipete · Darren2030 · steipete · commit 5c82305af476 · 2026-07-05T19:41:00.000+01:00
Co-authored-by: 曾文锋0668000834 &lt;zeng.wenfeng@xydigit.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -20,6 +20,7 @@ Docs: https://docs.openclaw.ai
 - **Unicode and plugin package verification:** match native slice semantics for reversed UTF-16 bounds, and reject published plugin packages that omit `openclaw.plugin.json`. (#100014, #99904) Thanks @Simon-XYDT and @849261680.
 - **Android invoke cancellation:** preserve coroutine cancellation through camera handlers and the Gateway invoke boundary so cancelled work cannot emit a stale result. (#99916) Thanks @xialonglee.
 - **Codex native hook relay diagnostics:** avoid bridge registry writes before the local relay server begins listening. (#100300) Thanks @nankingjing.
+- **Voice Call completed status:** resolve finalized calls from the full retained event store across Gateway, tool, and CLI status paths while preserving active-call lookup performance. (#99797) Thanks @Darren2030.
 - **Agent stop recovery:** prevent late-aborting prompts from reacquiring orphaned session locks after teardown, so `/stop` leaves the conversation ready for the next turn.
 - **Message delivery status:** report failed and partially failed best-effort channel delivery instead of returning a success-shaped message-tool result. (#99928) Thanks @masatohoshino.
 - **WhatsApp credential recovery:** restore malformed primary auth state from a valid backup during startup. (#99070) Thanks @LeonidasLux.
diff --git a/extensions/voice-call/index.test.ts b/extensions/voice-call/index.test.ts
@@ -86,6 +86,7 @@ function createRuntimeStub(callId = "call-1"): VoiceCallRuntime {
       endCall: vi.fn(async () => ({ success: true })),
       getCall: vi.fn((id: string) => (id === callId ? call : undefined)),
       getCallByProviderCallId: vi.fn(() => undefined),
+      getCallFromMemoryOrStore: vi.fn(async (id: string) => (id === callId ? call : undefined)),
       getActiveCalls: vi.fn(() => [call]),
       getCallHistory: vi.fn(async () => []),
     } as unknown as VoiceCallRuntime["manager"],
@@ -621,15 +622,15 @@ describe("voice-call plugin", () => {
   it("reports ended call history when speaking to a stale call", async () => {
     runtimeStub.manager.getCall = vi.fn(() => undefined);
     runtimeStub.manager.getCallByProviderCallId = vi.fn(() => undefined);
-    runtimeStub.manager.getCallHistory = vi.fn(async () => [
+    runtimeStub.manager.getCallFromMemoryOrStore = vi.fn(async () =>
       createCallRecord({
         callId: "call-1",
         providerCallId: "CA123",
         state: "completed",
         endReason: "completed",
         endedAt: Date.UTC(2026, 4, 2, 9, 18, 23),
       }),
-    ]);
+    );
     const { methods } = setup({ provider: "mock" });
     const handler = methods.get("voicecall.speak") as
       | ((ctx: {
@@ -652,15 +653,15 @@ describe("voice-call plugin", () => {
   it("reports stale call history with invalid ended timestamps", async () => {
     runtimeStub.manager.getCall = vi.fn(() => undefined);
     runtimeStub.manager.getCallByProviderCallId = vi.fn(() => undefined);
-    runtimeStub.manager.getCallHistory = vi.fn(async () => [
+    runtimeStub.manager.getCallFromMemoryOrStore = vi.fn(async () =>
       createCallRecord({
         callId: "call-1",
         providerCallId: "CA123",
         state: "completed",
         endReason: "completed",
         endedAt: Number.POSITIVE_INFINITY,
       }),
-    ]);
+    );
     const { methods } = setup({ provider: "mock" });
     const handler = methods.get("voicecall.speak") as
       | ((ctx: {
@@ -741,25 +742,15 @@ describe("voice-call plugin", () => {
     expectRedactedVoiceCallStatus(result.details.call);
   });
 
-  it("tool get_status falls back to the newest persisted snapshot when the call was evicted from memory", async () => {
-    // History is returned oldest-first (matching the on-disk store order). The
-    // fallback must resolve the NEWEST matching snapshot, not the first one — a
-    // forward find() would return the stale ringing record. See #96586.
-    const ringing = createCallRecord({
-      callId: "call-1",
-      providerCallId: "CA123",
-      state: "ringing",
-    });
+  it("tool get_status uses the manager's persisted fallback", async () => {
     const completed = createCallRecord({
       callId: "call-1",
       providerCallId: "CA123",
       state: "completed",
       endReason: "completed",
       endedAt: Date.UTC(2026, 4, 2, 9, 18, 23),
     });
-    runtimeStub.manager.getCall = vi.fn(() => undefined);
-    runtimeStub.manager.getCallByProviderCallId = vi.fn(() => undefined);
-    runtimeStub.manager.getCallHistory = vi.fn(async () => [ringing, completed]);
+    runtimeStub.manager.getCallFromMemoryOrStore = vi.fn(async () => completed);
     const { tools } = setup({ provider: "mock" });
     const tool = tools[0] as {
       execute: (id: string, params: unknown) => Promise<unknown>;
@@ -768,15 +759,13 @@ describe("voice-call plugin", () => {
       action: "get_status",
       callId: "call-1",
     })) as { details: { found?: boolean; call?: { state?: string } } };
-    expect(runtimeStub.manager["getCallHistory"]).toHaveBeenCalled();
+    expect(runtimeStub.manager["getCallFromMemoryOrStore"]).toHaveBeenCalledWith("call-1");
     expect(result.details.found).toBe(true);
     expect(result.details.call?.state).toBe("completed");
   });
 
   it("tool get_status reports found:false when the call is neither active nor persisted", async () => {
-    runtimeStub.manager.getCall = vi.fn(() => undefined);
-    runtimeStub.manager.getCallByProviderCallId = vi.fn(() => undefined);
-    runtimeStub.manager.getCallHistory = vi.fn(async () => []);
+    runtimeStub.manager.getCallFromMemoryOrStore = vi.fn(async () => undefined);
     const { tools } = setup({ provider: "mock" });
     const tool = tools[0] as {
       execute: (id: string, params: unknown) => Promise<unknown>;
diff --git a/extensions/voice-call/index.ts b/extensions/voice-call/index.ts
@@ -372,10 +372,7 @@ export default definePluginEntry({
     };
 
     const describeHistoricalCall = async (rt: VoiceCallRuntime, callId: string) => {
-      const history = await rt.manager.getCallHistory(100);
-      const call = history
-        .toReversed()
-        .find((candidate) => candidate.callId === callId || candidate.providerCallId === callId);
+      const call = await rt.manager.getCallFromMemoryOrStore(callId);
       if (!call) {
         return undefined;
       }
@@ -388,25 +385,6 @@ export default definePluginEntry({
       return `call is not active (${details.join(", ")})`;
     };
 
-    const resolveCallFromMemoryOrStore = async (
-      rt: VoiceCallRuntime,
-      callId: string,
-    ): Promise<CallRecord | undefined> => {
-      const active = rt.manager.getCall(callId) || rt.manager.getCallByProviderCallId(callId);
-      if (active) {
-        return active;
-      }
-      // Fall back to the persisted call store. Once a call is evicted from the
-      // in-memory manager (finalize, gateway restart, or max-duration expiry) it
-      // is gone from memory even though its full record remains on disk. Pick the
-      // NEWEST matching snapshot: history is sorted oldest-first, so a forward
-      // find() would return a stale record. See #96586.
-      const history = await rt.manager.getCallHistory(100);
-      return history
-        .toReversed()
-        .find((candidate) => candidate.callId === callId || candidate.providerCallId === callId);
-    };
-
     const resolveCallMessageRequest = async (params: GatewayRequestHandlerOptions["params"]) => {
       const callId = normalizeOptionalString(params?.callId) ?? "";
       const message = normalizeOptionalString(params?.message) ?? "";
@@ -677,7 +655,7 @@ export default definePluginEntry({
             });
             return;
           }
-          const call = await resolveCallFromMemoryOrStore(rt, raw);
+          const call = await rt.manager.getCallFromMemoryOrStore(raw);
           if (!call) {
             respond(true, { found: false });
             return;
@@ -809,7 +787,7 @@ export default definePluginEntry({
                 if (!callId) {
                   throw new Error("callId required");
                 }
-                const call = await resolveCallFromMemoryOrStore(rt, callId);
+                const call = await rt.manager.getCallFromMemoryOrStore(callId);
                 return json(
                   call ? { found: true, call: toVoiceCallStatus(call) } : { found: false },
                 );
@@ -823,7 +801,7 @@ export default definePluginEntry({
             if (!sid) {
               throw new Error("sid required for status");
             }
-            const call = await resolveCallFromMemoryOrStore(rt, sid);
+            const call = await rt.manager.getCallFromMemoryOrStore(sid);
             return json(call ? { found: true, call: toVoiceCallStatus(call) } : { found: false });
           }
 
diff --git a/extensions/voice-call/src/cli.test.ts b/extensions/voice-call/src/cli.test.ts
@@ -129,33 +129,24 @@ describe("voice-call CLI status fallback", () => {
     return JSON.parse(capturer.output().trim());
   }
 
-  it("resolves the newest persisted snapshot when the gateway is unavailable", async () => {
-    // History is oldest-first; the fallback must pick the newest (completed)
-    // snapshot, not the stale ringing one. See #96586.
+  it("uses the manager's persisted fallback when the gateway is unavailable", async () => {
     const result = await runStatusWithUnavailableGateway({
-      getCall: () => undefined,
-      getCallByProviderCallId: () => undefined,
       getActiveCalls: () => [],
-      getCallHistory: async () => [
-        { callId: "call-1", providerCallId: "CA123", state: "ringing" },
-        {
-          callId: "call-1",
-          providerCallId: "CA123",
-          state: "completed",
-          endReason: "completed",
-          endedAt: 1,
-        },
-      ],
+      getCallFromMemoryOrStore: async () => ({
+        callId: "call-1",
+        providerCallId: "CA123",
+        state: "completed",
+        endReason: "completed",
+        endedAt: 1,
+      }),
     });
     expect(result).toMatchObject({ callId: "call-1", state: "completed" });
   });
 
   it("reports found:false when the call is neither active nor persisted", async () => {
     const result = await runStatusWithUnavailableGateway({
-      getCall: () => undefined,
-      getCallByProviderCallId: () => undefined,
       getActiveCalls: () => [],
-      getCallHistory: async () => [],
+      getCallFromMemoryOrStore: async () => undefined,
     });
     expect(result).toEqual({ found: false });
   });
diff --git a/extensions/voice-call/src/cli.ts b/extensions/voice-call/src/cli.ts
@@ -733,19 +733,7 @@ export function registerVoiceCallCli(params: {
       }
       const rt = await ensureRuntime();
       if (options.callId) {
-        const id = options.callId;
-        const active = rt.manager.getCall(id) || rt.manager.getCallByProviderCallId(id);
-        let call = active;
-        if (!call) {
-          // Gateway is unavailable; fall back to the persisted call store so a
-          // completed/evicted call is still resolvable. Pick the NEWEST matching
-          // snapshot — history is oldest-first, so a forward find() would return
-          // a stale record. Mirrors the gateway/tool status paths. See #96586.
-          const history = await rt.manager.getCallHistory(100);
-          call = history
-            .toReversed()
-            .find((candidate) => candidate.callId === id || candidate.providerCallId === id);
-        }
+        const call = await rt.manager.getCallFromMemoryOrStore(options.callId);
         writeStdoutJson(call ?? { found: false });
         return;
       }
diff --git a/extensions/voice-call/src/manager.restore.test.ts b/extensions/voice-call/src/manager.restore.test.ts
@@ -103,6 +103,53 @@ describe("CallManager verification on restore", () => {
     expect(manager.getActiveCalls()).toHaveLength(0);
   });
 
+  it("resolves a terminal call from persisted state after restore", async () => {
+    const { call, manager } = await initializeManager({
+      callOverrides: { state: "completed", endReason: "completed", endedAt: Date.now() },
+    });
+
+    expect(manager.getCall(call.callId as string)).toBeUndefined();
+    expect(await manager.getCallFromMemoryOrStore(call.callId as string)).toMatchObject({
+      callId: call.callId,
+      state: "completed",
+    });
+    expect(await manager.getCallFromMemoryOrStore(call.providerCallId as string)).toMatchObject({
+      callId: call.callId,
+      state: "completed",
+    });
+  });
+
+  it("prefers active provider state before persisted fallback", async () => {
+    const storePath = createTestStorePath();
+    writeCallsToStore(storePath, [
+      makePersistedCall({
+        callId: "call-target",
+        providerCallId: "provider-completed",
+        state: "completed",
+        endReason: "completed",
+        endedAt: Date.now(),
+      }),
+      makePersistedCall({
+        callId: "call-active",
+        providerCallId: "call-target",
+        state: "answered",
+      }),
+    ]);
+    const config = VoiceCallConfigSchema.parse({
+      enabled: true,
+      provider: "plivo",
+      fromNumber: "+15550000000",
+    });
+    const manager = new CallManager(config, storePath);
+    await manager.initialize(new FakeProvider(), "https://example.com/voice/webhook");
+
+    expect(manager.getCallByProviderCallId("call-target")?.callId).toBe("call-active");
+    expect(await manager.getCallFromMemoryOrStore("call-target")).toMatchObject({
+      callId: "call-active",
+      state: "answered",
+    });
+  });
+
   it("keeps calls reported active by provider", async () => {
     const { call, manager } = await initializeManager({
       providerResult: { status: "in-progress", isTerminal: false },
diff --git a/extensions/voice-call/src/manager.ts b/extensions/voice-call/src/manager.ts
@@ -18,6 +18,7 @@ import {
   type SpeakOptions,
 } from "./manager/outbound.js";
 import {
+  findCallMatchesInStore,
   getCallHistoryFromStore,
   loadActiveCallsFromStore,
   persistCallRecord,
@@ -460,6 +461,18 @@ export class CallManager {
     return Array.from(this.activeCalls.values());
   }
 
+  /** Resolve a status record from active state or the retained event store. */
+  async getCallFromMemoryOrStore(callId: CallId): Promise<CallRecord | undefined> {
+    const active = this.getCall(callId) ?? this.getCallByProviderCallId(callId);
+    if (active) {
+      return active;
+    }
+    const persisted = await findCallMatchesInStore(this.storePath, callId);
+    // Active indexes are canonical for live calls and keep provider-id status
+    // lookups off the retained-store path. Persisted ids are fallback-only.
+    return persisted.byCallId ?? persisted.byProviderCallId;
+  }
+
   /**
    * Get call history (from persisted logs).
    */
diff --git a/extensions/voice-call/src/manager/store.test.ts b/extensions/voice-call/src/manager/store.test.ts
@@ -15,6 +15,7 @@ import {
 import { clearVoiceCallStateRuntime, setVoiceCallStateRuntime } from "../runtime-state.js";
 import { CallRecordSchema } from "../types.js";
 import {
+  findCallMatchesInStore,
   flushPendingCallRecordWritesForTest,
   getCallHistoryFromStore,
   loadActiveCallsFromStore,
@@ -151,4 +152,50 @@ describe("voice-call call record store", () => {
     const restored = loadActiveCallsFromStore(storePath);
     expect(restored.activeCalls.get("call-order")?.state).toBe("answered");
   });
+
+  it("finds retained snapshots outside recent history and preserves internal-id precedence", async () => {
+    const storePath = createTestStorePath();
+    persistCallRecord(
+      storePath,
+      CallRecordSchema.parse(
+        makePersistedCall({ callId: "call-target", providerCallId: "provider-target" }),
+      ),
+    );
+    persistCallRecord(
+      storePath,
+      CallRecordSchema.parse(
+        makePersistedCall({
+          callId: "call-target",
+          providerCallId: "provider-target",
+          state: "completed",
+        }),
+      ),
+    );
+    for (let index = 0; index < 101; index += 1) {
+      persistCallRecord(
+        storePath,
+        CallRecordSchema.parse(
+          makePersistedCall({
+            callId: `noise-${index}`,
+            providerCallId: index === 100 ? "call-target" : `provider-noise-${index}`,
+          }),
+        ),
+      );
+    }
+    await flushPendingCallRecordWritesForTest();
+
+    expect(await getCallHistoryFromStore(storePath, 100)).toHaveLength(100);
+    const internalMatches = await findCallMatchesInStore(storePath, "call-target");
+    expect(internalMatches.byCallId).toMatchObject({
+      callId: "call-target",
+      state: "completed",
+    });
+    expect(internalMatches.byProviderCallId).toMatchObject({ callId: "noise-100" });
+
+    const providerMatches = await findCallMatchesInStore(storePath, "provider-target");
+    expect(providerMatches.byProviderCallId).toMatchObject({
+      callId: "call-target",
+      state: "completed",
+    });
+  });
 });
diff --git a/extensions/voice-call/src/manager/store.ts b/extensions/voice-call/src/manager/store.ts
