Address Codex review feedback

Julius Marminge committed 6 months ago

Commit fa4a29f1 parent 3a38f065 files · +75 −8Browse files

Unified · Split

5 files

apps/server/src/provider/Layers/CodexAdapter.ts +2 −1
apps/server/src/provider/codex/CodexSessionRuntime.test.ts +21 −0
apps/server/src/provider/codex/CodexSessionRuntime.ts +15 −2
packages/effect-codex-app-server/src/client.test.ts +30 −0
packages/effect-codex-app-server/src/client.ts +7 −5

apps/server/src/provider/Layers/CodexAdapter.ts+2−1

 }
 function toTurnStatus(
-  value: EffectCodexSchema.V2TurnCompletedNotification["turn"]["status"],
+  value: EffectCodexSchema.V2TurnCompletedNotification["turn"]["status"] | "cancelled",
 ): "completed" | "failed" | "cancelled" | "interrupted" {
   switch (value) {
     case "completed":
     case "failed":
+    case "cancelled":
     case "interrupted":
       return value;
     default:

apps/server/src/provider/codex/CodexSessionRuntime.test.ts+21−0

@@ -171,6 +171,27 @@ describe("isRecoverableThreadResumeError", () => { · 170 unmodified lines
171	false,	171	false,
172	);	172	);
173	});	173	});
		174
		175	it("ignores unrelated missing-resource errors that do not mention threads", () => {
		176	assert.equal(
		177	isRecoverableThreadResumeError(
		178	new CodexErrors.CodexAppServerRequestError({
		179	code: -32603,
		180	errorMessage: "Config file not found",
		181	}),
		182	),
		183	false,
		184	);
		185	assert.equal(
		186	isRecoverableThreadResumeError(
		187	new CodexErrors.CodexAppServerRequestError({
		188	code: -32603,
		189	errorMessage: "Model does not exist",
		190	}),
		191	),
		192	false,
		193	);
		194	});
174	});	195	});
175		196
176	describe("openCodexThread", () => {	197	describe("openCodexThread", () => {

apps/server/src/provider/codex/CodexSessionRuntime.ts+15−2

 export function isRecoverableThreadResumeError(error: unknown): boolean {
   const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+  if (!message.includes("thread")) {
+    return false;
+  }
   return RECOVERABLE_THREAD_RESUME_ERROR_SNIPPETS.some((snippet) => message.includes(snippet));
 }
   | CodexRpc.ClientRequestResponsesByMethod["thread/start"]
   | CodexRpc.ClientRequestResponsesByMethod["thread/resume"];
+type CodexThreadOpenMethod = "thread/start" | "thread/resume";
+interface CodexThreadOpenClient {
+  readonly request: <M extends CodexThreadOpenMethod>(
+    method: M,
+    payload: CodexRpc.ClientRequestParamsByMethod[M],
+  ) => Effect.Effect<CodexRpc.ClientRequestResponsesByMethod[M], CodexErrors.CodexAppServerError>;
+}
 export const openCodexThread = (input: {
-  readonly client: CodexClient.CodexAppServerClientShape;
+  readonly client: CodexThreadOpenClient;
   readonly threadId: ThreadId;
   readonly runtimeMode: RuntimeMode;
   readonly cwd: string;
               requestId,
             });
           }
+          const codexAnswers = yield* toCodexUserInputAnswers(answers);
           yield* Ref.update(pendingUserInputsRef, (current) => {
             const next = new Map(current);
             next.delete(requestId);
             ...(pending.turnId ? { turnId: pending.turnId } : {}),
             ...(pending.itemId ? { itemId: pending.itemId } : {}),
             payload: {
-              answers: yield* toCodexUserInputAnswers(answers),
+              answers: codexAnswers,
             },
           });
         }),

packages/effect-codex-app-server/src/client.test.ts+30−0

@@ -121,4 +121,34 @@ it.layer(NodeServices.layer)("effect-codex-app-server client", (it) => { · 120 unmodified lines
121	]);	121	]);
122	}),	122	}),
123	);	123	);
		124
		125	it.effect("initializes a command-backed app-server client", () =>
		126	Effect.gen(function* () {
		127	const path = yield* Path.Path;
		128	const scope = yield* Scope.make();
		129	const clientLayer = CodexClient.layerCommand({
		130	command: "bun",
		131	args: ["run", yield* mockPeerPath],
		132	cwd: path.join(import.meta.dirname, ".."),
		133	});
		134	const context = yield* Layer.buildWithScope(clientLayer, scope);
		135
		136	const initialized = yield* Effect.gen(function* () {
		137	const client = yield* CodexClient.CodexAppServerClient;
		138	return yield* client.request("initialize", {
		139	clientInfo: {
		140	name: "effect-codex-app-server-test",
		141	title: "Effect Codex App Server Test",
		142	version: "0.0.0",
		143	},
		144	capabilities: {
		145	experimentalApi: true,
		146	optOutNotificationMethods: null,
		147	},
		148	});
		149	}).pipe(Effect.provide(context), Effect.ensuring(Scope.close(scope, Exit.void)));
		150
		151	assert.equal(initialized.userAgent, "mock-codex-app-server");
		152	}),
		153	);
124	});	154	});

packages/effect-codex-app-server/src/client.ts+7−5

           ...(options.env ? { env: { ...process.env, ...options.env } } : {}),
           shell: process.platform === "win32",
         });
-        const handle = yield* spawner.spawn(command).pipe(
+        return yield* spawner.spawn(command).pipe(
           Effect.mapError(
             (cause) =>
               new CodexError.CodexAppServerSpawnError({
               }),
           ),
         );
-        const client = yield* make(makeChildStdio(handle), options, makeTerminationError(handle));
-        return { client, handle };
       }),
-      ({ handle }) => handle.kill().pipe(Effect.orDie),
+      (handle) => handle.kill().pipe(Effect.orDie),
-    ).pipe(Effect.map(({ client }) => client)),
+    ).pipe(
+      Effect.flatMap((handle) =>
+        make(makeChildStdio(handle), options, makeTerminationError(handle)),
+      ),
+    ),
   );