refactor(server): use idiomatic Effect for OpenCode SDK errors

Cursor Agent committed 3 months ago

Commit 654d5521 parent 8b546984 files · +126 −132Browse files

Unified · Split

4 files

apps/server/src/provider/Layers/OpenCodeAdapter.ts +2 −1
apps/server/src/provider/opencodeRuntime.ts +12 −13
apps/server/src/textGeneration/OpenCodeTextGeneration.test.ts +80 −90
apps/server/src/textGeneration/OpenCodeTextGeneration.ts +32 −28

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

 import { type OpenCodeAdapterShape } from "../Services/OpenCodeAdapter.ts";
 import {
   buildOpenCodePermissionRules,
+  isOpenCodeRuntimeError,
   OpenCodeRuntime,
   OpenCodeRuntimeError,
   openCodeQuestionId,
   new ProviderAdapterProcessError({
     provider: PROVIDER,
     threadId,
-    detail: OpenCodeRuntimeError.is(cause) ? cause.detail : openCodeRuntimeErrorDetail(cause),
+    detail: isOpenCodeRuntimeError(cause) ? cause.detail : openCodeRuntimeErrorDetail(cause),
     cause,
   });

apps/server/src/provider/opencodeRuntime.ts+12−13

@@ -13,14 +13,12 @@ import { · 12 unmodified lines
13	} from "@opencode-ai/sdk/v2";	13	} from "@opencode-ai/sdk/v2";
14	import * as Cause from "effect/Cause";	14	import * as Cause from "effect/Cause";
15	import * as Context from "effect/Context";	15	import * as Context from "effect/Context";
16	import * as Data from "effect/Data";
17	import * as Deferred from "effect/Deferred";	16	import * as Deferred from "effect/Deferred";
18	import * as Effect from "effect/Effect";	17	import * as Effect from "effect/Effect";
19	import * as Exit from "effect/Exit";	18	import * as Exit from "effect/Exit";
20	import * as Fiber from "effect/Fiber";	19	import * as Fiber from "effect/Fiber";
21	import * as Layer from "effect/Layer";	20	import * as Layer from "effect/Layer";
22	import * as Option from "effect/Option";	21	import * as Option from "effect/Option";
23	import * as P from "effect/Predicate";
24	import * as Ref from "effect/Ref";	22	import * as Ref from "effect/Ref";
25	import * as Result from "effect/Result";	23	import * as Result from "effect/Result";
26	import * as Scope from "effect/Scope";	24	import * as Scope from "effect/Scope";
@@ -50,15 +48,16 @@ export interface OpenCodeServerConnection { · 23 unmodified lines
50	readonly external: boolean;	48	readonly external: boolean;
51	}	49	}
52		50
53	const OPENCODE_RUNTIME_ERROR_TAG = "OpenCodeRuntimeError";	51	export class OpenCodeRuntimeError extends Schema.TaggedErrorClass<OpenCodeRuntimeError>()(
54	export class OpenCodeRuntimeError extends Data.TaggedError(OPENCODE_RUNTIME_ERROR_TAG)<{	52	"OpenCodeRuntimeError",
55	readonly operation: string;	53	{
56	readonly cause?: unknown;	54	operation: Schema.String,
57	readonly detail: string;	55	cause: Schema.optional(Schema.Defect()),
58	}> {	56	detail: Schema.String,
59	static readonly is = (u: unknown): u is OpenCodeRuntimeError =>	57	},
60	P.isTagged(u, OPENCODE_RUNTIME_ERROR_TAG);	58	) {}
61	}	59
		60	export const isOpenCodeRuntimeError = Schema.is(OpenCodeRuntimeError);
