import path from "node:path";

import type { AgentMessage } from "@earendil-works/pi-agent-core";

import { runAgentHarnessBeforeMessageWriteHook } from "../agents/harness/hook-helpers.js";

import { appendSessionTranscriptMessage } from "../config/sessions/transcript-append.js";

import { resolveSessionTranscriptFile } from "../config/sessions/transcript.js";

import type { SessionEntry } from "../config/sessions/types.js";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { logVerbose } from "../globals.js";

import { mimeTypeFromFilePath } from "../media/mime.js";

import { emitSessionTranscriptUpdate } from "./transcript-events.js";

type TranscriptAppendConfig = Parameters<typeof appendSessionTranscriptMessage>[0]["config"];

type UserTurnSessionEntry = {

sessionId: string;

updatedAt: number;

sessionFile?: string;

threadId?: string | number;

} & Record<string, unknown>;

type PersistedUserTurnMediaInput = {

path?: string | null;

url?: string | null;

type UserTurnTranscriptUpdateMode = "inline" | "none";

export type UserTurnBeforeMessageWrite = (params: {

message: PersistedUserTurnMessage;

agentId?: string;

sessionKey?: string;

}) => AgentMessage | null;

type AppendUserTurnTranscriptMessageParams = {

transcriptPath: string;

input?: UserTurnInput;

agentId?: string;

sessionKey?: string;

cwd?: string;

config?: OpenClawConfig;

config?: TranscriptAppendConfig;

updateMode?: UserTurnTranscriptUpdateMode;

beforeMessageWrite?: UserTurnBeforeMessageWrite;

};

type PersistUserTurnTranscriptParams = {

input?: UserTurnInput;

message?: PersistedUserTurnMessage;

sessionId: string;

sessionKey: string;

sessionEntry: SessionEntry | undefined;

sessionStore?: Record<string, SessionEntry>;

sessionEntry: UserTurnSessionEntry | undefined;

sessionStore?: Record<string, UserTurnSessionEntry>;

storePath?: string;

agentId: string;

threadId?: string | number;

cwd?: string;

config?: OpenClawConfig;

config?: TranscriptAppendConfig;

updateMode?: UserTurnTranscriptUpdateMode;

beforeMessageWrite?: UserTurnBeforeMessageWrite;

};

type UserTurnTranscriptPersistenceTarget = Omit<

agentId?: string;

sessionKey?: string;

cwd?: string;

config?: OpenClawConfig;

config?: TranscriptAppendConfig;

};

type UserTurnTranscriptTarget = UserTurnTranscriptPersistenceTarget | UserTurnTranscriptFileTarget;

type UserTurnTranscriptPersistResult = {

sessionFile: string;

sessionEntry: SessionEntry | undefined;

sessionEntry: UserTurnSessionEntry | undefined;

messageId: string;

message: PersistedUserTurnMessage;

};

message?: PersistedUserTurnMessage;

target: UserTurnTranscriptTargetResolver;

updateMode?: UserTurnTranscriptUpdateMode;

beforeMessageWrite?: UserTurnBeforeMessageWrite;

errorContext?: string;

onPersistenceError?: (error: unknown) => void;

};

function applyBeforeMessageWriteToUserTurn(

message: PersistedUserTurnMessage,

params: Pick<AppendUserTurnTranscriptMessageParams, "agentId" | "sessionKey">,

params: Pick<

AppendUserTurnTranscriptMessageParams,

"agentId" | "sessionKey" | "beforeMessageWrite"

>,

): PersistedUserTurnMessage | undefined {

if (!params.beforeMessageWrite) {

return message;

}

const originalMessage = message as unknown as { idempotencyKey?: unknown };

const idempotencyKey =

typeof originalMessage.idempotencyKey === "string" ? originalMessage.idempotencyKey : undefined;

const nextMessage = runAgentHarnessBeforeMessageWriteHook({

const nextMessage = params.beforeMessageWrite({

message,

...(params.agentId ? { agentId: params.agentId } : {}),

...(params.sessionKey ? { sessionKey: params.sessionKey } : {}),

return undefined;

}

const { resolveSessionTranscriptFile } = await import("../config/sessions/transcript.js");

const { sessionFile, sessionEntry } = await resolveSessionTranscriptFile({

sessionId: params.sessionId,

sessionKey: params.sessionKey,

...(params.cwd ? { cwd: params.cwd } : {}),

...(params.config ? { config: params.config } : {}),

...(params.updateMode ? { updateMode: params.updateMode } : {}),

...(params.beforeMessageWrite ? { beforeMessageWrite: params.beforeMessageWrite } : {}),

});

if (!appended) {

return undefined;

params.onPersistenceError(error);

return;

}

logVerbose(

`failed to persist ${params.errorContext ?? "user turn transcript"}: ${String(error)}`,

);

void import("../globals.js")

.then(({ logVerbose }) => {

logVerbose(

`failed to persist ${params.errorContext ?? "user turn transcript"}: ${String(error)}`,

);

})

.catch(() => undefined);

};

const waitForRuntimePersistence = async () => {

...target,

message,

updateMode,

...(params.beforeMessageWrite ? { beforeMessageWrite: params.beforeMessageWrite } : {}),

}).then((appended) =>

appended

? {

...target,

message,

updateMode,

...(params.beforeMessageWrite ? { beforeMessageWrite: params.beforeMessageWrite } : {}),

});

if (result) {

persisted = true;