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

package/dist/effect/generated/client.js

@@ -0,0 +1,8 @@
+import {
+  make4
+} from "../../chunks/contract-w10x3kfx.js";
+import"../../chunks/contract-y2etg5bs.js";
+import"../../chunks/contract-vmytr4q8.js";
+export {
+  make4 as make
+};

package/dist/effect/generated/index.d.ts

@@ -0,0 +1,2 @@
+export { ClientError } from "./client-error.js";
+export * as OpenCode from "./client.js";

package/dist/effect/generated/index.js

@@ -0,0 +1,12 @@
+import"../../chunks/contract-6mptkzbc.js";
+import {
+  exports_client2
+} from "../../chunks/contract-w10x3kfx.js";
+import {
+  ClientError2
+} from "../../chunks/contract-y2etg5bs.js";
+import"../../chunks/contract-vmytr4q8.js";
+export {
+  ClientError2 as ClientError,
+  exports_client2 as OpenCode
+};

package/dist/effect/index.d.ts

@@ -0,0 +1,35 @@
+import type { Effect } from "effect";
+import type { OpenCode } from "./client.js";
+export * from "./generated/index";
+export { OpenCode } from "./client.js";
+export type { AgentApi, AppApi, CommandApi, ConfigApi, EventApi, IntegrationApi, ModelApi, PluginApi, ProviderApi, ReferenceApi, RpcApi, RpcClient, WebSearchApi, SessionApi, SkillApi, } from "./api.js";
+export { Agent } from "@opencode/schema/agent";
+export { Command } from "@opencode/schema/command";
+export { Config } from "@opencode/schema/config";
+export { Credential } from "@opencode/schema/credential";
+export { Event } from "@opencode/schema/event";
+export { EventLog } from "@opencode/schema/event-log";
+export { FileSystem } from "@opencode/schema/filesystem";
+export { Form } from "@opencode/schema/form";
+export { Integration } from "@opencode/schema/integration";
+export { Location } from "@opencode/schema/location";
+export { Model } from "@opencode/schema/model";
+export { Permission } from "@opencode/schema/permission";
+export { PermissionSaved } from "@opencode/schema/permission-saved";
+export { Project } from "@opencode/schema/project";
+export { Worktree } from "@opencode/schema/worktree";
+export { Vcs } from "@opencode/schema/vcs";
+export { Provider } from "@opencode/schema/provider";
+export { Pty } from "@opencode/schema/pty";
+export { Question } from "@opencode/schema/question";
+export { Reference } from "@opencode/schema/reference";
+export { WebSearch } from "@opencode/schema/websearch";
+export { AbsolutePath, RelativePath } from "@opencode/schema/schema";
+export { Session } from "@opencode/schema/session";
+export { SessionInbox } from "@opencode/schema/session-inbox";
+export { SessionMessage } from "@opencode/schema/session-message";
+export { Skill } from "@opencode/schema/skill";
+export { Prompt } from "@opencode/schema/prompt";
+export { PromptInput } from "@opencode/schema/prompt-input";
+export type { OpenCodeEvent } from "@opencode/protocol/groups/event";
+export type OpenCodeClient = Effect.Success<ReturnType<typeof OpenCode.make>>;

package/dist/effect/index.js

