@shivaedev/agent-codex 0.1.0 → 0.3.0

package/src/adapters/server.ts

@@ -0,0 +1,96 @@
+import process from "node:process";
+import { Clock, Context, Deferred, Effect, Exit, Fiber, Option, PubSub, Queue, Schema, type Scope } from "effect";
+import { BackendUnavailable } from "@shivaedev/agent/failures.ts";
+import { connect } from "#adapters/connect.ts";
+import { handshake } from "#adapters/handshake.ts";
+import { type LineProcess, spawnLineProcess } from "#adapters/process.ts";
+import { DynamicToolCallParams } from "#adapters/protocol.ts";
+import { residualApproval } from "#adapters/residualApproval.ts";
+import type { RpcNotification } from "#adapters/rpc.ts";
+import { tellCliVersionOnce } from "#adapters/tellCliVersionOnce.ts";
+import { openThreadClaims } from "#adapters/threadClaims.ts";
+import type { CodexConfiguration } from "#config.ts";
+export const openServer = Effect.fn("Codex.openServer")(function* (config: CodexConfiguration, spawn?: () => LineProcess) {
+	const notifications = yield* PubSub.unbounded<RpcNotification>();
+	const requests = yield* Queue.unbounded<{ id: number | string; method: string; params: unknown }>();
+	const exited = yield* Deferred.make<void>();
+	const stderr = yield* Queue.unbounded<string>();
+	const child = yield* Effect.acquireRelease(
+		Effect.try({
+			catch: () => new BackendUnavailable({ backend: "codex", message: "Could not start Codex app-server" }),
+			try: () =>
+				spawn?.() ?? spawnLineProcess({ args: config.args ?? ["app-server"], command: config.command ?? "codex", cwd: config.cwd ?? process.cwd() }),
+		}),
+		(processHandle) => Effect.sync(() => processHandle.kill()),
+	);
+	const rpc = connect(
+		child,
+		config.requestTimeoutMs ?? 30_000,
+		(n) => {
+			PubSub.publishUnsafe(notifications, n);
+		},
+		(id, method, params) => {
+			PubSub.publishUnsafe(notifications, { method, params });
+			Queue.offerUnsafe(requests, { id, method, params });
+		},
+		() => {
+			Deferred.doneUnsafe(exited, Effect.void);
+		},
+	);
+	child.onStderr((text) => {
+		Queue.offerUnsafe(stderr, text);
+	});
+	yield* Effect.forkScoped(
+		Queue.take(stderr).pipe(
+			Effect.flatMap((text) => Effect.logWarning("Codex app-server", { stderr: text })),
+			Effect.forever,
+		),
+	);
+	const claims = openThreadClaims();
+	const registrations = new Map<string, Scope.Scope>();
+	const handle = Effect.fn("Codex.handle")(function* (request: { id: number | string; method: string; params: unknown }) {
+		if (request.method === "currentTime/read") {
+			const millis = yield* Clock.currentTimeMillis;
+			yield* Effect.sync(() => rpc.respond(request.id, { currentTimeAt: Math.floor(millis / 1000) }));
+			return;
+		}
+		const declined = residualApproval(request);
+		if (declined._tag === "Some") {
+			yield* Effect.sync(() => rpc.respond(request.id, declined.value));
+			return;
+		}
+		if (request.method !== "item/tool/call") {
+			yield* Effect.sync(() => rpc.deny(request.id));
+			return;
+		}
+		const call = Schema.decodeUnknownOption(DynamicToolCallParams)(request.params);
+		const tool =
+			Option.isSome(call) && registrations.has(call.value.threadId)
+				? config.tools?.find((candidate) => candidate.name === call.value.tool)
+				: undefined;
+		const callScope = Option.isSome(call) ? registrations.get(call.value.threadId) : undefined;
+		const outcome =
+			tool !== undefined && Option.isSome(call) && callScope !== undefined
+				? yield* tool.execute(call.value.arguments, call.value.callId).pipe(
+						Effect.forkIn(callScope),
+						Effect.flatMap(Fiber.await),
+						Effect.map((exit) => (Exit.isSuccess(exit) ? exit.value : { ok: false, text: "The session closed or tool execution failed" })),
+					)
+				: { ok: false, text: "No registered tool for this thread" };
+		yield* Effect.sync(() => rpc.respond(request.id, { contentItems: [{ text: outcome.text, type: "inputText" }], success: outcome.ok }));
+	});
+	yield* Effect.forkScoped(
+		Queue.take(requests).pipe(
+			Effect.flatMap((request) => Effect.forkScoped(handle(request))),
+			Effect.forever,
+		),
+	);
+	const version = yield* handshake(rpc.request);
+	yield* Effect.sync(() => rpc.notify("initialized", {}));
+	const tell = yield* tellCliVersionOnce;
+	yield* tell(version);
+	return { ...rpc, claims, exited: Deferred.await(exited), notifications, registrations };
+});
+export type CodexServer = Effect.Success<ReturnType<typeof openServer>>;
+
+export class AppServer extends Context.Service<AppServer, CodexServer>()("@shivaedev/agent-codex/AppServer") {}