62		61
63	function encodeJsonStringForDiagnostics(input: unknown): string \| undefined {	62	function encodeJsonStringForDiagnostics(input: unknown): string \| undefined {
64	const result = encodeUnknownJsonStringExit(input);	63	const result = encodeUnknownJsonStringExit(input);
@@ -66,7 +65,7 @@ function encodeJsonStringForDiagnostics(input: unknown): string \| undefined { · 1 unmodified line
66	}	65	}
67		66
68	export function openCodeRuntimeErrorDetail(cause: unknown): string {	67	export function openCodeRuntimeErrorDetail(cause: unknown): string {
69	if (OpenCodeRuntimeError.is(cause)) return cause.detail;	68	if (isOpenCodeRuntimeError(cause)) return cause.detail;
70	if (cause instanceof Error && cause.message.trim().length > 0) return cause.message.trim();	69	if (cause instanceof Error && cause.message.trim().length > 0) return cause.message.trim();
71	if (cause && typeof cause === "object") {	70	if (cause && typeof cause === "object") {
72	// SDK v2 throws { response, request, error? } shapes — extract what's useful	71	// SDK v2 throws { response, request, error? } shapes — extract what's useful
@@ -270,7 +269,7 @@ function ensureRuntimeError( · 197 unmodified lines
270	detail: string,	269	detail: string,
271	cause: unknown,	270	cause: unknown,
272	): OpenCodeRuntimeError {	271	): OpenCodeRuntimeError {
273	return OpenCodeRuntimeError.is(cause)	272	return isOpenCodeRuntimeError(cause)
274	? cause	273	? cause
275	: new OpenCodeRuntimeError({ operation, detail, cause });	274	: new OpenCodeRuntimeError({ operation, detail, cause });
276	}	275	}

apps/server/src/textGeneration/OpenCodeTextGeneration.test.ts+80−90

 import { OpenCodeSettings, ProviderInstanceId, TextGenerationError } from "@t3tools/contracts";
 import * as NodeServices from "@effect/platform-node/NodeServices";
-import { it } from "@effect/vitest";
+import { assert, it } from "@effect/vitest";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
 import * as TestClock from "effect/testing/TestClock";
 import * as NetService from "@t3tools/shared/Net";
-import { beforeEach, expect } from "vite-plus/test";
+import { beforeEach } from "vite-plus/test";
 import * as ServerConfig from "../config.ts";
 import * as OpenCodeRuntime from "../provider/opencodeRuntime.ts";
   },
 };
-const OpenCodeRuntimeTestDouble: OpenCodeRuntime.OpenCodeRuntimeShape = {
+const OpenCodeRuntimeTestLayer = Layer.mock(OpenCodeRuntime.OpenCodeRuntime)({
   startOpenCodeServerProcess: ({ binaryPath }) =>
     Effect.gen(function* () {
       const index = runtimeMock.state.startCalls.length + 1;
         exitCode: Effect.never,
       };
     }),
-  connectToOpenCodeServer: ({ serverUrl }) =>
-    Effect.succeed({
-      url: serverUrl ?? "http://127.0.0.1:4301",
-      exitCode: null,
-      external: Boolean(serverUrl),
-    }),
-  runOpenCodeCommand: () => Effect.succeed({ stdout: "", stderr: "", code: 0 }),
   createOpenCodeSdkClient: ({ baseUrl, serverPassword }) =>
     ({
       session: {
         },
       },
     }) as unknown as ReturnType<OpenCodeRuntime.OpenCodeRuntimeShape["createOpenCodeSdkClient"]>,
-  loadOpenCodeInventory: () =>
+});
-    Effect.fail(
-      new OpenCodeRuntime.OpenCodeRuntimeError({
-        operation: "loadOpenCodeInventory",
-        detail: "OpenCodeRuntimeTestDouble.loadOpenCodeInventory not used in this test",
-        cause: null,
-      }),
-    ),
-};
 const DEFAULT_TEST_MODEL_SELECTION = {
   instanceId: ProviderInstanceId.make("opencode"),
 const OPENCODE_TEXT_GENERATION_IDLE_TTL_MS = 30_000;
-const OpenCodeTextGenerationTestLayer = Layer.succeed(
+const OpenCodeTextGenerationTestLayer = OpenCodeRuntimeTestLayer.pipe(
-  OpenCodeRuntime.OpenCodeRuntime,
-  OpenCodeRuntimeTestDouble,
-).pipe(
   Layer.provideMerge(
     ServerConfig.ServerConfig.layerTest(process.cwd(), {
       prefix: "t3code-opencode-text-generation-test-",
   Layer.provideMerge(NodeServices.layer),
 );
-const OpenCodeTextGenerationExistingServerTestLayer = Layer.succeed(
+const OpenCodeTextGenerationExistingServerTestLayer = OpenCodeRuntimeTestLayer.pipe(
-  OpenCodeRuntime.OpenCodeRuntime,
-  OpenCodeRuntimeTestDouble,
-).pipe(
   Layer.provideMerge(
     ServerConfig.ServerConfig.layerTest(process.cwd(), {
       prefix: "t3code-opencode-text-generation-existing-server-test-",
           modelSelection: DEFAULT_TEST_MODEL_SELECTION,
         });
-        expect(runtimeMock.state.startCalls).toEqual(["fake-opencode"]);
+        assert.deepStrictEqual(runtimeMock.state.startCalls, ["fake-opencode"]);
-        expect(runtimeMock.state.promptUrls).toEqual([
+        assert.deepStrictEqual(runtimeMock.state.promptUrls, [
           "http://127.0.0.1:4301",
           "http://127.0.0.1:4301",
         ]);
-        expect(runtimeMock.state.closeCalls).toEqual([]);
+        assert.deepStrictEqual(runtimeMock.state.closeCalls, []);
         yield* advanceIdleClock;
-        expect(runtimeMock.state.closeCalls).toEqual(["http://127.0.0.1:4301"]);
+        assert.deepStrictEqual(runtimeMock.state.closeCalls, ["http://127.0.0.1:4301"]);
       }),
     ).pipe(Effect.provide(TestClock.layer())),
   );
           modelSelection: DEFAULT_TEST_MODEL_SELECTION,
         });
-        expect(runtimeMock.state.startCalls).toEqual(["fake-opencode", "fake-opencode"]);
+        assert.deepStrictEqual(runtimeMock.state.startCalls, [
-        expect(runtimeMock.state.promptUrls).toEqual([
+          "fake-opencode",
+          "fake-opencode",
+        ]);
+        assert.deepStrictEqual(runtimeMock.state.promptUrls, [
           "http://127.0.0.1:4301",
           "http://127.0.0.1:4302",
         ]);
-        expect(runtimeMock.state.closeCalls).toEqual(["http://127.0.0.1:4301"]);
+        assert.deepStrictEqual(runtimeMock.state.closeCalls, ["http://127.0.0.1:4301"]);
       }),
     ).pipe(Effect.provide(TestClock.layer())),
   );
           .generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
           .pipe(Effect.flip);
-        expect(error).toBeInstanceOf(TextGenerationError);
+        assert.instanceOf(error, TextGenerationError);
-        expect(error.message).toContain("OpenCode session.create request failed.");
+        assert.include(error.message, "OpenCode session.create request failed.");
-        expect(error.cause).toMatchObject({
+        const cause = error.cause;
-          _tag: "OpenCodeTextGenerationSessionRequestError",
+        assert.instanceOf(
-          operation: "generateCommitMessage",
+          cause,
-          cwd: process.cwd(),
+          OpenCodeTextGeneration.OpenCodeTextGenerationSessionRequestError,
-          cause: sdkCause,
+        );
-        });
+        assert.strictEqual(cause.operation, "generateCommitMessage");
-        expect((error.cause as { cause: unknown }).cause).toBe(sdkCause);
+        assert.strictEqual(cause.cwd, process.cwd());
+        assert.strictEqual(cause.cause, sdkCause);
       }),
     ),
   );
           .generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
           .pipe(Effect.flip);
