@opencode/client 0.0.0-reserved → 2.0.1

package/dist/effect/client.js

@@ -0,0 +1,29 @@
+export * as OpenCode from "./client.js";
+import { Cause, Context, Effect, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { SharedEvents } from "../shared-events.js";
+import { ClientError, OpenCode } from "./generated/index.js";
+import { RpcClientRuntime } from "./rpc.js";
+const CurrentHeaders = Context.Reference("@opencode/client/effect/rpc/headers", {
+    defaultValue: () => undefined,
+});
+export const make = Effect.fn("OpenCode.make")(function* (options) {
+    const httpClient = yield* HttpClient.HttpClient;
+    const raw = yield* OpenCode.make(options).pipe(Effect.provideService(HttpClient.HttpClient, HttpClient.mapRequestEffect(httpClient, (request) => Effect.map(CurrentHeaders, (headers) => headers ? HttpClientRequest.setHeaders(request, new Headers(headers)) : request))));
+    const context = yield* Effect.context();
+    const native = raw.event.subscribe();
+    // Async iterators throw a squashed cause; retain the native typed failures and defects intact.
+    class EventFailure {
+        cause;
+        constructor(cause) {
+            this.cause = cause;
+        }
+    }
+    const shared = SharedEvents.make((signal) => Stream.toAsyncIterableWith(native.pipe(Stream.interruptWhen(RpcClientRuntime.aborted(signal)), Stream.catchCause((cause) => Stream.fail(new EventFailure(cause)))), context));
+    const subscribe = () => Stream.fromAsyncIterable(shared.subscribe(), (error) => error).pipe(Stream.catch((error) => Stream.failCause(error instanceof EventFailure ? error.cause : Cause.fail(new ClientError({ cause: error })))));
+    return {
+        ...raw,
+        event: { ...raw.event, subscribe },
+        rpc: Object.assign(RpcClientRuntime.make((input, options) => raw.rpc.call(input).pipe(Effect.provideService(CurrentHeaders, options?.headers)), subscribe), raw.rpc),
+    };
+});

package/dist/effect/generated/client-error.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+declare const ClientError_base: Schema.Class<ClientError, Schema.TaggedStruct<"ClientError", {
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class ClientError extends ClientError_base {
+}
+export {};

package/dist/effect/generated/client-error.js

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+export class ClientError extends Schema.TaggedError()("ClientError", {
+    cause: Schema.Defect(),
+}) {
+}