package/src/adapters/session.ts

@@ -0,0 +1,71 @@
+import { Effect, PubSub, Scope, Stream } from "effect";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import type { StartRequest } from "@shivaedev/agent/run.ts";
+import { delivery } from "#adapters/delivery.ts";
+import { toAgentEvents } from "#adapters/mapping.ts";
+import { ThreadResponse } from "#adapters/protocol.ts";
+import { decode } from "#adapters/reads.ts";
+import { AppServer } from "#adapters/server.ts";
+import { openThreadTree } from "#adapters/threadTree.ts";
+import type { CodexConfiguration } from "#config.ts";
+export const openSession = Effect.fn("Codex.openSession")(function* (
+	config: CodexConfiguration,
+	request: Omit<StartRequest, "input">,
+	resume: string | undefined,
+	remember: (operationId: string, threadId: string) => void,
+) {
+	const server = yield* AppServer;
+	const threadTools = config.tools?.map(({ name, description, inputSchema }) => ({ description, inputSchema, name, type: "function" }));
+	const opening = resume === undefined ? { ...(threadTools?.length ? { dynamicTools: threadTools } : {}) } : { threadId: resume };
+	const response = yield* server
+		.request(
+			resume === undefined ? "thread/start" : "thread/resume",
+			{
+				approvalsReviewer: "auto_review",
+				cwd: request.cwd,
+				model: request.model,
+				sandbox: config.sandbox ?? "workspace-write",
+				...(config.baseInstructions === undefined ? {} : { baseInstructions: config.baseInstructions }),
+				...opening,
+			},
+			request.operationId,
+		)
+		.pipe(Effect.flatMap((value) => decode(ThreadResponse, value)));
+	const threadId = response.thread.id;
+	const driver = yield* delivery(
+		threadId,
+		{
+			...(request.model === undefined ? {} : { model: request.model }),
+			...(request.effort === undefined ? {} : { effort: request.effort }),
+		},
+		(operationId) => remember(operationId, threadId),
+	);
+	const toolScope = yield* Scope.fork(yield* Effect.scope);
+	server.registrations.set(threadId, toolScope);
+	const events = yield* PubSub.unbounded<RunEvent>();
+	const tree = openThreadTree(threadId, server.claims, request.model ?? "");
+	const subscription = yield* PubSub.subscribe(server.notifications);
+	yield* Effect.forkScoped(
+		Stream.fromSubscription(subscription).pipe(
+			Stream.interruptWhen(server.exited),
+			Stream.runForEach((notification) =>
+				Effect.gen(function* () {
+					const mapped =
+						notification.method === "account/rateLimits/updated" ? toAgentEvents(notification, request.model ?? "") : tree.events(notification);
+					for (const event of mapped) {
+						yield* PubSub.publish(events, event);
+					}
+					yield* driver.track(notification);
+				}),
+			),
+		),
+	);
+	yield* Effect.addFinalizer(() =>
+		Effect.sync(() => {
+			server.registrations.delete(threadId);
+			server.claims.release(threadId);
+		}),
+	);
+	return { driver, events, threadId };
+});
+export type Session = Effect.Success<ReturnType<typeof openSession>>;

package/src/adapters/subagentItems.ts

