import {
DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER,
ProviderDriverKind,
type ModelSelection,
type ServerProvider,
} from "@t3tools/contracts";
import type { ProviderInstance } from "@t3tools/provider-core/server/driver";
import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { it } from "@effect/vitest";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import * as Scope from "effect/Scope";
import { createModelSelection } from "@t3tools/shared/model";
import { expect } from "vite-plus/test";
import { CodexSettings, ProviderInstanceId } from "@t3tools/contracts";
import * as ServerConfig from "../config.ts";
import { makeProcessProbe, processProbeSource } from "../testUtils/processProbe.ts";
import * as TextGeneration from "./TextGeneration.ts";
import { makeCodexTextGeneration } from "./CodexTextGeneration.ts";
import { writeFakeCli } from "@t3tools/provider-testing/fakeCli";
const decodeCodexSettings = Schema.decodeSync(CodexSettings);
const DEFAULT_TEST_MODEL_SELECTION = createModelSelection(
ProviderInstanceId.make("codex"),
"gpt-5.4-mini",
);
const layerCodexTextGenerationTest = ServerConfig.ServerConfig.layerTest(process.cwd(), {
prefix: "t3code-codex-text-generation-test-",
}).pipe(Layer.provideMerge(NodeServices.layer));
interface FakeCodexInput {
output: string;
lifecycle?: { port: number; command: "exec" | "mcp list" };
exitCode?: number;
stderr?: string;
requireImage?: boolean;
requireServiceTier?: string;
requireReasoningEffort?: string;
forbidReasoningEffort?: boolean;
requireArg?: string;
forbidArg?: string;
stdinMustContain?: string;
stdinMustNotContain?: string;
mcpServers?: ReadonlyArray<{ name: string; enabled: boolean }> | number;
requiredCwd?: string;
requireInstructions?: string;
}
function makeFakeCodexBinary(dir: string, input: FakeCodexInput) {
const check = JSON.stringify({
requireImage: input.requireImage ?? false,
requireServiceTier: input.requireServiceTier ?? null,
requireReasoningEffort: input.requireReasoningEffort ?? null,
forbidReasoningEffort: input.forbidReasoningEffort ?? false,
requireArg: input.requireArg ?? null,
forbidArg: input.forbidArg ?? null,
stdinMustContain: input.stdinMustContain ?? null,
stdinMustNotContain: input.stdinMustNotContain ?? null,
mcpServers: input.mcpServers ?? [],
requiredCwd: input.requiredCwd ?? null,
requireInstructions: input.requireInstructions ?? null,
stderr: input.stderr ?? null,
output: input.output,
exitCode: input.exitCode ?? 0,
});
return Effect.gen(function* () {
const path = yield* Path.Path;
return writeFakeCli({
directory: path.join(dir, "bin"),
name: "codex",
source: [
'import * as NodeFS from "node:fs";',
`const check = ${check};`,
"const args = process.argv.slice(2);",
'const isMcpList = args.includes("mcp") && args.includes("list");',
...(input.lifecycle === undefined
? []
: [
`if (isMcpList === ${input.lifecycle.command === "mcp list"}) {`,
'process.on("SIGTERM", () => {});',
processProbeSource(input.lifecycle.port),
"await new Promise(() => {});",
"}",
]),
"if (isMcpList) {",
' if (typeof check.mcpServers === "number") process.exit(check.mcpServers);',
" process.stdout.write(JSON.stringify(check.mcpServers));",
" process.exit(0);",
"}",
'const originalArgs = ` ${args.join(" ")} `;',
"let outputPath = null;",
"let seenImage = false;",
'let seenServiceTier = "";',
'let seenReasoningEffort = "";',
'let instructions = "";',
"for (let index = 0; index < args.length; index += 1) {",
' if (args[index] === "--image") {',
" index += 1;",
" if (args[index]) seenImage = true;",
' } else if (args[index] === "--config") {',
" index += 1;",
' const value = args[index] ?? "";',
' if (value.startsWith("developer_instructions=")) instructions = JSON.parse(value.slice("developer_instructions=".length));',
' if (value.startsWith("service_tier=")) seenServiceTier = value;',
' if (value.startsWith("model_reasoning_effort=")) seenReasoningEffort = value;',
' } else if (args[index] === "--output-last-message") {',
" index += 1;",
" outputPath = args[index] ?? null;",
" }",
"}",
"const chunks = [];",
"for await (const chunk of process.stdin) chunks.push(chunk);",
'const stdinContent = Buffer.concat(chunks).toString("utf8");',
"function fail(message, code) {",
' process.stderr.write(message + "\\n");',
" process.exit(code);",
"}",
'if (check.requiredCwd !== null && process.cwd() !== check.requiredCwd) fail("cannot inspect checkout", 10);',
'if (check.requireInstructions !== null && !instructions.includes(check.requireInstructions)) fail("missing writer task", 11);',
"if (check.requireArg !== null && !originalArgs.includes(` ${check.requireArg} `)) {",
' fail("missing arg: " + check.requireArg, 8);',
"}",
"if (check.forbidArg !== null && originalArgs.includes(` ${check.forbidArg} `)) {",
' fail("forbidden arg: " + check.forbidArg, 9);',
"}",
'if (check.requireImage && !seenImage) fail("missing --image input", 2);',
"if (",
" check.requireServiceTier !== null &&",
' seenServiceTier !== `service_tier="${check.requireServiceTier}"`',
") {",
' fail("unexpected service tier config: " + seenServiceTier, 5);',
"}",
"if (",
" check.requireReasoningEffort !== null &&",
' seenReasoningEffort !== `model_reasoning_effort="${check.requireReasoningEffort}"`',
") {",
' fail("unexpected reasoning effort config: " + seenReasoningEffort, 6);',
"}",
"if (check.forbidReasoningEffort && seenReasoningEffort.length > 0) {",
' fail("reasoning effort config should be omitted: " + seenReasoningEffort, 7);',
"}",
"if (check.stdinMustContain !== null && !stdinContent.includes(check.stdinMustContain)) {",
' fail("stdin missing expected content", 3);',
"}",
"if (check.stdinMustNotContain !== null && stdinContent.includes(check.stdinMustNotContain)) {",
' fail("stdin contained forbidden content", 4);',
"}",
'if (check.stderr !== null) process.stderr.write(check.stderr + "\\n");',
'if (outputPath !== null) NodeFS.writeFileSync(outputPath, check.output + "\\n");',
"process.exitCode = check.exitCode;",
"",
].join("\n"),
});
});
}
function withFakeCodexEnv<A, E, R>(
input: FakeCodexInput & {
launchArgs?: string;
environment?: NodeJS.ProcessEnv;
models?: ReadonlyArray<string>;
defaultModel?: string;
customModels?: ReadonlyArray<string>;
managedRuntime?: boolean;
},
effectFn: (textGeneration: TextGeneration.TextGeneration["Service"]) => Effect.Effect<A, E, R>,
) {
return Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3code-codex-text-" });
const codexPath = yield* makeFakeCodexBinary(tempDir, input);
const config = decodeCodexSettings({
binaryPath: codexPath,
launchArgs: input.launchArgs,
customModels: input.customModels,
});
const textGeneration = yield* makeCodexTextGeneration(
config,
input.environment === undefined ? undefined : { ...process.env, ...input.environment },
Effect.succeed(
(input.models ?? []).map((slug) => ({
slug,
name: slug,
isCustom: false,
...(slug === input.defaultModel ? { isDefault: true } : {}),
capabilities: null,
})),
),
input.managedRuntime
? Effect.succeed({
config,
environment: input.environment ?? process.env,
revision: "test",
})
: undefined,
);
return yield* effectFn(textGeneration);
}).pipe(Effect.scoped);
}
it.layer(layerCodexTextGenerationTest)("CodexTextGeneration", (it) => {
it.effect.each(["exec", "mcp list"] as const)(
"kills a stalled %s CLI when its request is interrupted",
(command) =>
Effect.gen(function* () {
const probe = yield* makeProcessProbe;
yield* withFakeCodexEnv(
{ output: "", lifecycle: { port: probe.port, command } },
(textGeneration) =>
Effect.gen(function* () {
const fiber = yield* textGeneration
.generateThreadTitle({
cwd: process.cwd(),
message: "Name this thread",
modelSelection: DEFAULT_TEST_MODEL_SELECTION,
})
.pipe(Effect.forkScoped);
yield* probe.started;
const interrupted = yield* Fiber.interrupt(fiber).pipe(Effect.forkScoped);
yield* probe.exited;
yield* Fiber.join(interrupted);
const exit = yield* Fiber.await(fiber);
expect(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)).toBe(true);
}),
);
}),
);
it.effect.each([
{
selectedModel: "gpt-5.6-luna",
models: ["openai.gpt-5.6-luna"],
expected: "openai.gpt-5.6-luna",
},
{
selectedModel: "openai.gpt-5.6-luna",
models: ["openai.gpt-5.6-luna"],
expected: "openai.gpt-5.6-luna",
},
{
selectedModel: "openai.gpt-5.6-luna",
models: ["gpt-6-astra", "gpt-5.6-luna"],
defaultModel: "gpt-6-astra",
expected: "gpt-5.6-luna",
},
{
selectedModel: "gpt-6-luna",
models: ["gpt-5.6-luna", "gpt-6-astra"],
defaultModel: "gpt-6-astra",
expected: "gpt-6-astra",
},
{ selectedModel: "gpt-6-luna", models: ["gpt-5.6-luna"], expected: "gpt-5.6-luna" },
{ selectedModel: "gpt-6-luna", models: [], expected: "gpt-6-luna" },
])(
"dispatches $expected for $selectedModel from $models",
({ selectedModel, models, defaultModel, expected }) =>
withFakeCodexEnv(
{
output: JSON.stringify({ title: "Live title" }),
models,
...(defaultModel ? { defaultModel } : {}),
requireArg: `--model ${expected}`,
},
(textGeneration) =>
Effect.gen(function* () {
const result = yield* textGeneration.generateThreadTitle({
cwd: process.cwd(),
message: "Describe this change",
modelSelection: createModelSelection(ProviderInstanceId.make("codex"), selectedModel),
});
expect(result.title).toBe("Live title");
}),
),
);
it.effect("drops the requested model's options when falling back to another model", () =>
withFakeCodexEnv(
{
output: JSON.stringify({ title: "Live title" }),
models: ["gpt-6-astra"],
requireArg: '--model gpt-6-astra --config model_reasoning_effort="low"',
forbidArg: 'service_tier="priority"',
},
(textGeneration) =>
textGeneration.generateThreadTitle({
cwd: process.cwd(),
message: "Describe this change",
modelSelection: createModelSelection(ProviderInstanceId.make("codex"), "gpt-6-luna", [
{ id: "reasoningEffort", value: "none" },
{ id: "serviceTier", value: "priority" },
]),
}),
),
);
it.effect("sends a configured custom model the managed snapshot leaves out", () =>
withFakeCodexEnv(
{
output: JSON.stringify({ title: "Live title" }),
models: ["gpt-6-astra", "gpt-5.6-luna"],
defaultModel: "gpt-6-astra",
customModels: ["gpt-5.6-luna-preview"],
managedRuntime: true,
requireArg: '--model gpt-5.6-luna-preview --config model_reasoning_effort="high"',
},
(textGeneration) =>
textGeneration.generateThreadTitle({
cwd: process.cwd(),
message: "Describe this change",
modelSelection: createModelSelection(
ProviderInstanceId.make("codex"),
"gpt-5.6-luna-preview",
[{ id: "reasoningEffort", value: "high" }],
),
}),
),
);
it.effect("omits a persisted service tier for managed ChatGPT text generation", () =>
withFakeCodexEnv(
{
output: JSON.stringify({ subject: "Update project", body: "" }),
managedRuntime: true,
forbidArg: 'service_tier="priority"',
},
(textGeneration) =>
textGeneration.generateCommitMessage({
cwd: process.cwd(),
branch: "feature/chatgpt",
stagedSummary: "M README.md",
stagedPatch: "diff --git a/README.md b/README.md",
modelSelection: createModelSelection(ProviderInstanceId.make("codex"), "gpt-5.4", [
{ id: "serviceTier", value: "priority" },
]),
}),
),
);
it.effect("preserves custom PR instructions while allowing checkout inspection", () =>
withFakeCodexEnv(
{
output: JSON.stringify({ title: "Remove default shapes", body: "Removes default shapes." }),
launchArgs: "--config 'developer_instructions=\"Use TEAM: as the PR title prefix\"'",
requiredCwd: process.cwd(),
requireInstructions: "Use TEAM: as the PR title prefix",
forbidArg: "--config features.shell_tool=false",
mcpServers: [
{ name: "augmenter", enabled: true },
{ name: "my.server", enabled: true },
{ name: "already-off", enabled: false },
],
requireArg:
'--config features.plugins=false --config features.apps=false --config mcp_servers={"augmenter"={enabled=false},"my.server"={enabled=false}}',
},
(textGeneration) =>
Effect.gen(function* () {
const result = yield* textGeneration.generatePrContent({
cwd: process.cwd(),
baseBranch: "main",
headBranch: "remove-default-shapes",
commitSummary: "Remove default shapes",
diffSummary: "shapes.ts | 2 --",
diffPatch: "-addDefaultShapes();",
threadContext: "user: in a few minutes PR will be up then $babysit-pr",
modelSelection: DEFAULT_TEST_MODEL_SELECTION,
});
expect(result.title).toBe("Remove default shapes");
}),
),
);
it.effect("still generates when Codex cannot list its MCP servers", () =>
withFakeCodexEnv(
{
output: JSON.stringify({ branch: "remove-default-shapes" }),
mcpServers: 2,
requireArg: "--config features.plugins=false --config features.apps=false --ephemeral",
forbidArg: "mcp_servers=",
},
(textGeneration) =>
Effect.gen(function* () {
const result = yield* textGeneration.generateBranchName({
cwd: process.cwd(),
message: "Remove default shapes from characters",
modelSelection: DEFAULT_TEST_MODEL_SELECTION,
});
expect(result.branch).toBe("remove-default-shapes");
}),
),
);
it.effect("keeps plugins and apps off over launch args that turn them on", () =>
withFakeCodexEnv(
{
output: JSON.stringify({ title: "Remove default shapes" }),
launchArgs: "--config features.plugins=true --config features.apps=true",
requireArg:
"--config features.plugins=true --config features.apps=true --config features.plugins=false --config features.apps=false --ephemeral",
},
(textGeneration) =>
Effect.gen(function* () {
const result = yield* textGeneration.generateThreadTitle({
cwd: process.cwd(),
message: "Remove default shapes from characters",
modelSelection: DEFAULT_TEST_MODEL_SELECTION,
});
expect(result.title).toBe("Remove default shapes");
}),
),
);
it.effect("passes exec-safe launch args into codex exec", () =>
withFakeCodexEnv(
{
output: JSON.stringify({
subject: "Add important change",
body: "",
}),
launchArgs: "--strict-config --listen off",
requireArg: "--strict-config",
forbidArg: "--listen",
},
(textGeneration) =>
textGeneration.generateCommitMessage({
cwd: process.cwd(),
branch: "feature/codex-effect",
stagedSummary: "M README.md",
stagedPatch: "diff --git a/README.md b/README.md",
modelSelection: DEFAULT_TEST_MODEL_SELECTION,
}),
),
);
it.effect("generates branch names even when the ambient scope is already closed", () =>
withFakeCodexEnv(
{
output: JSON.stringify({
branch: "feat/background-generation",
}),
},
(textGeneration) =>
Effect.gen(function* () {
// Background fibers can outlive request scopes; temp files scoped there would be reaped on creation.
const closedScope = yield* Scope.make();
yield* Scope.close(closedScope, Exit.void);
const generated = yield* textGeneration
.generateBranchName({
cwd: process.cwd(),
message: "Please update session handling.",
modelSelection: DEFAULT_TEST_MODEL_SELECTION,
})
.pipe(Effect.provideService(Scope.Scope, closedScope));
expect(generated.branch).toBe("feat/background-generation");
}),
),
);
it.effect("returns the refinement signal for an unresolved subject", () =>
withFakeCodexEnv(
{ output: JSON.stringify({ title: "Investigate issue", needsRefinement: true }) },
(textGeneration) =>
Effect.gen(function* () {
expect(
yield* textGeneration.generateThreadTitle({
cwd: process.cwd(),
message: "Fix this",
modelSelection: DEFAULT_TEST_MODEL_SELECTION,
}),
).toEqual({ title: "Investigate issue", needsRefinement: true });
}),
),
);
it.effect("resolves persisted attachment ids to files for codex image inputs", () =>
withFakeCodexEnv(
{
output: JSON.stringify({
branch: "fix/ui-regression",
}),
requireImage: true,
},
(textGeneration) =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const { attachmentsDir } = yield* ServerConfig.ServerConfig;
const attachmentId = "thread-1-attachment";
const imagePath = path.join(attachmentsDir, `${attachmentId}.png`);
yield* fs.makeDirectory(attachmentsDir, { recursive: true });
yield* fs.writeFile(imagePath, Buffer.from("hello"));
const generated = yield* textGeneration
.generateBranchName({
modelSelection: DEFAULT_TEST_MODEL_SELECTION,
cwd: process.cwd(),
message: "Fix layout bug from screenshot.",
attachments: [
{
type: "image",
id: attachmentId,
name: "bug.png",
mimeType: "image/png",
sizeBytes: 5,
},
],
})
.pipe(
Effect.tap(() =>
fs.stat(imagePath).pipe(
Effect.map((fileInfo) => {
expect(fileInfo.type).toBe("File");
}),
),
),
Effect.ensuring(fs.remove(imagePath).pipe(Effect.ignore)),
);
expect(generated.branch).toBe("fix/ui-regression");
}),
),
);
});
const PREFLIGHT_PRIMARY_STATES = [
"ready",
"pending",
"exhausted",
"not installed",
"signed out",
"signed out, fallback failed",
] as const;
it.effect.each(PREFLIGHT_PRIMARY_STATES)("text generation preflight: %s", (primaryState) =>
Effect.gen(function* () {
const primary = ProviderInstanceId.make("codex");
const fallback = ProviderInstanceId.make("claude_work");
const selection = {
instanceId: primary,
model: "chat-model",
options: [{ id: "effort", value: "high" }],
};
const calls: ModelSelection[] = [];
const instances: ProviderInstance[] = [primary, fallback].map((instanceId) => {
const driver = ProviderDriverKind.make(instanceId === primary ? "codex" : "claudeAgent");
const snapshot: ServerProvider = {
instanceId,
driver,
enabled: true,
installed: true,
status: "ready",
auth: { status: "authenticated" },
version: null,
checkedAt: "1970-01-01T00:00:00Z",
models: [],
slashCommands: [],
skills: [],
...(primaryState === "pending" && instanceId === primary
? { installed: false, status: "warning", auth: { status: "unknown" } }
: {}),
...(primaryState === "not installed" && instanceId === primary
? { installed: false, status: "error", auth: { status: "unknown" } }
: {}),
...(primaryState.startsWith("signed out") && instanceId === primary
? { status: "error", auth: { status: "unauthenticated" } }
: {}),
...(primaryState === "signed out, fallback failed" && instanceId === fallback
? { status: "error", auth: { status: "unknown" } }
: {}),
...(primaryState === "exhausted" && instanceId === primary
? {
usageLimits: {
checkedAt: "1970-01-01T00:00:00Z",
windows: [{ id: "session", kind: "session", label: "Session", usedPercent: 100 }],
},
}
: {}),
};
return {
instanceId,
driverKind: driver,
continuationIdentity: { driverKind: driver, continuationKey: instanceId },
displayName: undefined,
enabled: true,
snapshot: { getSnapshot: Effect.succeed(snapshot) } as ProviderInstance["snapshot"],
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
textGeneration: TextGeneration.TextGeneration.of({
generateCommitMessage: () => Effect.die("unused"),
generatePrContent: () => Effect.die("unused"),
generateBranchName: () => Effect.die("unused"),
generateReviewGuide: () => Effect.die("unused"),
generateTranscriptionPostProcessing: () => Effect.die("unused"),
generateThreadTitle: (input) =>
Effect.sync(() => {
calls.push(input.modelSelection);
return { title: "Generated title" };
}),
}),
};
});
const service = yield* TextGeneration.make.pipe(
Effect.provide(
Layer.mergeAll(
Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)({
listInstances: Effect.succeed(instances),
getInstance: (id) =>
Effect.succeed(instances.find((instance) => instance.instanceId === id)),
}),
ServerSettings.layerTest({
providerInstances: {
[fallback]: { driver: ProviderDriverKind.make("claudeAgent"), config: {} },
},
}),
Layer.mock(SourceControlProviderRegistry.SourceControlProviderRegistry)({
resolveLink: () => Effect.die("unused"),
}),
),
),
);
expect(
yield* service.generateThreadTitle({
cwd: "/tmp",
message: "hello",
linkedContext: "",
modelSelection: selection,
}),
).toEqual({ title: "Generated title" });
expect(calls).toEqual([
primaryState === "ready" ||
primaryState === "pending" ||
primaryState === "signed out, fallback failed"
? selection
: {
instanceId: fallback,
model:
DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER[ProviderDriverKind.make("claudeAgent")],
},
]);
}),
);