authorgravatar for julius0216@outlook.comJulius Marminge <julius0216@outlook.com> 2026-02-27 09:09:05-08:00
committergravatar for jmarminge@gmail.comJulius Marminge <jmarminge@gmail.com> 2026-03-05 23:00:41-08:00
log1b1ede92bae7e925827f9961fe322c55e79241c3
tree59577ddeab9a70003c4a27571bafef75f21dd5fe
parent4ec7ae33c5e47dc638bbfb80bd792724f5d7f1ce

Make Claude runtime boundary Effect-native

Co-authored-by: codex <codex@users.noreply.github.com>

2 files changed, 110 insertions(+), 111 deletions(-)

apps/server/src/provider/Layers/ClaudeCodeAdapter.test.ts+46-37
......@@ -32,9 +32,9 @@ class FakeClaudeRuntime implements ClaudeCodeRuntime {
3232 readonly streamEvents = Stream.fromQueue(this.runtimeEventQueue);
3333
3434 public startSessionImpl = vi.fn(
35 async (input: ProviderSessionStartInput): Promise<ProviderSession> => {
35 (input: ProviderSessionStartInput): Effect.Effect<ProviderSession> => {
3636 const now = new Date().toISOString();
37 return {
37 return Effect.succeed({
3838 sessionId: asSessionId("claude-sess-1"),
3939 provider: "claudeCode",
4040 status: "ready",
......@@ -44,88 +44,97 @@ class FakeClaudeRuntime implements ClaudeCodeRuntime {
4444 model: input.model,
4545 createdAt: now,
4646 updatedAt: now,
47 };
47 });
4848 },
4949 );
5050
5151 public sendTurnImpl = vi.fn(
52 async (_input: ProviderSendTurnInput): Promise<ProviderTurnStartResult> => ({
53 threadId: ProviderThreadId.makeUnsafe("claude-thread-1"),
54 turnId: asTurnId("claude-turn-1"),
55 }),
52 (_input: ProviderSendTurnInput): Effect.Effect<ProviderTurnStartResult> =>
53 Effect.succeed({
54 threadId: ProviderThreadId.makeUnsafe("claude-thread-1"),
55 turnId: asTurnId("claude-turn-1"),
56 }),
5657 );
5758
5859 public interruptTurnImpl = vi.fn(
59 async (_sessionId: ProviderSessionId, _turnId?: ProviderTurnId): Promise<void> => undefined,
60 (_sessionId: ProviderSessionId, _turnId?: ProviderTurnId): Effect.Effect<void> => Effect.void,
6061 );
6162
62 public readThreadImpl = vi.fn(async (_sessionId: ProviderSessionId) => ({
63 threadId: ProviderThreadId.makeUnsafe("claude-thread-1"),
64 turns: [],
65 }));
66
67 public rollbackThreadImpl = vi.fn(
68 async (_sessionId: ProviderSessionId, _numTurns: number) => ({
63 public readThreadImpl = vi.fn((_sessionId: ProviderSessionId): Effect.Effect<{
64 threadId: ProviderThreadId;
65 turns: never[];
66 }> =>
67 Effect.succeed({
6968 threadId: ProviderThreadId.makeUnsafe("claude-thread-1"),
7069 turns: [],
71 }),
70 }));
71
72 public rollbackThreadImpl = vi.fn(
73 (_sessionId: ProviderSessionId, _numTurns: number): Effect.Effect<{
74 threadId: ProviderThreadId;
75 turns: never[];
76 }> =>
77 Effect.succeed({
78 threadId: ProviderThreadId.makeUnsafe("claude-thread-1"),
79 turns: [],
80 }),
7281 );
7382
7483 public respondToRequestImpl = vi.fn(
75 async (
84 (
7685 _sessionId: ProviderSessionId,
7786 _requestId: ApprovalRequestId,
7887 _decision: ProviderApprovalDecision,
79 ): Promise<void> => undefined,
88 ): Effect.Effect<void> => Effect.void,
8089 );
8190
82 public stopSessionImpl = vi.fn((_sessionId: ProviderSessionId) => undefined);
83 public listSessionsImpl = vi.fn((): ReadonlyArray<ProviderSession> => []);
84 public hasSessionImpl = vi.fn((_sessionId: ProviderSessionId): boolean => false);
85 public stopAllImpl = vi.fn(() => undefined);
91 public stopSessionImpl = vi.fn((_sessionId: ProviderSessionId): Effect.Effect<void> => Effect.void);
92 public listSessionsImpl = vi.fn((): Effect.Effect<ReadonlyArray<ProviderSession>> => Effect.succeed([]));
93 public hasSessionImpl = vi.fn((_sessionId: ProviderSessionId): Effect.Effect<boolean> => Effect.succeed(false));
94 public stopAllImpl = vi.fn((): Effect.Effect<void> => Effect.void);
8695
87 async startSession(input: ProviderSessionStartInput): Promise<ProviderSession> {
96 startSession(input: ProviderSessionStartInput): Effect.Effect<ProviderSession> {
8897 return this.startSessionImpl(input);
8998 }
9099
91 async sendTurn(input: ProviderSendTurnInput): Promise<ProviderTurnStartResult> {
100 sendTurn(input: ProviderSendTurnInput): Effect.Effect<ProviderTurnStartResult> {
92101 return this.sendTurnImpl(input);
93102 }
94103
95 async interruptTurn(sessionId: ProviderSessionId, turnId?: ProviderTurnId): Promise<void> {
104 interruptTurn(sessionId: ProviderSessionId, turnId?: ProviderTurnId): Effect.Effect<void> {
96105 return this.interruptTurnImpl(sessionId, turnId);
97106 }
98107
99 async readThread(sessionId: ProviderSessionId) {
108 readThread(sessionId: ProviderSessionId) {
100109 return this.readThreadImpl(sessionId);
101110 }
102111
103 async rollbackThread(sessionId: ProviderSessionId, numTurns: number) {
112 rollbackThread(sessionId: ProviderSessionId, numTurns: number) {
104113 return this.rollbackThreadImpl(sessionId, numTurns);
105114 }
106115
107 async respondToRequest(
116 respondToRequest(
108117 sessionId: ProviderSessionId,
109118 requestId: ApprovalRequestId,
110119 decision: ProviderApprovalDecision,
111 ): Promise<void> {
120 ): Effect.Effect<void> {
112121 return this.respondToRequestImpl(sessionId, requestId, decision);
113122 }
114123
115 stopSession(sessionId: ProviderSessionId): void {
116 this.stopSessionImpl(sessionId);
124 stopSession(sessionId: ProviderSessionId): Effect.Effect<void> {
125 return this.stopSessionImpl(sessionId);
117126 }
118127
119 listSessions(): ReadonlyArray<ProviderSession> {
128 listSessions(): Effect.Effect<ReadonlyArray<ProviderSession>> {
120129 return this.listSessionsImpl();
121130 }
122131
123 hasSession(sessionId: ProviderSessionId): boolean {
132 hasSession(sessionId: ProviderSessionId): Effect.Effect<boolean> {
124133 return this.hasSessionImpl(sessionId);
125134 }
126135
127 stopAll(): void {
128 this.stopAllImpl();
136 stopAll(): Effect.Effect<void> {
137 return this.stopAllImpl();
129138 }
130139
131140 emitRuntimeEvent(event: ProviderRuntimeEvent): void {
......@@ -160,8 +169,8 @@ validationLayer("ClaudeCodeAdapterLive validation", (it) => {
160169});
161170
162171const sessionErrorRuntime = new FakeClaudeRuntime();
163sessionErrorRuntime.sendTurnImpl.mockImplementation(async () => {
164 throw new Error("Unknown session: claude-sess-missing");
172sessionErrorRuntime.sendTurnImpl.mockImplementation(() => {
173 return Effect.fail(new Error("Unknown session: claude-sess-missing"));
165174});
166175const sessionErrorLayer = it.layer(makeClaudeCodeAdapterLive({ runtime: sessionErrorRuntime }));
167176
apps/server/src/provider/Layers/ClaudeCodeAdapter.ts+64-74
......@@ -36,23 +36,32 @@ import {
3636const PROVIDER = "claudeCode" as const;
3737
3838export interface ClaudeCodeRuntime {
39 readonly startSession: (input: ProviderSessionStartInput) => Promise<ProviderSession>;
40 readonly sendTurn: (input: ProviderSendTurnInput) => Promise<ProviderTurnStartResult>;
41 readonly interruptTurn: (sessionId: ProviderSessionId, turnId?: ProviderTurnId) => Promise<void>;
42 readonly readThread: (sessionId: ProviderSessionId) => Promise<ProviderThreadSnapshot>;
39 readonly startSession: (
40 input: ProviderSessionStartInput,
41 ) => Effect.Effect<ProviderSession, unknown>;
42 readonly sendTurn: (
43 input: ProviderSendTurnInput,
44 ) => Effect.Effect<ProviderTurnStartResult, unknown>;
45 readonly interruptTurn: (
46 sessionId: ProviderSessionId,
47 turnId?: ProviderTurnId,
48 ) => Effect.Effect<void, unknown>;
49 readonly readThread: (
50 sessionId: ProviderSessionId,
51 ) => Effect.Effect<ProviderThreadSnapshot, unknown>;
4352 readonly rollbackThread: (
4453 sessionId: ProviderSessionId,
4554 numTurns: number,
46 ) => Promise<ProviderThreadSnapshot>;
55 ) => Effect.Effect<ProviderThreadSnapshot, unknown>;
4756 readonly respondToRequest: (
4857 sessionId: ProviderSessionId,
4958 requestId: ApprovalRequestId,
5059 decision: ProviderApprovalDecision,
51 ) => Promise<void>;
52 readonly stopSession: (sessionId: ProviderSessionId) => void;
53 readonly listSessions: () => ReadonlyArray<ProviderSession>;
54 readonly hasSession: (sessionId: ProviderSessionId) => boolean;
55 readonly stopAll: () => void;
60 ) => Effect.Effect<void, unknown>;
61 readonly stopSession: (sessionId: ProviderSessionId) => Effect.Effect<void>;
62 readonly listSessions: () => Effect.Effect<ReadonlyArray<ProviderSession>>;
63 readonly hasSession: (sessionId: ProviderSessionId) => Effect.Effect<boolean>;
64 readonly stopAll: () => Effect.Effect<void>;
5665 readonly streamEvents: Stream.Stream<ProviderRuntimeEvent>;
5766}
5867
......@@ -107,22 +116,20 @@ function toRequestError(
107116 });
108117}
109118
110function makeUnavailableRuntime(): ClaudeCodeRuntime {
111 const unavailable = async (): Promise<never> => {
112 throw new Error("Claude Code runtime is not configured.");
113 };
119const unavailableRuntimeError = () => new Error("Claude Code runtime is not configured.");
114120
121function makeUnavailableRuntime(): ClaudeCodeRuntime {
115122 return {
116 startSession: unavailable,
117 sendTurn: unavailable,
118 interruptTurn: unavailable,
119 readThread: unavailable,
120 rollbackThread: unavailable,
121 respondToRequest: unavailable,
122 stopSession: () => {},
123 listSessions: () => [],
124 hasSession: () => false,
125 stopAll: () => {},
123 startSession: () => Effect.fail(unavailableRuntimeError()),
124 sendTurn: () => Effect.fail(unavailableRuntimeError()),
125 interruptTurn: () => Effect.fail(unavailableRuntimeError()),
126 readThread: () => Effect.fail(unavailableRuntimeError()),
127 rollbackThread: () => Effect.fail(unavailableRuntimeError()),
128 respondToRequest: () => Effect.fail(unavailableRuntimeError()),
129 stopSession: () => Effect.void,
130 listSessions: () => Effect.succeed([]),
131 hasSession: () => Effect.succeed(false),
132 stopAll: () => Effect.void,
126133 streamEvents: Stream.empty,
127134 };
128135}
......@@ -140,13 +147,9 @@ const makeClaudeCodeAdapter = (options?: ClaudeCodeAdapterLiveOptions) =>
140147 return makeUnavailableRuntime();
141148 }),
142149 (runtime) =>
143 Effect.sync(() => {
144 try {
145 runtime.stopAll();
146 } catch {
147 // Finalizers should never fail and block shutdown.
148 }
149 }),
150 runtime.stopAll().pipe(
151 Effect.orElseSucceed(() => undefined),
152 ),
150153 );
151154
152155 const startSession: ClaudeCodeAdapterShape["startSession"] = (input) => {
......@@ -160,35 +163,33 @@ const makeClaudeCodeAdapter = (options?: ClaudeCodeAdapterLiveOptions) =>
160163 );
161164 }
162165
163 return Effect.tryPromise({
164 try: () => runtime.startSession(input),
165 catch: (cause) =>
166 new ProviderAdapterProcessError({
167 provider: PROVIDER,
168 sessionId: "pending",
169 detail: toMessage(cause, "Failed to start Claude Code adapter session."),
170 cause,
171 }),
172 });
166 return runtime.startSession(input).pipe(
167 Effect.mapError(
168 (cause) =>
169 new ProviderAdapterProcessError({
170 provider: PROVIDER,
171 sessionId: "pending",
172 detail: toMessage(cause, "Failed to start Claude Code adapter session."),
173 cause,
174 }),
175 ),
176 );
173177 };
174178
175179 const sendTurn: ClaudeCodeAdapterShape["sendTurn"] = (input) =>
176 Effect.tryPromise({
177 try: () => runtime.sendTurn(input),
178 catch: (cause) => toRequestError(input.sessionId, "turn/start", cause),
179 });
180 runtime.sendTurn(input).pipe(
181 Effect.mapError((cause) => toRequestError(input.sessionId, "turn/start", cause)),
182 );
180183
181184 const interruptTurn: ClaudeCodeAdapterShape["interruptTurn"] = (sessionId, turnId) =>
182 Effect.tryPromise({
183 try: () => runtime.interruptTurn(sessionId, turnId),
184 catch: (cause) => toRequestError(sessionId, "turn/interrupt", cause),
185 });
185 runtime.interruptTurn(sessionId, turnId).pipe(
186 Effect.mapError((cause) => toRequestError(sessionId, "turn/interrupt", cause)),
187 );
186188
187189 const readThread: ClaudeCodeAdapterShape["readThread"] = (sessionId) =>
188 Effect.tryPromise({
189 try: () => runtime.readThread(sessionId),
190 catch: (cause) => toRequestError(sessionId, "thread/read", cause),
191 });
190 runtime.readThread(sessionId).pipe(
191 Effect.mapError((cause) => toRequestError(sessionId, "thread/read", cause)),
192 );
192193
193194 const rollbackThread: ClaudeCodeAdapterShape["rollbackThread"] = (sessionId, numTurns) => {
194195 if (!Number.isInteger(numTurns) || numTurns < 1) {
......@@ -201,10 +202,9 @@ const makeClaudeCodeAdapter = (options?: ClaudeCodeAdapterLiveOptions) =>
201202 );
202203 }
203204
204 return Effect.tryPromise({
205 try: () => runtime.rollbackThread(sessionId, numTurns),
206 catch: (cause) => toRequestError(sessionId, "thread/rollback", cause),
207 });
205 return runtime.rollbackThread(sessionId, numTurns).pipe(
206 Effect.mapError((cause) => toRequestError(sessionId, "thread/rollback", cause)),
207 );
208208 };
209209
210210 const respondToRequest: ClaudeCodeAdapterShape["respondToRequest"] = (
......@@ -212,26 +212,17 @@ const makeClaudeCodeAdapter = (options?: ClaudeCodeAdapterLiveOptions) =>
212212 requestId,
213213 decision,
214214 ) =>
215 Effect.tryPromise({
216 try: () => runtime.respondToRequest(sessionId, requestId, decision),
217 catch: (cause) => toRequestError(sessionId, "item/requestApproval/decision", cause),
218 });
215 runtime.respondToRequest(sessionId, requestId, decision).pipe(
216 Effect.mapError((cause) => toRequestError(sessionId, "item/requestApproval/decision", cause)),
217 );
219218
220 const stopSession: ClaudeCodeAdapterShape["stopSession"] = (sessionId) =>
221 Effect.sync(() => {
222 runtime.stopSession(sessionId);
223 });
219 const stopSession: ClaudeCodeAdapterShape["stopSession"] = (sessionId) => runtime.stopSession(sessionId);
224220
225 const listSessions: ClaudeCodeAdapterShape["listSessions"] = () =>
226 Effect.sync(() => runtime.listSessions());
221 const listSessions: ClaudeCodeAdapterShape["listSessions"] = () => runtime.listSessions();
227222
228 const hasSession: ClaudeCodeAdapterShape["hasSession"] = (sessionId) =>
229 Effect.sync(() => runtime.hasSession(sessionId));
223 const hasSession: ClaudeCodeAdapterShape["hasSession"] = (sessionId) => runtime.hasSession(sessionId);
230224
231 const stopAll: ClaudeCodeAdapterShape["stopAll"] = () =>
232 Effect.sync(() => {
233 runtime.stopAll();
234 });
225 const stopAll: ClaudeCodeAdapterShape["stopAll"] = () => runtime.stopAll();
235226
236227 return {
237228 provider: PROVIDER,
......@@ -254,4 +245,3 @@ export const ClaudeCodeAdapterLive = Layer.effect(ClaudeCodeAdapter, makeClaudeC
254245export function makeClaudeCodeAdapterLive(options?: ClaudeCodeAdapterLiveOptions) {
255246 return Layer.effect(ClaudeCodeAdapter, makeClaudeCodeAdapter(options));
256247}
257