import { historyResponseItems } from "@t3tools/provider-core/server/handoffBudget";
import { makeProviderFailure } from "@t3tools/provider-core/server/failure";
import {
makeProviderTextDeltaCoalescer,
type ProviderTextDeltaUpdate,
} from "./ProviderTextDeltaCoalescer.ts";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import {
CommandId,
CheckpointId,
CodexSettings,
EnvironmentId,
MessageId,
type ModelSelection,
NodeId,
type OrchestrationV2AppThread,
type OrchestrationV2ProviderThread,
type OrchestrationV2ProviderTurn,
type OrchestrationV2RuntimeRequest,
type OrchestrationV2Subagent,
type OrchestrationV2TurnItem,
ProjectId,
type ProviderApprovalDecision,
ProviderInstanceId,
ProviderSessionId,
ProviderSetupError,
ProviderThreadId,
ProviderTurnId,
RunAttemptId,
RunId,
ThreadId,
TurnItemId,
} from "@t3tools/contracts";
import { assert, describe, it } from "@effect/vitest";
import * as CodexClient from "effect-codex-app-server/client";
import * as CodexReplay from "effect-codex-app-server/replay";
import * as CodexError from "effect-codex-app-server/errors";
import type * as CodexSchema from "effect-codex-app-server/schema";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Digest from "effect/crypto/Digest";
import * as Effect from "effect/Effect";
import * as Predicate from "effect/Predicate";
import * as FileSystem from "effect/FileSystem";
import { MCP_APP_OUTPUT_KEY, readMcpAppReference } from "@t3tools/shared/mcpApp";
import { toolOutputImages } from "@t3tools/shared/toolOutput";
import { resolveAttachmentPathById } from "../../attachmentStore.ts";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as PubSub from "effect/PubSub";
import * as Queue from "effect/Queue";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as Sink from "effect/Sink";
import * as Stdio from "effect/Stdio";
import * as Exit from "effect/Exit";
import * as Cause from "effect/Cause";
import * as PlatformError from "effect/PlatformError";
import { TestClock } from "effect/testing";
import { ChildProcess, ChildProcessSpawner } from "effect/process";
import packageJson from "../../../package.json" with { type: "json" };
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import * as EffectWorker from "../EffectWorker.ts";
import * as Orchestrator from "../Orchestrator.ts";
import * as ProviderReplayHarness from "../testkit/ProviderReplayHarness.ts";
import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
import type * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
import * as ModelManifest from "../../provider/ModelManifest.ts";
import * as PortScanner from "../../preview/PortScanner.ts";
import { resolveProviderCompatibility } from "../../provider/providerCompatibility.ts";
import * as CodexAdapterV2 from "./CodexAdapterV2.ts";
import { withCodexReplayChildMetadata } from "./CodexAdapterV2.testkit.ts";
import * as CodexAdapterV2Testkit from "./CodexAdapterV2.testkit.ts";
const replayTranscriptJson = Schema.fromJsonString(CodexReplay.CodexAppServerReplayTranscript);
const encodeReplayTranscriptJson = Schema.encodeEffect(replayTranscriptJson);
const decodeReplayTranscriptJson = Schema.decodeUnknownEffect(replayTranscriptJson);
const encodeStringJson = Schema.encodeEffect(Schema.fromJsonString(Schema.String));
const isProviderAdapterEventStreamError = Schema.is(
ProviderAdapter.ProviderAdapterEventStreamError,
);
const encodeUnknownJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
describe("CodexAdapterV2 context usage", () => {
it("uses the current context rather than cumulative processed tokens", () => {
const usage = CodexAdapterV2.codexProviderTurnTokenUsage(
{
total: {
totalTokens: 180_000,
inputTokens: 160_000,
cachedInputTokens: 20_000,
outputTokens: 20_000,
reasoningOutputTokens: 5_000,
},
last: {
totalTokens: 50_000,
inputTokens: 45_000,
cachedInputTokens: 10_000,
outputTokens: 5_000,
reasoningOutputTokens: 1_000,
},
modelContextWindow: 200_000,
},
"2026-08-29T00:00:00.000Z",
);
assert.deepEqual(usage, {
usedTokens: 50_000,
maxTokens: 200_000,
inputTokens: 45_000,
cachedInputTokens: 10_000,
outputTokens: 5_000,
reasoningOutputTokens: 1_000,
updatedAt: "2026-08-29T00:00:00.000Z",
});
});
});
describe("CodexAdapterV2 assistant message streaming", () => {
it.effect("flushes buffered text synchronously before item and turn completion", () =>
Effect.gen(function* () {
const updates = yield* Ref.make<ReadonlyArray<ProviderTextDeltaUpdate>>([]);
const coalescer = yield* makeProviderTextDeltaCoalescer({
flushIntervalMs: 50,
emit: (update) => Ref.update(updates, (current) => [...current, update]),
});
yield* coalescer.append({ turnId: "turn-1", itemId: "message-1", delta: "item final" });
const completedText = yield* coalescer.complete({
turnId: "turn-1",
itemId: "message-1",
});
yield* coalescer.append({ turnId: "turn-1", itemId: "message-2", delta: "turn final" });
yield* coalescer.flushTurn("turn-1");
assert.equal(completedText, "item final");
assert.deepEqual(yield* Ref.get(updates), [
{ turnId: "turn-1", itemId: "message-1", text: "item final", completed: true },
{ turnId: "turn-1", itemId: "message-2", text: "turn final", completed: true },
]);
yield* Effect.yieldNow;
yield* TestClock.adjust("50 millis");
yield* Effect.yieldNow;
assert.equal((yield* Ref.get(updates)).length, 2);
}),
);
});
describe("CodexAdapterV2 runtime policy", () => {
it.effect.each([undefined, false, true])(
"selects native collaboration modes without prompt overrides with hasT3Mcp=%s",
(hasT3Mcp) =>
Effect.gen(function* () {
for (const interactionMode of ["plan", "default"] as const) {
for (const reasoningEffort of [undefined, "high"] as const) {
const params = yield* CodexAdapterV2.buildCodexTurnStartParams({
nativeThreadId: "native-mode-switch",
codexInput: [{ type: "text", text: "test" }],
runtimePolicy: { runtimeMode: "full-access", interactionMode, cwd: null },
modelSelection: {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5.4",
...(reasoningEffort === undefined
? {}
: { options: [{ id: "reasoningEffort", value: reasoningEffort }] }),
},
...(hasT3Mcp === undefined ? {} : { hasT3Mcp }),
});
assert.deepEqual(params.collaborationMode, {
mode: interactionMode,
settings: {
model: "gpt-5.4",
...(reasoningEffort === undefined ? {} : { reasoning_effort: reasoningEffort }),
},
});
assert.equal(params.effort, reasoningEffort);
assert.equal(params.additionalContext !== undefined, hasT3Mcp === true);
}
}
}),
);
it.effect("derives concrete Codex turn policies from every T3 runtime mode", () =>
Effect.gen(function* () {
const build = (
runtimeMode: "approval-required" | "auto-accept-edits" | "auto" | "full-access",
) =>
CodexAdapterV2.buildCodexTurnStartParams({
nativeThreadId: `native-${runtimeMode}`,
codexInput: [{ type: "text", text: "test" }],
runtimePolicy: {
runtimeMode,
interactionMode: "default",
cwd: null,
},
modelSelection: {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5.4",
},
});
const approvalRequired = yield* build("approval-required");
const autoAcceptEdits = yield* build("auto-accept-edits");
const auto = yield* build("auto");
const fullAccess = yield* build("full-access");
assert.equal(approvalRequired.approvalPolicy, "untrusted");
assert.equal(approvalRequired.approvalsReviewer, "user");
assert.equal(approvalRequired.sandboxPolicy?.type, "readOnly");
assert.equal(autoAcceptEdits.approvalPolicy, "on-request");
assert.equal(autoAcceptEdits.approvalsReviewer, "user");
assert.equal(autoAcceptEdits.sandboxPolicy?.type, "workspaceWrite");
assert.equal(auto.approvalPolicy, "on-request");
assert.equal(auto.approvalsReviewer, "auto_review");
assert.equal(auto.sandboxPolicy?.type, "workspaceWrite");
assert.equal(fullAccess.approvalPolicy, "never");
assert.equal(fullAccess.approvalsReviewer, "user");
assert.equal(fullAccess.sandboxPolicy?.type, "dangerFullAccess");
}),
);
it.effect("sends MCP app model context as untrusted Codex context", () =>
Effect.gen(function* () {
const policy = { runtimeMode: "full-access", interactionMode: "default", cwd: null } as const;
const modelSelection = { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" };
const appContext = [{ key: "mcp_app_todos_list_todos_item-1", text: "Filtered to overdue" }];
const alone = yield* CodexAdapterV2.buildCodexTurnStartParams({
nativeThreadId: "native-app-context",
codexInput: [{ type: "text", text: "what's on my list?" }],
runtimePolicy: policy,
modelSelection,
appContext,
});
assert.deepEqual(alone.additionalContext, {
"mcp_app_todos_list_todos_item-1": { kind: "untrusted", value: "Filtered to overdue" },
});
const withT3 = yield* CodexAdapterV2.buildCodexTurnStartParams({
nativeThreadId: "native-app-context",
codexInput: [{ type: "text", text: "what's on my list?" }],
runtimePolicy: policy,
modelSelection,
hasT3Mcp: true,
appContext,
});
assert.deepEqual(withT3.additionalContext?.["mcp_app_todos_list_todos_item-1"], {
kind: "untrusted",
value: "Filtered to overdue",
});
assert.isDefined(withT3.additionalContext?.["t3_code_runtime"]);
}),
);
});
describe("CodexAdapterV2 native protocol logging", () => {
it.effect("logs decoded app-server frames once with credentials redacted", () =>
Effect.gen(function* () {
const writes: Array<{
readonly event: unknown;
readonly threadId: ThreadId | null;
}> = [];
const logger: ProviderEventLoggers.EventNdjsonLogger = {
filePath: "/tmp/events.log",
write: (event, threadId) =>
Effect.sync(() => {
writes.push({ event, threadId });
}),
close: () => Effect.void,
};
const threadId = ThreadId.make("thread-1");
const providerSessionId = ProviderSessionId.make("provider-session-1");
const protocolLogger = CodexAdapterV2.makeCodexAppServerProtocolLogger({
nativeEventLogger: logger,
threadId,
providerSessionId,
});
assert.notEqual(protocolLogger, undefined);
if (protocolLogger === undefined) {
return;
}
yield* protocolLogger({
direction: "incoming",
stage: "decoded",
payload: {
method: "thread/event",
params: {
id: "evt-1",
http_headers: { Authorization: "Bearer secret-codex-token" },
usage: { inputTokens: 12, outputTokens: 8, totalTokens: 20 },
},
},
});
yield* protocolLogger({
direction: "incoming",
stage: "raw",
payload:
'{"method":"thread/event","params":{"http_headers":{"Authorization":"Bearer secret-codex-token"}}}\n',
});
assert.equal(writes.length, 1);
assert.equal(writes[0]?.threadId, threadId);
assert.deepEqual(writes[0]?.event, {
provider: "codex",
protocol: "codex.app-server",
kind: "protocol",
providerSessionId,
event: {
direction: "incoming",
stage: "decoded",
payload: {
method: "thread/event",
params: {
id: "evt-1",
http_headers: { Authorization: "[REDACTED]" },
usage: { inputTokens: 12, outputTokens: 8, totalTokens: 20 },
},
},
},
});
}),
);
});
describe("CodexAdapterV2 rollback mapping", () => {
it.effect("derives native rollback count from durable provider turns", () =>
Effect.gen(function* () {
const now = yield* DateTime.now;
const providerThreadId = ProviderThreadId.make("provider-thread-codex-rollback");
const providerThread: OrchestrationV2ProviderThread = {
id: providerThreadId,
driver: CodexAdapterV2.CODEX_DRIVER_KIND,
providerInstanceId: ProviderInstanceId.make("codex"),
providerSessionId: ProviderSessionId.make("provider-session-codex-rollback"),
appThreadId: ThreadId.make("thread-codex-rollback"),
ownerNodeId: null,
nativeThreadRef: {
driver: CodexAdapterV2.CODEX_DRIVER_KIND,
nativeId: "native-thread-codex-rollback",
strength: "strong",
},
nativeConversationHeadRef: null,
status: "idle",
firstRunOrdinal: 1,
lastRunOrdinal: 3,
handoffIds: [],
forkedFrom: null,
createdAt: now,
updatedAt: now,
};
const providerTurn = (
id: string,
ordinal: number,
status: OrchestrationV2ProviderTurn["status"],
): OrchestrationV2ProviderTurn => ({
id: ProviderTurnId.make(id),
providerThreadId,
nodeId: NodeId.make(`node-${id}`),
runAttemptId: RunAttemptId.make(`run-attempt-${id}`),
nativeTurnRef: {
driver: CodexAdapterV2.CODEX_DRIVER_KIND,
nativeId: `native-${id}`,
strength: "strong",
},
ordinal,
status,
startedAt: now,
completedAt: status === "running" || status === "pending" ? null : now,
});
const firstTurn = providerTurn("provider-turn-first", 1, "completed");
const secondTurn = providerTurn("provider-turn-second", 2, "completed");
const runningTurn = providerTurn("provider-turn-running", 3, "running");
const interruptedTurn = providerTurn("provider-turn-interrupted", 4, "interrupted");
const goalCommandTurn = {
...providerTurn("provider-turn-goal-command", 5, "completed"),
nativeTurnRef: null,
};
const numTurns = yield* CodexAdapterV2.resolveCodexRollbackTurnCount({
providerThread,
target: {
type: "provider_turn",
checkpointId: CheckpointId.make("checkpoint-first"),
appRunOrdinal: 1,
providerTurn: firstTurn,
},
providerThreadTurns: [goalCommandTurn, interruptedTurn, runningTurn, secondTurn, firstTurn],
});
assert.equal(numTurns, 2);
}),
);
});
describe("CodexAdapterV2 fork boundary", () => {
const providerThreadId = ProviderThreadId.make("provider-thread-codex-fork-boundary");
const makeProviderThread = (now: DateTime.Utc): OrchestrationV2ProviderThread => ({
id: providerThreadId,
driver: CodexAdapterV2.CODEX_DRIVER_KIND,
providerInstanceId: ProviderInstanceId.make("codex"),
providerSessionId: ProviderSessionId.make("provider-session-codex-fork-boundary"),
appThreadId: ThreadId.make("thread-codex-fork-boundary"),
ownerNodeId: null,
nativeThreadRef: {
driver: CodexAdapterV2.CODEX_DRIVER_KIND,
nativeId: "native-thread-codex-fork-boundary",
strength: "strong",
},
nativeConversationHeadRef: null,
status: "idle",
firstRunOrdinal: 1,
lastRunOrdinal: 2,
handoffIds: [],
forkedFrom: null,
createdAt: now,
updatedAt: now,
});
const makeProviderTurn = (
id: string,
ordinal: number,
nativeId: string | null,
now: DateTime.Utc,
): OrchestrationV2ProviderTurn => ({
id: ProviderTurnId.make(id),
providerThreadId,
nodeId: NodeId.make(`node-${id}`),
runAttemptId: RunAttemptId.make(`run-attempt-${id}`),
nativeTurnRef:
nativeId === null
? { driver: CodexAdapterV2.CODEX_DRIVER_KIND, nativeId: null, strength: "none" }
: { driver: CodexAdapterV2.CODEX_DRIVER_KIND, nativeId, strength: "strong" },
ordinal,
status: "completed",
startedAt: now,
completedAt: now,
});
it.effect("resolves the selected provider turn to an inclusive native fork boundary", () =>
Effect.gen(function* () {
const now = yield* DateTime.now;
const firstTurn = makeProviderTurn("provider-turn-first", 1, "native-turn-first", now);
const secondTurn = makeProviderTurn("provider-turn-second", 2, "native-turn-second", now);
const boundary = yield* CodexAdapterV2.resolveCodexForkBoundary({
sourceProviderThread: makeProviderThread(now),
sourceProviderTurns: [firstTurn, secondTurn],
providerTurnId: firstTurn.id,
targetThreadId: ThreadId.make("thread-codex-fork-target"),
});
assert.deepEqual(boundary, {
lastTurnId: "native-turn-first",
rollbackTurnCount: 0,
});
}),
);
it.effect("keeps the rollback-count fallback when the boundary turn lacks a native id", () =>
Effect.gen(function* () {
const now = yield* DateTime.now;
const firstTurn = makeProviderTurn("provider-turn-first", 1, null, now);
const secondTurn = makeProviderTurn("provider-turn-second", 2, "native-turn-second", now);
const boundary = yield* CodexAdapterV2.resolveCodexForkBoundary({
sourceProviderThread: makeProviderThread(now),
sourceProviderTurns: [firstTurn, secondTurn],
providerTurnId: firstTurn.id,
targetThreadId: ThreadId.make("thread-codex-fork-target"),
});
assert.deepEqual(boundary, { lastTurnId: undefined, rollbackTurnCount: 1 });
}),
);
});
const DEFAULT_CODEX_SETTINGS = Schema.decodeSync(CodexSettings)({});
const CHATGPT_SHARING_LIMIT_MESSAGE =
"stream disconnected before completion: The ChatGPT user has reached their Subscription Sharing usage limit. Ask the user to try again after their usage limit resets or use an API key instead.";
const CODEX_TEST_MODEL_SELECTION = {
instanceId: CodexAdapterV2.CODEX_DEFAULT_INSTANCE_ID,
model: "gpt-5.4",
} satisfies ModelSelection;
const CODEX_TEST_RUNTIME_POLICY = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
runtimeMode: "full-access",
interactionMode: "default",
cwd: "/workspace",
});
const T3_THREAD_ENV_KEY = "shell_environment_policy.set.T3CODE_THREAD_ID";
const threadEnvOf = (params: unknown) =>
Predicate.hasProperty(params, "config") && Predicate.hasProperty(params.config, T3_THREAD_ENV_KEY)
? params.config[T3_THREAD_ENV_KEY]
: undefined;
function makeCodexTestAppThread(input: {
readonly threadId: ThreadId;
readonly providerThread: OrchestrationV2ProviderThread;
readonly now: DateTime.Utc;
}): OrchestrationV2AppThread {
return {
createdBy: "user",
creationSource: "web",
id: input.threadId,
projectId: ProjectId.make(`project-${input.threadId}`),
title: "Codex continuation test",
providerInstanceId: CodexAdapterV2.CODEX_DEFAULT_INSTANCE_ID,
modelSelection: CODEX_TEST_MODEL_SELECTION,
runtimeMode: "full-access",
interactionMode: "default",
branch: null,
worktreePath: null,
activeProviderThreadId: input.providerThread.id,
lineage: {
parentThreadId: null,
relationshipToParent: null,
rootThreadId: input.threadId,
},
forkedFrom: null,
createdAt: input.now,
updatedAt: input.now,
archivedAt: null,
settledOverride: null,
settledAt: null,
lastVisitedAt: null,
deletedAt: null,
};
}
function makeCodexTestTurnInput(input: {
readonly threadId: ThreadId;
readonly providerThread: OrchestrationV2ProviderThread;
readonly now: DateTime.Utc;
readonly attemptId: RunAttemptId;
readonly text: string;
}): ProviderAdapter.ProviderAdapterV2TurnInput {
return {
appThread: makeCodexTestAppThread(input),
threadId: input.threadId,
runId: RunId.make(`run-${input.attemptId}`),
runOrdinal: 1,
providerTurnOrdinal: 1,
attemptId: input.attemptId,
rootNodeId: NodeId.make(`node-${input.attemptId}`),
providerThread: input.providerThread,
message: {
createdBy: "user",
creationSource: "web",
messageId: MessageId.make(`message-${input.attemptId}`),
text: input.text,
attachments: [],
},
modelSelection: CODEX_TEST_MODEL_SELECTION,
runtimePolicy: CODEX_TEST_RUNTIME_POLICY,
};
}
function makeCodexReplayTurn(input: {
readonly id: string;
readonly status: "inProgress" | "completed" | "interrupted" | "failed";
}): Record<string, unknown> {
const terminal =
input.status === "completed" || input.status === "interrupted" || input.status === "failed";
return {
id: input.id,
items: [],
itemsView: "notLoaded",
status: input.status,
error: null,
startedAt: 1782622440,
completedAt: terminal ? 1782622450 : null,
durationMs: null,
};
}
function codexReplayPreamble(input: {
readonly nativeThreadId: string;
readonly nativeTurnId: string;
readonly prompt: string;
readonly sentPrompt?: string;
readonly effort?: string;
}): Array<CodexReplay.CodexAppServerReplayEntry> {
return [
{
type: "expect_outbound",
label: "initialize",
frame: {
id: 1,
method: "initialize",
params: {
clientInfo: { name: "T3 Code", title: "T3 Code", version: packageJson.version },
capabilities: {
experimentalApi: true,
optOutNotificationMethods: ["turn/diff/updated"],
extensions: {
"io.modelcontextprotocol/ui": { mimeTypes: ["text/html;profile=mcp-app"] },
},
},
},
},
},
{
type: "emit_inbound",
label: "initialize",
frame: {
id: 1,
result: {
userAgent: "T3 Code/0.156.1",
codexHome: "/tmp/codex-home",
platformFamily: "unix",
platformOs: "macos",
},
},
},
{ type: "expect_outbound", label: "initialized", frame: { method: "initialized" } },
{
type: "expect_outbound",
label: "thread/start",
frame: {
id: 2,
method: "thread/start",
params: { config: CodexAdapterV2.CODEX_THREAD_CONFIG },
},
},
{
type: "emit_inbound",
label: "thread/start",
frame: {
id: 2,
result: {
thread: {
id: input.nativeThreadId,
sessionId: input.nativeThreadId,
projectId: null,
forkedFromId: null,
preview: "",
ephemeral: false,
modelProvider: "openai",
createdAt: 1782622440,
updatedAt: 1782622440,
status: { type: "idle" },
path: `/tmp/${input.nativeThreadId}.jsonl`,
cwd: "/workspace",
cliVersion: "0.144.0",
source: "vscode",
threadSource: null,
agentNickname: null,
agentRole: null,
gitInfo: null,
name: null,
turns: [],
},
model: "gpt-5.4",
modelProvider: "openai",
serviceTier: null,
cwd: "/workspace",
instructionSources: [],
approvalPolicy: "on-request",
approvalsReviewer: "user",
sandbox: { type: "workspaceWrite", writableRoots: [], networkAccess: false },
reasoningEffort: "medium",
},
},
},
{
type: "expect_outbound",
label: "turn/start",
frame: {
id: 3,
method: "turn/start",
params: {
threadId: input.nativeThreadId,
input: [{ type: "text", text: input.sentPrompt ?? input.prompt }],
cwd: "/workspace",
model: "gpt-5.4",
approvalPolicy: "never",
approvalsReviewer: "user",
sandboxPolicy: { type: "dangerFullAccess" },
summary: "detailed",
...(input.effort === undefined ? {} : { effort: input.effort }),
collaborationMode: {
mode: "default",
settings: {
model: "gpt-5.4",
...(input.effort === undefined ? {} : { reasoning_effort: input.effort }),
},
},
},
},
},
{
type: "emit_inbound",
label: "turn/start",
frame: {
id: 3,
result: { turn: makeCodexReplayTurn({ id: input.nativeTurnId, status: "inProgress" }) },
},
},
{
type: "emit_inbound",
label: "turn/started",
frame: {
method: "turn/started",
params: {
threadId: input.nativeThreadId,
turn: makeCodexReplayTurn({ id: input.nativeTurnId, status: "inProgress" }),
},
},
},
];
}
function makeCodexReplayTranscript(input: {
readonly scenario: string;
readonly entries: ReadonlyArray<CodexReplay.CodexAppServerReplayEntry>;
}): CodexReplay.CodexAppServerReplayTranscript {
return {
provider: "codex",
protocol: "codex.app-server",
version: "0.144.0",
scenario: input.scenario,
entries: input.entries,
};
}
function withReplayRequestId(
entry: CodexReplay.CodexAppServerReplayEntry,
id: number,
): CodexReplay.CodexAppServerReplayEntry {
return entry.type !== "runtime_exit" && Predicate.isObject(entry.frame)
? { ...entry, frame: { ...entry.frame, id } }
: entry;
}
describe("CodexAdapterV2 process exit", () => {
it.effect.each([
{ exit: "numeric", active: false },
{ exit: "SIGKILL", active: false },
{ exit: "numeric", active: true },
{ exit: "SIGKILL", active: true },
] as const)("retires the shared session after $exit (active turn: $active)", ({ exit, active }) =>
Effect.gen(function* () {
const scenario = `process-exit-${exit}-${active}`;
const nativeThreadId = `native-${scenario}`;
const nativeTurnId = `turn-${scenario}`;
const input = yield* Queue.unbounded<Uint8Array, Cause.Done>();
const emit = (frame: unknown) =>
Queue.offer(input, new TextEncoder().encode(JSON.stringify(frame) + "\n"));
const outputEnded = yield* Deferred.make<void>();
const turnStarted = yield* Deferred.make<void>();
const turnCompleted = yield* Deferred.make<void>();
const events: Array<ProviderAdapter.ProviderAdapterV2Event> = [];
const preamble = codexReplayPreamble({ nativeThreadId, nativeTurnId, prompt: "work" });
const terminationError =
exit === "numeric"
? new CodexError.CodexAppServerProcessExitedError({ code: 17, pid: 52 })
: new CodexError.CodexAppServerTransportError({
operation: "read-process-exit-status",
pid: 52,
cause: PlatformError.systemError({
_tag: "Unknown",
module: "ChildProcess",
method: "exitCode",
cause: new Error("Process terminated by SIGKILL"),
}),
});
const client = yield* CodexClient.make(
Stdio.make({
args: Effect.succeed([]),
stdin: Stream.fromQueue(input),
stdout: () =>
Sink.forEach((chunk: string | Uint8Array) =>
Effect.gen(function* () {
const frame = JSON.parse(
typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk),
) as { readonly id?: number; readonly method: string };
const response = preamble.find(
(entry) =>
entry.type === "emit_inbound" &&
entry.label === frame.method &&
Predicate.isObject(entry.frame) &&
"id" in entry.frame,
);
if (response?.type === "emit_inbound") {
yield* emit(response.frame);
}
}),
).pipe(Sink.ensuring(Deferred.succeed(outputEnded, undefined))),
stderr: () => Sink.drain,
}),
{},
Effect.succeed(terminationError),
);
const adapter = yield* CodexAdapterV2.makeCodexAdapterV2({
instanceId: CodexAdapterV2.CODEX_DEFAULT_INSTANCE_ID,
settings: DEFAULT_CODEX_SETTINGS,
environment: {},
clientFactory: { open: () => Effect.succeed(client) },
digest: yield* Digest.Digest,
fileSystem: yield* FileSystem.FileSystem,
idAllocator: yield* IdAllocator.IdAllocatorV2,
serverConfig: yield* ProviderReplayHarness.makeReplayServerConfig(scenario).pipe(
Effect.orDie,
),
});
const threadId = ThreadId.make(`thread-${scenario}`);
const runtime = yield* adapter.openSession({
threadId,
providerSessionId: ProviderSessionId.make(`session-${scenario}`),
modelSelection: CODEX_TEST_MODEL_SELECTION,
runtimePolicy: CODEX_TEST_RUNTIME_POLICY,
});
const eventReader = yield* runtime.events.pipe(
Stream.runForEach((event) =>
Effect.sync(() => events.push(event)).pipe(
Effect.andThen(
event.type === "provider_turn.updated" && event.providerTurn.status === "running"
? Deferred.succeed(turnStarted, undefined)
: event.type === "turn.terminal"
? Deferred.succeed(turnCompleted, undefined)
: Effect.void,
),
),
),
Effect.forkScoped,
);
const providerThread = yield* runtime.ensureThread({
threadId,
modelSelection: CODEX_TEST_MODEL_SELECTION,
runtimePolicy: CODEX_TEST_RUNTIME_POLICY,
});
yield* runtime.startTurn(
makeCodexTestTurnInput({
threadId,
providerThread,
now: yield* DateTime.now,
attemptId: RunAttemptId.make(`attempt-${scenario}`),
text: "work",
}),
);
yield* emit({
method: "turn/started",
params: {
threadId: nativeThreadId,
turn: makeCodexReplayTurn({ id: nativeTurnId, status: "inProgress" }),
},
});
yield* Deferred.await(turnStarted);
if (!active) {
yield* emit({
method: "turn/completed",
params: {
threadId: nativeThreadId,
turn: makeCodexReplayTurn({ id: nativeTurnId, status: "completed" }),
},
});
yield* Deferred.await(turnCompleted);
assert.isTrue(
events.some((event) => event.type === "turn.terminal" && event.status === "completed"),
);
}
yield* Queue.end(input);
// Output closes only after the protocol records the process termination.
yield* Deferred.await(outputEnded);
const rpcError = yield* client.request("thread/list", {}).pipe(Effect.flip);
assert.strictEqual(rpcError, terminationError);
// Without the fix the stream never ends, so this waits until the project timeout.
const readerExit = yield* Fiber.await(eventReader);
// A failure, not a clean end, carries the Codex error into the session's lastError.
assert.isTrue(
Exit.isFailure(readerExit) &&
isProviderAdapterEventStreamError(Cause.squash(readerExit.cause)),
"the session manager must receive process death so it can retire the shared process",
);
}).pipe(
Effect.scoped,
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
NodeServices.layer,
NodeCrypto.layer,
),
),
),
);
it.effect("counts the app-server as a running agent until its session closes", () => {
let runningAgents = 0;
const factoryLayer = CodexAdapterV2.layerAppServerClientFactory.pipe(
Layer.provide(
Layer.mock(PortScanner.PortDiscovery)({
trackAgent: () => {
runningAgents += 1;
return () => {
runningAgents -= 1;
};
},
}),
),
Layer.provide(
Layer.succeed(ProviderEventLoggers.ProviderEventLoggers, {
native: undefined,
canonical: undefined,
}),
),
Layer.provide(
Layer.succeed(
ChildProcessSpawner.ChildProcessSpawner,
ChildProcessSpawner.make(() =>
Effect.succeed(
ChildProcessSpawner.makeHandle({
pid: ChildProcessSpawner.ProcessId(999_999_999),
exitCode: Effect.never,
isRunning: Effect.succeed(true),
kill: () => Effect.void,
unref: Effect.succeed(Effect.void),
stdin: Sink.drain,
stdout: Stream.never,
stderr: Stream.empty,
all: Stream.empty,
getInputFd: () => Sink.drain,
getOutputFd: () => Stream.empty,
}),
),
),
),
),
);
return Effect.gen(function* () {
const factory = yield* CodexAdapterV2.CodexAppServerClientFactory;
yield* Effect.scoped(
factory
.open({
instanceId: CodexAdapterV2.CODEX_DEFAULT_INSTANCE_ID,
threadId: ThreadId.make("thread-codex-agent"),
providerSessionId: ProviderSessionId.make("session-codex-agent"),
runtimePolicy: CODEX_TEST_RUNTIME_POLICY,
settings: DEFAULT_CODEX_SETTINGS,
environment: {},
})
.pipe(Effect.tap(() => Effect.sync(() => assert.equal(runningAgents, 1)))),
);
assert.equal(runningAgents, 0);
}).pipe(Effect.provide(factoryLayer));
});
});
describe("CodexAdapterV2 session initialize", () => {
const openReplaySession = (
transcript: CodexReplay.CodexAppServerReplayTranscript,
beforeEmitInbound?: CodexReplay.CodexAppServerReplayDriver["beforeEmitInbound"],
compatibility?: CodexAdapterV2.CodexAdapterV2Options["compatibility"],
) =>
Effect.gen(function* () {
const driver = yield* CodexReplay.makeReplayDriver(
transcript,
beforeEmitInbound === undefined ? {} : { beforeEmitInbound },
);
let initializeRequests = 0;
const adapter = yield* CodexAdapterV2.makeCodexAdapterV2({
instanceId: CodexAdapterV2.CODEX_DEFAULT_INSTANCE_ID,
settings: DEFAULT_CODEX_SETTINGS,
environment: {},
...(compatibility === undefined ? {} : { compatibility }),
clientFactory: {
open: (openInput) =>
Layer.build(CodexReplay.layerReplayWithDriver(driver)).pipe(
Effect.flatMap((context) =>
Effect.service(CodexClient.CodexAppServerClient).pipe(Effect.provide(context)),
),
Effect.map(
(client) =>
({
...client,
request: (method, params) =>
Effect.sync(() => {
if (method === "initialize") initializeRequests++;
}).pipe(Effect.andThen(client.request(method, params))),
}) satisfies CodexClient.CodexAppServerClient["Service"],
),
Effect.mapError(
(cause) =>
new ProviderAdapter.ProviderAdapterOpenSessionError({
driver: CodexAdapterV2.CODEX_DRIVER_KIND,
providerSessionId: openInput.providerSessionId,
cause,
}),
),
),
},
digest: yield* Digest.Digest,
fileSystem: yield* FileSystem.FileSystem,
idAllocator: yield* IdAllocator.IdAllocatorV2,
serverConfig: yield* ProviderReplayHarness.makeReplayServerConfig(transcript.scenario).pipe(
Effect.orDie,
),
});
const runtime = yield* adapter.openSession({
threadId: ThreadId.make(`thread-${transcript.scenario}`),
providerSessionId: ProviderSessionId.make(`provider-session-${transcript.scenario}`),
modelSelection: CODEX_TEST_MODEL_SELECTION,
runtimePolicy: CODEX_TEST_RUNTIME_POLICY,
});
return {
ensureThread: (threadId: string) =>
runtime.ensureThread({
threadId: ThreadId.make(threadId),
modelSelection: CODEX_TEST_MODEL_SELECTION,
runtimePolicy: CODEX_TEST_RUNTIME_POLICY,
}),
initializeRequests: () => initializeRequests,
};
});
const replayPreamble = (nativeThreadId: string) =>
codexReplayPreamble({ nativeThreadId, nativeTurnId: "unused", prompt: "unused" });
it.effect("sends one initialize when two threads start on a fresh session at once", () =>
Effect.gen(function* () {
const initializeAwaitingResponse = yield* Deferred.make<void>();
const releaseInitialize = yield* Deferred.make<void>();
// Codex rejects a second initialize; the replay permits one handshake.
const session = yield* openReplaySession(
makeCodexReplayTranscript({
scenario: "concurrent-initialize",
entries: [
...replayPreamble("concurrent-first").slice(0, 5),
...replayPreamble("concurrent-second")
.slice(3, 5)
.map((entry) => withReplayRequestId(entry, 3)),
],
}),
(entry) =>
entry.label === "initialize"
? Deferred.succeed(initializeAwaitingResponse, undefined).pipe(
Effect.andThen(Deferred.await(releaseInitialize)),
)
: Effect.void,
);
const first = yield* session
.ensureThread("thread-concurrent-first")
.pipe(Effect.forkChild({ startImmediately: true }));
yield* Deferred.await(initializeAwaitingResponse);
const second = yield* session
.ensureThread("thread-concurrent-second")
.pipe(Effect.forkChild({ startImmediately: true }));
yield* Deferred.succeed(releaseInitialize, undefined);
const providerThreads = [yield* Fiber.join(first), yield* Fiber.join(second)];
assert.equal(session.initializeRequests(), 1);
assert.sameMembers(
providerThreads.map((providerThread) => providerThread.nativeThreadRef?.nativeId),
["concurrent-first", "concurrent-second"],
);
}).pipe(
Effect.scoped,
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
NodeServices.layer,
NodeCrypto.layer,
),
),
),
);
// regression: #16260 one-shot initializers raced; a failed handshake must be retried
it.effect("retries initialize after a failed handshake", () =>
Effect.gen(function* () {
const preamble = replayPreamble("initialize-retry");
const entries: Array<CodexReplay.CodexAppServerReplayEntry> = [
...preamble.slice(0, 1),
{
type: "emit_inbound",
label: "initialize",
frame: { id: 1, error: { code: -32603, message: "Codex is not ready." } },
},
...preamble.slice(0, 2).map((entry) => withReplayRequestId(entry, 2)),
...preamble.slice(2, 3),
...preamble.slice(3, 5).map((entry) => withReplayRequestId(entry, 3)),
];
const session = yield* openReplaySession(
makeCodexReplayTranscript({ scenario: "initialize-retry", entries }),
);
const failure = yield* session.ensureThread("thread-initialize-retry").pipe(Effect.flip);
assert.equal(failure._tag, "ProviderAdapterEnsureThreadError");
const providerThread = yield* session.ensureThread("thread-initialize-retry");
assert.equal(providerThread.nativeThreadRef?.nativeId, "initialize-retry");
assert.equal(session.initializeRequests(), 2);
}).pipe(
Effect.scoped,
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
NodeServices.layer,
NodeCrypto.layer,
),
),
),
);
it.effect("refuses to open a session on a Codex version marked broken", () =>
Effect.gen(function* () {
const [initialize] = replayPreamble("broken-version");
const failure = yield* openReplaySession(
makeCodexReplayTranscript({
scenario: "broken-version",
entries: [
initialize!,
{
type: "emit_inbound",
label: "initialize",
frame: {
id: 1,
result: {
userAgent: "T3 Code/0.144.3 (Mac OS 15.5.0; x86_64) unknown (T3 Code; 0.1.5)",
codexHome: "/tmp/codex-home",
platformFamily: "unix",
platformOs: "macos",
},
},
},
],
}),
undefined,
(version) =>
Effect.succeed(
resolveProviderCompatibility(
ModelManifest.BUNDLED_MODEL_MANIFEST.compatibility,
CodexAdapterV2.CODEX_DRIVER_KIND,
version,
),
),
).pipe(Effect.flip);
assert.instanceOf(failure, ProviderAdapter.ProviderAdapterOpenSessionError);
assert.instanceOf(failure.cause, ProviderSetupError);
assert.equal(
failure.cause.message,
"Codex 0.144.3 does not work with this T3 Code release. Update Codex to >=0.159.0, then retry.",
);
}).pipe(
Effect.scoped,
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
NodeServices.layer,
NodeCrypto.layer,
),
),
),
);
it.effect("completes the handshake after a caller is interrupted mid-initialize", () =>
Effect.gen(function* () {
const initializeAwaitingResponse = yield* Deferred.make<void>();
const releaseInitialize = yield* Deferred.make<void>();
const preamble = replayPreamble("initialize-interrupted");
const session = yield* openReplaySession(
makeCodexReplayTranscript({
scenario: "initialize-interrupted",
entries: [
...preamble.slice(0, 2),
...preamble.slice(0, 1).map((entry) => withReplayRequestId(entry, 2)),
{
type: "emit_inbound",
label: "initialize-rejected",
frame: { id: 2, error: { code: -32600, message: "Already initialized" } },
},
...preamble.slice(2, 3),
...preamble.slice(3, 5).map((entry) => withReplayRequestId(entry, 3)),
],
}),
(entry) =>
entry.label === "initialize"
? Deferred.succeed(initializeAwaitingResponse, undefined).pipe(
Effect.andThen(Deferred.await(releaseInitialize)),
)
: Effect.void,
);
const interrupted = yield* session
.ensureThread("thread-initialize-interrupted")
.pipe(Effect.forkChild({ startImmediately: true }));
yield* Deferred.await(initializeAwaitingResponse);
yield* Fiber.interrupt(interrupted);
yield* Deferred.succeed(releaseInitialize, undefined);
const providerThread = yield* session.ensureThread("thread-initialize-interrupted");
assert.equal(providerThread.nativeThreadRef?.nativeId, "initialize-interrupted");
assert.equal(session.initializeRequests(), 2);
}).pipe(
Effect.scoped,
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
NodeServices.layer,
NodeCrypto.layer,
),
),
),
);
});
describe("CodexAdapterV2 post-settle continuation", () => {
// The harness notifies after every recorded event or continuation, so a wait
// re-checks exactly when the state it reads changes. Subscribing before the
// first check means a change that lands in between is not lost.
const makeChangeSignal = Effect.gen(function* () {
const changes = yield* PubSub.unbounded<void>();
const until = (predicate: () => boolean): Effect.Effect<void> =>
Effect.scoped(
Effect.gen(function* () {
const subscription = yield* PubSub.subscribe(changes);
while (!predicate()) yield* PubSub.take(subscription);
}),
);
return { notify: PubSub.publish(changes, undefined), until };
});
const makeCodexReplayHarness = (
transcript: CodexReplay.CodexAppServerReplayTranscript,
onEvent: (event: ProviderAdapter.ProviderAdapterV2Event) => Effect.Effect<unknown> = () =>
Effect.void,
onRequest: (method: string, params: unknown) => Effect.Effect<void> = () => Effect.void,
readChildMetadata?: Parameters<typeof withCodexReplayChildMetadata>[2],
beforeEmitInbound?: CodexReplay.CodexAppServerReplayDriver["beforeEmitInbound"],
onUsageLimits?: CodexAdapterV2.CodexAdapterV2Options["onUsageLimits"],
) =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const serverConfig = yield* ProviderReplayHarness.makeReplayServerConfig(
transcript.scenario,
).pipe(Effect.orDie);
const changes = yield* makeChangeSignal;
const continuationRequests: Array<ProviderContinuationRequests.ProviderContinuationRequest> =
[];
const driver = yield* CodexReplay.makeReplayDriver(
transcript,
beforeEmitInbound === undefined ? {} : { beforeEmitInbound },
);
const clientFactory: CodexAdapterV2.CodexAppServerClientFactoryShape = {
open: (openInput) =>
Layer.build(CodexReplay.layerReplayWithDriver(driver)).pipe(
Effect.mapError(
(cause) =>
new ProviderAdapter.ProviderAdapterOpenSessionError({
driver: CodexAdapterV2.CODEX_DRIVER_KIND,
providerSessionId: openInput.providerSessionId,
cause,
}),
),
Effect.flatMap((context) =>
Effect.service(CodexClient.CodexAppServerClient).pipe(
Effect.map((client) =>
withCodexReplayChildMetadata(client, transcript, readChildMetadata),
),
Effect.map(
(client) =>
({
...client,
request: (method, params) =>
onRequest(method, params).pipe(
Effect.andThen(client.request(method, params)),
),
raw: {
...client.raw,
request: (method, params) =>
onRequest(method, params).pipe(
Effect.andThen(client.raw.request(method, params)),
),
},
}) satisfies CodexClient.CodexAppServerClient["Service"],
),
Effect.provide(context),
),
),
),
};
const adapter = yield* CodexAdapterV2.makeCodexAdapterV2({
instanceId: CodexAdapterV2.CODEX_DEFAULT_INSTANCE_ID,
settings: DEFAULT_CODEX_SETTINGS,
environment: {},
clientFactory,
...(onUsageLimits ? { onUsageLimits } : {}),
digest: yield* Digest.Digest,
fileSystem,
idAllocator,
serverConfig,
continuationRequests: {
offer: (request) =>
Effect.sync(() => {
continuationRequests.push(request);
}).pipe(Effect.andThen(changes.notify)),
},
});
const threadId = ThreadId.make(`thread-${transcript.scenario}`);
const runtime = yield* adapter.openSession({
threadId,
providerSessionId: ProviderSessionId.make(`provider-session-${transcript.scenario}`),
modelSelection: CODEX_TEST_MODEL_SELECTION,
runtimePolicy: CODEX_TEST_RUNTIME_POLICY,
});
const providerThread = yield* runtime.ensureThread({
threadId,
modelSelection: CODEX_TEST_MODEL_SELECTION,
runtimePolicy: CODEX_TEST_RUNTIME_POLICY,
});
const events: Array<ProviderAdapter.ProviderAdapterV2Event> = [];
const firstTerminal = yield* Deferred.make<void>();
yield* runtime.events.pipe(
Stream.runForEach((event) =>
Effect.sync(() => {
events.push(event);
}).pipe(
Effect.andThen(
event.type === "turn.terminal"
? Deferred.succeed(firstTerminal, undefined)
: Effect.void,
),
Effect.andThen(changes.notify),
Effect.andThen(onEvent(event)),
),
),
Effect.forkScoped,
);
if (runtime.hasPendingBackgroundWork === undefined) {
return yield* Effect.die("Codex adapter runtime must expose hasPendingBackgroundWork.");
}
const hasPendingBackgroundWork = runtime.hasPendingBackgroundWork;
const terminalEvents = () =>
events.filter(
(
event,
): event is Extract<ProviderAdapter.ProviderAdapterV2Event, { type: "turn.terminal" }> =>
event.type === "turn.terminal",
);
const subagentUpdates = () =>
events.filter(
(
event,
): event is Extract<
ProviderAdapter.ProviderAdapterV2Event,
{ type: "subagent.updated" }
> => event.type === "subagent.updated",
);
return {
runtime,
providerThread,
threadId,
serverConfig,
events,
continuationRequests,
terminalEvents,
subagentUpdates,
hasPendingBackgroundWork,
firstTerminal: Deferred.await(firstTerminal),
until: changes.until,
awaitTerminal: (count: number) => changes.until(() => terminalEvents().length >= count),
};
});
it.effect.each(["before", "after"] as const)(
"rejects a previous run's native turn when it completes %s the new start response",
(completionOrder) =>
Effect.gen(function* () {
const nativeThreadId = "reused-turn-thread";
const nativeTurnId = "reused-turn";
const preamble = codexReplayPreamble({ nativeThreadId, nativeTurnId, prompt: "work" });
const retry = codexReplayPreamble({
nativeThreadId,
nativeTurnId: "retry-turn",
prompt: "work",
});
const completion: CodexReplay.CodexAppServerReplayEntry = {
type: "emit_inbound",
label: "original turn completed",
frame: {
method: "turn/completed",
params: {
threadId: nativeThreadId,
turn: makeCodexReplayTurn({ id: nativeTurnId, status: "completed" }),
},
},
};
const harness = yield* makeCodexReplayHarness(
makeCodexReplayTranscript({
scenario: `reused-turn-${completionOrder}`,
entries: [
...preamble,
withReplayRequestId(preamble[5]!, 4),
...(completionOrder === "before" ? [completion] : []),
withReplayRequestId(preamble[6]!, 4),
...(completionOrder === "after" ? [completion] : []),
...retry.slice(5, 7).map((entry) => withReplayRequestId(entry, 5)),
{
type: "emit_inbound",
label: "retry completed",
frame: {
method: "turn/completed",
params: {
threadId: nativeThreadId,
turn: makeCodexReplayTurn({ id: "retry-turn", status: "completed" }),
},
},
},
],
}),
);
const first = makeCodexTestTurnInput({
threadId: harness.threadId,
providerThread: harness.providerThread,
now: yield* DateTime.now,
attemptId: RunAttemptId.make("original"),
text: "work",
});
yield* harness.runtime.startTurn(first);
const result = yield* harness.runtime
.startTurn({
...first,
runId: RunId.make("replacement"),
attemptId: RunAttemptId.make("replacement"),
rootNodeId: NodeId.make("replacement"),
runOrdinal: 2,
providerTurnOrdinal: 2,
})
.pipe(Effect.result);
assert.equal(result._tag, "Failure", "a different run must not adopt the original turn");
if (result._tag !== "Failure") return;
const failure = result.failure;
assert.equal(failure._tag, "ProviderAdapterTurnStartError");
assert.instanceOf(failure.cause, ProviderAdapter.ProviderAdapterProtocolError);
yield* harness.firstTerminal;
assert.deepEqual(
harness.terminalEvents().map((event) => event.runOrdinal),
[1],
);
yield* harness.runtime.startTurn({
...first,
runId: RunId.make("retry"),
attemptId: RunAttemptId.make("retry"),
rootNodeId: NodeId.make("retry"),
runOrdinal: 3,
providerTurnOrdinal: 3,
});
yield* harness.awaitTerminal(2);
assert.deepEqual(
harness.terminalEvents().map((event) => [event.runOrdinal, event.status]),
[
[1, "completed"],
[3, "completed"],
],
);
}).pipe(
Effect.scoped,
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
NodeServices.layer,
NodeCrypto.layer,
),
),
),
);
it.effect.each(["supported", "unsupported", "invalid"] as const)(
"delivers native history with %s app-server protocol",
(response) =>
Effect.gen(function* () {
const nativeThreadId = `inject-${response}`;
const prompt = "Only the current request";
const history: ProviderAdapter.ProviderAdapterV2HistoricalContext = {
context: "Historical conversation",
messages: (["user", "assistant"] as const).map((role) => ({
role,
text:
role === "user"
? "Original request\n" + "界".repeat(300)
: "Partial interrupted work",
threadId: ThreadId.make("source"),
runId: RunId.make("source-run"),
itemId: TurnItemId.make(`source-${role}`),
providerThreadId: null,
kind: `${role}_message`,
status: "interrupted",
})),
};
const items = historyResponseItems(history.messages, history.context);
const preamble = codexReplayPreamble({
nativeThreadId,
nativeTurnId: "current-turn",
prompt,
});
const transcript = makeCodexReplayTranscript({
scenario: `inject-${response}`,
entries: [
...preamble.slice(0, -3),
{
type: "expect_outbound",
label: "inject",
frame: {
id: 3,
method: "thread/inject_items",
params: { threadId: nativeThreadId, items },
},
},
{
type: "emit_inbound",
label: "inject-result",
frame:
response === "supported"
? { id: 3, result: {} }
: {
id: 3,
error: {
code: response === "unsupported" ? -32601 : -32602,
message: "Injection rejected",
},
},
},
...(response === "invalid"
? []
: preamble
.slice(-3)
.map((entry) =>
"frame" in entry && Predicate.isObject(entry.frame) && "id" in entry.frame
? { ...entry, frame: { ...entry.frame, id: 4 } }
: entry,
)),
],
});
const requests: string[] = [];
const harness = yield* makeCodexReplayHarness(
transcript,
() => Effect.void,
(method) =>
Effect.sync(() => {
requests.push(method);
}),
);
const injection = yield* harness.runtime.injectHistory!({
providerThread: harness.providerThread,
...history,
}).pipe(Effect.result);
if (response === "invalid") {
assert.equal(injection._tag, "Failure");
if (injection._tag === "Failure") {
assert.equal(injection.failure._tag, "ProviderAdapterProtocolError");
assert.propertyVal(injection.failure.cause, "code", -32602);
assert.notProperty(injection.failure, "payload");
}
assert.notInclude(requests, "turn/start");
return;
}
assert.equal(injection._tag, "Success");
if (injection._tag === "Success") assert.equal(injection.success, response === "supported");
yield* harness.runtime.startTurn(
makeCodexTestTurnInput({
threadId: harness.threadId,
providerThread: harness.providerThread,
now: yield* DateTime.now,
attemptId: RunAttemptId.make("inject-attempt"),
text: prompt,
}),
);
assert.equal(requests.filter((method) => method === "turn/start").length, 1);
assert.isBelow(requests.indexOf("thread/inject_items"), requests.indexOf("turn/start"));
}).pipe(
Effect.scoped,
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
NodeServices.layer,
NodeCrypto.layer,
),
),
),
);
it.effect("adds the session MCP server without replacing launch-argument servers", () =>
Effect.gen(function* () {
const scenario = "launch-mcp-servers";
yield* (yield* McpProviderSessions.McpProviderSessions).set({
environmentId: EnvironmentId.make("environment-codex-mcp"),
threadId: ThreadId.make(`thread-${scenario}`),
providerSessionId: `provider-session-${scenario}`,
providerInstanceId: ProviderInstanceId.make("codex"),
endpoint: "http://127.0.0.1:43123/mcp",
authorizationHeader: "Bearer secret-codex-token",
browserToolsAvailable: true,
});
const requests: Array<unknown> = [];
yield* makeCodexReplayHarness(
makeCodexReplayTranscript({
scenario,
entries: codexReplayPreamble({
nativeThreadId: "launch-mcp-thread",
nativeTurnId: "unused",
prompt: "unused",
}).slice(0, 5),
}),
() => Effect.void,
(method, params) =>
Effect.sync(() => {
if (method === "thread/start") requests.push(params);
}),
);
assert.deepEqual(requests, [
{
cwd: "/workspace",
model: "gpt-5.4",
config: {
"tools.update_plan.enabled": true,
mcp_optional_startup_grace_ms: 10_000,
"shell_environment_policy.set.T3CODE_THREAD_ID": `thread-${scenario}`,
"mcp_servers.t3-code": {
url: "http://127.0.0.1:43123/mcp",
tool_timeout_sec: 3_900,
http_headers: { Authorization: "Bearer secret-codex-token" },
disabled_tools: ["t3_thread_wait"],
},
"mcp_servers.t3-code-direct": {
url: "http://127.0.0.1:43123/mcp",
tool_timeout_sec: 3_900,
http_headers: { Authorization: "Bearer secret-codex-token" },
enabled_tools: ["t3_thread_wait"],
omit_tools_from: ["code_mode", "deferred"],
},
},
},
]);
}).pipe(
Effect.scoped,
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
NodeServices.layer,
NodeCrypto.layer,
),
),
),
);
// regression: #15839 launch-arg MCP servers survive the thread's t3-code server
it.effect("replays historical and dotted MCP config while enforcing other thread config", () =>
Effect.gen(function* () {
const recordedServer = {
url: "http://127.0.0.1:41000/mcp",
http_headers: { Authorization: "Bearer recorded-token" },
};
const currentConfig = {
"tools.update_plan.enabled": true,
"mcp_servers.t3-code": {
url: "http://127.0.0.1:42000/mcp",
http_headers: { Authorization: "Bearer current-token" },
},
"mcp_servers.extra.command": "cat",
};
for (const recordedMcp of [
{ mcp_servers: { "t3-code": recordedServer } },
{ "mcp_servers.t3-code": recordedServer, "mcp_servers.extra.command": "echo" },
]) {
const entries = codexReplayPreamble({
nativeThreadId: "replayed-mcp-thread",
nativeTurnId: "unused",
prompt: "unused",
})
.slice(3, 5)
.map((entry) => withReplayRequestId(entry, 1));
entries[0] = {
type: "expect_outbound",
frame: {
id: 1,
method: "thread/start",
params: { config: { "tools.update_plan.enabled": true, ...recordedMcp } },
},
};
entries.push({
...entries[0],
frame: {
id: 2,
method: "thread/start",
params: { config: { "tools.update_plan.enabled": true, ...recordedMcp } },
},
});
const driver = yield* CodexReplay.makeReplayDriver(
makeCodexReplayTranscript({
scenario: "mcp-config-normalization",
entries,
}),
);
yield* Effect.gen(function* () {
const client = yield* CodexClient.CodexAppServerClient;
const response = yield* client.request("thread/start", { config: currentConfig });
assert.equal(response.thread.id, "replayed-mcp-thread");
assert.isNull((yield* Ref.get(driver.state)).failure);
yield* client
.request("thread/start", {
config: { ...currentConfig, "tools.update_plan.enabled": false },
})
.pipe(Effect.flip);
assert.instanceOf(
(yield* Ref.get(driver.state)).failure,
CodexReplay.CodexAppServerReplayFrameMismatchError,
);
}).pipe(Effect.provide(CodexReplay.layerReplayWithDriver(driver)));
}
}).pipe(Effect.scoped),
);
it.effect("waits for native start before interrupting an acknowledged queued turn", () =>
Effect.gen(function* () {
const nativeThreadId = "early-stop-thread";
const nativeTurnId = "early-stop-turn";
const prompt = "Run a command.";
const preamble = codexReplayPreamble({ nativeThreadId, nativeTurnId, prompt });
const transcript = makeCodexReplayTranscript({
scenario: "early-stop-await-native-start",
entries: [
...preamble.slice(0, -2),
{
type: "emit_inbound",
label: "turn/start/queued",
frame: {
id: 3,
result: {
turn: {
...makeCodexReplayTurn({ id: nativeTurnId, status: "inProgress" }),
startedAt: null,
},
},
},
},
{
type: "emit_inbound",
label: "turn/started",
afterMs: 1000,
frame: {
method: "turn/started",
params: {
threadId: nativeThreadId,
turn: makeCodexReplayTurn({ id: nativeTurnId, status: "inProgress" }),
},
},
},
{
type: "expect_outbound",
label: "turn/interrupt",
frame: {
id: 4,
method: "turn/interrupt",
params: { threadId: nativeThreadId, turnId: nativeTurnId },
},
},
{ type: "emit_inbound", label: "turn/interrupt", frame: { id: 4, result: {} } },
{
type: "emit_inbound",
label: "turn/completed",