@shivaedev/agent-codex 0.2.0 → 0.3.1

package/dist/adapters/initializeEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializeEngine.d.ts","sourceRoot":"","sources":["../../src/adapters/initializeEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAa,MAAM,QAAQ,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAKxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,eAAO,MAAM,gBAAgB,8CAA4F,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAyD/G,OAAO;;;;;;;mBACX,MAAM,UAAU,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAhBf,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,GAAG;QAAE,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;KAAE,YAAY;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;mLAqBjI,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC"}

package/dist/adapters/initializeEngine.js

@@ -0,0 +1,63 @@
+import { Effect, Semaphore } from "effect";
+import { Rejected, UnknownAcceptance } from "@shivaedev/agent/failures.ts";
+import { features } from "#adapters/features.ts";
+import { observe, readRequest } from "#adapters/reads.ts";
+import { receiptOf, recovery } from "#adapters/recovery.ts";
+import { AppServer, openServer } from "#adapters/server.ts";
+import { openSession } from "#adapters/session.ts";
+export const initializeEngine = Effect.fn("Codex.initializeEngine")(function* (config, spawn) {
+    const server = yield* openServer(config, spawn);
+    const sessions = new Map();
+    const { operations, refusals, reconcile } = yield* recovery(sessions).pipe(Effect.provideService(AppServer, server));
+    const submissionGate = yield* Semaphore.make(1);
+    const submit = Effect.fn("Codex.submit")(function* (request, reference) {
+        if (operations.has(request.operationId)) {
+            const result = yield* reconcile(request.operationId);
+            if (result.type === "accepted") {
+                return result.receipt;
+            }
+            if (result.type === "not-accepted") {
+                return yield* new Rejected({ backend: "codex", message: result.evidence });
+            }
+            return yield* new UnknownAcceptance({
+                backend: "codex",
+                message: result.reason,
+                operationId: request.operationId,
+            });
+        }
+        if (reference !== undefined && (reference.version !== 1 || server.claims.isNode(reference.value))) {
+            return yield* new Rejected({ backend: "codex", message: "Child threads are observed passively and cannot be resumed" });
+        }
+        operations.set(request.operationId, reference?.value);
+        const session = yield* openSession(config, request, reference?.value, (operationId, threadId) => {
+            operations.set(operationId, threadId);
+        }).pipe(Effect.provideService(AppServer, server));
+        operations.set(request.operationId, session.threadId);
+        sessions.set(session.threadId, session);
+        yield* Effect.addFinalizer(() => Effect.sync(() => {
+            if (sessions.get(session.threadId) === session) {
+                sessions.delete(session.threadId);
+            }
+        }));
+        const turnId = yield* session.driver.start(request.input, request.operationId);
+        return receiptOf(request.operationId, session.threadId, turnId);
+    });
+    function start(request, session) {
+        return Semaphore.withPermit(submissionGate)(submit(request, session)).pipe(Effect.tapError((error) => Effect.sync(() => {
+            if (error._tag === "Rejected") {
+                refusals.set(request.operationId, error.message);
+            }
+        })));
+    }
+    return {
+        claims: server.claims,
+        exited: server.exited,
+        features: yield* features(sessions, start).pipe(Effect.provideService(AppServer, server)),
+        inspect: (receipt) => observe(receipt).pipe(Effect.provideService(AppServer, server)),
+        read: (method, params) => readRequest(method, params).pipe(Effect.provideService(AppServer, server)),
+        reconcile,
+        sessions,
+        start,
+    };
+});
+//# sourceMappingURL=initializeEngine.js.map