@@ -0,0 +1,73 @@
+import type { Raw as RawSchema } from "@shivaedev/agent/eventData.ts";
+import type { RunEvent as AgentEvent } from "@shivaedev/agent/events.ts";
+
+type RawPayload = typeof RawSchema.Type;
+
+import { Option, Schema } from "effect";
+import { KnownItem } from "#adapters/protocolItems.ts";
+
+type Item<T extends KnownItem["type"]> = Extract<KnownItem, { type: T }>;
+
+export type SubAgentActivity = Item<"subAgentActivity">;
+export type CollabCall = Item<"collabAgentToolCall">;
+
+const decodeItem = Schema.decodeUnknownOption(KnownItem);
+
+export function subAgentItem(item: unknown): SubAgentActivity | CollabCall | undefined {
+	return Option.match(decodeItem(item), {
+		onNone: () => undefined,
+		onSome: (known) => (known.type === "subAgentActivity" || known.type === "collabAgentToolCall" ? known : undefined),
+	});
+}
+
+export function announced(item: SubAgentActivity, threadId: string, spawnedBy: string, raw: RawPayload): AgentEvent {
+	return {
+		childRef: item.agentThreadId,
+		label: item.agentPath,
+		parentRef: threadId,
+		raw,
+		spawnedBy,
+		type: "child.opened",
+	};
+}
+
+// Codex reports forced sub-agent termination as `interrupted`.
+export function interrupted(item: SubAgentActivity, raw: RawPayload): AgentEvent {
+	return {
+		childRef: item.agentThreadId,
+		outcome: "interrupted",
+		raw,
+		type: "child.ended",
+	};
+}
+
+export function closedWithoutWord(childRef: string, raw: RawPayload): AgentEvent {
+	return {
+		childRef,
+		outcome: "unknown",
+		raw,
+		type: "child.ended",
+	};
+}
+
+export function collabEvents(item: CollabCall, raw: RawPayload, started: boolean): readonly AgentEvent[] {
+	return started
+		? [
+				{
+					input: item.prompt ?? "",
+					name: item.tool,
+					raw,
+					toolId: item.id,
+					type: "tool.started",
+				},
+			]
+		: [
+				{
+					ok: item.status === "completed",
+					output: item.receiverThreadIds.join("\n"),
+					raw,
+					toolId: item.id,
+					type: "tool.completed",
+				},
+			];
+}

package/src/adapters/tellCliVersionOnce.ts

@@ -0,0 +1,20 @@
+import { Effect, Option, Ref } from "effect";
+import { PINNED_CLI_VERSION } from "#adapters/protocol.ts";
+
+type TellCliVersion = (version: Option.Option<string>) => Effect.Effect<void>;
+
+// Codex has no protocol negotiation; the userAgent it reports at initialize is compared with the pinned CLI version.
+function tell(version: Option.Option<string>): Effect.Effect<void> {
+	return Option.match(version, {
+		onNone: () => Effect.logWarning("codex: initialize response unrecognised"),
+		onSome: (installed) =>
+			installed === PINNED_CLI_VERSION
+				? Effect.logInfo("codex app-server", { version: installed })
+				: Effect.logWarning("codex app-server version differs from the pin", { pinned: PINNED_CLI_VERSION, version: installed }),
+	});
+}
+
+export const tellCliVersionOnce: Effect.Effect<TellCliVersion> = Effect.map(
+	Ref.make(false),
+	(told) => (version) => Effect.flatMap(Ref.getAndSet(told, true), (already) => (already ? Effect.void : tell(version))),
+);

package/src/adapters/threadClaims.ts

@@ -0,0 +1,26 @@
+export interface ThreadClaims {
+	readonly claim: (rootThreadId: string, threadId: string) => void;
+	readonly isNode: (threadId: string) => boolean;
+	readonly ownerOf: (threadId: string) => string | undefined;
+	readonly release: (rootThreadId: string) => void;
+}
+
+export function openThreadClaims(): ThreadClaims {
+	const owners = new Map<string, string>();
+	return {
+		claim: (rootThreadId, threadId) => {
+			if (!owners.has(threadId)) {
+				owners.set(threadId, rootThreadId);
+			}
+		},
+		isNode: (threadId) => owners.has(threadId),
+		ownerOf: (threadId) => owners.get(threadId),
+		release: (rootThreadId) => {
+			for (const [threadId, owner] of [...owners]) {
+				if (owner === rootThreadId) {
+					owners.delete(threadId);
+				}
+			}
+		},
+	};
+}

package/src/adapters/threadSweep.ts

