import { readCodexTurn } from "./protocol-validators.js";

import {

isJsonObject,

type CodexDynamicToolCallOutputContentItem,

type CodexServerNotification,

type CodexThreadItem,

type CodexTurn,

] as const;

const MAX_TOOL_OUTPUT_DELTA_MESSAGES_PER_ITEM = 20;

const TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS = 12_000;

type ToolTranscriptCallInput = {

id: string;

name: string;

arguments?: unknown;

};

type ToolTranscriptResultInput = {

id: string;

name: string;

text?: string;

isError: boolean;

};

export class CodexAppServerEventProjector {

private readonly assistantTextByItem = new Map<string, string>();

{ chars: number; messages: number; truncated: boolean }

>();

private readonly toolMetas = new Map<string, { toolName: string; meta?: string }>();

private readonly toolTranscriptMessages: AgentMessage[] = [];

private readonly toolTranscriptCallIds = new Set<string>();

private readonly toolTranscriptResultIds = new Set<string>();

private assistantStarted = false;

private reasoningStarted = false;

private reasoningEnded = false;

),

);

}

messagesSnapshot.push(...this.toolTranscriptMessages);

if (lastAssistant) {

messagesSnapshot.push(attachCodexMirrorIdentity(lastAssistant, `${turnId}:assistant`));

}

};

}

recordDynamicToolCall(params: { callId: string; tool: string; arguments?: JsonValue }): void {

this.recordToolTranscriptCall({

id: params.callId,

name: params.tool,

arguments: sanitizeCodexToolArguments(params.arguments),

});

}

recordDynamicToolResult(params: {

callId: string;

tool: string;

success: boolean;

contentItems: CodexDynamicToolCallOutputContentItem[];

}): void {

this.recordToolTranscriptResult({

id: params.callId,

name: params.tool,

text: collectDynamicToolContentText(params.contentItems),

isError: !params.success,

});

}

markTimedOut(): void {

this.aborted = true;

this.promptError = "codex app-server attempt timed out";

}

this.emitStandardItemEvent({ phase: "start", item });

this.emitNormalizedToolItemEvent({ phase: "start", item });

this.recordNativeToolTranscriptCall(item);

this.emitToolResultSummary(item);

this.emitAgentEvent({

stream: "codex_app_server.item",

this.recordToolMeta(item);

this.emitStandardItemEvent({ phase: "end", item });

this.emitNormalizedToolItemEvent({ phase: "result", item });

this.recordNativeToolTranscriptCall(item);

this.recordNativeToolTranscriptResult(item);

this.emitToolResultSummary(item);

this.emitToolResultOutput(item);

this.emitAgentEvent({

this.emitPlanUpdate({ explanation: undefined, steps: splitPlanText(item.text) });

}

this.recordToolMeta(item);

this.recordNativeToolTranscriptCall(item);

this.recordNativeToolTranscriptResult(item);

this.emitToolResultSummary(item);

this.emitToolResultOutput(item);

}

});

}

private recordNativeToolTranscriptCall(item: CodexThreadItem | undefined): void {

if (!item || !shouldSynthesizeToolProgressForItem(item)) {

return;

}

const name = itemName(item);

if (!name) {

return;

}

this.recordToolTranscriptCall({

id: item.id,

name,

arguments: itemToolArgs(item),

});

}

private recordNativeToolTranscriptResult(item: CodexThreadItem | undefined): void {

if (!item || !shouldSynthesizeToolProgressForItem(item)) {

return;

}

const name = itemName(item);

if (!name) {

return;

}

this.recordToolTranscriptResult({

id: item.id,

name,

text: itemTranscriptResultText(item),

isError: isNonSuccessItemStatus(itemStatus(item)),

});

}

private recordToolTranscriptCall(params: ToolTranscriptCallInput): void {

if (!params.id || !params.name || this.toolTranscriptCallIds.has(params.id)) {

return;

}

this.toolTranscriptCallIds.add(params.id);

this.toolTranscriptMessages.push(

attachCodexMirrorIdentity(

this.createToolCallMessage(params),

`${this.turnId}:tool:${params.id}:call`,

),

);

}

private recordToolTranscriptResult(params: ToolTranscriptResultInput): void {

if (!params.id || !params.name || this.toolTranscriptResultIds.has(params.id)) {

return;

}

this.toolTranscriptResultIds.add(params.id);

this.toolTranscriptMessages.push(

attachCodexMirrorIdentity(

this.createToolResultMessage(params),

`${this.turnId}:tool:${params.id}:result`,

),

);

}

private formatCodexErrorMessage(params: JsonObject): string | undefined {

const error = isJsonObject(params.error) ? params.error : undefined;

return (

};

}

private createToolCallMessage(params: ToolTranscriptCallInput): AgentMessage {

return {

role: "assistant",

content: [

{

type: "toolCall",

id: params.id,

name: params.name,

arguments: normalizeToolTranscriptArguments(params.arguments),

},

],

api: this.params.model.api ?? "openai-codex-responses",

provider: this.params.provider,

model: this.params.modelId,

usage: ZERO_USAGE,

stopReason: "toolUse",

timestamp: Date.now(),

} as unknown as AgentMessage;

}

private createToolResultMessage(params: ToolTranscriptResultInput): AgentMessage {

const text = truncateToolTranscriptText(params.text?.trim() || toolResultStatusText(params));

return {

role: "toolResult",

toolCallId: params.id,

toolName: params.name,

isError: params.isError,

content: [

{

type: "toolResult",

toolCallId: params.id,

toolUseId: params.id,

tool_use_id: params.id,

content: text,

text,

},

],

timestamp: Date.now(),

} as unknown as AgentMessage;

}

private isNotificationForTurn(params: JsonObject): boolean {

const threadId = readString(params, "threadId");

const turnId = readNotificationTurnId(params);

return undefined;

}

function itemTranscriptResultText(item: CodexThreadItem): string | undefined {

const output = itemOutputText(item);

if (output) {

return output;

}

const result = itemToolResult(item).result;

return result ? stringifyJsonValue(result) : itemStatus(item);

}

function normalizeToolTranscriptArguments(value: unknown): Record<string, unknown> {

if (!value || typeof value !== "object" || Array.isArray(value)) {

return {};

}

return value as Record<string, unknown>;

}

function collectDynamicToolContentText(contentItems: CodexThreadItem["contentItems"]): string {

if (!Array.isArray(contentItems)) {

return "";

.join("\n");

}

function truncateToolTranscriptText(text: string): string {

if (text.length <= TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS) {

return text;

}

return `${text.slice(0, TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS)}\n...(truncated)...`;

}

function toolResultStatusText(params: ToolTranscriptResultInput): string {

return params.isError ? `${params.name} failed` : `${params.name} completed`;

}

function stringifyJsonValue(value: unknown): string | undefined {

try {

return JSON.stringify(value, null, 2);