package/dist/adapters/initializeEngine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializeEngine.js","sourceRoot":"","sources":["../../src/adapters/initializeEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAE3E,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAgB,MAAM,sBAAsB,CAAC;AAEjE,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,EAAE,CAAC,wBAAwB,CAAC,CAAC,QAAQ,CAAC,EAAE,MAA0B,EAAE,KAAyB;IACnI,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAChD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAmB,CAAC;IAC5C,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,KAAK,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;IACrH,MAAM,cAAc,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAChD,MAAM,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC,cAAc,CAAC,CAAC,QAAQ,CAAC,EACjD,OAAqE,EACrE,SAA8C;QAE9C,IAAI,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;YACzC,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;YACrD,IAAI,MAAM,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;gBAChC,OAAO,MAAM,CAAC,OAAO,CAAC;YACvB,CAAC;YACD,IAAI,MAAM,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;gBACpC,OAAO,KAAK,CAAC,CAAC,IAAI,QAAQ,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;YAC5E,CAAC;YACD,OAAO,KAAK,CAAC,CAAC,IAAI,iBAAiB,CAAC;gBACnC,OAAO,EAAE,OAAO;gBAChB,OAAO,EAAE,MAAM,CAAC,MAAM;gBACtB,WAAW,EAAE,OAAO,CAAC,WAAW;aAChC,CAAC,CAAC;QACJ,CAAC;QACD,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,SAAS,CAAC,OAAO,KAAK,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;YACnG,OAAO,KAAK,CAAC,CAAC,IAAI,QAAQ,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,4DAA4D,EAAE,CAAC,CAAC;QACzH,CAAC;QACD,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QACtD,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,WAAW,EAAE,QAAQ,EAAE,EAAE;YAC/F,UAAU,CAAC,GAAG,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;QAClD,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QACtD,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACxC,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAC/B,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;YAChB,IAAI,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,OAAO,EAAE,CAAC;gBAChD,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YACnC,CAAC;QACF,CAAC,CAAC,CACF,CAAC;QACF,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;QAC/E,OAAO,SAAS,CAAC,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IACH,SAAS,KAAK,CAAC,OAAqE,EAAE,OAA4C;QACjI,OAAO,SAAS,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,CACzE,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACzB,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;YAChB,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;gBAC/B,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YAClD,CAAC;QACF,CAAC,CAAC,CACF,CACD,CAAC;IACH,CAAC;IACD,OAAO;QACN,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,QAAQ,EAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACzF,OAAO,EAAE,CAAC,OAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAC9F,IAAI,EAAE,CAAC,MAAc,EAAE,MAAe,EAAE,EAAE,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACrH,SAAS;QACT,QAAQ;QACR,KAAK;KACL,CAAC;AACH,CAAC,CAAC,CAAC"}

package/dist/codex.d.ts

@@ -2,8 +2,8 @@ import { Effect, Layer } from "effect";
 import { Backend } from "@shivaedev/agent/backend.ts";
 import { CodexConfig } from "#config.ts";
 export declare const Codex: import("effect/Context").Service<"@shivaedev/agent-codex/Codex", Readonly<{
-    backend: () => Effect.Effect<import("@shivaedev/agent/backend.ts").ConfiguredBackend, never, never>;
-    census: (rootThreadId: string) => Effect.Effect<import("./adapters/threadSweep.ts").CensusSweep, import("@shivaedev/agent/failures.ts").ReadFailure, never>;
+    readonly backend: () => Effect.Effect<import("@shivaedev/agent/backend.ts").ConfiguredBackend, never, never>;
+    readonly census: (rootThreadId: string) => Effect.Effect<import("./adapters/threadSweep.ts").CensusSweep, import("@shivaedev/agent/failures.ts").ReadFailure, never>;
 }>> & {
     readonly layer: Layer.Layer<"@shivaedev/agent-codex/Codex", import("@shivaedev/agent/failures.ts").BackendUnavailable | import("@shivaedev/agent/failures.ts").ProtocolFailure | import("@shivaedev/agent/failures.ts").Rejected | import("@shivaedev/agent/failures.ts").UnknownAcceptance, CodexConfig>;
 };

package/dist/codex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../src/codex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAGtD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,eAAO,MAAM,KAAK;;;;;CAQhB,CAAC;AACH,eAAO,MAAM,UAAU,qSAAiH,CAAC"}
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../src/codex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAMtD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,eAAO,MAAM,KAAK;;;;;CAKhB,CAAC;AACH,eAAO,MAAM,UAAU,qSAAwG,CAAC"}