@@ -0,0 +1,79 @@
+import { Effect, Option, Schema } from "effect";
+import type { ReadFailure as BackendFailure } from "@shivaedev/agent/failures.ts";
+import { codexFailure } from "#adapters/codexFailure.ts";
+import { ThreadListResponse, type ThreadStatus } from "#adapters/protocol.ts";
+
+type Request = (method: string, params: unknown) => Effect.Effect<unknown, BackendFailure>;
+
+export interface SpawnedChild {
+	readonly agentNickname: string | undefined;
+	readonly agentPath: string | undefined;
+	readonly agentRole: string | undefined;
+	readonly parentThreadId: string;
+	readonly threadId: string;
+	readonly working: boolean;
+}
+
+export type CensusSweep = readonly SpawnedChild[];
+
+// Codex caps thread-list pages at 100 rows.
+const PAGE = 100;
+const PAGES = 200;
+
+const decodeListing = Schema.decodeUnknownOption(ThreadListResponse);
+
+function named(value: string | null | undefined): string | undefined {
+	return value === null ? undefined : value;
+}
+
+function isWorking(status: typeof ThreadStatus.Type): boolean {
+	return status.type === "active";
+}
+
+function childrenOf(listed: typeof ThreadListResponse.Type): readonly SpawnedChild[] {
+	return listed.data.map((thread) => {
+		const spawn = thread.source.subAgent.threadSpawn;
+		return {
+			agentNickname: named(spawn.agentNickname),
+			agentPath: named(spawn.agentPath),
+			agentRole: named(spawn.agentRole),
+			parentThreadId: spawn.parentThreadId,
+			threadId: thread.id,
+			working: isWorking(thread.status),
+		};
+	});
+}
+
+// Codex thread/list with ancestorThreadId returns the descendant tree without attaching to it.
+export const sweepSpawnedDescendants = Effect.fn("Codex.sweepSpawnedDescendants")(function* (
+	request: Request,
+	rootThreadId: string,
+): Effect.fn.Return<CensusSweep, BackendFailure> {
+	const found = new Map<string, SpawnedChild>();
+	const cursors = new Set<string>();
+	let cursor: string | undefined;
+	for (let page = 0; page < PAGES; page += 1) {
+		const response = yield* request("thread/list", {
+			ancestorThreadId: rootThreadId,
+			...(cursor === undefined ? {} : { cursor }),
+			limit: PAGE,
+		});
+		const decoded = decodeListing(response);
+		if (Option.isNone(decoded)) {
+			return yield* Effect.fail(codexFailure("it answered in a shape this backend cannot read"));
+		}
+		for (const child of childrenOf(decoded.value)) {
+			found.set(child.threadId, child);
+		}
+		const nextCursor = named(decoded.value.nextCursor);
+		if (nextCursor === undefined) {
+			return [...found.values()];
+		}
+		if (cursors.has(nextCursor)) {
+			return yield* codexFailure("Repeated descendant pagination cursor");
+		}
+		cursors.add(nextCursor);
+		cursor = nextCursor;
+	}
+	return yield* Effect.fail(codexFailure("its listing of this session's threads never ended"));
+});

package/src/adapters/threadTree.ts

