codex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67// Scoped adapter runtime for the provider's original scripted-peer tests.
// A local Promise facade keeps their scenarios and assertions unchanged.
import type { PluginServices } from "convergence/effect";
import { afterEach } from "node:test";
import * as Queue from "effect/Queue";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Layer from "effect/Layer";
import * as ManagedRuntime from "effect/ManagedRuntime";
import * as Scope from "effect/Scope";
import { liveLayer } from "convergence/effect";
import type { Api } from "convergence";
import { RpcTransport } from "../sdk/effect.ts";
import { CodexAgent } from "./agent.ts";
import { defaultAccount } from "./instances.ts";

type PromiseMethods<A> = {
  [K in keyof A]: A[K] extends (...args: infer P) => Effect.Effect<infer R, infer _E, infer _S>
    ? (...args: P) => Promise<R>
    : A[K];
};
const cleanups = new Set<() => Promise<void>>();
afterEach(async () => {
  for (const close of cleanups) await close();
  cleanups.clear();
});

export function testAgent(api: Api, env: Record<string, string> = {}) {
  const scope = Scope.makeUnsafe();
  const builtins = liveLayer(
    api,
    (effect) => runtime.runPromise(effect),
    () => {},
  );
  const runtime = ManagedRuntime.make(RpcTransport.layer.pipe(Layer.provideMerge(builtins)));
  let agent: CodexAgent | undefined;
  runtime.runFork(
    Effect.gen(function* () {
      const transport = yield* RpcTransport;
      const jobs = yield* Effect.acquireRelease(
        Queue.make<Effect.Effect<unknown, unknown, PluginServices>>(),
        Queue.shutdown,
      ).pipe(Effect.provideService(Scope.Scope, scope));
      agent = new CodexAgent({ scope, transport, jobs, instance: defaultAccount(), env });
      yield* agent.background();
    }),
  );
  cleanups.add(async () => {
    await runtime.runPromise(Scope.close(scope, Exit.void));
    await runtime.dispose();
  });
  if (!agent) throw new Error("the synchronous adapter did not create the test agent");
  // This locally built proxy changes only Effect methods into Promise methods.
  // Their environment is the same PluginServices provided by this runtime.
  return new Proxy(agent, {
    get(target, key, receiver) {
      const value: unknown = Reflect.get(target, key, receiver);
      if (typeof value !== "function") return value;
      return (...args: unknown[]) => {
        const result: unknown = Reflect.apply(value, target, args);
        return Effect.isEffect(result)
          ? runtime.runPromise(result as Effect.Effect<unknown, unknown, PluginServices>)
          : result;
      };
    },
  }) as unknown as PromiseMethods<CodexAgent>;
}