-        expect(error.message).toContain("OpenCode session.create returned no session payload.");
+        assert.include(error.message, "OpenCode session.create returned no session payload.");
-        expect(error.cause).toMatchObject({
+        const cause = error.cause;
-          _tag: "OpenCodeTextGenerationSessionPayloadError",
+        assert.instanceOf(
-          operation: "generateCommitMessage",
+          cause,
-          cwd: process.cwd(),
+          OpenCodeTextGeneration.OpenCodeTextGenerationSessionPayloadError,
-        });
+        );
-        expect(error.cause).not.toHaveProperty("cause");
+        assert.strictEqual(cause.operation, "generateCommitMessage");
+        assert.strictEqual(cause.cwd, process.cwd());
+        assert.notProperty(cause, "cause");
       }),
     ),
   );
           .generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
           .pipe(Effect.flip);
-        expect(error.message).toContain("OpenCode session.prompt request failed.");
+        assert.include(error.message, "OpenCode session.prompt request failed.");
-        expect(error.cause).toMatchObject({
+        const cause = error.cause;
-          _tag: "OpenCodeTextGenerationPromptRequestError",
+        assert.instanceOf(
-          operation: "generateCommitMessage",
+          cause,
-          cwd: process.cwd(),
+          OpenCodeTextGeneration.OpenCodeTextGenerationPromptRequestError,
-          sessionId: "http://127.0.0.1:4301/session",
+        );
-          providerId: "openai",
+        assert.strictEqual(cause.operation, "generateCommitMessage");
-          modelId: "gpt-5",
+        assert.strictEqual(cause.cwd, process.cwd());
-          cause: sdkCause,
+        assert.strictEqual(cause.sessionId, "http://127.0.0.1:4301/session");
-        });
+        assert.strictEqual(cause.providerId, "openai");
-        expect((error.cause as { cause: unknown }).cause).toBe(sdkCause);
+        assert.strictEqual(cause.modelId, "gpt-5");
+        assert.strictEqual(cause.cause, sdkCause);
       }),
     ),
   );
           .generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
           .pipe(Effect.flip);