@@ -0,0 +1,149 @@
+import type { Origin as OriginSchema } from "@shivaedev/agent/eventData.ts";
+import type { RunEvent as AgentEvent } from "@shivaedev/agent/events.ts";
+
+type Origin = typeof OriginSchema.Type;
+
+import type { Raw as RawSchema } from "@shivaedev/agent/eventData.ts";
+
+type RawPayload = typeof RawSchema.Type;
+
+import { Option, Schema } from "effect";
+import { attributed } from "#adapters/attributed.ts";
+import { rawOf, toAgentEvents } from "#adapters/mapping.ts";
+import { ItemNotification, SpawnedThread, ThreadScoped, ThreadSettingsUpdatedNotification } from "#adapters/protocol.ts";
+import type { RpcNotification } from "#adapters/rpc.ts";
+import {
+	announced,
+	type CollabCall,
+	closedWithoutWord,
+	collabEvents,
+	interrupted,
+	type SubAgentActivity,
+	subAgentItem,
+} from "#adapters/subagentItems.ts";
+import type { ThreadClaims } from "#adapters/threadClaims.ts";
+
+const decodeScoped = Schema.decodeUnknownOption(ThreadScoped);
+const decodeSpawned = Schema.decodeUnknownOption(SpawnedThread);
+const decodeItem = Schema.decodeUnknownOption(ItemNotification);
+const decodeSettings = Schema.decodeUnknownOption(ThreadSettingsUpdatedNotification);
+
+export interface ThreadTree {
+	readonly events: (notification: RpcNotification) => readonly AgentEvent[];
+}
+
+// Ownership is tracked even when the application has no event subscriber.
+export function openThreadTree(rootThreadId: string, claims: ThreadClaims, sessionModel: string): ThreadTree {
+	const spawnCalls = new Map<string, string>();
+	const stated = new Set<string>();
+	const billing = new Map<string, string>();
+	function owns(threadId: string): boolean {
+		return threadId === rootThreadId || claims.ownerOf(threadId) === rootThreadId;
+	}
+	function billedOn(threadId: string): string {
+		return billing.get(threadId) ?? sessionModel;
+	}
+	// A thread spends on what the thread that spawned it was spending on, until something names a model for it.
+	function claimed(parent: string, child: string): void {
+		claims.claim(rootThreadId, child);
+		if (!billing.has(child)) {
+			billing.set(child, billedOn(parent));
+		}
+	}
+	function once(key: string): boolean {
+		if (stated.has(key)) {
+			return false;
+		}
+		stated.add(key);
+		return true;
+	}
+	function spawnedThread(params: unknown): readonly AgentEvent[] {
+		const spawned = decodeSpawned(params);
+		if (Option.isNone(spawned)) {
+			return [];
+		}
+		const { id, source } = spawned.value.thread;
+		const parent = source.subAgent.threadSpawn.parentThreadId;
+		if (owns(parent)) {
+			claimed(parent, id);
+		}
+		return [];
+	}
+	function collab(item: CollabCall, threadId: string, raw: RawPayload, started: boolean): readonly AgentEvent[] {
+		for (const receiver of item.receiverThreadIds) {
+			claimed(threadId, receiver);
+			spawnCalls.set(receiver, item.id);
+		}
+		return collabEvents(item, raw, started);
+	}
+	function activity(item: SubAgentActivity, threadId: string, raw: RawPayload): readonly AgentEvent[] {
+		claimed(threadId, item.agentThreadId);
+		const node = item.agentThreadId;
+		if (item.kind === "interrupted") {
+			return once(`ended/${node}`) ? [interrupted(item, raw)] : [{ raw, type: "raw" }];
+		}
+		return item.kind !== "started" || !once(`opened/${node}`)
+			? [{ raw, type: "raw" }]
+			: [announced(item, threadId, spawnCalls.get(node) ?? item.id, raw)];
+	}
+	function lifecycle(notification: RpcNotification, threadId: string): readonly AgentEvent[] | undefined {
+		const decoded = decodeItem(notification.params);
+		if (Option.isNone(decoded)) {
+			return undefined;
+		}
+		const item = subAgentItem(decoded.value.item);
+		if (item === undefined) {
+			return undefined;
+		}
+		const raw = rawOf(notification.method, notification.params);
+		return item.type === "collabAgentToolCall" ? collab(item, threadId, raw, notification.method === "item/started") : activity(item, threadId, raw);
+	}
+	function closed(threadId: string, params: unknown): readonly AgentEvent[] {
+		const raw = rawOf("thread/closed", params);
+		return once(`ended/${threadId}`) ? [closedWithoutWord(threadId, raw)] : [{ raw, type: "raw" }];
+	}
+	function mapped(notification: RpcNotification, threadId: string, root: boolean): readonly AgentEvent[] {
+		return !root && notification.method === "thread/closed"
+			? closed(threadId, notification.params)
+			: (lifecycle(notification, threadId) ?? toAgentEvents(notification, billedOn(threadId)));
+	}
+	function rebill(threadId: string, foundEvents: readonly AgentEvent[]): void {
+		for (const mappedEvent of foundEvents) {
+			if (mappedEvent.type === "model.changed") {
+				billing.set(threadId, mappedEvent.model);
+			}
+		}
+	}
+	function settled(notification: RpcNotification, threadId: string): void {
+		if (notification.method !== "thread/settings/updated") {
+			return;
+		}
+		const settings = decodeSettings(notification.params);
+		if (Option.isSome(settings)) {
+			billing.set(threadId, settings.value.threadSettings.model);
+		}
+	}
+	function events(notification: RpcNotification): readonly AgentEvent[] {
+		if (notification.method === "thread/started") {
+			return spawnedThread(notification.params);
+		}
+		const scoped = decodeScoped(notification.params);
+		if (Option.isNone(scoped) || !owns(scoped.value.threadId)) {
+			return [];
+		}
+		const threadId = scoped.value.threadId;
+		const root = threadId === rootThreadId;
+		settled(notification, threadId);
+		const found = mapped(notification, threadId, root);
+		rebill(threadId, found);
+		if (root) {
+			return found;
+		}
+		const origin: Origin = {
+			node: threadId,
+			spawnedBy: spawnCalls.get(threadId) ?? threadId,
+		};
+		return found.map((event) => attributed(event, origin));
+	}
+	return { events };
+}

package/src/adapters/turnRequests.ts