@@ -0,0 +1,75 @@
+import {
+  ClientError2
+} from "../chunks/contract-y2etg5bs.js";
+import"../chunks/contract-vmytr4q8.js";
+import"../chunks/contract-w10x3kfx.js";
+import"../chunks/contract-6mptkzbc.js";
+import"../chunks/contract-8bbb028w.js";
+import"../chunks/contract-ryy6kscr.js";
+import"../chunks/contract-15p82y03.js";
+import {
+  exports_client
+} from "../chunks/contract-hjez4bfs.js";
+
+// src/effect/index.ts
+import { Agent } from "@opencode/schema/agent";
+import { Command } from "@opencode/schema/command";
+import { Config } from "@opencode/schema/config";
+import { Credential } from "@opencode/schema/credential";
+import { Event } from "@opencode/schema/event";
+import { EventLog } from "@opencode/schema/event-log";
+import { FileSystem } from "@opencode/schema/filesystem";
+import { Form } from "@opencode/schema/form";
+import { Integration } from "@opencode/schema/integration";
+import { Location } from "@opencode/schema/location";
+import { Model } from "@opencode/schema/model";
+import { Permission } from "@opencode/schema/permission";
+import { PermissionSaved } from "@opencode/schema/permission-saved";
+import { Project } from "@opencode/schema/project";
+import { Worktree } from "@opencode/schema/worktree";
+import { Vcs } from "@opencode/schema/vcs";
+import { Provider } from "@opencode/schema/provider";
+import { Pty } from "@opencode/schema/pty";
+import { Question } from "@opencode/schema/question";
+import { Reference } from "@opencode/schema/reference";
+import { WebSearch } from "@opencode/schema/websearch";
+import { AbsolutePath, RelativePath } from "@opencode/schema/schema";
+import { Session } from "@opencode/schema/session";
+import { SessionInbox } from "@opencode/schema/session-inbox";
+import { SessionMessage } from "@opencode/schema/session-message";
+import { Skill } from "@opencode/schema/skill";
+import { Prompt } from "@opencode/schema/prompt";
+import { PromptInput } from "@opencode/schema/prompt-input";
+export {
+  AbsolutePath,
+  Agent,
+  ClientError2 as ClientError,
+  Command,
+  Config,
+  Credential,
+  Event,
+  EventLog,
+  FileSystem,
+  Form,
+  Integration,
+  Location,
+  Model,
+  exports_client as OpenCode,
+  Permission,
+  PermissionSaved,
+  Project,
+  Prompt,
+  PromptInput,
+  Provider,
+  Pty,
+  Question,
+  Reference,
+  RelativePath,
+  Session,
+  SessionInbox,
+  SessionMessage,
+  Skill,
+  Vcs,
+  WebSearch,
+  Worktree
+};

package/dist/effect/rpc.d.ts

@@ -0,0 +1,20 @@
+export * as RpcClientRuntime from "./rpc.js";
+import type { Rpc } from "@opencode/schema/rpc";
+import type { RpcError, RpcInternalError } from "@opencode/protocol/errors";
+import type { OpenCodeEvent } from "@opencode/protocol/groups/event";
+import { Effect, Schema, Stream } from "effect";
+import type { RpcArguments, RpcCallOptions } from "../promise/rpc.js";
+import type { RpcCallInput, RpcCallOutput } from "./api/api.js";
+type DecodeError<S> = S extends Schema.Top ? Schema.SchemaError : never;
+export type RpcClient<D extends Rpc.Definition, E = never, Options = RpcCallOptions, EventError = E> = {
+    readonly [Name in keyof D["methods"]]: (...args: RpcArguments<Rpc.Input<D["methods"][Name]["input"]>, Options>) => Effect.Effect<Rpc.Output<D["methods"][Name]["output"]>, Rpc.MethodError<D["methods"][Name]> | DecodeError<D["methods"][Name]["output"]> | E>;
+} & {
+    readonly events: {
+        readonly subscribe: <Name extends keyof D["events"] & string>(name: Name) => Stream.Stream<Rpc.EventPayload<D, Name>, DecodeError<D["events"][Name]["schema"]> | EventError>;
+    };
+};
+export interface RpcApi<E = never, Options = RpcCallOptions, EventError = E> {
+    <D extends Rpc.Definition>(definition: D): RpcClient<D, E, Options, EventError>;
+}
+export declare function make<CallError, EventError>(call: (input: RpcCallInput, options?: RpcCallOptions) => Effect.Effect<RpcCallOutput, CallError>, subscribe: () => Stream.Stream<OpenCodeEvent, EventError>): RpcApi<Exclude<CallError, RpcError | RpcInternalError> | Rpc.SystemError, RpcCallOptions, EventError>;
+export declare function aborted(signal: AbortSignal): Effect.Effect<void, never, never>;

package/dist/effect/rpc.js

@@ -0,0 +1,11 @@
+import {
+  make3,
+  aborted2,
+  exports_rpc
+} from "../chunks/contract-15p82y03.js";
+import"../chunks/contract-ryy6kscr.js";
+export {
+  exports_rpc as RpcClientRuntime,
+  aborted2 as aborted,
+  make3 as make
+};

package/dist/effect/service.d.ts

