assistantTexts: [],

toolMetas: [],

lastAssistant: undefined,

currentAttemptAssistant: undefined,

didSendViaMessagingTool: false,

messagingToolSentTexts: [],

messagingToolSentMediaUrls: [],

expect(result.sideEffectEvidence).toBe(true);

});

it("keeps audited core read-only dynamic tools replay-safe", async () => {

const bridge = createBridgeWithToolResult("search", textToolResult("no matches"));

const result = await bridge.handleToolCall({

threadId: "thread-1",

turnId: "turn-1",

callId: "call-1",

namespace: null,

tool: "search",

arguments: { query: "scheduler" },

});

expect(result).toEqual(expectInputText("no matches"));

expect(result.sideEffectEvidence).toBeUndefined();

});

it("keeps async-started read-only tools replay-unsafe", async () => {

const bridge = createBridgeWithToolResult(

"search",

textToolResult("Background task started.", {

async: true,

status: "started",

taskId: "task-1",

}),

);

const result = await bridge.handleToolCall({

threadId: "thread-1",

turnId: "turn-1",

callId: "call-1",

namespace: null,

tool: "search",

arguments: { query: "scheduler" },

});

expect(result.asyncStarted).toBe(true);

expect(result.sideEffectEvidence).toBe(true);

});

it("does not mark pre-execution argument failures as side-effect evidence", async () => {

const execute = vi.fn(async () => textToolResult("should not run"));

const bridge = createCodexDynamicToolBridge({

filterToolResultMediaUrls,

HEARTBEAT_RESPONSE_TOOL_NAME,

embeddedAgentLog,

getChannelAgentToolMeta,

getPluginToolMeta,

type EmbeddedRunAttemptParams,

isAgentToolReplaySafe,

isToolWrappedWithBeforeToolCallHook,

isToolResultError,

isMessagingTool,

runtime: "codex",

...toolResultHookContext,

});

const isReplaySafeTool = (tool: AnyAgentTool) =>

isAgentToolReplaySafe(tool, {

declaredReplaySafe: (candidate) => {

const pluginMeta = getPluginToolMeta(candidate as AnyAgentTool);

if (pluginMeta) {

return pluginMeta.replaySafe === true;

}

return getChannelAgentToolMeta(candidate as never) ? false : undefined;

},

});

const legacyExtensionRunner =

createCodexAppServerToolResultExtensionRunner(toolResultHookContext);

const directToolNames = new Set([

isToolResultYield(rawResult) ||

isToolResultYield(result),

);

withDynamicToolAsyncStarted(

const asyncStarted =

isAsyncStartedToolResult(rawResult) || isAsyncStartedToolResult(result);

withDynamicToolAsyncStarted(response, asyncStarted);

return withSideEffectEvidence(

response,

isAsyncStartedToolResult(rawResult) || isAsyncStartedToolResult(result),

asyncStarted || (terminalType !== "blocked" && !isReplaySafeTool(toolEntry.tool)),

);

return withSideEffectEvidence(response, terminalType !== "blocked");

} catch (error) {

const errorMessage = error instanceof Error ? error.message : String(error);

notifyAgentToolResult(

},

"error",

),

didStartExecution,

didStartExecution && !isReplaySafeTool(toolEntry.tool),

);

}

},

expect(result.assistantTexts).toEqual(["hello"]);

expect(result.messagesSnapshot.map((message) => message.role)).toEqual(["user", "assistant"]);

expect(result.lastAssistant?.content).toEqual([{ type: "text", text: "hello" }]);

expect(result.currentAttemptAssistant?.content).toEqual([{ type: "text", text: "hello" }]);

expectUsageFields(result.attemptUsage, { input: 3, output: 7, cacheRead: 2, total: 12 });

expectUsageFields(result.lastAssistant?.usage, {

input: 3,

expect(result.assistantTexts).toEqual([]);

expect(result.lastAssistant).toBeUndefined();

expect(result.currentAttemptAssistant).toBeUndefined();

});

it("does not treat app-server interrupted status as a user cancellation by itself", async () => {

expect(JSON.stringify(result.messagesSnapshot)).not.toContain("checking thread context");

});

it("preserves an empty final assistant item after tool activity", async () => {

const projector = await createProjector();

projector.recordDynamicToolCall({

callId: "call-search",

tool: "memory_search",

arguments: { query: "scheduler" },

});

projector.recordDynamicToolResult({

callId: "call-search",

tool: "memory_search",

success: true,

sideEffectEvidence: false,

contentItems: [{ type: "inputText", text: "no matches" }],

});

await projector.handleNotification(

turnCompleted([

{ type: "agentMessage", id: "msg-before-tool", text: "Checking the scheduler now." },

{ type: "agentMessage", id: "msg-final", text: "" },

]),

);

const result = projector.buildResult(buildEmptyToolTelemetry());

expect(result.assistantTexts).toEqual(["Checking the scheduler now."]);

expect(result.currentAttemptAssistant?.content).toEqual([{ type: "text", text: "" }]);

expect(result.replayMetadata).toEqual({ hadPotentialSideEffects: false, replaySafe: true });

});