-        expect(error.message).toContain("OpenCode returned empty output.");
+        assert.include(error.message, "OpenCode returned empty output.");
-        expect(error.cause).toMatchObject({
+        const cause = error.cause;
-          _tag: "OpenCodeTextGenerationEmptyOutputError",
+        assert.instanceOf(
-          operation: "generateCommitMessage",
+          cause,
-          cwd: process.cwd(),
+          OpenCodeTextGeneration.OpenCodeTextGenerationEmptyOutputError,
-          sessionId: "http://127.0.0.1:4301/session",
+        );
-          providerId: "openai",
+        assert.strictEqual(cause.operation, "generateCommitMessage");
-          modelId: "gpt-5",
+        assert.strictEqual(cause.cwd, process.cwd());
-          responsePartCount: 3,
+        assert.strictEqual(cause.sessionId, "http://127.0.0.1:4301/session");
-          textPartCount: 1,
+        assert.strictEqual(cause.providerId, "openai");
-        });
+        assert.strictEqual(cause.modelId, "gpt-5");
-        expect(error.cause).not.toHaveProperty("cause");
+        assert.strictEqual(cause.responsePartCount, 3);
+        assert.strictEqual(cause.textPartCount, 1);
+        assert.notProperty(cause, "cause");
       }),
     ),
   );
           modelSelection: DEFAULT_TEST_MODEL_SELECTION,
         });
-        expect(result).toEqual({
+        assert.deepStrictEqual(result, {
           subject: "Tighten OpenCode parsing",
           body: "Handle JSON text output locally.",
         });
           .generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
           .pipe(Effect.flip);
-        expect(error.message).toContain("Model did not produce structured output");
+        assert.include(error.message, "Model did not produce structured output");
-        expect(error.cause).toMatchObject({
+        const cause = error.cause;
-          _tag: "OpenCodeTextGenerationPromptResponseError",
+        assert.instanceOf(
-          operation: "generateCommitMessage",
+          cause,
-          cwd: process.cwd(),
+          OpenCodeTextGeneration.OpenCodeTextGenerationPromptResponseError,
-          sessionId: "http://127.0.0.1:4301/session",
+        );
-          providerId: "openai",
+        assert.strictEqual(cause.operation, "generateCommitMessage");
-          modelId: "gpt-5",
+        assert.strictEqual(cause.cwd, process.cwd());
-          providerErrorName: "StructuredOutputError",
+        assert.strictEqual(cause.sessionId, "http://127.0.0.1:4301/session");
-          providerMessage: "Model did not produce structured output",
+        assert.strictEqual(cause.providerId, "openai");
-        });
+        assert.strictEqual(cause.modelId, "gpt-5");
-        expect(error.cause).not.toHaveProperty("cause");
+        assert.strictEqual(cause.providerErrorName, "StructuredOutputError");
+        assert.strictEqual(cause.providerMessage, "Model did not produce structured output");
+        assert.notProperty(cause, "cause");
       }),
     ),
   );
             modelSelection: DEFAULT_TEST_MODEL_SELECTION,
           });