@@ -0,0 +1,90 @@
+import { Effect, FileSystem, Schema } from "effect";
+import type { DiscoverOptions, EnsureOptions, StopOptions } from "../service.js";
+import { headers } from "../service-probe.js";
+export * from "../service.js";
+export { headers };
+/** Contents of the local service registration file. */
+export type Info = typeof Info.Type;
+/** Discover a healthy, compatible local service without starting one. */
+export declare const discover: (options?: DiscoverOptions | undefined) => Effect.Effect<{
+    url: string;
+    auth: {
+        type: "basic";
+        username: string;
+        password: string;
+    } | undefined;
+} | undefined, never, FileSystem.FileSystem>;
+/** Recognize an authenticated compatible service bound to an expected URL, including while it starts or fails. */
+export declare const incumbent: (options: DiscoverOptions & {
+    readonly url: string;
+}) => Effect.Effect<{
+    endpoint: {
+        url: string;
+        auth: {
+            type: "basic";
+            username: string;
+            password: string;
+        } | undefined;
+    };
+    state: "failed" | "ready" | "waiting";
+} | undefined, never, FileSystem.FileSystem>;
+/** Ensure a healthy, compatible local service is running. */
+export declare const ensure: (options?: EnsureOptions | undefined) => Effect.Effect<{
+    url: string;
+    auth: {
+        type: "basic";
+        username: string;
+        password: string;
+    } | undefined;
+}, Error, FileSystem.FileSystem>;
+/** Stop the registered local service. */
+export declare const stop: (options?: StopOptions | undefined) => Effect.Effect<void, Error, FileSystem.FileSystem>;
+/** Schema for the local service registration file. */
+export declare const Info: Schema.Struct<{
+    readonly id: Schema.optional<Schema.String>;
+    readonly version: Schema.optional<Schema.String>;
+    readonly url: Schema.String;
+    readonly pid: Schema.Int;
+    readonly password: Schema.optional<Schema.String>;
+}>;
+/** Effect-based local service lifecycle operations. */
+export declare const Service: {
+    discover: (options?: DiscoverOptions | undefined) => Effect.Effect<{
+        url: string;
+        auth: {
+            type: "basic";
+            username: string;
+            password: string;
+        } | undefined;
+    } | undefined, never, FileSystem.FileSystem>;
+    incumbent: (options: DiscoverOptions & {
+        readonly url: string;
+    }) => Effect.Effect<{
+        endpoint: {
+            url: string;
+            auth: {
+                type: "basic";
+                username: string;
+                password: string;
+            } | undefined;
+        };
+        state: "failed" | "ready" | "waiting";
+    } | undefined, never, FileSystem.FileSystem>;
+    ensure: (options?: EnsureOptions | undefined) => Effect.Effect<{
+        url: string;
+        auth: {
+            type: "basic";
+            username: string;
+            password: string;
+        } | undefined;
+    }, Error, FileSystem.FileSystem>;
+    stop: (options?: StopOptions | undefined) => Effect.Effect<void, Error, FileSystem.FileSystem>;
+    headers: typeof headers;
+    Info: Schema.Struct<{
+        readonly id: Schema.optional<Schema.String>;
+        readonly version: Schema.optional<Schema.String>;
+        readonly url: Schema.String;
+        readonly pid: Schema.Int;
+        readonly password: Schema.optional<Schema.String>;
+    }>;
+};

package/dist/effect/service.js

