/** Tests ACP turn terminal results and detached-task progress outcomes. */

import type { AcpRuntimeEvent } from "@openclaw/acp-core/runtime/types";

import { describe, expect, it, vi } from "vitest";

import {

requireTaskByRunId,

}

});

it("retries once with a fresh persistent session after an early missing-session turn failure", async () => {

// Drives a thread-bound persistent ACP session whose first turn fails because

// the backend can no longer resume the stale session id, then a clean second

// turn. Returns observers so each case can assert whether the manager

// discarded the stale identity and retried fresh (#87830).

function setupStaleResumeScenario(firstTurn: () => AsyncIterable<AcpRuntimeEvent>) {

const runtimeState = createRuntime();

hoisted.requireAcpRuntimeBackendMock.mockReturnValue({

id: "acpx",

runtime: runtimeState.runtime,

});

const sessionKey = "agent:claude:acp:binding:discord:default:retry-no-session";

let currentMeta: SessionAcpMeta = {

...readySessionMeta({

agent: "claude",

}),

...readySessionMeta({ agent: "claude" }),

runtimeSessionName: sessionKey,

identity: {

state: "resolved",

};

hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => {

const key = (paramsUnknown as { sessionKey?: string }).sessionKey ?? sessionKey;

return {

sessionKey: key,

storeSessionKey: key,

acp: currentMeta,

};

return { sessionKey: key, storeSessionKey: key, acp: currentMeta };

});

hoisted.upsertAcpSessionMetaMock.mockImplementation(async (paramsUnknown: unknown) => {

const params = paramsUnknown as {

if (next) {

currentMeta = next;

}

return {

sessionId: "session-1",

updatedAt: Date.now(),

acp: currentMeta,

};

return { sessionId: "session-1", updatedAt: Date.now(), acp: currentMeta };

});

runtimeState.ensureSession.mockImplementation(async (inputUnknown: unknown) => {

const input = inputUnknown as {

details: { status: "alive" },

});

runtimeState.runTurn

.mockImplementationOnce(async function* () {

yield {

type: "error" as const,

code: "NO_SESSION",

message:

"Persistent ACP session acpx-sid-stale could not be resumed: Resource not found: acpx-sid-stale",

};

})

.mockImplementationOnce(firstTurn)

.mockImplementationOnce(async function* () {

yield { type: "done" as const };

});

const manager = new AcpSessionManager();

await expect(

const runTurn = () =>

manager.runTurn({

cfg: baseCfg,

sessionKey,

text: "do work",

mode: "prompt",

requestId: "run-no-session",

}),

).resolves.toBeUndefined();

});

return { runtimeState, sessionKey, runTurn, getMeta: () => currentMeta };

}

expect(runtimeState.prepareFreshSession).toHaveBeenCalledWith({

sessionKey,

function expectFreshRetry(scenario: ReturnType<typeof setupStaleResumeScenario>) {

expect(scenario.runtimeState.prepareFreshSession).toHaveBeenCalledWith({

sessionKey: scenario.sessionKey,

});

expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2);

expectRecordFields(mockCallArg(runtimeState.ensureSession), {

sessionKey,

expect(scenario.runtimeState.ensureSession).toHaveBeenCalledTimes(2);

expectRecordFields(mockCallArg(scenario.runtimeState.ensureSession), {

sessionKey: scenario.sessionKey,

resumeSessionId: "acpx-sid-stale",

});

const retryInput = mockCallArg(runtimeState.ensureSession, 1);

expect(retryInput.resumeSessionId).toBeUndefined();

expect(currentMeta.identity?.acpxSessionId).toBe("acpx-sid-fresh");

expect(currentMeta.identity?.state).toBe("resolved");

expect(mockCallArg(scenario.runtimeState.ensureSession, 1).resumeSessionId).toBeUndefined();

expect(scenario.getMeta().identity?.acpxSessionId).toBe("acpx-sid-fresh");

expect(scenario.getMeta().identity?.state).toBe("resolved");

const states = extractStatesFromUpserts();

expect(states).toContain("running");

expect(states).toContain("idle");

expect(states).not.toContain("error");

}

// The structured SESSION_RESUME_REQUIRED detail code drives recovery

// regardless of the backend's human-readable reason. Claude reports

// "Resource not found"; Kiro reports "Internal error" (RequestError -32603) —

// both must discard the stale persistent id and retry fresh (#87830).

it.each([

["Resource not found", "Resource not found: acpx-sid-stale"],

["Internal error (Kiro RequestError -32603)", "Internal error"],

])(

"retries with a fresh persistent session on a resume-required error: %s",

async (_label, reason) => {

const scenario = setupStaleResumeScenario(async function* () {

yield {

type: "error" as const,

code: "NO_SESSION",

detailCode: "SESSION_RESUME_REQUIRED",

message: `Persistent ACP session acpx-sid-stale could not be resumed: ${reason}`,

};

});

await expect(scenario.runTurn()).resolves.toBeUndefined();

expectFreshRetry(scenario);

},

);

it("recovers when the resume-required error is wrapped as a thrown cause", async () => {

const scenario = setupStaleResumeScenario(

// eslint-disable-next-line require-yield -- an async generator that only throws is a valid empty stream.

async function* () {

const error = new Error(

"Persistent ACP session acpx-sid-stale could not be resumed: Internal error",

) as Error & { detailCode?: string };

error.detailCode = "SESSION_RESUME_REQUIRED";

throw error;

},

);

await expect(scenario.runTurn()).resolves.toBeUndefined();

expectFreshRetry(scenario);

});

it("does not retry a generic Internal error that is not a resume-required failure", async () => {

const scenario = setupStaleResumeScenario(async function* () {

// No SESSION_RESUME_REQUIRED detail code: a generic backend failure must

// surface, not silently discard the persistent session and retry.

yield {

type: "error" as const,

code: "ACP_TURN_FAILED",

message: "Internal error",

};

});

await expect(scenario.runTurn()).rejects.toThrow();

expect(scenario.runtimeState.prepareFreshSession).not.toHaveBeenCalled();

expect(scenario.runtimeState.ensureSession).toHaveBeenCalledTimes(1);

});

});