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

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

export type PersistedUserTurnMediaInput = {

type PersistedUserTurnMediaInput = {

path?: string | null;

url?: string | null;

contentType?: string | null;

kind?: string | null;

};

export type PersistedUserTurnMediaFields = {

type PersistedUserTurnMediaFields = {

MediaPath?: string;

MediaPaths?: string[];

MediaType?: string;

mediaOnlyText?: string;

};

export type BuildPersistedUserTurnMessageParams = UserTurnInput;

type UserTurnTranscriptUpdateMode = "inline" | "file-only" | "none";

export type UserTurnTranscriptUpdateMode = "inline" | "file-only" | "none";

export type AppendUserTurnTranscriptMessageParams = {

type AppendUserTurnTranscriptMessageParams = {

transcriptPath: string;

input?: UserTurnInput;

message?: PersistedUserTurnMessage;

updateMode?: UserTurnTranscriptUpdateMode;

};

export type AppendInlineUserTurnTranscriptMessageParams = Omit<

AppendUserTurnTranscriptMessageParams,

"updateMode"

>;

export type PersistUserTurnTranscriptParams = {

type PersistUserTurnTranscriptParams = {

input?: UserTurnInput;

message?: PersistedUserTurnMessage;

sessionId: string;

updateMode?: UserTurnTranscriptUpdateMode;

};

export type UserTurnTranscriptPersistenceTarget = Omit<

type UserTurnTranscriptPersistenceTarget = Omit<

PersistUserTurnTranscriptParams,

"input" | "message" | "updateMode"

>;

export type UserTurnTranscriptFileTarget = {

type UserTurnTranscriptFileTarget = {

transcriptPath: string;

sessionId?: string;

agentId?: string;

config?: OpenClawConfig;

};

export type UserTurnTranscriptTarget =

| UserTurnTranscriptPersistenceTarget

| UserTurnTranscriptFileTarget;

type UserTurnTranscriptTarget = UserTurnTranscriptPersistenceTarget | UserTurnTranscriptFileTarget;

export type UserTurnTranscriptPersistResult = {

type UserTurnTranscriptPersistResult = {

sessionFile: string;

sessionEntry: SessionEntry | undefined;

messageId: string;

message: PersistedUserTurnMessage;

};

export type UserTurnTranscriptTargetResolver =

type UserTurnTranscriptTargetResolver =

| UserTurnTranscriptTarget

| (() => UserTurnTranscriptTarget | undefined | Promise<UserTurnTranscriptTarget | undefined>);

}) => Promise<UserTurnTranscriptPersistResult | undefined>;

};

export type CreateUserTurnTranscriptRecorderParams = {

type CreateUserTurnTranscriptRecorderParams = {

input?: UserTurnInput;

message?: PersistedUserTurnMessage;

target: UserTurnTranscriptTargetResolver;

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

};

export type PersistedUserTurnTextFieldSource = {

type PersistedUserTurnTextFieldSource = {

Transcript?: string | null;

RawBody?: string | null;

CommandBody?: string | null;

BodyStripped?: string | null;

};

export type ResolvePersistedUserTurnTextOptions = {

type ResolvePersistedUserTurnTextOptions = {

hasMedia?: boolean;

fallback?: string | null;

};

export type PersistedUserTurnMediaFieldSource = {

type PersistedUserTurnMediaFieldSource = {

MediaPath?: string | null;

MediaPaths?: readonly (string | null | undefined)[] | null;

MediaUrl?: string | null;

return media;

}

export function buildPersistedUserTurnMediaFields(

function buildPersistedUserTurnMediaFields(

media: readonly PersistedUserTurnMediaInput[] | null | undefined,

): PersistedUserTurnMediaFields {

const entries = Array.isArray(media) ? media : [];

};

}

export function buildPersistedUserTurnMessage(

params: BuildPersistedUserTurnMessageParams,

): PersistedUserTurnMessage {

export function buildPersistedUserTurnMessage(params: UserTurnInput): PersistedUserTurnMessage {

const mediaFields = buildPersistedUserTurnMediaFields(params.media);

const hasMedia = Boolean(mediaFields.MediaPath);

const text = normalizeTranscriptText(params.text);

};

}

export async function appendInlineUserTurnTranscriptMessage(

params: AppendInlineUserTurnTranscriptMessageParams,

): ReturnType<typeof appendUserTurnTranscriptMessage> {

return await appendUserTurnTranscriptMessage({

...params,

updateMode: "inline",

});

}

export async function persistUserTurnTranscript(

params: PersistUserTurnTranscriptParams,

): Promise<UserTurnTranscriptPersistResult | undefined> {