@@ -0,0 +1,187 @@
+import {
+  spawnServiceContender2,
+  contenderPool2
+} from "../chunks/contract-ve4aws36.js";
+import {
+  defaultEnsureTiming2,
+  ensureTiming2
+} from "../chunks/contract-xgnj2w4v.js";
+import {
+  matchesVersion2
+} from "../chunks/contract-sxt88q69.js";
+import {
+  decide2,
+  fallback2,
+  same2,
+  probeResult2,
+  headers2
+} from "../chunks/contract-8ye1ye6f.js";
+import {
+  prepare2,
+  environment2,
+  complete2,
+  clear2
+} from "../chunks/contract-5bf0yjkp.js";
+import"../chunks/contract-qav6mfdz.js";
+
+// src/effect/service.ts
+import { Effect, FileSystem, Option, Schedule, Schema } from "effect";
+var discover = Effect.fn("service.discover")(function* (options = {}) {
+  const found = (yield* registered(options.file)).service;
+  if (found?.state !== "ready")
+    return;
+  if (!found.compatible)
+    return;
+  if (!matchesVersion2(found.version, options))
+    return;
+  return found.endpoint;
+});
+var incumbent = Effect.fn("service.incumbent")(function* (options) {
+  const info = yield* read(options.file);
+  if (info === undefined)
+    return;
+  const found = (yield* Effect.promise(() => probeResult2({ ...info, url: options.url }))).service;
+  if (!found?.compatible)
+    return;
+  if (!matchesVersion2(found.version, options))
+    return;
+  return { endpoint: found.endpoint, state: found.state };
+});
+var ensure = Effect.fn("service.ensure")(function* (options = {}) {
+  const timing = ensureTiming2(options);
+  const pool = contenderPool2(timing);
+  let timeouts;
+  let announced = false;
+  const announce = (reason, previousVersion) => Effect.sync(() => {
+    if (announced)
+      return;
+    announced = true;
+    options.onStart?.(reason, previousVersion);
+  });
+  const spawnContender = Effect.gen(function* () {
+    const [command, ...args] = options.command ?? ["opencode", "serve", "--service"];
+    if (command === undefined)
+      return yield* Effect.fail(new Error("Missing service command"));
+    const env = yield* Effect.tryPromise(() => environment2(options.file ?? fallback2(), options.env));
+    return yield* Effect.try({
+      try: () => {
+        return spawnServiceContender2(command, args, env);
+      },
+      catch: (cause) => new Error("Failed to start server", { cause })
+    });
+  });
+  const found = yield* Effect.gen(function* () {
+    const registration = yield* registered(options.file, timing.requestTimeout);
+    const info = registration.info;
+    const service2 = registration.service;
+    if (registration.timedOut && info !== undefined) {
+      timeouts = {
+        info,
+        count: timeouts !== undefined && same2(timeouts.info, info) ? timeouts.count + 1 : 1
+      };
+      if (timeouts.count >= 3) {
+        yield* announce("missing");
+        yield* Effect.logWarning("Background service is unresponsive; recovery cannot preserve persistent terminals");
+        yield* Effect.tryPromise(() => clear2(options.file ?? fallback2()));
+        yield* terminate(info, options, timing);
+        pool.evict(info.pid);
+        pool.recruitNow();
+        timeouts = undefined;
+      }
+    } else
+      timeouts = undefined;
+    if (service2 !== undefined) {
+      pool.serviceAnswered();
+      const decision = decide2(service2, options);
+      if (decision._tag === "fail")
+        return yield* Effect.fail(decision.error);
+      if (decision._tag === "reuse") {
+        yield* Effect.tryPromise(() => complete2(options.file ?? fallback2(), service2.info));
+        return Option.some(service2);
+      }
+      if (decision._tag === "replace") {
+        yield* announce("version-mismatch", service2.version);
+        if (service2.state !== "ready")
+          yield* Effect.logWarning("Background service is not ready; replacement cannot preserve persistent terminals");
+        yield* stop({ file: options.file, pty: decision.pty }).pipe(Effect.ignore);
+        pool.evict(service2.info.pid);
+      }
+      return Option.none();
+    }
+    const failed = pool.reap();
+    if (failed !== undefined)
+      return yield* Effect.fail(failed);
+    if (pool.shouldRecruit(info !== undefined)) {
+      yield* announce("missing");
+      pool.add(yield* spawnContender);
+    }
+    return Option.none();
+  }).pipe(Effect.repeat({
+    until: Option.isSome,
+    schedule: Schedule.spaced(timing.pollInterval).pipe(Schedule.upTo({ duration: timing.promiseTimeout }))
+  }), Effect.ensuring(Effect.sync(() => pool.releaseAll())));
+  if (Option.isNone(found))
+    return yield* Effect.fail(pool.failure() ?? new Error("Timed out waiting for the background service to start"));
+  return found.value.endpoint;
+});
+var stop = Effect.fn("service.stop")(function* (options = {}) {
+  const info = yield* read(options.file);
+  yield* Effect.tryPromise(() => options.pty === "handoff" && info !== undefined ? prepare2(options.file ?? fallback2(), info, defaultEnsureTiming2.requestTimeout) : clear2(options.file ?? fallback2())).pipe(Effect.catch((cause) => Effect.logWarning("Failed to prepare persistent terminals for replacement", cause)));
+  if (info !== undefined)
+    yield* terminate(info, options, ensureTiming2(options));
+});
+var Info = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  version: Schema.optional(Schema.String),
+  url: Schema.String,
+  pid: Schema.Int.check(Schema.isGreaterThan(0)),
+  password: Schema.optional(Schema.String)
+});
+var decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Info));
+var read = Effect.fnUntraced(function* (file) {
+  const fs = yield* FileSystem.FileSystem;
+  const text = yield* fs.readFileString(file ?? fallback2()).pipe(Effect.option);
+  if (Option.isNone(text))
+    return;
+  return yield* decode(text.value).pipe(Effect.option, Effect.map(Option.getOrUndefined));
+});
+var registered = Effect.fnUntraced(function* (file, timeout) {
+  const info = yield* read(file);
+  if (info === undefined)
+    return { info: undefined, service: undefined, timedOut: false };
+  return { info, ...yield* Effect.promise(() => probeResult2(info, timeout)) };
+});
+var poll = (timing) => Schedule.max([Schedule.spaced(timing.stopPollInterval), Schedule.recurs(timing.stopPollAttempts)]);
+var signal = (pid, name) => Effect.try({ try: () => process.kill(pid, name), catch: (cause) => cause }).pipe(Effect.ignore);
+var stopped = Effect.fnUntraced(function* (pid) {
+  const running = yield* Effect.try({ try: () => process.kill(pid, 0), catch: () => false }).pipe(Effect.orElseSucceed(() => false));
+  if (!running)
+    return true;
+  return yield* Effect.fail(new Error(`Server process ${pid} is still running`));
+});
+var terminate = Effect.fnUntraced(function* (info, options, timing) {
+  const current = yield* read(options.file);
+  if (current === undefined || !same2(current, info))
+    return;
+  yield* signal(info.pid, "SIGTERM");
+  const done = yield* stopped(info.pid).pipe(Effect.retry(poll(timing)), Effect.option);
+  if (Option.isNone(done)) {
+    yield* signal(info.pid, "SIGKILL");
+    yield* stopped(info.pid).pipe(Effect.retry(poll(timing)));
+  }
+  const latest = yield* read(options.file);
+  if (latest === undefined || !same2(latest, info))
+    return;
+  const fs = yield* FileSystem.FileSystem;
+  yield* fs.remove(options.file ?? fallback2()).pipe(Effect.ignore);
+});
+var Service = { discover, incumbent, ensure, stop, headers: headers2, Info };
+export {
+  Info,
+  Service,
+  discover,
+  ensure,
+  headers2 as headers,
+  incumbent,
+  stop
+};