it("streams commentary agent messages as keyed progress events", async () => {

const onAgentEvent = vi.fn();

const onPartialReply = vi.fn();

assistantTexts.length > 0

? this.createAssistantMessage(assistantTexts.join("\n\n"))

: undefined;

const currentAttemptAssistant = this.createCurrentAttemptAssistantMessage();

// Each snapshot entry is tagged with a stable mirror identity of the

// shape `${turnId}:${kind}`. The mirror's idempotency key is derived

// from this identity rather than from snapshot position or content

assistantTexts,

toolMetas,

lastAssistant,

currentAttemptAssistant,

...(this.lastNativeToolError ? { lastToolError: this.lastNativeToolError } : {}),

didSendViaMessagingTool: toolTelemetry.didSendViaMessagingTool,

messagingToolSentTexts: toolTelemetry.messagingToolSentTexts,

this.completedItemIds.add(itemId);

}

this.rememberAssistantPhase(item);

if (item?.type === "agentMessage" && typeof item.text === "string" && item.text) {

if (item?.type === "agentMessage" && typeof item.text === "string") {

this.rememberAssistantItem(item.id);

this.assistantTextByItem.set(item.id, item.text);

if (this.isCommentaryAssistantItem(item.id)) {

if (item.text && this.isCommentaryAssistantItem(item.id)) {

this.emitCommentaryProgress({ itemId: item.id, text: item.text });

}

}

}

for (const item of turn.items ?? []) {

this.rememberAssistantPhase(item);

if (item.type === "agentMessage" && typeof item.text === "string" && item.text) {

if (item.type === "agentMessage" && typeof item.text === "string") {

this.rememberAssistantItem(item.id);

this.assistantTextByItem.set(item.id, item.text);

}

this.assistantItemOrder.push(itemId);

}

private createCurrentAttemptAssistantMessage(): AssistantMessage | undefined {

for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {

const itemId = this.assistantItemOrder[i];

if (

!itemId ||

this.isCommentaryAssistantItem(itemId) ||

!this.assistantTextByItem.has(itemId)

) {

continue;

}

const text = this.assistantTextByItem.get(itemId) ?? "";

const normalizedText = text.trim();

if (normalizedText && this.toolProgressTexts.has(normalizedText)) {

continue;

}

return this.createAssistantMessage(text);

}

return undefined;

}

private async readMirroredSessionMessages(): Promise<AgentMessage[]> {

return (await readCodexMirroredSessionHistoryMessages(this.params.sessionFile)) ?? [];

}

expect(copilotToolMetasHavePotentialSideEffects([{ toolName: "status" }])).toBe(false);

expect(copilotToolMetasHavePotentialSideEffects([{ toolName: "file_read" }])).toBe(false);

expect(copilotToolMetasHavePotentialSideEffects([{ toolName: "memory_get" }])).toBe(false);

expect(copilotToolMetasHavePotentialSideEffects([{ toolName: "memory_search" }])).toBe(false);

expect(copilotToolMetasHavePotentialSideEffects([{ toolName: "sessions_history" }])).toBe(

false,

);

expect(copilotToolMetasHavePotentialSideEffects([{ toolName: "web_search" }])).toBe(false);

});

it("treats memory_search recall tracking as a potential side effect", () => {

expect(copilotToolMetasHavePotentialSideEffects([{ toolName: "memory_search" }])).toBe(true);

});

it("detects async-started tools even without a mutating name", () => {

expect(

copilotToolMetasHavePotentialSideEffects([{ asyncStarted: true, toolName: "read" }]),

"list",

"ls",

"memory_get",

"memory_search",

"probe",

"query",

"read",

"contracts": {

"tools": ["memory_get", "memory_search"]

},

"toolMetadata": {

"memory_get": {

"replaySafe": true

}

},

"commandAliases": [

{

"name": "dreaming",

]

},

"x_search": {

"replaySafe": true,

"authSignals": [

{

"provider": "xai"

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

import {

copyChannelAgentToolMeta,

getChannelAgentToolMeta,

setChannelAgentToolMeta,

} from "./channel-tool-metadata.js";

describe("channel tool metadata", () => {

it("preserves ownership when a concrete tool is wrapped", () => {

const source = {};

const wrapped = {};

setChannelAgentToolMeta(source as never, { channelId: "telegram" });

copyChannelAgentToolMeta(source as never, wrapped as never);

expect(getChannelAgentToolMeta(wrapped as never)).toEqual({ channelId: "telegram" });

});

});