alchemylab-opencode 1.0.3 → 1.0.5

package/dist/run-YFVCQJQM.js

@@ -0,0 +1,4791 @@
+// Built by esbuild from opencode-server source
+if (typeof globalThis.Bun === 'undefined') {
+  globalThis.Bun = {
+    version: '0.0.0-node-compat',
+    stdin: { async text() { const chunks = []; for await (const c of process.stdin) chunks.push(c); return Buffer.concat(chunks).toString(); } },
+    which(cmd) { try { return require('child_process').execFileSync('which', [cmd], { encoding: 'utf8' }).trim(); } catch { return null; } },
+  };
+}
+if (typeof globalThis.__name === 'undefined') { globalThis.__name = (t, n) => { Object.defineProperty(t, 'name', { value: n, configurable: true }); return t; }; }
+if (typeof globalThis.__export === 'undefined') { globalThis.__export = (t, a) => { for (const k in a) Object.defineProperty(t, k, { get: a[k], enumerable: true }); }; }
+
+import {
+  Server
+} from "./chunk-UWZSRZHA.js";
+import {
+  InstanceBootstrap
+} from "./chunk-MCWTARFP.js";
+import "./chunk-ANDTK76Q.js";
+import {
+  Agent,
+  Provider
+} from "./chunk-DSPC5QIG.js";
+import "./chunk-CYXMV3J3.js";
+import {
+  Filesystem,
+  Flag,
+  Instance,
+  NamedError
+} from "./chunk-B3FN2B2N.js";
+import "./chunk-CR6IREZA.js";
+import "./chunk-BI5OUHTQ.js";
+import {
+  __require
+} from "./chunk-HORZKFCR.js";
+
+// packages/opencode/src/cli/cmd/run.ts
+import path from "path";
+import { pathToFileURL } from "url";
+
+// packages/opencode/src/cli/ui.ts
+import z from "zod";
+import { EOL } from "os";
+
+// packages/opencode/src/cli/logo.ts
+var logo = {
+  left: ["                   ", "\u2588\u2580\u2580\u2588 \u2588\u2580\u2580\u2588 \u2588\u2580\u2580\u2588 \u2588\u2580\u2580\u2584", "\u2588__\u2588 \u2588__\u2588 \u2588^^^ \u2588__\u2588", "\u2580\u2580\u2580\u2580 \u2588\u2580\u2580\u2580 \u2580\u2580\u2580\u2580 \u2580~~\u2580"],
+  right: ["             \u2584     ", "\u2588\u2580\u2580\u2580 \u2588\u2580\u2580\u2588 \u2588\u2580\u2580\u2588 \u2588\u2580\u2580\u2588", "\u2588___ \u2588__\u2588 \u2588__\u2588 \u2588^^^", "\u2580\u2580\u2580\u2580 \u2580\u2580\u2580\u2580 \u2580\u2580\u2580\u2580 \u2580\u2580\u2580\u2580"]
+};
+
+// packages/opencode/src/cli/ui.ts
+var UI;
+((UI2) => {
+  const wordmark = [
+    `\u2800                                \u2584     `,
+    `\u2588\u2580\u2580\u2588 \u2588\u2580\u2580\u2588 \u2588\u2580\u2580\u2588 \u2588\u2580\u2580\u2584 \u2588\u2580\u2580\u2580 \u2588\u2580\u2580\u2588 \u2588\u2580\u2580\u2588 \u2588\u2580\u2580\u2588`,
+    `\u2588  \u2588 \u2588  \u2588 \u2588\u2580\u2580\u2580 \u2588  \u2588 \u2588    \u2588  \u2588 \u2588  \u2588 \u2588\u2580\u2580\u2580`,
+    `\u2580\u2580\u2580\u2580 \u2588\u2580\u2580\u2580 \u2580\u2580\u2580\u2580 \u2580  \u2580 \u2580\u2580\u2580\u2580 \u2580\u2580\u2580\u2580 \u2580\u2580\u2580\u2580 \u2580\u2580\u2580\u2580`
+  ];
+  UI2.CancelledError = NamedError.create("UICancelledError", z.void());
+  UI2.Style = {
+    TEXT_HIGHLIGHT: "\x1B[96m",
+    TEXT_HIGHLIGHT_BOLD: "\x1B[96m\x1B[1m",
+    TEXT_DIM: "\x1B[90m",
+    TEXT_DIM_BOLD: "\x1B[90m\x1B[1m",
+    TEXT_NORMAL: "\x1B[0m",
+    TEXT_NORMAL_BOLD: "\x1B[1m",
+    TEXT_WARNING: "\x1B[93m",
+    TEXT_WARNING_BOLD: "\x1B[93m\x1B[1m",
+    TEXT_DANGER: "\x1B[91m",
+    TEXT_DANGER_BOLD: "\x1B[91m\x1B[1m",
+    TEXT_SUCCESS: "\x1B[92m",
+    TEXT_SUCCESS_BOLD: "\x1B[92m\x1B[1m",
+    TEXT_INFO: "\x1B[94m",
+    TEXT_INFO_BOLD: "\x1B[94m\x1B[1m"
+  };
+  function println(...message) {
+    print(...message);
+    process.stderr.write(EOL);
+  }
+  UI2.println = println;
+  function print(...message) {
+    blank = false;
+    process.stderr.write(message.join(" "));
+  }
+  UI2.print = print;
+  let blank = false;
+  function empty() {
+    if (blank) return;
+    println("" + UI2.Style.TEXT_NORMAL);
+    blank = true;
+  }
+  UI2.empty = empty;
+  function logo2(pad) {
+    if (!process.stdout.isTTY && !process.stderr.isTTY) {
+      const result2 = [];
+      for (const row of wordmark) {
+        if (pad) result2.push(pad);
+        result2.push(row);
+        result2.push(EOL);
+      }
+      return result2.join("").trimEnd();
+    }
+    const result = [];
+    const reset = "\x1B[0m";
+    const left = {
+      fg: "\x1B[90m",
+      shadow: "\x1B[38;5;235m",
+      bg: "\x1B[48;5;235m"
+    };
+    const right = {
+      fg: reset,
+      shadow: "\x1B[38;5;238m",
+      bg: "\x1B[48;5;238m"
+    };
+    const gap = " ";
+    const draw = (line, fg, shadow, bg) => {
+      const parts = [];
+      for (const char of line) {
+        if (char === "_") {
+          parts.push(bg, " ", reset);
+          continue;
+        }
+        if (char === "^") {
+          parts.push(fg, bg, "\u2580", reset);
+          continue;
+        }
+        if (char === "~") {
+          parts.push(shadow, "\u2580", reset);
+          continue;
+        }
+        if (char === " ") {
+          parts.push(" ");
+          continue;
+        }
+        parts.push(fg, char, reset);
+      }
+      return parts.join("");
+    };
+    logo.left.forEach((row, index) => {
+      if (pad) result.push(pad);
+      result.push(draw(row, left.fg, left.shadow, left.bg));
+      result.push(gap);
+      const other = logo.right[index] ?? "";
+      result.push(draw(other, right.fg, right.shadow, right.bg));
+      result.push(EOL);
+    });
+    return result.join("").trimEnd();
+  }
+  UI2.logo = logo2;
+  async function input(prompt) {
+    const readline = __require("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+  UI2.input = input;
+  function error(message) {
+    if (message.startsWith("Error: ")) {
+      message = message.slice("Error: ".length);
+    }
+    println(UI2.Style.TEXT_DANGER_BOLD + "Error: " + UI2.Style.TEXT_NORMAL + message);
+  }
+  UI2.error = error;
+  function markdown(text) {
+    return text;
+  }
+  UI2.markdown = markdown;
+})(UI || (UI = {}));
+
+// packages/opencode/src/cli/cmd/cmd.ts
+function cmd(input) {
+  return input;
+}
+
+// packages/opencode/src/cli/bootstrap.ts
+async function bootstrap(directory, cb) {
+  return Instance.provide({
+    directory,
+    init: InstanceBootstrap,
+    fn: async () => {
+      try {
+        const result = await cb();
+        return result;
+      } finally {
+        await Instance.dispose();
+      }
+    }
+  });
+}
+
+// packages/opencode/src/cli/cmd/run.ts
+import { EOL as EOL2 } from "os";
+
+// packages/sdk/src/v2/gen/core/serverSentEvents.gen.ts
+var createSseClient = ({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}) => {
+  let lastEventId;
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3e3;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted) break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== void 0) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
+        }
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+        if (!response.body) throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {
+          }
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += value;
+            buffer = buffer.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+            const chunks = buffer.split("\n\n");
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split("\n");
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join("\n");
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
+        await sleep(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+};
+
+// packages/sdk/src/v2/gen/core/pathSerializer.gen.ts
+var separatorArrayExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var separatorArrayNoExplode = (style) => {
+  switch (style) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+};
+var separatorObjectExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value
+}) => {
+  if (!explode) {
+    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(
+      separatorArrayNoExplode(style)
+    );
+    switch (style) {
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      case "simple":
+        return joinedValues2;
+      default:
+        return `${name}=${joinedValues2}`;
+    }
+  }
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value.map((v) => {
+    if (style === "label" || style === "simple") {
+      return allowReserved ? v : encodeURIComponent(v);
+    }
+    return serializePrimitiveParam({
+      allowReserved,
+      name,
+      value: v
+    });
+  }).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+var serializePrimitiveParam = ({ allowReserved, name, value }) => {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+var serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+  if (style !== "deepObject" && !explode) {
+    let values = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values = [...values, key, allowReserved ? v : encodeURIComponent(v)];
+    });
+    const joinedValues2 = values.join(",");
+    switch (style) {
+      case "form":
+        return `${name}=${joinedValues2}`;
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      default:
+        return joinedValues2;
+    }
+  }
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value).map(
+    ([key, v]) => serializePrimitiveParam({
+      allowReserved,
+      name: style === "deepObject" ? `${name}[${key}]` : key,
+      value: v
+    })
+  ).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+// packages/sdk/src/v2/gen/core/utils.gen.ts
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var defaultPathSerializer = ({ path: path2, url: _url }) => {
+  let url = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name = match.substring(1, match.length - 1);
+      let style = "simple";
+      if (name.endsWith("*")) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+      if (name.startsWith(".")) {
+        name = name.substring(1);
+        style = "label";
+      } else if (name.startsWith(";")) {
+        name = name.substring(1);
+        style = "matrix";
+      }
+      const value = path2[name];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
+        continue;
+      }
+      if (typeof value === "object") {
+        url = url.replace(
+          match,
+          serializeObjectParam({
+            explode,
+            name,
+            style,
+            value,
+            valueOnly: true
+          })
+        );
+        continue;
+      }
+      if (style === "matrix") {
+        url = url.replace(
+          match,
+          `;${serializePrimitiveParam({
+            name,
+            value
+          })}`
+        );
+        continue;
+      }
+      const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+      url = url.replace(match, replaceValue);
+    }
+  }
+  return url;
+};
+var getUrl = ({
+  baseUrl,
+  path: path2,
+  query,
+  querySerializer,
+  url: _url
+}) => {
+  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+  let url = (baseUrl ?? "") + pathUrl;
+  if (path2) {
+    url = defaultPathSerializer({ path: path2, url });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url += `?${search}`;
+  }
+  return url;
+};
+function getValidRequestBody(options) {
+  const hasBody = options.body !== void 0;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return void 0;
+}
+
+// packages/sdk/src/v2/gen/core/auth.gen.ts
+var getAuthToken = async (auth, callback) => {
+  const token = typeof callback === "function" ? await callback(auth) : callback;
+  if (!token) {
+    return;
+  }
+  if (auth.scheme === "bearer") {
+    return `Bearer ${token}`;
+  }
+  if (auth.scheme === "basic") {
+    return `Basic ${btoa(token)}`;
+  }
+  return token;
+};
+
+// packages/sdk/src/v2/gen/core/bodySerializer.gen.ts
+var jsonBodySerializer = {
+  bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
+};
+
+// packages/sdk/src/v2/gen/client/utils.gen.ts
+var createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
+  const querySerializer = (queryParams) => {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        const options = parameters[name] || args;
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "form",
+            value,
+            ...options.array
+          });
+          if (serializedArray) search.push(serializedArray);
+        } else if (typeof value === "object") {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "deepObject",
+            value,
+            ...options.object
+          });
+          if (serializedObject) search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name,
+            value
+          });
+          if (serializedPrimitive) search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join("&");
+  };
+  return querySerializer;
+};
+var getParseAs = (contentType) => {
+  if (!contentType) {
+    return "stream";
+  }
+  const cleanContent = contentType.split(";")[0]?.trim();
+  if (!cleanContent) {
+    return;
+  }
+  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+    return "json";
+  }
+  if (cleanContent === "multipart/form-data") {
+    return "formData";
+  }
+  if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
+    return "blob";
+  }
+  if (cleanContent.startsWith("text/")) {
+    return "text";
+  }
+  return;
+};
+var checkForExistence = (options, name) => {
+  if (!name) {
+    return false;
+  }
+  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+    return true;
+  }
+  return false;
+};
+var setAuthParams = async ({
+  security,
+  ...options
+}) => {
+  for (const auth of security) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+    const token = await getAuthToken(auth, options.auth);
+    if (!token) {
+      continue;
+    }
+    const name = auth.name ?? "Authorization";
+    switch (auth.in) {
+      case "query":
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name] = token;
+        break;
+      case "cookie":
+        options.headers.append("Cookie", `${name}=${token}`);
+        break;
+      case "header":
+      default:
+        options.headers.set(name, token);
+        break;
+    }
+  }
+};
+var buildUrl = (options) => getUrl({
+  baseUrl: options.baseUrl,
+  path: options.path,
+  query: options.query,
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+  url: options.url
+});
+var mergeConfigs = (a, b) => {
+  const config = { ...a, ...b };
+  if (config.baseUrl?.endsWith("/")) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a.headers, b.headers);
+  return config;
+};
+var headersEntries = (headers) => {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+};
+var mergeHeaders = (...headers) => {
+  const mergedHeaders = new Headers();
+  for (const header of headers) {
+    if (!header) {
+      continue;
+    }
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v);
+        }
+      } else if (value !== void 0) {
+        mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+      }
+    }
+  }
+  return mergedHeaders;
+};
+var Interceptors = class {
+  fns = [];
+  clear() {
+    this.fns = [];
+  }
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
+    }
+  }
+  exists(id) {
+    const index = this.getInterceptorIndex(id);
+    return Boolean(this.fns[index]);
+  }
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this.fns[id] ? id : -1;
+    }
+    return this.fns.indexOf(id);
+  }
+  update(id, fn) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = fn;
+      return id;
+    }
+    return false;
+  }
+  use(fn) {
+    this.fns.push(fn);
+    return this.fns.length - 1;
+  }
+};
+var createInterceptors = () => ({
+  error: new Interceptors(),
+  request: new Interceptors(),
+  response: new Interceptors()
+});
+var defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: "form"
+  },
+  object: {
+    explode: true,
+    style: "deepObject"
+  }
+});
+var defaultHeaders = {
+  "Content-Type": "application/json"
+};
+var createConfig = (override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: "auto",
+  querySerializer: defaultQuerySerializer,
+  ...override
+});
+
+// packages/sdk/src/v2/gen/client/client.gen.ts
+var createClient = (config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
+  const getConfig = () => ({ ..._config });
+  const setConfig = (config2) => {
+    _config = mergeConfigs(_config, config2);
+    return getConfig();
+  };
+  const interceptors = createInterceptors();
+  const beforeRequest = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: void 0
+    };
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security
+      });
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body !== void 0 && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.body === void 0 || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const url = buildUrl(opts);
+    return { opts, url };
+  };
+  const request = async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    const requestInit = {
+      redirect: "follow",
+      ...opts,
+      body: getValidRequestBody(opts)
+    };
+    let request2 = new Request(url, requestInit);
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        request2 = await fn(request2, opts);
+      }
+    }
+    const _fetch = opts.fetch;
+    let response;
+    try {
+      response = await _fetch(request2);
+    } catch (error2) {
+      let finalError2 = error2;
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError2 = await fn(error2, void 0, request2, opts);
+        }
+      }
+      finalError2 = finalError2 || {};
+      if (opts.throwOnError) {
+        throw finalError2;
+      }
+      return opts.responseStyle === "data" ? void 0 : {
+        error: finalError2,
+        request: request2,
+        response: void 0
+      };
+    }
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, request2, opts);
+      }
+    }
+    const result = {
+      request: request2,
+      response
+    };
+    if (response.ok) {
+      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        let emptyData;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "text":
+            emptyData = await response[parseAs]();
+            break;
+          case "formData":
+            emptyData = new FormData();
+            break;
+          case "stream":
+            emptyData = response.body;
+            break;
+          case "json":
+          default:
+            emptyData = {};
+            break;
+        }
+        return opts.responseStyle === "data" ? emptyData : {
+          data: emptyData,
+          ...result
+        };
+      }
+      let data;
+      switch (parseAs) {
+        case "arrayBuffer":
+        case "blob":
+        case "formData":
+        case "text":
+          data = await response[parseAs]();
+          break;
+        case "json": {
+          const text = await response.text();
+          data = text ? JSON.parse(text) : {};
+          break;
+        }
+        case "stream":
+          return opts.responseStyle === "data" ? response.body : {
+            data: response.body,
+            ...result
+          };
+      }
+      if (parseAs === "json") {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+      return opts.responseStyle === "data" ? data : {
+        data,
+        ...result
+      };
+    }
+    const textError = await response.text();
+    let jsonError;
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {
+    }
+    const error = jsonError ?? textError;
+    let finalError = error;
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = await fn(error, response, request2, opts);
+      }
+    }
+    finalError = finalError || {};
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+    return opts.responseStyle === "data" ? void 0 : {
+      error: finalError,
+      ...result
+    };
+  };
+  const makeMethodFn = (method) => (options) => request({ ...options, method });
+  const makeSseFn = (method) => async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      headers: opts.headers,
+      method,
+      onRequest: async (url2, init) => {
+        let request2 = new Request(url2, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request2 = await fn(request2, opts);
+          }
+        }
+        return request2;
+      },
+      serializedBody: getValidRequestBody(opts),
+      url
+    });
+  };
+  return {
+    buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE")
+    },
+    trace: makeMethodFn("TRACE")
+  };
+};
+
+// packages/sdk/src/v2/gen/core/params.gen.ts
+var extraPrefixesMap = {
+  $body_: "body",
+  $headers_: "headers",
+  $path_: "path",
+  $query_: "query"
+};
+var extraPrefixes = Object.entries(extraPrefixesMap);
+var buildKeyMap = (fields, map) => {
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+  }
+  for (const config of fields) {
+    if ("in" in config) {
+      if (config.key) {
+        map.set(config.key, {
+          in: config.in,
+          map: config.map
+        });
+      }
+    } else if ("key" in config) {
+      map.set(config.key, {
+        map: config.map
+      });
+    } else if (config.args) {
+      buildKeyMap(config.args, map);
+    }
+  }
+  return map;
+};
+var stripEmptySlots = (params) => {
+  for (const [slot, value] of Object.entries(params)) {
+    if (value && typeof value === "object" && !Object.keys(value).length) {
+      delete params[slot];
+    }
+  }
+};
+var buildClientParams = (args, fields) => {
+  const params = {
+    body: {},
+    headers: {},
+    path: {},
+    query: {}
+  };
+  const map = buildKeyMap(fields);
+  let config;
+  for (const [index, arg] of args.entries()) {
+    if (fields[index]) {
+      config = fields[index];
+    }
+    if (!config) {
+      continue;
+    }
+    if ("in" in config) {
+      if (config.key) {
+        const field = map.get(config.key);
+        const name = field.map || config.key;
+        if (field.in) {
+          ;
+          params[field.in][name] = arg;
+        }
+      } else {
+        params.body = arg;
+      }
+    } else {
+      for (const [key, value] of Object.entries(arg ?? {})) {
+        const field = map.get(key);
+        if (field) {
+          if (field.in) {
+            const name = field.map || key;
+            params[field.in][name] = value;
+          } else {
+            params[field.map] = value;
+          }
+        } else {
+          const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix));
+          if (extra) {
+            const [prefix, slot] = extra;
+            params[slot][key.slice(prefix.length)] = value;
+          } else if ("allowExtra" in config && config.allowExtra) {
+            for (const [slot, allowed] of Object.entries(config.allowExtra)) {
+              if (allowed) {
+                ;
+                params[slot][key] = value;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  stripEmptySlots(params);
+  return params;
+};
+
+// packages/sdk/src/v2/gen/client.gen.ts
+var client = createClient(createConfig({ baseUrl: "http://localhost:4096" }));
+
+// packages/sdk/src/v2/gen/sdk.gen.ts
+var HeyApiClient = class {
+  client;
+  constructor(args) {
+    this.client = args?.client ?? client;
+  }
+};
+var HeyApiRegistry = class {
+  defaultKey = "default";
+  instances = /* @__PURE__ */ new Map();
+  get(key) {
+    const instance = this.instances.get(key ?? this.defaultKey);
+    if (!instance) {
+      throw new Error(`No SDK client found. Create one with "new OpencodeClient()" to fix this error.`);
+    }
+    return instance;
+  }
+  set(value, key) {
+    this.instances.set(key ?? this.defaultKey, value);
+  }
+};
+var SyncEvent = class extends HeyApiClient {
+  /**
+   * Subscribe to global sync events
+   *
+   * Get global sync events
+   */
+  subscribe(options) {
+    return (options?.client ?? this.client).sse.get({
+      url: "/global/sync-event",
+      ...options
+    });
+  }
+};
+var Config = class extends HeyApiClient {
+  /**
+   * Get global configuration
+   *
+   * Retrieve the current global OpenCode configuration settings and preferences.
+   */
+  get(options) {
+    return (options?.client ?? this.client).get({
+      url: "/global/config",
+      ...options
+    });
+  }
+  /**
+   * Update global configuration
+   *
+   * Update global OpenCode configuration settings and preferences.
+   */
+  update(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ key: "config", map: "body" }] }]);
+    return (options?.client ?? this.client).patch({
+      url: "/global/config",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+};
+var Global = class extends HeyApiClient {
+  /**
+   * Get health
+   *
+   * Get health information about the OpenCode server.
+   */
+  health(options) {
+    return (options?.client ?? this.client).get({
+      url: "/global/health",
+      ...options
+    });
+  }
+  /**
+   * Get global events
+   *
+   * Subscribe to global events from the OpenCode system using server-sent events.
+   */
+  event(options) {
+    return (options?.client ?? this.client).sse.get({
+      url: "/global/event",
+      ...options
+    });
+  }
+  /**
+   * Dispose instance
+   *
+   * Clean up and dispose all OpenCode instances, releasing all resources.
+   */
+  dispose(options) {
+    return (options?.client ?? this.client).post({
+      url: "/global/dispose",
+      ...options
+    });
+  }
+  /**
+   * Upgrade opencode
+   *
+   * Upgrade opencode to the specified version or latest if not specified.
+   */
+  upgrade(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "body", key: "target" }] }]);
+    return (options?.client ?? this.client).post({
+      url: "/global/upgrade",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  _syncEvent;
+  get syncEvent() {
+    return this._syncEvent ??= new SyncEvent({ client: this.client });
+  }
+  _config;
+  get config() {
+    return this._config ??= new Config({ client: this.client });
+  }
+};
+var Auth = class extends HeyApiClient {
+  /**
+   * Remove auth credentials
+   *
+   * Remove authentication credentials
+   */
+  remove(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "providerID" }] }]);
+    return (options?.client ?? this.client).delete({
+      url: "/auth/{providerID}",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Set auth credentials
+   *
+   * Set authentication credentials
+   */
+  set(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "providerID" },
+            { key: "auth", map: "body" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).put({
+      url: "/auth/{providerID}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+};
+var App = class extends HeyApiClient {
+  /**
+   * Write log
+   *
+   * Write a log entry to the server logs with specified level and metadata.
+   */
+  log(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "service" },
+            { in: "body", key: "level" },
+            { in: "body", key: "message" },
+            { in: "body", key: "extra" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/log",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * List agents
+   *
+   * Get a list of all available AI agents in the OpenCode system.
+   */
+  agents(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/agent",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * List skills
+   *
+   * Get a list of all available skills in the OpenCode system.
+   */
+  skills(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/skill",
+      ...options,
+      ...params
+    });
+  }
+};
+var Project = class extends HeyApiClient {
+  /**
+   * List all projects
+   *
+   * Get a list of projects that have been opened with OpenCode.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/project",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Get current project
+   *
+   * Retrieve the currently active project that OpenCode is working with.
+   */
+  current(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/project/current",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Initialize git repository
+   *
+   * Create a git repository for the current project and return the refreshed project info.
+   */
+  initGit(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/project/git/init",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Update project
+   *
+   * Update project properties such as name, icon, and commands.
+   */
+  update(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "projectID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "name" },
+            { in: "body", key: "icon" },
+            { in: "body", key: "commands" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).patch({
+      url: "/project/{projectID}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+};
+var Pty = class extends HeyApiClient {
+  /**
+   * List PTY sessions
+   *
+   * Get a list of all active pseudo-terminal (PTY) sessions managed by OpenCode.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/pty",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Create PTY session
+   *
+   * Create a new pseudo-terminal (PTY) session for running shell commands and processes.
+   */
+  create(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "command" },
+            { in: "body", key: "args" },
+            { in: "body", key: "cwd" },
+            { in: "body", key: "title" },
+            { in: "body", key: "env" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/pty",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Remove PTY session
+   *
+   * Remove and terminate a specific pseudo-terminal (PTY) session.
+   */
+  remove(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "ptyID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).delete({
+      url: "/pty/{ptyID}",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Get PTY session
+   *
+   * Retrieve detailed information about a specific pseudo-terminal (PTY) session.
+   */
+  get(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "ptyID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/pty/{ptyID}",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Update PTY session
+   *
+   * Update properties of an existing pseudo-terminal (PTY) session.
+   */
+  update(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "ptyID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "title" },
+            { in: "body", key: "size" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).put({
+      url: "/pty/{ptyID}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Connect to PTY session
+   *
+   * Establish a WebSocket connection to interact with a pseudo-terminal (PTY) session in real-time.
+   */
+  connect(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "ptyID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/pty/{ptyID}/connect",
+      ...options,
+      ...params
+    });
+  }
+};
+var Config2 = class extends HeyApiClient {
+  /**
+   * Get configuration
+   *
+   * Retrieve the current OpenCode configuration settings and preferences.
+   */
+  get(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/config",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Update configuration
+   *
+   * Update OpenCode configuration settings and preferences.
+   */
+  update(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { key: "config", map: "body" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).patch({
+      url: "/config",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * List config providers
+   *
+   * Get a list of all configured AI providers and their default models.
+   */
+  providers(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/config/providers",
+      ...options,
+      ...params
+    });
+  }
+};
+var Console = class extends HeyApiClient {
+  /**
+   * Get active Console provider metadata
+   *
+   * Get the active Console org name and the set of provider IDs managed by that Console org.
+   */
+  get(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/experimental/console",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * List switchable Console orgs
+   *
+   * Get the available Console orgs across logged-in accounts, including the current active org.
+   */
+  listOrgs(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/experimental/console/orgs",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Switch active Console org
+   *
+   * Persist a new active Console account/org selection for the current local OpenCode state.
+   */
+  switchOrg(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "accountID" },
+            { in: "body", key: "orgID" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/experimental/console/switch",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+};
+var Workspace = class extends HeyApiClient {
+  /**
+   * List workspaces
+   *
+   * List all workspaces.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/experimental/workspace",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Create workspace
+   *
+   * Create a workspace for the current project.
+   */
+  create(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "id" },
+            { in: "body", key: "type" },
+            { in: "body", key: "branch" },
+            { in: "body", key: "extra" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/experimental/workspace",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Remove workspace
+   *
+   * Remove an existing workspace.
+   */
+  remove(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "id" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).delete({
+      url: "/experimental/workspace/{id}",
+      ...options,
+      ...params
+    });
+  }
+};
+var Session = class extends HeyApiClient {
+  /**
+   * List sessions
+   *
+   * Get a list of all OpenCode sessions across projects, sorted by most recently updated. Archived sessions are excluded by default.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "roots" },
+            { in: "query", key: "start" },
+            { in: "query", key: "cursor" },
+            { in: "query", key: "search" },
+            { in: "query", key: "limit" },
+            { in: "query", key: "archived" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/experimental/session",
+      ...options,
+      ...params
+    });
+  }
+};
+var Resource = class extends HeyApiClient {
+  /**
+   * Get MCP resources
+   *
+   * Get all available MCP resources from connected servers. Optionally filter by name.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/experimental/resource",
+      ...options,
+      ...params
+    });
+  }
+};
+var Experimental = class extends HeyApiClient {
+  _console;
+  get console() {
+    return this._console ??= new Console({ client: this.client });
+  }
+  _workspace;
+  get workspace() {
+    return this._workspace ??= new Workspace({ client: this.client });
+  }
+  _session;
+  get session() {
+    return this._session ??= new Session({ client: this.client });
+  }
+  _resource;
+  get resource() {
+    return this._resource ??= new Resource({ client: this.client });
+  }
+};
+var Tool = class extends HeyApiClient {
+  /**
+   * List tool IDs
+   *
+   * Get a list of all available tool IDs, including both built-in tools and dynamically registered tools.
+   */
+  ids(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/experimental/tool/ids",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * List tools
+   *
+   * Get a list of available tools with their JSON schema parameters for a specific provider and model combination.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "provider" },
+            { in: "query", key: "model" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/experimental/tool",
+      ...options,
+      ...params
+    });
+  }
+};
+var Worktree = class extends HeyApiClient {
+  /**
+   * Remove worktree
+   *
+   * Remove a git worktree and delete its branch.
+   */
+  remove(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { key: "worktreeRemoveInput", map: "body" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).delete({
+      url: "/experimental/worktree",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * List worktrees
+   *
+   * List all sandbox worktrees for the current project.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/experimental/worktree",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Create worktree
+   *
+   * Create a new git worktree for the current project and run any configured startup scripts.
+   */
+  create(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { key: "worktreeCreateInput", map: "body" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/experimental/worktree",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Reset worktree
+   *
+   * Reset a worktree branch to the primary default branch.
+   */
+  reset(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { key: "worktreeResetInput", map: "body" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/experimental/worktree/reset",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+};
+var Session2 = class extends HeyApiClient {
+  /**
+   * List sessions
+   *
+   * Get a list of all OpenCode sessions, sorted by most recently updated.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "roots" },
+            { in: "query", key: "start" },
+            { in: "query", key: "search" },
+            { in: "query", key: "limit" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/session",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Create session
+   *
+   * Create a new OpenCode session for interacting with AI assistants and managing conversations.
+   */
+  create(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "parentID" },
+            { in: "body", key: "title" },
+            { in: "body", key: "permission" },
+            { in: "body", key: "workspaceID" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Get session status
+   *
+   * Retrieve the current status of all sessions, including active, idle, and completed states.
+   */
+  status(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/session/status",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Delete session
+   *
+   * Delete a session and permanently remove all associated data, including messages and history.
+   */
+  delete(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).delete({
+      url: "/session/{sessionID}",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Get session
+   *
+   * Retrieve detailed information about a specific OpenCode session.
+   */
+  get(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Update session
+   *
+   * Update properties of an existing session, such as title or other metadata.
+   */
+  update(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "title" },
+            { in: "body", key: "time" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).patch({
+      url: "/session/{sessionID}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Get session children
+   *
+   * Retrieve all child sessions that were forked from the specified parent session.
+   */
+  children(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/children",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Get session todos
+   *
+   * Retrieve the todo list associated with a specific session, showing tasks and action items.
+   */
+  todo(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/todo",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Initialize session
+   *
+   * Analyze the current application and create an AGENTS.md file with project-specific agent configurations.
+   */
+  init(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "modelID" },
+            { in: "body", key: "providerID" },
+            { in: "body", key: "messageID" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/init",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Fork session
+   *
+   * Create a new session by forking an existing session at a specific message point.
+   */
+  fork(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "messageID" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/fork",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Abort session
+   *
+   * Abort an active session and stop any ongoing AI processing or command execution.
+   */
+  abort(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/abort",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Unshare session
+   *
+   * Remove the shareable link for a session, making it private again.
+   */
+  unshare(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).delete({
+      url: "/session/{sessionID}/share",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Share session
+   *
+   * Create a shareable link for a session, allowing others to view the conversation.
+   */
+  share(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/share",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Get message diff
+   *
+   * Get the file changes (diff) that resulted from a specific user message in the session.
+   */
+  diff(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "messageID" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/diff",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Summarize session
+   *
+   * Generate a concise summary of the session using AI compaction to preserve key information.
+   */
+  summarize(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "providerID" },
+            { in: "body", key: "modelID" },
+            { in: "body", key: "auto" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/summarize",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Get session messages
+   *
+   * Retrieve all messages in a session, including user prompts and AI responses.
+   */
+  messages(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "limit" },
+            { in: "query", key: "before" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/message",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Send message
+   *
+   * Create and send a new message to a session, streaming the AI response.
+   */
+  prompt(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "messageID" },
+            { in: "body", key: "model" },
+            { in: "body", key: "agent" },
+            { in: "body", key: "noReply" },
+            { in: "body", key: "tools" },
+            { in: "body", key: "format" },
+            { in: "body", key: "system" },
+            { in: "body", key: "variant" },
+            { in: "body", key: "parts" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/message",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Delete message
+   *
+   * Permanently delete a specific message (and all of its parts) from a session. This does not revert any file changes that may have been made while processing the message.
+   */
+  deleteMessage(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "path", key: "messageID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).delete({
+      url: "/session/{sessionID}/message/{messageID}",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Get message
+   *
+   * Retrieve a specific message from a session by its message ID.
+   */
+  message(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "path", key: "messageID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/message/{messageID}",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Send async message
+   *
+   * Create and send a new message to a session asynchronously, starting the session if needed and returning immediately.
+   */
+  promptAsync(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "messageID" },
+            { in: "body", key: "model" },
+            { in: "body", key: "agent" },
+            { in: "body", key: "noReply" },
+            { in: "body", key: "tools" },
+            { in: "body", key: "format" },
+            { in: "body", key: "system" },
+            { in: "body", key: "variant" },
+            { in: "body", key: "parts" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/prompt_async",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Send command
+   *
+   * Send a new command to a session for execution by the AI assistant.
+   */
+  command(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "messageID" },
+            { in: "body", key: "agent" },
+            { in: "body", key: "model" },
+            { in: "body", key: "arguments" },
+            { in: "body", key: "command" },
+            { in: "body", key: "variant" },
+            { in: "body", key: "parts" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/command",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Run shell command
+   *
+   * Execute a shell command within the session context and return the AI's response.
+   */
+  shell(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "messageID" },
+            { in: "body", key: "agent" },
+            { in: "body", key: "model" },
+            { in: "body", key: "command" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/shell",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Revert message
+   *
+   * Revert a specific message in a session, undoing its effects and restoring the previous state.
+   */
+  revert(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "messageID" },
+            { in: "body", key: "partID" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/revert",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Restore reverted messages
+   *
+   * Restore all previously reverted messages in a session.
+   */
+  unrevert(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/unrevert",
+      ...options,
+      ...params
+    });
+  }
+};
+var Part = class extends HeyApiClient {
+  /**
+   * Delete a part from a message
+   */
+  delete(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "path", key: "messageID" },
+            { in: "path", key: "partID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).delete({
+      url: "/session/{sessionID}/message/{messageID}/part/{partID}",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Update a part in a message
+   */
+  update(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "path", key: "messageID" },
+            { in: "path", key: "partID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { key: "part", map: "body" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).patch({
+      url: "/session/{sessionID}/message/{messageID}/part/{partID}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+};
+var Permission = class extends HeyApiClient {
+  /**
+   * Respond to permission
+   *
+   * Approve or deny a permission request from the AI assistant.
+   *
+   * @deprecated
+   */
+  respond(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "path", key: "permissionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "response" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/permissions/{permissionID}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Respond to permission request
+   *
+   * Approve or deny a permission request from the AI assistant.
+   */
+  reply(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "requestID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "reply" },
+            { in: "body", key: "message" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/permission/{requestID}/reply",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * List pending permissions
+   *
+   * Get all pending permission requests across all sessions.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/permission",
+      ...options,
+      ...params
+    });
+  }
+};
+var Question = class extends HeyApiClient {
+  /**
+   * List pending questions
+   *
+   * Get all pending question requests across all sessions.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/question",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Reply to question request
+   *
+   * Provide answers to a question request from the AI assistant.
+   */
+  reply(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "requestID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "answers" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/question/{requestID}/reply",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Reject question request
+   *
+   * Reject a question request from the AI assistant.
+   */
+  reject(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "requestID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/question/{requestID}/reject",
+      ...options,
+      ...params
+    });
+  }
+};
+var Oauth = class extends HeyApiClient {
+  /**
+   * OAuth authorize
+   *
+   * Initiate OAuth authorization for a specific AI provider to get an authorization URL.
+   */
+  authorize(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "providerID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "method" },
+            { in: "body", key: "inputs" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/provider/{providerID}/oauth/authorize",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * OAuth callback
+   *
+   * Handle the OAuth callback from a provider after user authorization.
+   */
+  callback(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "providerID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "method" },
+            { in: "body", key: "code" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/provider/{providerID}/oauth/callback",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+};
+var Provider2 = class extends HeyApiClient {
+  /**
+   * List providers
+   *
+   * Get a list of all available AI providers, including both available and connected ones.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/provider",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Get provider auth methods
+   *
+   * Retrieve available authentication methods for all AI providers.
+   */
+  auth(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/provider/auth",
+      ...options,
+      ...params
+    });
+  }
+  _oauth;
+  get oauth() {
+    return this._oauth ??= new Oauth({ client: this.client });
+  }
+};
+var Find = class extends HeyApiClient {
+  /**
+   * Find text
+   *
+   * Search for text patterns across files in the project using ripgrep.
+   */
+  text(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "pattern" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/find",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Find files
+   *
+   * Search for files or directories by name or pattern in the project directory.
+   */
+  files(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "query" },
+            { in: "query", key: "dirs" },
+            { in: "query", key: "type" },
+            { in: "query", key: "limit" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/find/file",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Find symbols
+   *
+   * Search for workspace symbols like functions, classes, and variables using LSP.
+   */
+  symbols(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "query" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/find/symbol",
+      ...options,
+      ...params
+    });
+  }
+};
+var File = class extends HeyApiClient {
+  /**
+   * List files
+   *
+   * List files and directories in a specified path.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "path" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/file",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Read file
+   *
+   * Read the content of a specified file.
+   */
+  read(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "path" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/file/content",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Get file status
+   *
+   * Get the git status of all files in the project.
+   */
+  status(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/file/status",
+      ...options,
+      ...params
+    });
+  }
+};
+var Event = class extends HeyApiClient {
+  /**
+   * Subscribe to events
+   *
+   * Get events
+   */
+  subscribe(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).sse.get({
+      url: "/event",
+      ...options,
+      ...params
+    });
+  }
+};
+var Auth2 = class extends HeyApiClient {
+  /**
+   * Remove MCP OAuth
+   *
+   * Remove OAuth credentials for an MCP server
+   */
+  remove(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "name" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).delete({
+      url: "/mcp/{name}/auth",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Start MCP OAuth
+   *
+   * Start OAuth authentication flow for a Model Context Protocol (MCP) server.
+   */
+  start(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "name" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/mcp/{name}/auth",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Complete MCP OAuth
+   *
+   * Complete OAuth authentication for a Model Context Protocol (MCP) server using the authorization code.
+   */
+  callback(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "name" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "code" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/mcp/{name}/auth/callback",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Authenticate MCP OAuth
+   *
+   * Start OAuth flow and wait for callback (opens browser)
+   */
+  authenticate(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "name" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post(
+      {
+        url: "/mcp/{name}/auth/authenticate",
+        ...options,
+        ...params
+      }
+    );
+  }
+};
+var Mcp = class extends HeyApiClient {
+  /**
+   * Get MCP status
+   *
+   * Get the status of all Model Context Protocol (MCP) servers.
+   */
+  status(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/mcp",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Add MCP server
+   *
+   * Dynamically add a new Model Context Protocol (MCP) server to the system.
+   */
+  add(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "name" },
+            { in: "body", key: "config" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/mcp",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Connect an MCP server
+   */
+  connect(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "name" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/mcp/{name}/connect",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Disconnect an MCP server
+   */
+  disconnect(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "name" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/mcp/{name}/disconnect",
+      ...options,
+      ...params
+    });
+  }
+  _auth;
+  get auth() {
+    return this._auth ??= new Auth2({ client: this.client });
+  }
+};
+var Control = class extends HeyApiClient {
+  /**
+   * Get next TUI request
+   *
+   * Retrieve the next TUI (Terminal User Interface) request from the queue for processing.
+   */
+  next(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/tui/control/next",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Submit TUI response
+   *
+   * Submit a response to the TUI request queue to complete a pending request.
+   */
+  response(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { key: "body", map: "body" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/control/response",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+};
+var Tui = class extends HeyApiClient {
+  /**
+   * Append TUI prompt
+   *
+   * Append prompt to the TUI
+   */
+  appendPrompt(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "text" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/append-prompt",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Open help dialog
+   *
+   * Open the help dialog in the TUI to display user assistance information.
+   */
+  openHelp(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/open-help",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Open sessions dialog
+   *
+   * Open the session dialog
+   */
+  openSessions(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/open-sessions",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Open themes dialog
+   *
+   * Open the theme dialog
+   */
+  openThemes(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/open-themes",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Open models dialog
+   *
+   * Open the model dialog
+   */
+  openModels(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/open-models",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Submit TUI prompt
+   *
+   * Submit the prompt
+   */
+  submitPrompt(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/submit-prompt",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Clear TUI prompt
+   *
+   * Clear the prompt
+   */
+  clearPrompt(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/clear-prompt",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Execute TUI command
+   *
+   * Execute a TUI command (e.g. agent_cycle)
+   */
+  executeCommand(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "command" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/execute-command",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Show TUI toast
+   *
+   * Show a toast notification in the TUI
+   */
+  showToast(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "title" },
+            { in: "body", key: "message" },
+            { in: "body", key: "variant" },
+            { in: "body", key: "duration" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/show-toast",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Publish TUI event
+   *
+   * Publish a TUI event
+   */
+  publish(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { key: "body", map: "body" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/publish",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  /**
+   * Select session
+   *
+   * Navigate the TUI to display the specified session.
+   */
+  selectSession(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "body", key: "sessionID" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/tui/select-session",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  _control;
+  get control() {
+    return this._control ??= new Control({ client: this.client });
+  }
+};
+var Instance2 = class extends HeyApiClient {
+  /**
+   * Dispose instance
+   *
+   * Clean up and dispose the current OpenCode instance, releasing all resources.
+   */
+  dispose(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).post({
+      url: "/instance/dispose",
+      ...options,
+      ...params
+    });
+  }
+};
+var Path = class extends HeyApiClient {
+  /**
+   * Get paths
+   *
+   * Retrieve the current working directory and related path information for the OpenCode instance.
+   */
+  get(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/path",
+      ...options,
+      ...params
+    });
+  }
+};
+var Vcs = class extends HeyApiClient {
+  /**
+   * Get VCS info
+   *
+   * Retrieve version control system (VCS) information for the current project, such as git branch.
+   */
+  get(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/vcs",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Get VCS diff
+   *
+   * Retrieve the current git diff for the working tree or against the default branch.
+   */
+  diff(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { in: "query", key: "mode" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/vcs/diff",
+      ...options,
+      ...params
+    });
+  }
+};
+var Command = class extends HeyApiClient {
+  /**
+   * List commands
+   *
+   * Get a list of all available commands in the OpenCode system.
+   */
+  list(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/command",
+      ...options,
+      ...params
+    });
+  }
+};
+var Lsp = class extends HeyApiClient {
+  /**
+   * Get LSP status
+   *
+   * Get LSP server status
+   */
+  status(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/lsp",
+      ...options,
+      ...params
+    });
+  }
+};
+var Formatter = class extends HeyApiClient {
+  /**
+   * Get formatter status
+   *
+   * Get formatter status
+   */
+  status(parameters, options) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" }
+          ]
+        }
+      ]
+    );
+    return (options?.client ?? this.client).get({
+      url: "/formatter",
+      ...options,
+      ...params
+    });
+  }
+};
+var OpencodeClient = class _OpencodeClient extends HeyApiClient {
+  static __registry = new HeyApiRegistry();
+  constructor(args) {
+    super(args);
+    _OpencodeClient.__registry.set(this, args?.key);
+  }
+  _global;
+  get global() {
+    return this._global ??= new Global({ client: this.client });
+  }
+  _auth;
+  get auth() {
+    return this._auth ??= new Auth({ client: this.client });
+  }
+  _app;
+  get app() {
+    return this._app ??= new App({ client: this.client });
+  }
+  _project;
+  get project() {
+    return this._project ??= new Project({ client: this.client });
+  }
+  _pty;
+  get pty() {
+    return this._pty ??= new Pty({ client: this.client });
+  }
+  _config;
+  get config() {
+    return this._config ??= new Config2({ client: this.client });
+  }
+  _experimental;
+  get experimental() {
+    return this._experimental ??= new Experimental({ client: this.client });
+  }
+  _tool;
+  get tool() {
+    return this._tool ??= new Tool({ client: this.client });
+  }
+  _worktree;
+  get worktree() {
+    return this._worktree ??= new Worktree({ client: this.client });
+  }
+  _session;
+  get session() {
+    return this._session ??= new Session2({ client: this.client });
+  }
+  _part;
+  get part() {
+    return this._part ??= new Part({ client: this.client });
+  }
+  _permission;
+  get permission() {
+    return this._permission ??= new Permission({ client: this.client });
+  }
+  _question;
+  get question() {
+    return this._question ??= new Question({ client: this.client });
+  }
+  _provider;
+  get provider() {
+    return this._provider ??= new Provider2({ client: this.client });
+  }
+  _find;
+  get find() {
+    return this._find ??= new Find({ client: this.client });
+  }
+  _file;
+  get file() {
+    return this._file ??= new File({ client: this.client });
+  }
+  _event;
+  get event() {
+    return this._event ??= new Event({ client: this.client });
+  }
+  _mcp;
+  get mcp() {
+    return this._mcp ??= new Mcp({ client: this.client });
+  }
+  _tui;
+  get tui() {
+    return this._tui ??= new Tui({ client: this.client });
+  }
+  _instance;
+  get instance() {
+    return this._instance ??= new Instance2({ client: this.client });
+  }
+  _path;
+  get path() {
+    return this._path ??= new Path({ client: this.client });
+  }
+  _vcs;
+  get vcs() {
+    return this._vcs ??= new Vcs({ client: this.client });
+  }
+  _command;
+  get command() {
+    return this._command ??= new Command({ client: this.client });
+  }
+  _lsp;
+  get lsp() {
+    return this._lsp ??= new Lsp({ client: this.client });
+  }
+  _formatter;
+  get formatter() {
+    return this._formatter ??= new Formatter({ client: this.client });
+  }
+};
+
+// packages/sdk/src/v2/client.ts
+function pick(value, fallback2, encode) {
+  if (!value) return;
+  if (!fallback2) return value;
+  if (value === fallback2) return fallback2;
+  if (encode && value === encode(fallback2)) return fallback2;
+  return value;
+}
+function rewrite(request, values) {
+  if (request.method !== "GET" && request.method !== "HEAD") return request;
+  const url = new URL(request.url);
+  let changed = false;
+  for (const [name, key] of [
+    ["x-opencode-directory", "directory"],
+    ["x-opencode-workspace", "workspace"]
+  ]) {
+    const value = pick(
+      request.headers.get(name),
+      key === "directory" ? values.directory : values.workspace,
+      key === "directory" ? encodeURIComponent : void 0
+    );
+    if (!value) continue;
+    if (!url.searchParams.has(key)) {
+      url.searchParams.set(key, value);
+    }
+    changed = true;
+  }
+  if (!changed) return request;
+  const next = new Request(url, request);
+  next.headers.delete("x-opencode-directory");
+  next.headers.delete("x-opencode-workspace");
+  return next;
+}
+function createOpencodeClient(config) {
+  if (!config?.fetch) {
+    const customFetch = (req) => {
+      req.timeout = false;
+      return fetch(req);
+    };
+    config = {
+      ...config,
+      fetch: customFetch
+    };
+  }
+  if (config?.directory) {
+    config.headers = {
+      ...config.headers,
+      "x-opencode-directory": encodeURIComponent(config.directory)
+    };
+  }
+  if (config?.experimental_workspaceID) {
+    config.headers = {
+      ...config.headers,
+      "x-opencode-workspace": config.experimental_workspaceID
+    };
+  }
+  const client2 = createClient(config);
+  client2.interceptors.request.use(
+    (request) => rewrite(request, {
+      directory: config?.directory,
+      workspace: config?.experimental_workspaceID
+    })
+  );
+  return new OpencodeClient({ client: client2 });
+}
+
+// packages/sdk/src/v2/server.ts
+import launch from "cross-spawn";
+
+// packages/opencode/src/util/locale.ts
+var Locale;
+((Locale2) => {
+  function titlecase(str) {
+    return str.replace(/\b\w/g, (c) => c.toUpperCase());
+  }
+  Locale2.titlecase = titlecase;
+  function time(input) {
+    const date = new Date(input);
+    return date.toLocaleTimeString(void 0, { timeStyle: "short" });
+  }
+  Locale2.time = time;
+  function datetime(input) {
+    const date = new Date(input);
+    const localTime = time(input);
+    const localDate = date.toLocaleDateString();
+    return `${localTime} \xB7 ${localDate}`;
+  }
+  Locale2.datetime = datetime;
+  function todayTimeOrDateTime(input) {
+    const date = new Date(input);
+    const now = /* @__PURE__ */ new Date();
+    const isToday = date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate();
+    if (isToday) {
+      return time(input);
+    } else {
+      return datetime(input);
+    }
+  }
+  Locale2.todayTimeOrDateTime = todayTimeOrDateTime;
+  function number(num) {
+    if (num >= 1e6) {
+      return (num / 1e6).toFixed(1) + "M";
+    } else if (num >= 1e3) {
+      return (num / 1e3).toFixed(1) + "K";
+    }
+    return num.toString();
+  }
+  Locale2.number = number;
+  function duration(input) {
+    if (input < 1e3) {
+      return `${input}ms`;
+    }
+    if (input < 6e4) {
+      return `${(input / 1e3).toFixed(1)}s`;
+    }
+    if (input < 36e5) {
+      const minutes = Math.floor(input / 6e4);
+      const seconds = Math.floor(input % 6e4 / 1e3);
+      return `${minutes}m ${seconds}s`;
+    }
+    if (input < 864e5) {
+      const hours2 = Math.floor(input / 36e5);
+      const minutes = Math.floor(input % 36e5 / 6e4);
+      return `${hours2}h ${minutes}m`;
+    }
+    const hours = Math.floor(input / 36e5);
+    const days = Math.floor(input % 36e5 / 864e5);
+    return `${days}d ${hours}h`;
+  }
+  Locale2.duration = duration;
+  function truncate(str, len) {
+    if (str.length <= len) return str;
+    return str.slice(0, len - 1) + "\u2026";
+  }
+  Locale2.truncate = truncate;
+  function truncateMiddle(str, maxLength = 35) {
+    if (str.length <= maxLength) return str;
+    const ellipsis = "\u2026";
+    const keepStart = Math.ceil((maxLength - ellipsis.length) / 2);
+    const keepEnd = Math.floor((maxLength - ellipsis.length) / 2);
+    return str.slice(0, keepStart) + ellipsis + str.slice(-keepEnd);
+  }
+  Locale2.truncateMiddle = truncateMiddle;
+  function pluralize(count, singular, plural) {
+    const template = count === 1 ? singular : plural;
+    return template.replace("{}", count.toString());
+  }
+  Locale2.pluralize = pluralize;
+})(Locale || (Locale = {}));
+
+// packages/opencode/src/cli/cmd/run.ts
+function props(part) {
+  const state = part.state;
+  return {
+    input: state.input,
+    metadata: "metadata" in state ? state.metadata : {},
+    part
+  };
+}
+function inline(info) {
+  const suffix = info.description ? UI.Style.TEXT_DIM + ` ${info.description}` + UI.Style.TEXT_NORMAL : "";
+  UI.println(UI.Style.TEXT_NORMAL + info.icon, UI.Style.TEXT_NORMAL + info.title + suffix);
+}
+function block(info, output) {
+  UI.empty();
+  inline(info);
+  if (!output?.trim()) return;
+  UI.println(output);
+  UI.empty();
+}
+function fallback(part) {
+  const state = part.state;
+  const input = "input" in state ? state.input : void 0;
+  const title = ("title" in state && state.title ? state.title : void 0) || (input && typeof input === "object" && Object.keys(input).length > 0 ? JSON.stringify(input) : "Unknown");
+  inline({
+    icon: "\u2699",
+    title: `${part.tool} ${title}`
+  });
+}
+function glob(info) {
+  const root = info.input.path ?? "";
+  const title = `Glob "${info.input.pattern}"`;
+  const suffix = root ? `in ${normalizePath(root)}` : "";
+  const num = info.metadata.count;
+  const description = num === void 0 ? suffix : `${suffix}${suffix ? " \xB7 " : ""}${num} ${num === 1 ? "match" : "matches"}`;
+  inline({
+    icon: "\u2731",
+    title,
+    ...description && { description }
+  });
+}
+function grep(info) {
+  const root = info.input.path ?? "";
+  const title = `Grep "${info.input.pattern}"`;
+  const suffix = root ? `in ${normalizePath(root)}` : "";
+  const num = info.metadata.matches;
+  const description = num === void 0 ? suffix : `${suffix}${suffix ? " \xB7 " : ""}${num} ${num === 1 ? "match" : "matches"}`;
+  inline({
+    icon: "\u2731",
+    title,
+    ...description && { description }
+  });
+}
+function list(info) {
+  const dir = info.input.path ? normalizePath(info.input.path) : "";
+  inline({
+    icon: "\u2192",
+    title: dir ? `List ${dir}` : "List"
+  });
+}
+function read(info) {
+  const file = normalizePath(info.input.filePath);
+  const pairs = Object.entries(info.input).filter(([key, value]) => {
+    if (key === "filePath") return false;
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  });
+  const description = pairs.length ? `[${pairs.map(([key, value]) => `${key}=${value}`).join(", ")}]` : void 0;
+  inline({
+    icon: "\u2192",
+    title: `Read ${file}`,
+    ...description && { description }
+  });
+}
+function write(info) {
+  block(
+    {
+      icon: "\u2190",
+      title: `Write ${normalizePath(info.input.filePath)}`
+    },
+    info.part.state.status === "completed" ? info.part.state.output : void 0
+  );
+}
+function webfetch(info) {
+  inline({
+    icon: "%",
+    title: `WebFetch ${info.input.url}`
+  });
+}
+function edit(info) {
+  const title = normalizePath(info.input.filePath);
+  const diff = info.metadata.diff;
+  block(
+    {
+      icon: "\u2190",
+      title: `Edit ${title}`
+    },
+    diff
+  );
+}
+function codesearch(info) {
+  inline({
+    icon: "\u25C7",
+    title: `Exa Code Search "${info.input.query}"`
+  });
+}
+function websearch(info) {
+  inline({
+    icon: "\u25C8",
+    title: `Exa Web Search "${info.input.query}"`
+  });
+}
+function task(info) {
+  const input = info.part.state.input;
+  const status = info.part.state.status;
+  const subagent = typeof input.subagent_type === "string" && input.subagent_type.trim().length > 0 ? input.subagent_type : "unknown";
+  const agent = Locale.titlecase(subagent);
+  const desc = typeof input.description === "string" && input.description.trim().length > 0 ? input.description : void 0;
+  const icon = status === "error" ? "\u2717" : status === "running" ? "\u2022" : "\u2713";
+  const name = desc ?? `${agent} Task`;
+  inline({
+    icon,
+    title: name,
+    description: desc ? `${agent} Agent` : void 0
+  });
+}
+function skill(info) {
+  inline({
+    icon: "\u2192",
+    title: `Skill "${info.input.name}"`
+  });
+}
+function bash(info) {
+  const output = info.part.state.status === "completed" ? info.part.state.output?.trim() : void 0;
+  block(
+    {
+      icon: "$",
+      title: `${info.input.command}`
+    },
+    output
+  );
+}
+function todo(info) {
+  block(
+    {
+      icon: "#",
+      title: "Todos"
+    },
+    info.input.todos.map((item) => `${item.status === "completed" ? "[x]" : "[ ]"} ${item.content}`).join("\n")
+  );
+}
+function normalizePath(input) {
+  if (!input) return "";
+  if (path.isAbsolute(input)) return path.relative(process.cwd(), input) || ".";
+  return input;
+}
+var RunCommand = cmd({
+  command: "run [message..]",
+  describe: "run opencode with a message",
+  builder: (yargs) => {
+    return yargs.positional("message", {
+      describe: "message to send",
+      type: "string",
+      array: true,
+      default: []
+    }).option("command", {
+      describe: "the command to run, use message for args",
+      type: "string"
+    }).option("continue", {
+      alias: ["c"],
+      describe: "continue the last session",
+      type: "boolean"
+    }).option("session", {
+      alias: ["s"],
+      describe: "session id to continue",
+      type: "string"
+    }).option("fork", {
+      describe: "fork the session before continuing (requires --continue or --session)",
+      type: "boolean"
+    }).option("share", {
+      type: "boolean",
+      describe: "share the session"
+    }).option("model", {
+      type: "string",
+      alias: ["m"],
+      describe: "model to use in the format of provider/model"
+    }).option("agent", {
+      type: "string",
+      describe: "agent to use"
+    }).option("format", {
+      type: "string",
+      choices: ["default", "json"],
+      default: "default",
+      describe: "format: default (formatted) or json (raw JSON events)"
+    }).option("file", {
+      alias: ["f"],
+      type: "string",
+      array: true,
+      describe: "file(s) to attach to message"
+    }).option("title", {
+      type: "string",
+      describe: "title for the session (uses truncated prompt if no value provided)"
+    }).option("attach", {
+      type: "string",
+      describe: "attach to a running opencode server (e.g., http://localhost:4096)"
+    }).option("password", {
+      alias: ["p"],
+      type: "string",
+      describe: "basic auth password (defaults to OPENCODE_SERVER_PASSWORD)"
+    }).option("dir", {
+      type: "string",
+      describe: "directory to run in, path on remote server if attaching"
+    }).option("port", {
+      type: "number",
+      describe: "port for the local server (defaults to random port if no value provided)"
+    }).option("variant", {
+      type: "string",
+      describe: "model variant (provider-specific reasoning effort, e.g., high, max, minimal)"
+    }).option("thinking", {
+      type: "boolean",
+      describe: "show thinking blocks",
+      default: false
+    }).option("dangerously-skip-permissions", {
+      type: "boolean",
+      describe: "auto-approve permissions that are not explicitly denied (dangerous!)",
+      default: false
+    });
+  },
+  handler: async (args) => {
+    let message = [...args.message, ...args["--"] || []].map((arg) => arg.includes(" ") ? `"${arg.replace(/"/g, '\\"')}"` : arg).join(" ");
+    const directory = (() => {
+      if (!args.dir) return void 0;
+      if (args.attach) return args.dir;
+      try {
+        process.chdir(args.dir);
+        return process.cwd();
+      } catch {
+        UI.error("Failed to change directory to " + args.dir);
+        process.exit(1);
+      }
+    })();
+    const files = [];
+    if (args.file) {
+      const list2 = Array.isArray(args.file) ? args.file : [args.file];
+      for (const filePath of list2) {
+        const resolvedPath = path.resolve(process.cwd(), filePath);
+        if (!await Filesystem.exists(resolvedPath)) {
+          UI.error(`File not found: ${filePath}`);
+          process.exit(1);
+        }
+        const mime = await Filesystem.isDir(resolvedPath) ? "application/x-directory" : "text/plain";
+        files.push({
+          type: "file",
+          url: pathToFileURL(resolvedPath).href,
+          filename: path.basename(resolvedPath),
+          mime
+        });
+      }
+    }
+    if (!process.stdin.isTTY) message += "\n" + await Bun.stdin.text();
+    if (message.trim().length === 0 && !args.command) {
+      UI.error("You must provide a message or a command");
+      process.exit(1);
+    }
+    if (args.fork && !args.continue && !args.session) {
+      UI.error("--fork requires --continue or --session");
+      process.exit(1);
+    }
+    const rules = [
+      {
+        permission: "question",
+        action: "deny",
+        pattern: "*"
+      },
+      {
+        permission: "plan_enter",
+        action: "deny",
+        pattern: "*"
+      },
+      {
+        permission: "plan_exit",
+        action: "deny",
+        pattern: "*"
+      }
+    ];
+    function title() {
+      if (args.title === void 0) return;
+      if (args.title !== "") return args.title;
+      return message.slice(0, 50) + (message.length > 50 ? "..." : "");
+    }
+    async function session(sdk) {
+      const baseID = args.continue ? (await sdk.session.list()).data?.find((s) => !s.parentID)?.id : args.session;
+      if (baseID && args.fork) {
+        const forked = await sdk.session.fork({ sessionID: baseID });
+        return forked.data?.id;
+      }
+      if (baseID) return baseID;
+      const name = title();
+      const result = await sdk.session.create({ title: name, permission: rules });
+      return result.data?.id;
+    }
+    async function share(sdk, sessionID) {
+      const cfg = await sdk.config.get();
+      if (!cfg.data) return;
+      if (cfg.data.share !== "auto" && !Flag.OPENCODE_AUTO_SHARE && !args.share) return;
+      const res = await sdk.session.share({ sessionID }).catch((error) => {
+        if (error instanceof Error && error.message.includes("disabled")) {
+          UI.println(UI.Style.TEXT_DANGER_BOLD + "!  " + error.message);
+        }
+        return { error };
+      });
+      if (!res.error && "data" in res && res.data?.share?.url) {
+        UI.println(UI.Style.TEXT_INFO_BOLD + "~  " + res.data.share.url);
+      }
+    }
+    async function execute(sdk) {
+      function tool(part) {
+        try {
+          if (part.tool === "bash") return bash(props(part));
+          if (part.tool === "glob") return glob(props(part));
+          if (part.tool === "grep") return grep(props(part));
+          if (part.tool === "list") return list(props(part));
+          if (part.tool === "read") return read(props(part));
+          if (part.tool === "write") return write(props(part));
+          if (part.tool === "webfetch") return webfetch(props(part));
+          if (part.tool === "edit") return edit(props(part));
+          if (part.tool === "codesearch") return codesearch(props(part));
+          if (part.tool === "websearch") return websearch(props(part));
+          if (part.tool === "task") return task(props(part));
+          if (part.tool === "todowrite") return todo(props(part));
+          if (part.tool === "skill") return skill(props(part));
+          return fallback(part);
+        } catch {
+          return fallback(part);
+        }
+      }
+      function emit(type, data) {
+        if (args.format === "json") {
+          process.stdout.write(JSON.stringify({ type, timestamp: Date.now(), sessionID, ...data }) + EOL2);
+          return true;
+        }
+        return false;
+      }
+      const events = await sdk.event.subscribe();
+      let error;
+      async function loop() {
+        const toggles = /* @__PURE__ */ new Map();
+        for await (const event of events.stream) {
+          if (event.type === "message.updated" && event.properties.info.role === "assistant" && args.format !== "json" && toggles.get("start") !== true) {
+            UI.empty();
+            UI.println(`> ${event.properties.info.agent} \xB7 ${event.properties.info.modelID}`);
+            UI.empty();
+            toggles.set("start", true);
+          }
+          if (event.type === "message.part.updated") {
+            const part = event.properties.part;
+            if (part.sessionID !== sessionID) continue;
+            if (part.type === "tool" && (part.state.status === "completed" || part.state.status === "error")) {
+              if (emit("tool_use", { part })) continue;
+              if (part.state.status === "completed") {
+                tool(part);
+                continue;
+              }
+              inline({
+                icon: "\u2717",
+                title: `${part.tool} failed`
+              });
+              UI.error(part.state.error);
+            }
+            if (part.type === "tool" && part.tool === "task" && part.state.status === "running" && args.format !== "json") {
+              if (toggles.get(part.id) === true) continue;
+              task(props(part));
+              toggles.set(part.id, true);
+            }
+            if (part.type === "step-start") {
+              if (emit("step_start", { part })) continue;
+            }
+            if (part.type === "step-finish") {
+              if (emit("step_finish", { part })) continue;
+            }
+            if (part.type === "text" && part.time?.end) {
+              if (emit("text", { part })) continue;
+              const text = part.text.trim();
+              if (!text) continue;
+              if (!process.stdout.isTTY) {
+                process.stdout.write(text + EOL2);
+                continue;
+              }
+              UI.empty();
+              UI.println(text);
+              UI.empty();
+            }
+            if (part.type === "reasoning" && part.time?.end && args.thinking) {
+              if (emit("reasoning", { part })) continue;
+              const text = part.text.trim();
+              if (!text) continue;
+              const line = `Thinking: ${text}`;
+              if (process.stdout.isTTY) {
+                UI.empty();
+                UI.println(`${UI.Style.TEXT_DIM}\x1B[3m${line}\x1B[0m${UI.Style.TEXT_NORMAL}`);
+                UI.empty();
+                continue;
+              }
+              process.stdout.write(line + EOL2);
+            }
+          }
+          if (event.type === "session.error") {
+            const props2 = event.properties;
+            if (props2.sessionID !== sessionID || !props2.error) continue;
+            let err = String(props2.error.name);
+            if ("data" in props2.error && props2.error.data && "message" in props2.error.data) {
+              err = String(props2.error.data.message);
+            }
+            error = error ? error + EOL2 + err : err;
+            if (emit("error", { error: props2.error })) continue;
+            UI.error(err);
+          }
+          if (event.type === "session.status" && event.properties.sessionID === sessionID && event.properties.status.type === "idle") {
+            break;
+          }
+          if (event.type === "permission.asked") {
+            const permission = event.properties;
+            if (permission.sessionID !== sessionID) continue;
+            if (args["dangerously-skip-permissions"]) {
+              await sdk.permission.reply({
+                requestID: permission.id,
+                reply: "once"
+              });
+            } else {
+              UI.println(
+                UI.Style.TEXT_WARNING_BOLD + "!",
+                UI.Style.TEXT_NORMAL + `permission requested: ${permission.permission} (${permission.patterns.join(", ")}); auto-rejecting`
+              );
+              await sdk.permission.reply({
+                requestID: permission.id,
+                reply: "reject"
+              });
+            }
+          }
+        }
+      }
+      const agent = await (async () => {
+        if (!args.agent) return void 0;
+        if (args.attach) {
+          const modes = await sdk.app.agents(void 0, { throwOnError: true }).then((x) => x.data ?? []).catch(() => void 0);
+          if (!modes) {
+            UI.println(
+              UI.Style.TEXT_WARNING_BOLD + "!",
+              UI.Style.TEXT_NORMAL,
+              `failed to list agents from ${args.attach}. Falling back to default agent`
+            );
+            return void 0;
+          }
+          const agent2 = modes.find((a) => a.name === args.agent);
+          if (!agent2) {
+            UI.println(
+              UI.Style.TEXT_WARNING_BOLD + "!",
+              UI.Style.TEXT_NORMAL,
+              `agent "${args.agent}" not found. Falling back to default agent`
+            );
+            return void 0;
+          }
+          if (agent2.mode === "subagent") {
+            UI.println(
+              UI.Style.TEXT_WARNING_BOLD + "!",
+              UI.Style.TEXT_NORMAL,
+              `agent "${args.agent}" is a subagent, not a primary agent. Falling back to default agent`
+            );
+            return void 0;
+          }
+          return args.agent;
+        }
+        const entry = await Agent.get(args.agent);
+        if (!entry) {
+          UI.println(
+            UI.Style.TEXT_WARNING_BOLD + "!",
+            UI.Style.TEXT_NORMAL,
+            `agent "${args.agent}" not found. Falling back to default agent`
+          );
+          return void 0;
+        }
+        if (entry.mode === "subagent") {
+          UI.println(
+            UI.Style.TEXT_WARNING_BOLD + "!",
+            UI.Style.TEXT_NORMAL,
+            `agent "${args.agent}" is a subagent, not a primary agent. Falling back to default agent`
+          );
+          return void 0;
+        }
+        return args.agent;
+      })();
+      const sessionID = await session(sdk);
+      if (!sessionID) {
+        UI.error("Session not found");
+        process.exit(1);
+      }
+      await share(sdk, sessionID);
+      loop().catch((e) => {
+        console.error(e);
+        process.exit(1);
+      });
+      if (args.command) {
+        await sdk.session.command({
+          sessionID,
+          agent,
+          model: args.model,
+          command: args.command,
+          arguments: message,
+          variant: args.variant
+        });
+      } else {
+        const model = args.model ? Provider.parseModel(args.model) : void 0;
+        await sdk.session.prompt({
+          sessionID,
+          agent,
+          model,
+          variant: args.variant,
+          parts: [...files, { type: "text", text: message }]
+        });
+      }
+    }
+    if (args.attach) {
+      const headers = (() => {
+        const password = args.password ?? process.env.OPENCODE_SERVER_PASSWORD;
+        if (!password) return void 0;
+        const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode";
+        const auth = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+        return { Authorization: auth };
+      })();
+      const sdk = createOpencodeClient({ baseUrl: args.attach, directory, headers });
+      return await execute(sdk);
+    }
+    await bootstrap(process.cwd(), async () => {
+      const fetchFn = (async (input, init) => {
+        const request = new Request(input, init);
+        return Server.Default().fetch(request);
+      });
+      const sdk = createOpencodeClient({ baseUrl: "http://opencode.internal", fetch: fetchFn });
+      await execute(sdk);
+    });
+  }
+});
+export {
+  RunCommand
+};
+//# sourceMappingURL=run-YFVCQJQM.js.map