-          expect(runtimeMock.state.startCalls).toEqual([]);
+          assert.deepStrictEqual(runtimeMock.state.startCalls, []);
-          expect(runtimeMock.state.promptUrls).toEqual([
+          assert.deepStrictEqual(runtimeMock.state.promptUrls, [
             "http://127.0.0.1:9999",
             "http://127.0.0.1:9999",
           ]);
-          expect(runtimeMock.state.authHeaders).toEqual([
+          assert.deepStrictEqual(runtimeMock.state.authHeaders, [
             `Basic ${btoa("opencode:secret-password")}`,
             `Basic ${btoa("opencode:secret-password")}`,
           ]);
           yield* advanceIdleClock;
-          expect(runtimeMock.state.closeCalls).toEqual([]);
+          assert.deepStrictEqual(runtimeMock.state.closeCalls, []);
         }),
       ).pipe(Effect.provide(TestClock.layer())),
     );

apps/server/src/textGeneration/OpenCodeTextGeneration.ts+32−28

@@ -389,19 +389,21 @@ export const makeOpenCodeTextGeneration = Effect.fn("makeOpenCodeTextGeneration" · 388 unmodified lines
389	? { serverPassword: openCodeSettings.serverPassword }	389	? { serverPassword: openCodeSettings.serverPassword }
390	: {}),	390	: {}),
391	});	391	});
392	const session = yield* Effect.tryPromise({	392	const session = yield* OpenCodeRuntime.runOpenCodeSdk("session.create", () =>
393	try: () =>	393	client.session.create({
394	client.session.create({	394	title: `T3 Code ${input.operation}`,
395	title: `T3 Code ${input.operation}`,	395	permission: [{ permission: "", pattern: "", action: "deny" }],
396	permission: [{ permission: "", pattern: "", action: "deny" }],	396	}),
397	}),	397	).pipe(
398	catch: (cause) =>	398	Effect.mapError(
399	new OpenCodeTextGenerationSessionRequestError({	399	(cause) =>
400	operation: input.operation,	400	new OpenCodeTextGenerationSessionRequestError({
401	cwd: input.cwd,	401	operation: input.operation,
402	cause,	402	cwd: input.cwd,
403	}),	403	cause: cause.cause,
404	});	404	}),
		405	),
		406	);
405	if (!session.data) {	407	if (!session.data) {
406	return yield* new OpenCodeTextGenerationSessionPayloadError({	408	return yield* new OpenCodeTextGenerationSessionPayloadError({
407	operation: input.operation,	409	operation: input.operation,
@@ -418,21 +420,23 @@ export const makeOpenCodeTextGeneration = Effect.fn("makeOpenCodeTextGeneration" · 10 unmodified lines
418	modelId: parsedModel.modelID,	420	modelId: parsedModel.modelID,
419	};	421	};
420		422
421	const result = yield* Effect.tryPromise({	423	const result = yield* OpenCodeRuntime.runOpenCodeSdk("session.prompt", () =>
422	try: () =>	424	client.session.prompt({
423	client.session.prompt({	425	sessionID: session.data.id,
424	sessionID: session.data.id,	426	model: parsedModel,
425	model: parsedModel,	427	...(selectedAgent ? { agent: selectedAgent } : {}),
426	...(selectedAgent ? { agent: selectedAgent } : {}),	428	...(selectedVariant ? { variant: selectedVariant } : {}),
427	...(selectedVariant ? { variant: selectedVariant } : {}),	429	parts: [{ type: "text", text: input.prompt }, ...fileParts],
428	parts: [{ type: "text", text: input.prompt }, ...fileParts],	430	}),
429	}),	431	).pipe(
430	catch: (cause) =>	432	Effect.mapError(
431	new OpenCodeTextGenerationPromptRequestError({	433	(cause) =>
432	...promptContext,	434	new OpenCodeTextGenerationPromptRequestError({
433	cause,	435	...promptContext,
434	}),	436	cause: cause.cause,
435	});	437	}),
		438	),
		439	);
436	const promptFailure = getOpenCodePromptFailure(result.data?.info?.error);	440	const promptFailure = getOpenCodePromptFailure(result.data?.info?.error);
437	if (promptFailure) {	441	if (promptFailure) {
438	return yield* new OpenCodeTextGenerationPromptResponseError({	442	return yield* new OpenCodeTextGenerationPromptResponseError({