@@ -0,0 +1,45 @@
+import { Effect } from "effect";
+import { UnknownAcceptance } from "@shivaedev/agent/failures.ts";
+import type { ImageInput, Input } from "@shivaedev/agent/run.ts";
+import { TurnResponse } from "#adapters/protocol.ts";
+import { decode } from "#adapters/reads.ts";
+import { AppServer } from "#adapters/server.ts";
+
+function userInput(input: ImageInput) {
+	return input.parts.map((part) =>
+		part.type === "text" ? { text: part.text, "text_elements": [], type: "text" } : { path: part.path, type: "localImage" },
+	);
+}
+export const turnRequests = Effect.fn("Codex.turnRequests")(function* (threadId: string, settings: { model?: string; effort?: string }) {
+	const server = yield* AppServer;
+	return {
+		interrupt: (turnId: string) =>
+			server.request("turn/interrupt", { threadId, turnId }, turnId).pipe(
+				Effect.as("draining" as const),
+				Effect.catchTag("Rejected", (error) => {
+					if (error.message.includes("no active turn")) {
+						return Effect.succeed("inactive" as const);
+					}
+					if (error.message.includes("timeout waiting")) {
+						return Effect.succeed("draining" as const);
+					}
+					return Effect.fail(error);
+				}),
+			),
+		start: (input: ImageInput, operationId: string) =>
+			server.request("turn/start", { clientUserMessageId: operationId, input: userInput(input), threadId, ...settings }, operationId).pipe(
+				Effect.flatMap((value) =>
+					decode(TurnResponse, value).pipe(
+						Effect.mapError(
+							() => new UnknownAcceptance({ backend: "codex", message: "Codex accepted a mutation but returned no readable turn", operationId }),
+						),
+					),
+				),
+				Effect.map(({ turn }) => turn.id),
+			),
+		steer: (expectedTurnId: string, input: Input, operationId: string) =>
+			server
+				.request("turn/steer", { clientUserMessageId: operationId, expectedTurnId, input: userInput(input), threadId }, operationId)
+				.pipe(Effect.asVoid),
+	};
+});

package/src/adapters/userMessageEvent.ts

@@ -0,0 +1,22 @@
+import type { Raw } from "@shivaedev/agent/eventData.ts";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import type { KnownItem } from "#adapters/protocolItems.ts";
+
+function contentPart(part: Extract<KnownItem, { type: "userMessage" }>["content"][number]): Extract<RunEvent, { type: "message" }>["parts"][number] {
+	if (part.type === "text") {
+		return { text: part.text, type: "text" };
+	}
+	if (part.type === "localImage") {
+		return { mediaType: "application/octet-stream", path: part.path, type: "image" };
+	}
+	return { kind: "image", payload: JSON.stringify(part), type: "native" };
+}
+export function userMessageEvent(item: Extract<KnownItem, { type: "userMessage" }>, raw: typeof Raw.Type): RunEvent {
+	return {
+		raw,
+		role: "user",
+		type: "message",
+		...(item.clientId === null || item.clientId === undefined ? {} : { inputId: item.clientId }),
+		parts: item.content.map(contentPart),
+	};
+}

package/src/codex.ts

@@ -1 +1,15 @@
-export {};
+import { Effect, Layer } from "effect";
+import { Backend } from "@shivaedev/agent/backend.ts";
+import { defineService } from "@shivaedev/service/defineService.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: initializeCodex,
+	methods: (state) => ({ backend: backend(state), census: census(state) }),
+	requires: [CodexConfig],
+});
+export const codexLayer = Layer.effect(Backend)(Effect.flatMap(Codex, configuredBackend)).pipe(Layer.provideMerge(Codex.layer));

package/src/config.ts

@@ -0,0 +1,17 @@
+import { Context, type Effect } from "effect";
+export interface DynamicTool {
+	readonly description: string;
+	readonly execute: (input: unknown, callId: string) => Effect.Effect<{ readonly ok: boolean; readonly text: string }>;
+	readonly inputSchema: unknown;
+	readonly name: string;
+}
+export interface CodexConfiguration {
+	readonly args?: readonly string[];
+	readonly baseInstructions?: string;
+	readonly command?: string;
+	readonly cwd?: string;
+	readonly requestTimeoutMs?: number;
+	readonly sandbox?: "read-only" | "workspace-write" | "danger-full-access";
+	readonly tools?: readonly DynamicTool[];
+}
+export class CodexConfig extends Context.Service<CodexConfig, CodexConfiguration>()("@shivaedev/agent-codex/CodexConfig") {}