package/dist/mcp.d.ts

@@ -0,0 +1,44 @@
+export type ClientMcpOptions = {
+    /** Base URL of the opencode server, for example `http://127.0.0.1:4096`. Its query params are kept. */
+    readonly url: string;
+    /** Client name, `[a-zA-Z0-9_-]+`. Tools are exposed to the model as `<name>_<tool>`. */
+    readonly name: string;
+    /** Sent as `location[directory]`. */
+    readonly directory?: string;
+    /** Handshake headers, such as `authorization`. Browsers cannot send them; use a ticket in `url` instead. */
+    readonly headers?: Record<string, string>;
+    readonly tools: ReadonlyArray<ClientMcpTool>;
+    readonly WebSocket?: typeof WebSocket;
+};
+export type ClientMcpTool = {
+    /** `[a-zA-Z0-9_-]+` */
+    readonly name: string;
+    readonly description?: string;
+    /** JSON Schema for the arguments; `type: "object"` is always set. Arguments are not validated here. */
+    readonly inputSchema?: Record<string, unknown>;
+    readonly handler: (args: Record<string, unknown>, ctx: ClientMcpToolContext) => ClientMcpToolResult | Promise<ClientMcpToolResult>;
+};
+export type ClientMcpToolContext = {
+    /** The opencode session that issued the call. */
+    readonly sessionID?: string;
+};
+export type ClientMcpToolResult = {
+    readonly content: ReadonlyArray<{
+        readonly type: "text";
+        readonly text: string;
+    } | {
+        readonly type: "image";
+        readonly data: string;
+        readonly mimeType: string;
+    }>;
+    readonly isError?: boolean;
+};
+export type ClientMcpConnection = {
+    close(): Promise<void>;
+};
+/**
+ * Exposes tools to the opencode server: opens a WebSocket to `/api/experimental/client-mcp` and answers MCP
+ * JSON-RPC over it (one message per text frame), so the opencode server is the MCP client. Reconnects with
+ * backoff until `close()`.
+ */
+export declare function connectClientMcp(options: ClientMcpOptions): ClientMcpConnection;

package/dist/mcp.js