package/dist/codex.js

@@ -1,16 +1,16 @@
 import { Effect, Layer } from "effect";
 import { Backend } from "@shivaedev/agent/backend.ts";
 import { defineService } from "@shivaedev/service/defineService.ts";
-import { engine } from "#adapters/engine.ts";
+import { backend } from "#adapters/backend.ts";
+import { census } from "#adapters/census.ts";
+import { configuredBackend } from "#adapters/configuredBackend.ts";
+import { initializeCodex } from "#adapters/initializeCodex.ts";
 import { CodexConfig } from "#config.ts";
 export const Codex = defineService({
     id: "@shivaedev/agent-codex/Codex",
-    initialize: Effect.gen(function* () {
-        const config = yield* CodexConfig;
-        return yield* engine(config);
-    }),
-    methods: (state) => state,
+    initialize: initializeCodex,
+    methods: (state) => ({ backend: backend(state), census: census(state) }),
     requires: [CodexConfig],
 });
-export const codexLayer = Layer.effect(Backend)(Effect.flatMap(Codex, (codex) => codex.backend())).pipe(Layer.provideMerge(Codex.layer));
+export const codexLayer = Layer.effect(Backend)(Effect.flatMap(Codex, configuredBackend)).pipe(Layer.provideMerge(Codex.layer));
 //# sourceMappingURL=codex.js.map

package/dist/codex.js.map

