@kilocode/client 0.0.0-stage → 0.0.0-v2-9

package/dist/chunks/contract-5bf0yjkp.js

@@ -0,0 +1,111 @@
+import {
+  headers2
+} from "./contract-8ye1ye6f.js";
+import {
+  __export
+} from "./contract-9rqn6x4v.js";
+
+// src/pty-handoff.ts
+var exports_pty_handoff = {};
+__export(exports_pty_handoff, {
+  PtyHandoff: () => exports_pty_handoff,
+  clear: () => clear2,
+  complete: () => complete2,
+  environment: () => environment2,
+  prepare: () => prepare2
+});
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+async function prepare2(file, info, timeout) {
+  const existing = await read(file);
+  if (existing !== undefined && existing.expiresAt > Date.now() && same(existing.source, info))
+    return;
+  const { OpenCode } = await import("../promise/index.js");
+  const client = OpenCode.make({
+    baseUrl: info.url,
+    headers: headers2({
+      url: info.url,
+      auth: info.password === undefined ? undefined : { type: "basic", username: "opencode", password: info.password }
+    })
+  });
+  const handoff = await client.experimental.persistentPty.handoff({ signal: AbortSignal.timeout(timeout) }).then(parse).catch(async (cause) => {
+    const concurrent = await read(file);
+    if (concurrent !== undefined && concurrent.expiresAt > Date.now() && same(concurrent.source, info))
+      return;
+    console.warn("Background service cannot hand off persistent terminals; shutting them down before replacement", cause);
+    await client.experimental.persistentPty.shutdown({ signal: AbortSignal.timeout(timeout) }).catch(() => {});
+    return null;
+  });
+  if (handoff === undefined)
+    return;
+  await publish(file, info, handoff).catch((cause) => console.warn("Failed to publish persistent terminal handoff", cause));
+}
+function parse(body) {
+  if (typeof body !== "object" || body === null || !("handoff" in body))
+    throw new Error("Invalid persistent terminal handoff response");
+  if (body.handoff === null)
+    return null;
+  if (!isHandoff(body.handoff) || body.handoff.expiresAt <= Date.now())
+    throw new Error("Invalid or expired persistent terminal handoff");
+  return body.handoff;
+}
+async function publish(file, info, handoff) {
+  const temporary = `${file}.pty-handoff.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify({
+    source: { id: info.id, pid: info.pid, url: info.url },
+    handoff,
+    expiresAt: handoff?.expiresAt ?? Date.now() + 30000
+  }), { mode: 384, flag: "wx" });
+  await rename(temporary, file + ".pty-handoff").finally(() => rm(temporary, { force: true }));
+}
+async function environment2(file, env) {
+  const record = await read(file);
+  const current = await readFile(file, "utf8").then((text) => JSON.parse(text)).catch(() => {
+    return;
+  });
+  const handoff = record !== undefined && record.expiresAt > Date.now() && (current === undefined || same(record.source, current)) ? record.handoff : undefined;
+  return { ...env, OPENCODE_PTY_HANDOFF: handoff == null ? undefined : JSON.stringify(handoff) };
+}
+async function complete2(file, info) {
+  const record = await read(file);
+  if (record !== undefined && !same(record.source, info))
+    await clear2(file);
+}
+async function clear2(file) {
+  await rm(file + ".pty-handoff", { force: true });
+}
+async function read(file) {
+  const value = await readFile(file + ".pty-handoff", "utf8").then((text) => JSON.parse(text)).catch(() => {
+    return;
+  });
+  if (typeof value !== "object" || value === null || !("source" in value) || !("handoff" in value))
+    return;
+  if (typeof value.source !== "object" || value.source === null)
+    return;
+  if (!("pid" in value.source) || typeof value.source.pid !== "number")
+    return;
+  if (!("url" in value.source) || typeof value.source.url !== "string")
+    return;
+  if ("id" in value.source && typeof value.source.id !== "string")
+    return;
+  if (value.handoff !== null && !isHandoff(value.handoff))
+    return;
+  if (!("expiresAt" in value) || typeof value.expiresAt !== "number" || !Number.isFinite(value.expiresAt))
+    return;
+  return {
+    source: {
+      id: "id" in value.source && typeof value.source.id === "string" ? value.source.id : undefined,
+      pid: value.source.pid,
+      url: value.source.url
+    },
+    handoff: value.handoff,
+    expiresAt: value.expiresAt
+  };
+}
+function same(left, right) {
+  return left.id === right.id && left.pid === right.pid && left.url === right.url;
+}
+function isHandoff(value) {
+  return typeof value === "object" && value !== null && "directory" in value && typeof value.directory === "string" && "instanceID" in value && typeof value.instanceID === "string" && "ticket" in value && typeof value.ticket === "string" && "expiresAt" in value && typeof value.expiresAt === "number" && Number.isFinite(value.expiresAt);
+}
+
+export { prepare2, environment2, complete2, clear2, exports_pty_handoff };

package/dist/chunks/contract-8bbb028w.js

@@ -0,0 +1,145 @@
+import {
+  __export
+} from "./contract-9rqn6x4v.js";
+
+// src/shared-events.ts
+var exports_shared_events = {};
+__export(exports_shared_events, {
+  SharedEvents: () => exports_shared_events,
+  make: () => make7
+});
+function make7(connect) {
+  let current;
+  const capacity = 4096;
+  function stop(connection) {
+    connection.connected = undefined;
+    connection.controller.abort();
+    if (current === connection)
+      current = undefined;
+  }
+  async function run(connection) {
+    let iterator;
+    let completion = {};
+    try {
+      if (connection.controller.signal.aborted)
+        return;
+      iterator = connect(connection.controller.signal, () => {
+        connection.subscribers.forEach((subscriber) => subscriber.activity?.());
+      })[Symbol.asyncIterator]();
+      while (!connection.controller.signal.aborted) {
+        const item = await iterator.next();
+        if (item.done || connection.controller.signal.aborted)
+          break;
+        if (item.value.type === "server.connected")
+          connection.connected = item.value;
+        connection.subscribers.forEach((subscriber) => subscriber.push(item.value));
+      }
+    } catch (error) {
+      completion = { error };
+    } finally {
+      stop(connection);
+      try {
+        await iterator?.return?.();
+      } catch (error) {
+        if (!("error" in completion))
+          completion = { error };
+      }
+      connection.subscribers.forEach((subscriber) => subscriber.finish(completion));
+    }
+  }
+  return {
+    subscribe(options) {
+      return {
+        [Symbol.asyncIterator]() {
+          const pending = [];
+          const queued = [];
+          let started = false;
+          let completion;
+          let connection;
+          function finish(result, discard = true) {
+            completion = result;
+            if (discard)
+              queued.length = 0;
+            options?.signal?.removeEventListener("abort", abort);
+            if (connection?.subscribers.delete(subscriber) && !connection.subscribers.size)
+              stop(connection);
+            pending.splice(0).forEach((request) => {
+              if ("error" in result)
+                request.reject(result.error);
+              else
+                request.resolve({ done: true, value: undefined });
+            });
+          }
+          function abort() {
+            finish({});
+          }
+          const subscriber = {
+            activity: options?.onActivity,
+            finish(result) {
+              finish(result, false);
+            },
+            push(value) {
+              if (completion)
+                return;
+              const request = pending.shift();
+              if (request) {
+                request.resolve({ done: false, value });
+                return;
+              }
+              if (queued.length === capacity) {
+                finish({ error: new Error(`Event subscriber exceeded its ${capacity}-event capacity`) });
+                return;
+              }
+              queued.push(value);
+            }
+          };
+          function start() {
+            if (completion)
+              return;
+            const fresh = !current;
+            connection = current ?? {
+              controller: new AbortController,
+              subscribers: new Set
+            };
+            current = connection;
+            connection.subscribers.add(subscriber);
+            if (connection.connected)
+              subscriber.push(connection.connected);
+            if (fresh)
+              run(connection);
+          }
+          return {
+            next() {
+              const value = queued.shift();
+              if (value)
+                return Promise.resolve({ done: false, value });
+              if (completion) {
+                if ("error" in completion)
+                  return Promise.reject(completion.error);
+                return Promise.resolve({ done: true, value: undefined });
+              }
+              if (options?.signal?.aborted) {
+                abort();
+                return Promise.resolve({ done: true, value: undefined });
+              }
+              const request = Promise.withResolvers();
+              pending.push(request);
+              if (!started) {
+                started = true;
+                options?.signal?.addEventListener("abort", abort, { once: true });
+                start();
+              }
+              return request.promise;
+            },
+            return() {
+              finish({});
+              return Promise.resolve({ done: true, value: undefined });
+            }
+          };
+        }
+      };
+    }
+  };
+}
+
+export { make7, exports_shared_events };

package/dist/chunks/contract-8s2anffy.js

@@ -0,0 +1,11 @@
+// src/solid/usage.ts
+function lastAssistantWithUsage2(messages, boundary) {
+  const boundaryIndex = boundary ? messages.findIndex((message) => message.id === boundary) : -1;
+  if (boundary && boundaryIndex === -1)
+    return;
+  const end = boundaryIndex === -1 ? messages.length : boundaryIndex;
+  const compactionIndex = messages.findLastIndex((message, index) => message.type === "compaction" && message.status === "completed" && index < end);
+  return messages.findLast((message, index) => message.type === "assistant" && message.tokens !== undefined && index > compactionIndex && index < end);
+}
+
+export { lastAssistantWithUsage2 };

package/dist/chunks/contract-8ye1ye6f.js

@@ -0,0 +1,92 @@
+import {
+  defaultEnsureTiming2
+} from "./contract-xgnj2w4v.js";
+import {
+  matchesVersion2
+} from "./contract-sxt88q69.js";
+
+// src/service-probe.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+function decide2(service, options) {
+  if (!matchesVersion2(service.version, options))
+    return { _tag: "replace", pty: service.state === "ready" ? "handoff" : "clear" };
+  if (!service.compatible)
+    return fail("Background service uses an incompatible health protocol. Update this client or explicitly restart the service.");
+  if (service.state === "ready")
+    return { _tag: "reuse" };
+  if (service.state === "failed")
+    return fail("Background service failed to start");
+  return { _tag: "wait" };
+}
+function fail(message) {
+  return { _tag: "fail", error: new Error(message) };
+}
+function fallback2() {
+  return join(process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state"), "opencode", "service.json");
+}
+function same2(left, right) {
+  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid;
+}
+async function probeResult2(info, timeout = defaultEnsureTiming2.requestTimeout) {
+  const endpoint = {
+    url: info.url,
+    auth: info.password === undefined ? undefined : { type: "basic", username: "opencode", password: info.password }
+  };
+  const signal = AbortSignal.timeout(timeout);
+  const result = await fetch(new URL("/api/info", info.url), { headers: headers2(endpoint), signal }).then(async (response) => ({
+    response,
+    body: response.status === 404 ? undefined : await response.json()
+  })).catch(() => {
+    return;
+  });
+  if (result === undefined)
+    return { service: undefined, timedOut: signal.aborted };
+  const response = result.response;
+  if (response.status === 404)
+    return {
+      service: {
+        info,
+        endpoint,
+        version: info.version,
+        state: "ready",
+        compatible: false
+      },
+      timedOut: false
+    };
+  const serverInfo = decodeInfo(result.body);
+  if (serverInfo === undefined)
+    return { service: undefined, timedOut: false };
+  if (serverInfo.pid !== info.pid)
+    return { service: undefined, timedOut: false };
+  if (info.version !== undefined && serverInfo.version !== info.version)
+    return { service: undefined, timedOut: false };
+  return {
+    service: {
+      info,
+      endpoint,
+      version: serverInfo.version,
+      state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
+      compatible: true
+    },
+    timedOut: false
+  };
+}
+function headers2(endpoint) {
+  if (endpoint.auth === undefined)
+    return;
+  return {
+    authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64")
+  };
+}
+function decodeInfo(input) {
+  if (typeof input !== "object" || input === null)
+    return;
+  if (!("version" in input) || typeof input.version !== "string")
+    return;
+  if (!("pid" in input) || typeof input.pid !== "number" || !Number.isInteger(input.pid) || input.pid < 0)
+    return;
+  return { version: input.version, pid: input.pid };
+}
+
+export { decide2, fallback2, same2, probeResult2, headers2 };

package/dist/chunks/contract-9rqn6x4v.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+export { __export };

package/dist/chunks/contract-c46qzyff.js

@@ -0,0 +1,37 @@
+// src/promise/generated/types.ts
+var isInvalidRequestError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "InvalidRequestError";
+var isUnauthorizedError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "UnauthorizedError";
+var isLocationNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "LocationNotFoundError";
+var isServiceUnavailableError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ServiceUnavailableError";
+var isAgentNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "AgentNotFoundError";
+var isInvalidCursorError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "InvalidCursorError";
+var isSessionNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "SessionNotFoundError";
+var isConflictError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ConflictError";
+var isUnknownError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "UnknownError";
+var isMessageNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "MessageNotFoundError";
+var isCommandNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "CommandNotFoundError";
+var isCommandExecutionError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "CommandExecutionError";
+var isSkillNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "SkillNotFoundError";
+var isSessionBusyError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "SessionBusyError";
+var isInstructionEntryValueTooLargeError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "InstructionEntryValueTooLargeError";
+var isFormNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "FormNotFoundError";
+var isFormInvalidAnswerError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "FormInvalidAnswerError";
+var isFormAlreadySettledError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "FormAlreadySettledError";
+var isProviderNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ProviderNotFoundError";
+var isIntegrationNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "IntegrationNotFoundError";
+var isIntegrationAttemptNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "IntegrationAttemptNotFoundError";
+var isIntegrationMethodNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "IntegrationMethodNotFoundError";
+var isMcpServerNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "McpServerNotFoundError";
+var isForbiddenError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ForbiddenError";
+var isProjectNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ProjectNotFoundError";
+var isPermissionSavedNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "PermissionSavedNotFoundError";
+var isPermissionNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "PermissionNotFoundError";
+var isFileNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "FileNotFoundError";
+var isRpcError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "RpcError";
+var isRpcInternalError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "RpcInternalError";
+var isPtyNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "PtyNotFoundError";
+var isShellNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ShellNotFoundError";
+var isWorktreeError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "WorktreeError";
+var isVcsInitNotSupportedError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "VcsInitNotSupportedError";
+
+export { isInvalidRequestError2, isUnauthorizedError2, isLocationNotFoundError2, isServiceUnavailableError2, isAgentNotFoundError2, isInvalidCursorError2, isSessionNotFoundError2, isConflictError2, isUnknownError2, isMessageNotFoundError2, isCommandNotFoundError2, isCommandExecutionError2, isSkillNotFoundError2, isSessionBusyError2, isInstructionEntryValueTooLargeError2, isFormNotFoundError2, isFormInvalidAnswerError2, isFormAlreadySettledError2, isProviderNotFoundError2, isIntegrationNotFoundError2, isIntegrationAttemptNotFoundError2, isIntegrationMethodNotFoundError2, isMcpServerNotFoundError2, isForbiddenError2, isProjectNotFoundError2, isPermissionSavedNotFoundError2, isPermissionNotFoundError2, isFileNotFoundError2, isRpcError2, isRpcInternalError2, isPtyNotFoundError2, isShellNotFoundError2, isWorktreeError2, isVcsInitNotSupportedError2 };

package/dist/chunks/contract-gne7h7mq.js

@@ -0,0 +1,50 @@
+// src/solid/pty.ts
+function createPtyClient2(api, options) {
+  return {
+    async connect(input) {
+      const result = await api.pty.connect.token({
+        ptyID: input.ptyID,
+        location: input.location,
+        "x-opencode-ticket": "1"
+      });
+      const baseUrl = new URL(options.url);
+      if (!baseUrl.pathname.endsWith("/"))
+        baseUrl.pathname += "/";
+      const url = new URL(`api/pty/${encodeURIComponent(input.ptyID)}/connect`, baseUrl);
+      if (input.location?.directory)
+        url.searchParams.set("location[directory]", input.location.directory);
+      if (input.cursor !== undefined)
+        url.searchParams.set("cursor", String(input.cursor));
+      url.searchParams.set("ticket", result.data.ticket);
+      url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+      const socket = options.openSocket?.(url) ?? new WebSocket(url);
+      socket.binaryType = "arraybuffer";
+      return socket;
+    }
+  };
+}
+function createPersistentPtyClient2(api, options) {
+  return {
+    async connect(input) {
+      const token = await api.experimental.persistentPty.connectToken({
+        ptyID: input.ptyID,
+        "x-opencode-ticket": "1"
+      });
+      const baseUrl = new URL(options.url);
+      if (!baseUrl.pathname.endsWith("/"))
+        baseUrl.pathname += "/";
+      const url = new URL(`api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}/connect`, baseUrl);
+      url.searchParams.set("ticket", token.ticket);
+      url.searchParams.set("cursor", String(input.cursor));
+      url.searchParams.set("attachment_id", input.attachmentID);
+      url.searchParams.set("takeover", String(input.takeover ?? false));
+      url.searchParams.set("input_protocol", "1");
+      url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+      const socket = options.openSocket?.(url) ?? new WebSocket(url);
+      socket.binaryType = "arraybuffer";
+      return socket;
+    }
+  };
+}
+
+export { createPtyClient2, createPersistentPtyClient2 };

package/dist/chunks/contract-hjez4bfs.js

@@ -0,0 +1,52 @@
+import {
+  make7
+} from "./contract-8bbb028w.js";
+import {
+  ClientError2
+} from "./contract-y2etg5bs.js";
+import {
+  make4
+} from "./contract-w10x3kfx.js";
+import {
+  make3,
+  aborted2
+} from "./contract-15p82y03.js";
+import {
+  __export
+} from "./contract-9rqn6x4v.js";
+
+// src/effect/client.ts
+var exports_client = {};
+__export(exports_client, {
+  OpenCode: () => exports_client,
+  make: () => make2
+});
+import { Cause, Context, Effect, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+var CurrentHeaders = Context.Reference("@opencode/client/effect/rpc/headers", {
+  defaultValue: () => {
+    return;
+  }
+});
+var make2 = Effect.fn("OpenCode.make")(function* (options) {
+  const httpClient = yield* HttpClient.HttpClient;
+  const raw = yield* make4(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();
+
+  class EventFailure {
+    cause;
+    constructor(cause) {
+      this.cause = cause;
+    }
+  }
+  const shared = make7((signal) => Stream.toAsyncIterableWith(native.pipe(Stream.interruptWhen(aborted2(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 ClientError2({ cause: error })))));
+  return {
+    ...raw,
+    event: { ...raw.event, subscribe },
+    rpc: Object.assign(make3((input, options) => raw.rpc.call(input).pipe(Effect.provideService(CurrentHeaders, options?.headers)), subscribe), raw.rpc)
+  };
+});
+
+export { make2, exports_client };

package/dist/chunks/contract-nwcpakzx.js

@@ -0,0 +1,12 @@
+// src/promise/generated/client-error.ts
+class ClientError3 extends Error {
+  reason;
+  name = "ClientError";
+  constructor(reason, options) {
+    const detail = options?.detail ?? (options?.cause instanceof Error ? options.cause.message : undefined);
+    super(detail ? `${reason}: ${detail}` : reason, options);
+    this.reason = reason;
+  }
+}
+
+export { ClientError3 };

package/dist/chunks/contract-ryy6kscr.js

@@ -0,0 +1,39 @@
+import {
+  __export
+} from "./contract-9rqn6x4v.js";
+
+// src/rpc-runtime.ts
+var exports_rpc_runtime = {};
+__export(exports_rpc_runtime, {
+  RpcRuntime: () => exports_rpc_runtime,
+  event: () => event2,
+  eventType: () => eventType2,
+  read: () => read2,
+  readError: () => readError2
+});
+import { RpcError, RpcInternalError } from "@opencode/protocol/errors";
+import { Effect, Schema } from "effect";
+function read2(schema, value) {
+  return Schema.isSchema(schema) ? Schema.decodeUnknownEffect(schema)(value) : Effect.succeed(value);
+}
+function readError2(method, error) {
+  if (!(error instanceof RpcError) && !(error instanceof RpcInternalError))
+    return Effect.fail(error);
+  if (!method.errors || !Object.hasOwn(method.errors, error.type)) {
+    return Effect.fail(error.data === undefined ? { type: error.type, message: error.message } : { type: error.type, message: error.message, data: error.data });
+  }
+  return read2(method.errors[error.type], error.data).pipe(Effect.catch((cause) => Effect.die(cause)), Effect.flatMap((data) => Effect.fail(data === undefined ? { type: error.type, message: error.message } : { type: error.type, message: error.message, data })));
+}
+var event2 = Effect.fn("Client.Rpc.event")(function* (definition, name, schema, event) {
+  const data = yield* read2(schema.schema, event.data);
+  return {
+    ...event,
+    type: eventType2(definition, name),
+    data
+  };
+});
+function eventType2(definition, name) {
+  return `rpc.${definition.id}.${name}`;
+}
+
+export { read2, readError2, event2, eventType2, exports_rpc_runtime };