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

import { flushEmbeddedAttemptTrajectoryRecorder } from "./attempt-trajectory-flush-cleanup.js";

describe("embedded attempt trajectory flush cleanup", () => {

const log = {

warn: vi.fn(),

};

beforeEach(() => {

vi.useFakeTimers();

log.warn.mockClear();

});

afterEach(() => {

vi.useRealTimers();

});

it("times out a stalled trajectory flush without rejecting attempt cleanup", async () => {

const flush = vi.fn(async () => new Promise<never>(() => {}));

const describeFlushState = vi.fn(

() => "pendingWrites=1 queuedBytes=704 activeOperation=file-append",

);

const result = flushEmbeddedAttemptTrajectoryRecorder({

runId: "run-trajectory",

sessionId: "session-trajectory",

trajectoryRecorder: {

describeFlushState,

flush,

},

log,

timeoutMs: 5,

});

await vi.advanceTimersByTimeAsync(4);

expect(log.warn).not.toHaveBeenCalled();

await vi.advanceTimersByTimeAsync(1);

await expect(result).resolves.toBeUndefined();

expect(flush).toHaveBeenCalledTimes(1);

expect(describeFlushState).toHaveBeenCalledTimes(1);

expect(log.warn).toHaveBeenCalledWith(

"agent cleanup timed out: runId=run-trajectory sessionId=session-trajectory step=openclaw-trajectory-flush timeoutMs=5 details=pendingWrites=1 queuedBytes=704 activeOperation=file-append",

);

});

});

import { runAgentCleanupStep } from "../../run-cleanup-timeout.js";

export type EmbeddedAttemptTrajectoryRecorder = {

describeFlushState: () => string | undefined;

flush: () => Promise<void>;

};

export async function flushEmbeddedAttemptTrajectoryRecorder(params: {

runId: string;

sessionId: string;

trajectoryRecorder: EmbeddedAttemptTrajectoryRecorder | null;

log: {

warn: (message: string) => void;

};

env?: NodeJS.ProcessEnv;

timeoutMs?: number;

}): Promise<void> {

await runAgentCleanupStep({

runId: params.runId,

sessionId: params.sessionId,

step: "openclaw-trajectory-flush",

log: params.log,

env: params.env,

timeoutMs: params.timeoutMs,

getTimeoutDetails: () => params.trajectoryRecorder?.describeFlushState(),

cleanup: async () => {

await params.trajectoryRecorder?.flush();

},

});

}

import { resolveAgentPromptSurfaceForSessionKey } from "../../prompt-surface.js";

import { describeProviderRequestRoutingSummary } from "../../provider-attribution.js";

import { registerProviderStreamForModel } from "../../provider-stream.js";

import { runAgentCleanupStep } from "../../run-cleanup-timeout.js";

import { collectRuntimeChannelCapabilities } from "../../runtime-capabilities.js";

import {

logAgentRuntimeToolDiagnostics,

shouldWarnEmbeddedRunStageSummary,

} from "./attempt-stage-timing.js";

import { buildAttemptSystemPrompt } from "./attempt-system-prompt.js";

import { flushEmbeddedAttemptTrajectoryRecorder } from "./attempt-trajectory-flush-cleanup.js";

import {

assembleAttemptContextEngine,

buildLoopPromptCacheInfo,

promptError: promptError ? formatErrorMessage(promptError) : undefined,

});

}

await runAgentCleanupStep({

await flushEmbeddedAttemptTrajectoryRecorder({

runId: params.runId,

sessionId: params.sessionId,

step: "openclaw-trajectory-flush",

log,

getTimeoutDetails: () => trajectoryRecorder?.describeFlushState(),

cleanup: async () => {

await trajectoryRecorder?.flush();

},

trajectoryRecorder,

});

// Always tear down the session (and release the lock) before we leave this attempt.

//