@@ -1 +1 @@
-{"version":3,"file":"codex.js","sourceRoot":"","sources":["../src/codex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,MAAM,CAAC,MAAM,KAAK,GAAG,aAAa,CAAC;IAClC,EAAE,EAAE,8BAA8B;IAClC,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAC/B,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,WAAW,CAAC;QAClC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC,CAAC;IACF,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK;IACzB,QAAQ,EAAE,CAAC,WAAW,CAAC;CACvB,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC"}
+{"version":3,"file":"codex.js","sourceRoot":"","sources":["../src/codex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,MAAM,CAAC,MAAM,KAAK,GAAG,aAAa,CAAC;IAClC,EAAE,EAAE,8BAA8B;IAClC,UAAU,EAAE,eAAe;IAC3B,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;IACxE,QAAQ,EAAE,CAAC,WAAW,CAAC;CACvB,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/agent-codex",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Codex integration for Effect applications",
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/agent-codex#readme",
   "bugs": {
@@ -16,7 +16,7 @@
   "type": "module",
   "imports": {
     "#*.ts": {
-      "source": "./src/*.ts",
+      "@shivaedev/source": "./src/*.ts",
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
     },
@@ -24,7 +24,7 @@
   },
   "exports": {
     "./*.ts": {
-      "source": "./src/*.ts",
+      "@shivaedev/source": "./src/*.ts",
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
     },
@@ -40,20 +40,20 @@
     "README.md"
   ],
   "dependencies": {
-    "@shivaedev/agent": "0.2.0",
-    "@shivaedev/service": "0.6.2"
+    "@shivaedev/agent": "0.3.1",
+    "@shivaedev/service": "0.7.1"
   },
   "devDependencies": {
-    "@effect/vitest": "4.0.6",
-    "@shivaedev/quality": "0.58.0",
-    "@shivaedev/test-story": "0.37.0",
+    "@effect/vitest": "4.0.7",
+    "@shivaedev/quality": "0.61.1",
+    "@shivaedev/test-story": "0.39.1",
     "@types/node": "24.19.2",
-    "effect": "4.0.6",
+    "effect": "4.0.7",
     "typescript": "7.0.2",
     "vitest": "5.0.5"
   },
   "peerDependencies": {
-    "effect": "4.0.6"
+    "effect": "4.0.7"
   },
   "engines": {
     "node": ">=24"

package/src/adapters/backend.ts

@@ -0,0 +1,29 @@
+import { Effect, PubSub, Stream } from "effect";
+import type { ConfiguredBackend } from "@shivaedev/agent/backend.ts";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import type { EngineState } from "#adapters/initializeEngine.ts";
+
+export function backend(state: EngineState) {
+	const configured: ConfiguredBackend = {
+		backend: "codex",
+		events: (receipt) =>
+			Stream.unwrap(
+				Effect.gen(function* () {
+					const session = state.sessions.get(receipt.session?.value ?? "");
+					if (session === undefined) {
+						return Stream.empty;
+					}
+					const subscription = yield* PubSub.subscribe(session.events);
+					return Stream.fromIterable<RunEvent>([
+						{ receipt, type: "acknowledged" },
+						{ reference: session.threadId, type: "session.opened" },
+					]).pipe(Stream.concat(Stream.fromSubscription(subscription)), Stream.interruptWhen(state.exited));
+				}),
+			),
+		features: state.features,
+		inspect: state.inspect,
+		reconcile: state.reconcile,
+		start: state.start,
+	};
+	return Effect.fn("Codex.backend")(() => Effect.succeed(configured));
+}

package/src/adapters/census.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import type { EngineState } from "#adapters/initializeEngine.ts";
+import { sweepSpawnedDescendants } from "#adapters/threadSweep.ts";
+
+export function census(state: Pick<EngineState, "claims" | "read">) {
+	return Effect.fn("Codex.census")((rootThreadId: string) =>
+		sweepSpawnedDescendants(state.read, rootThreadId).pipe(
+			Effect.tap((children) =>
+				Effect.sync(() => {
+					for (const child of children) {
+						state.claims.claim(rootThreadId, child.threadId);
+					}
+				}),
+			),
+		),
+	);
+}

package/src/adapters/configuredBackend.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import type { ConfiguredBackend } from "@shivaedev/agent/backend.ts";
+
+export const configuredBackend = Effect.fn("Codex.configuredBackend")((codex: { readonly backend: () => Effect.Effect<ConfiguredBackend> }) =>
+	codex.backend(),
+);

package/src/adapters/engine.ts

@@ -1,101 +1,11 @@
-import { Effect, PubSub, Semaphore, Stream } from "effect";
-import type { ConfiguredBackend } from "@shivaedev/agent/backend.ts";
-import type { RunEvent } from "@shivaedev/agent/events.ts";
-import { Rejected, UnknownAcceptance } from "@shivaedev/agent/failures.ts";
-import type { ImageInput, StartRequest } from "@shivaedev/agent/run.ts";
-import { features } from "#adapters/features.ts";
+import { Effect } from "effect";
+import { backend } from "#adapters/backend.ts";
+import { census } from "#adapters/census.ts";
+import { initializeEngine } from "#adapters/initializeEngine.ts";
 import type { LineProcess } from "#adapters/process.ts";
-import { observe, readRequest } from "#adapters/reads.ts";
-import { receiptOf, recovery } from "#adapters/recovery.ts";
-import { AppServer, openServer } from "#adapters/server.ts";
-import { openSession, type Session } from "#adapters/session.ts";
-import { sweepSpawnedDescendants } from "#adapters/threadSweep.ts";
 import type { CodexConfiguration } from "#config.ts";
+
 export const engine = Effect.fn("Codex.engine")(function* (config: CodexConfiguration, spawn?: () => LineProcess) {
-	const server = yield* openServer(config, spawn);
-	const sessions = new Map<string, Session>();
-	const { operations, refusals, reconcile } = yield* recovery(sessions).pipe(Effect.provideService(AppServer, server));
-	const submissionGate = yield* Semaphore.make(1);
-	const submit = Effect.fn("Codex.submit")(function* (
-		request: Omit<StartRequest, "input"> & { readonly input: ImageInput },
-		reference?: { value: string; version: number },
-	) {
-		if (operations.has(request.operationId)) {
-			const result = yield* reconcile(request.operationId);
-			if (result.type === "accepted") {
-				return result.receipt;
-			}
-			if (result.type === "not-accepted") {
-				return yield* new Rejected({ backend: "codex", message: result.evidence });
-			}
-			return yield* new UnknownAcceptance({
-				backend: "codex",
-				message: result.reason,
-				operationId: request.operationId,
-			});
-		}
-		if (reference !== undefined && (reference.version !== 1 || server.claims.isNode(reference.value))) {
-			return yield* new Rejected({ backend: "codex", message: "Child threads are observed passively and cannot be resumed" });
-		}
-		operations.set(request.operationId, reference?.value);
-		const session = yield* openSession(config, request, reference?.value, (operationId, threadId) => {
-			operations.set(operationId, threadId);
-		}).pipe(Effect.provideService(AppServer, server));
-		operations.set(request.operationId, session.threadId);
-		sessions.set(session.threadId, session);
-		yield* Effect.addFinalizer(() =>
-			Effect.sync(() => {
-				if (sessions.get(session.threadId) === session) {
-					sessions.delete(session.threadId);
-				}
-			}),
-		);
-		const turnId = yield* session.driver.start(request.input, request.operationId);
-		return receiptOf(request.operationId, session.threadId, turnId);
-	});
-	function start(request: Omit<StartRequest, "input"> & { readonly input: ImageInput }, session?: { value: string; version: number }) {
-		return Semaphore.withPermit(submissionGate)(submit(request, session)).pipe(
-			Effect.tapError((error) =>
-				Effect.sync(() => {
-					if (error._tag === "Rejected") {
-						refusals.set(request.operationId, error.message);
-					}
-				}),
-			),
-		);
-	}
-	const backend: ConfiguredBackend = {
-		backend: "codex",
-		events: (receipt) =>
-			Stream.unwrap(
-				Effect.gen(function* () {
-					const session = sessions.get(receipt.session?.value ?? "");
-					if (session === undefined) {
-						return Stream.empty;
-					}
-					const subscription = yield* PubSub.subscribe(session.events);
-					return Stream.fromIterable<RunEvent>([
-						{ receipt, type: "acknowledged" },
-						{ reference: session.threadId, type: "session.opened" },
-					]).pipe(Stream.concat(Stream.fromSubscription(subscription)), Stream.interruptWhen(server.exited));
-				}),
-			),
-		features: yield* features(sessions, start).pipe(Effect.provideService(AppServer, server)),
-		inspect: (receipt) => observe(receipt).pipe(Effect.provideService(AppServer, server)),
-		reconcile,
-		start,
-	};
-	return {
-		backend: () => Effect.succeed(backend),
-		census: (rootThreadId: string) =>
-			sweepSpawnedDescendants((method, params) => readRequest(method, params).pipe(Effect.provideService(AppServer, server)), rootThreadId).pipe(
-				Effect.tap((children) =>
-					Effect.sync(() => {
-						for (const child of children) {
-							server.claims.claim(rootThreadId, child.threadId);
-						}
-					}),
-				),
-			),
-	};
+	const state = yield* initializeEngine(config, spawn);
+	return { backend: backend(state), census: census(state) };
 });

package/src/adapters/initializeCodex.ts

@@ -0,0 +1,8 @@
+import { Effect } from "effect";
+import { initializeEngine } from "#adapters/initializeEngine.ts";
+import { CodexConfig } from "#config.ts";
+
+export const initializeCodex = Effect.gen(function* () {
+	const config = yield* CodexConfig;
+	return yield* initializeEngine(config);
+});

package/src/adapters/initializeEngine.ts

@@ -0,0 +1,75 @@
+import { Effect, Semaphore } from "effect";
+import { Rejected, UnknownAcceptance } from "@shivaedev/agent/failures.ts";
+import type { ImageInput, Receipt, StartRequest } from "@shivaedev/agent/run.ts";
+import { features } from "#adapters/features.ts";
+import type { LineProcess } from "#adapters/process.ts";
+import { observe, readRequest } from "#adapters/reads.ts";
+import { receiptOf, recovery } from "#adapters/recovery.ts";
+import { AppServer, openServer } from "#adapters/server.ts";
+import { openSession, type Session } from "#adapters/session.ts";
+import type { CodexConfiguration } from "#config.ts";
+export const initializeEngine = Effect.fn("Codex.initializeEngine")(function* (config: CodexConfiguration, spawn?: () => LineProcess) {
+	const server = yield* openServer(config, spawn);
+	const sessions = new Map<string, Session>();
+	const { operations, refusals, reconcile } = yield* recovery(sessions).pipe(Effect.provideService(AppServer, server));
+	const submissionGate = yield* Semaphore.make(1);
+	const submit = Effect.fn("Codex.submit")(function* (
+		request: Omit<StartRequest, "input"> & { readonly input: ImageInput },
+		reference?: { value: string; version: number },
+	) {
+		if (operations.has(request.operationId)) {
+			const result = yield* reconcile(request.operationId);
+			if (result.type === "accepted") {
+				return result.receipt;
+			}
+			if (result.type === "not-accepted") {
+				return yield* new Rejected({ backend: "codex", message: result.evidence });
+			}
+			return yield* new UnknownAcceptance({
+				backend: "codex",
+				message: result.reason,
+				operationId: request.operationId,
+			});
+		}
+		if (reference !== undefined && (reference.version !== 1 || server.claims.isNode(reference.value))) {
+			return yield* new Rejected({ backend: "codex", message: "Child threads are observed passively and cannot be resumed" });
+		}
+		operations.set(request.operationId, reference?.value);
+		const session = yield* openSession(config, request, reference?.value, (operationId, threadId) => {
+			operations.set(operationId, threadId);
+		}).pipe(Effect.provideService(AppServer, server));
+		operations.set(request.operationId, session.threadId);
+		sessions.set(session.threadId, session);
+		yield* Effect.addFinalizer(() =>
+			Effect.sync(() => {
+				if (sessions.get(session.threadId) === session) {
+					sessions.delete(session.threadId);
+				}
+			}),
+		);
+		const turnId = yield* session.driver.start(request.input, request.operationId);
+		return receiptOf(request.operationId, session.threadId, turnId);
+	});
+	function start(request: Omit<StartRequest, "input"> & { readonly input: ImageInput }, session?: { value: string; version: number }) {
+		return Semaphore.withPermit(submissionGate)(submit(request, session)).pipe(
+			Effect.tapError((error) =>
+				Effect.sync(() => {
+					if (error._tag === "Rejected") {
+						refusals.set(request.operationId, error.message);
+					}
+				}),
+			),
+		);
+	}
+	return {
+		claims: server.claims,
+		exited: server.exited,
+		features: yield* features(sessions, start).pipe(Effect.provideService(AppServer, server)),
+		inspect: (receipt: Receipt) => observe(receipt).pipe(Effect.provideService(AppServer, server)),
+		read: (method: string, params: unknown) => readRequest(method, params).pipe(Effect.provideService(AppServer, server)),
+		reconcile,
+		sessions,
+		start,
+	};
+});
+export type EngineState = Effect.Success<ReturnType<typeof initializeEngine>>;

package/src/codex.ts

@@ -1,15 +1,15 @@
 import { Effect, Layer } from "effect";
 import { Backend } from "@shivaedev/agent/backend.ts";
 import { defineService } from "@shivaedev/service/defineService.ts";
-import { engine } from "#adapters/engine.ts";
+import { backend } from "#adapters/backend.ts";
+import { census } from "#adapters/census.ts";
+import { configuredBackend } from "#adapters/configuredBackend.ts";
+import { initializeCodex } from "#adapters/initializeCodex.ts";
 import { CodexConfig } from "#config.ts";
 export const Codex = defineService({
 	id: "@shivaedev/agent-codex/Codex",
-	initialize: Effect.gen(function* () {
-		const config = yield* CodexConfig;
-		return yield* engine(config);
-	}),
-	methods: (state) => state,
+	initialize: initializeCodex,
+	methods: (state) => ({ backend: backend(state), census: census(state) }),
 	requires: [CodexConfig],
 });
-export const codexLayer = Layer.effect(Backend)(Effect.flatMap(Codex, (codex) => codex.backend())).pipe(Layer.provideMerge(Codex.layer));
+export const codexLayer = Layer.effect(Backend)(Effect.flatMap(Codex, configuredBackend)).pipe(Layer.provideMerge(Codex.layer));