@@ -0,0 +1,110 @@
+// src/mcp.ts
+var SESSION_ID_META_KEY = "ai.opencode/sessionID";
+var PROTOCOL_VERSION = "2025-11-25";
+var RECONNECT_MIN = 500;
+var RECONNECT_MAX = 1e4;
+function connectClientMcp(options) {
+  const state = {
+    disposed: false,
+    delay: RECONNECT_MIN
+  };
+  const connect = () => {
+    if (state.disposed)
+      return;
+    const Socket = options.WebSocket ?? WebSocket;
+    const socket = options.headers ? new Socket(endpoint(options), { headers: options.headers }) : new Socket(endpoint(options));
+    state.socket = socket;
+    socket.addEventListener("message", (event) => {
+      if (state.disposed || typeof event.data !== "string")
+        return;
+      const message = parse(event.data);
+      if (!message)
+        return;
+      if (message.method === "notifications/initialized")
+        state.delay = RECONNECT_MIN;
+      if (typeof message.id !== "string" && typeof message.id !== "number" || typeof message.method !== "string")
+        return;
+      respond(options, message.method, message.params).then((reply) => send(socket, { jsonrpc: "2.0", id: message.id, ...reply }));
+    });
+    socket.addEventListener("close", () => {
+      if (state.socket === socket)
+        state.socket = undefined;
+      if (state.disposed)
+        return;
+      state.timer = setTimeout(connect, state.delay);
+      state.delay = Math.min(state.delay * 2, RECONNECT_MAX);
+    });
+  };
+  connect();
+  return {
+    async close() {
+      state.disposed = true;
+      clearTimeout(state.timer);
+      state.socket?.close(1000);
+    }
+  };
+}
+async function respond(options, method, params) {
+  switch (method) {
+    case "initialize":
+      return {
+        result: {
+          protocolVersion: typeof params?.protocolVersion === "string" ? params.protocolVersion : PROTOCOL_VERSION,
+          capabilities: { tools: {} },
+          serverInfo: { name: options.name, version: "1.0.0" }
+        }
+      };
+    case "ping":
+      return { result: {} };
+    case "tools/list":
+      return {
+        result: {
+          tools: options.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: { type: "object", ...tool.inputSchema }
+          }))
+        }
+      };
+    case "tools/call": {
+      const tool = options.tools.find((tool) => tool.name === params?.name);
+      if (!tool)
+        return { error: { code: -32602, message: `Unknown tool: ${String(params?.name)}` } };
+      const meta = params?._meta?.[SESSION_ID_META_KEY];
+      return Promise.resolve().then(() => tool.handler(params?.arguments ?? {}, { sessionID: typeof meta === "string" ? meta : undefined })).then((result) => ({ result }), (error) => ({
+        result: {
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          isError: true
+        }
+      }));
+    }
+  }
+  return { error: { code: -32601, message: `Method not found: ${method}` } };
+}
+function send(socket, message) {
+  if (socket.readyState === socket.OPEN)
+    socket.send(JSON.stringify(message));
+}
+function parse(text) {
+  try {
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+function endpoint(options) {
+  const base = new URL(options.url);
+  if (!base.pathname.endsWith("/"))
+    base.pathname += "/";
+  const url = new URL("api/experimental/client-mcp", base);
+  url.search = base.search;
+  if (options.directory)
+    url.searchParams.set("location[directory]", options.directory);
+  url.searchParams.set("name", options.name);
+  url.protocol = url.protocol === "https:" || url.protocol === "wss:" ? "wss:" : "ws:";
+  return url;
+}
+export {
+  connectClientMcp
+};

package/dist/promise/api.d.ts

@@ -0,0 +1,21 @@
+import type { OpenCode } from "./client.js";
+type Client = ReturnType<typeof OpenCode.make>;
+export type { RpcApi, RpcCallOptions, RpcClient, RpcEventPayload } from "./rpc.js";
+export type AgentApi = Client["agent"];
+export type CommandApi = Client["command"];
+export type ConfigApi = Client["config"];
+export type CredentialApi = Client["credential"];
+export type EventApi = Client["event"];
+export type GenerateApi = Client["generate"];
+export type IntegrationApi = Client["integration"];
+export type McpApi = Client["mcp"];
+export type ModelApi = Client["model"];
+export type PluginApi = Client["plugin"];
+export type PermissionApi = Client["permission"];
+export type ProviderApi = Client["provider"];
+export type ReferenceApi = Client["reference"];
+export type WebSearchApi = Client["websearch"];
+export type SessionApi = Client["session"];
+export type SkillApi = Client["skill"];
+export type VcsApi = Client["vcs"];
+export type WorktreeApi = Client["worktree"];