@hueyexe/opencode-ensemble 0.5.1 → 0.6.1

package/dist/index.js

@@ -12334,8 +12334,2960 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
+// node_modules/@opencode-ai/sdk/dist/v2/gen/core/serverSentEvents.gen.js
+var createSseClient = ({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url: url2, ...options }) => {
+  let lastEventId;
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3000;
+    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 !== undefined) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url2, requestInit);
+        if (onRequest) {
+          request = await onRequest(url2, 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, `
+`).replace(/\r/g, `
+`);
+            const chunks = buffer.split(`
+
+`);
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split(`
+`);
+              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(`
+`);
+                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 (error45) {
+        onSseError?.(error45);
+        if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 30000);
+        await sleep(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+};
+
+// node_modules/@opencode-ai/sdk/dist/v2/gen/core/pathSerializer.gen.js
+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 === undefined || 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;
+};
+
+// node_modules/@opencode-ai/sdk/dist/v2/gen/core/utils.gen.js
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var defaultPathSerializer = ({ path, url: _url2 }) => {
+  let url2 = _url2;
+  const matches = _url2.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 = path[name];
+      if (value === undefined || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url2 = url2.replace(match, serializeArrayParam({ explode, name, style, value }));
+        continue;
+      }
+      if (typeof value === "object") {
+        url2 = url2.replace(match, serializeObjectParam({
+          explode,
+          name,
+          style,
+          value,
+          valueOnly: true
+        }));
+        continue;
+      }
+      if (style === "matrix") {
+        url2 = url2.replace(match, `;${serializePrimitiveParam({
+          name,
+          value
+        })}`);
+        continue;
+      }
+      const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+      url2 = url2.replace(match, replaceValue);
+    }
+  }
+  return url2;
+};
+var getUrl = ({ baseUrl, path, query, querySerializer, url: _url2 }) => {
+  const pathUrl = _url2.startsWith("/") ? _url2 : `/${_url2}`;
+  let url2 = (baseUrl ?? "") + pathUrl;
+  if (path) {
+    url2 = defaultPathSerializer({ path, url: url2 });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url2 += `?${search}`;
+  }
+  return url2;
+};
+function getValidRequestBody(options) {
+  const hasBody = options.body !== undefined;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== undefined && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return;
+}
+
+// node_modules/@opencode-ai/sdk/dist/v2/gen/core/auth.gen.js
+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;
+};
+
+// node_modules/@opencode-ai/sdk/dist/v2/gen/core/bodySerializer.gen.js
+var jsonBodySerializer = {
+  bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
+};
+
+// node_modules/@opencode-ai/sdk/dist/v2/gen/client/utils.gen.js
+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 === undefined || 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 config2 = { ...a, ...b };
+  if (config2.baseUrl?.endsWith("/")) {
+    config2.baseUrl = config2.baseUrl.substring(0, config2.baseUrl.length - 1);
+  }
+  config2.headers = mergeHeaders(a.headers, b.headers);
+  return config2;
+};
+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 !== undefined) {
+        mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+      }
+    }
+  }
+  return mergedHeaders;
+};
+
+class Interceptors {
+  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
+});
+
+// node_modules/@opencode-ai/sdk/dist/v2/gen/client/client.gen.js
+var createClient = (config2 = {}) => {
+  let _config = mergeConfigs(createConfig(), config2);
+  const getConfig = () => ({ ..._config });
+  const setConfig = (config3) => {
+    _config = mergeConfigs(_config, config3);
+    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: undefined
+    };
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security
+      });
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body !== undefined && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.body === undefined || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const url2 = buildUrl(opts);
+    return { opts, url: url2 };
+  };
+  const request = async (options) => {
+    const { opts, url: url2 } = await beforeRequest(options);
+    const requestInit = {
+      redirect: "follow",
+      ...opts,
+      body: getValidRequestBody(opts)
+    };
+    let request2 = new Request(url2, 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 (error46) {
+      let finalError2 = error46;
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError2 = await fn(error46, undefined, request2, opts);
+        }
+      }
+      finalError2 = finalError2 || {};
+      if (opts.throwOnError) {
+        throw finalError2;
+      }
+      return opts.responseStyle === "data" ? undefined : {
+        error: finalError2,
+        request: request2,
+        response: undefined
+      };
+    }
+    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 error45 = jsonError ?? textError;
+    let finalError = error45;
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = await fn(error45, response, request2, opts);
+      }
+    }
+    finalError = finalError || {};
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+    return opts.responseStyle === "data" ? undefined : {
+      error: finalError,
+      ...result
+    };
+  };
+  const makeMethodFn = (method) => (options) => request({ ...options, method });
+  const makeSseFn = (method) => async (options) => {
+    const { opts, url: url2 } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      headers: opts.headers,
+      method,
+      onRequest: async (url3, init) => {
+        let request2 = new Request(url3, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request2 = await fn(request2, opts);
+          }
+        }
+        return request2;
+      },
+      serializedBody: getValidRequestBody(opts),
+      url: url2
+    });
+  };
+  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")
+  };
+};
+// node_modules/@opencode-ai/sdk/dist/v2/gen/core/params.gen.js
+var extraPrefixesMap = {
+  $body_: "body",
+  $headers_: "headers",
+  $path_: "path",
+  $query_: "query"
+};
+var extraPrefixes = Object.entries(extraPrefixesMap);
+var buildKeyMap = (fields, map2) => {
+  if (!map2) {
+    map2 = new Map;
+  }
+  for (const config2 of fields) {
+    if ("in" in config2) {
+      if (config2.key) {
+        map2.set(config2.key, {
+          in: config2.in,
+          map: config2.map
+        });
+      }
+    } else if ("key" in config2) {
+      map2.set(config2.key, {
+        map: config2.map
+      });
+    } else if (config2.args) {
+      buildKeyMap(config2.args, map2);
+    }
+  }
+  return map2;
+};
+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 map2 = buildKeyMap(fields);
+  let config2;
+  for (const [index, arg] of args.entries()) {
+    if (fields[index]) {
+      config2 = fields[index];
+    }
+    if (!config2) {
+      continue;
+    }
+    if ("in" in config2) {
+      if (config2.key) {
+        const field = map2.get(config2.key);
+        const name = field.map || config2.key;
+        if (field.in) {
+          params[field.in][name] = arg;
+        }
+      } else {
+        params.body = arg;
+      }
+    } else {
+      for (const [key, value] of Object.entries(arg ?? {})) {
+        const field = map2.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 config2 && config2.allowExtra) {
+            for (const [slot, allowed] of Object.entries(config2.allowExtra)) {
+              if (allowed) {
+                params[slot][key] = value;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  stripEmptySlots(params);
+  return params;
+};
+// node_modules/@opencode-ai/sdk/dist/v2/gen/client.gen.js
+var client = createClient(createConfig({ baseUrl: "http://localhost:4096" }));
+
+// node_modules/@opencode-ai/sdk/dist/v2/gen/sdk.gen.js
+class HeyApiClient {
+  client;
+  constructor(args) {
+    this.client = args?.client ?? client;
+  }
+}
+
+class HeyApiRegistry {
+  defaultKey = "default";
+  instances = 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);
+  }
+}
+
+class Config extends HeyApiClient {
+  get(options) {
+    return (options?.client ?? this.client).get({
+      url: "/global/config",
+      ...options
+    });
+  }
+  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
+      }
+    });
+  }
+}
+
+class Global extends HeyApiClient {
+  health(options) {
+    return (options?.client ?? this.client).get({
+      url: "/global/health",
+      ...options
+    });
+  }
+  event(options) {
+    return (options?.client ?? this.client).sse.get({
+      url: "/global/event",
+      ...options
+    });
+  }
+  dispose(options) {
+    return (options?.client ?? this.client).post({
+      url: "/global/dispose",
+      ...options
+    });
+  }
+  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
+      }
+    });
+  }
+  _config;
+  get config() {
+    return this._config ??= new Config({ client: this.client });
+  }
+}
+
+class Auth extends HeyApiClient {
+  remove(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "providerID" }] }]);
+    return (options?.client ?? this.client).delete({
+      url: "/auth/{providerID}",
+      ...options,
+      ...params
+    });
+  }
+  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
+      }
+    });
+  }
+}
+
+class Project extends HeyApiClient {
+  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
+    });
+  }
+  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
+    });
+  }
+  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(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
+      }
+    });
+  }
+}
+
+class Pty extends HeyApiClient {
+  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(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(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(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(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(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
+    });
+  }
+}
+
+class Config2 extends HeyApiClient {
+  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(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
+      }
+    });
+  }
+  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
+    });
+  }
+}
+
+class Tool extends HeyApiClient {
+  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(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
+    });
+  }
+}
+
+class Workspace extends HeyApiClient {
+  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(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(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
+    });
+  }
+}
+
+class Session extends HeyApiClient {
+  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
+    });
+  }
+}
+
+class Resource extends HeyApiClient {
+  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
+    });
+  }
+}
+
+class Experimental extends HeyApiClient {
+  _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 });
+  }
+}
+
+class Worktree extends HeyApiClient {
+  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(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(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(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
+      }
+    });
+  }
+}
+
+class Session2 extends HeyApiClient {
+  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(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
+      }
+    });
+  }
+  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(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(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(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
+      }
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+  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(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(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(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(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
+    });
+  }
+  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(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
+      }
+    });
+  }
+  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
+    });
+  }
+  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
+      }
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+  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
+      }
+    });
+  }
+  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
+      }
+    });
+  }
+  shell(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { 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(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
+      }
+    });
+  }
+  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
+    });
+  }
+}
+
+class Part extends HeyApiClient {
+  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(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
+      }
+    });
+  }
+}
+
+class Permission extends HeyApiClient {
+  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
+      }
+    });
+  }
+  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(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
+    });
+  }
+}
+
+class Question extends HeyApiClient {
+  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(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(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
+    });
+  }
+}
+
+class Oauth extends HeyApiClient {
+  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
+      }
+    });
+  }
+  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
+      }
+    });
+  }
+}
+
+class Provider extends HeyApiClient {
+  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
+    });
+  }
+  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 });
+  }
+}
+
+class Find extends HeyApiClient {
+  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
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+}
+
+class File2 extends HeyApiClient {
+  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(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
+    });
+  }
+  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
+    });
+  }
+}
+
+class Event extends HeyApiClient {
+  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
+    });
+  }
+}
+
+class Auth2 extends HeyApiClient {
+  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(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
+    });
+  }
+  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(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
+    });
+  }
+}
+
+class Mcp extends HeyApiClient {
+  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(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(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(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 });
+  }
+}
+
+class Control extends HeyApiClient {
+  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
+    });
+  }
+  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
+      }
+    });
+  }
+}
+
+class Tui extends HeyApiClient {
+  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
+      }
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+  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
+      }
+    });
+  }
+  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(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
+      }
+    });
+  }
+  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 });
+  }
+}
+
+class Instance extends HeyApiClient {
+  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
+    });
+  }
+}
+
+class Path extends HeyApiClient {
+  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
+    });
+  }
+}
+
+class Vcs extends HeyApiClient {
+  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
+    });
+  }
+}
+
+class Command extends HeyApiClient {
+  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
+    });
+  }
+}
+
+class App extends HeyApiClient {
+  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
+      }
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+}
+
+class Lsp extends HeyApiClient {
+  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
+    });
+  }
+}
+
+class Formatter extends HeyApiClient {
+  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
+    });
+  }
+}
+
+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 });
+  }
+  _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 });
+  }
+  _tool;
+  get tool() {
+    return this._tool ??= new Tool({ client: this.client });
+  }
+  _experimental;
+  get experimental() {
+    return this._experimental ??= new Experimental({ 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 Provider({ client: this.client });
+  }
+  _find;
+  get find() {
+    return this._find ??= new Find({ client: this.client });
+  }
+  _file;
+  get file() {
+    return this._file ??= new File2({ 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 Instance({ 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 });
+  }
+  _app;
+  get app() {
+    return this._app ??= new App({ 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 });
+  }
+}
 // src/index.ts
-import path3 from "path";
+import path2 from "path";
 import { mkdirSync } from "fs";
 
 // src/db.ts
@@ -12413,7 +15365,8 @@ var MIGRATIONS = [
   `ALTER TABLE team_member ADD COLUMN worktree_dir TEXT;
    ALTER TABLE team_member ADD COLUMN worktree_branch TEXT;`,
   `ALTER TABLE team_member ADD COLUMN plan_approval TEXT NOT NULL DEFAULT 'none'
-     CHECK(plan_approval IN ('none', 'pending', 'approved', 'rejected'));`
+     CHECK(plan_approval IN ('none', 'pending', 'approved', 'rejected'));`,
+  `ALTER TABLE team ADD COLUMN lead_agent TEXT;`
 ];
 function applyMigrations(db) {
   const { user_version: current } = db.query("PRAGMA user_version").get();
@@ -12438,6 +15391,43 @@ function createDb(path2) {
   return db;
 }
 
+// src/client.ts
+function extractError(err) {
+  if (err && typeof err === "object" && "message" in err)
+    return String(err.message);
+  return String(err);
+}
+function throwing(fn) {
+  return async (...args) => {
+    const result = await fn(...args);
+    if (result && typeof result === "object" && "error" in result && result.error !== undefined) {
+      throw new Error(extractError(result.error));
+    }
+    return result;
+  };
+}
+function wrapThrowingClient(raw) {
+  const r = raw;
+  return {
+    session: {
+      create: throwing(r.session.create.bind(r.session)),
+      promptAsync: throwing(r.session.promptAsync.bind(r.session)),
+      abort: throwing(r.session.abort.bind(r.session)),
+      status: throwing(r.session.status.bind(r.session))
+    },
+    tui: {
+      showToast: throwing(r.tui.showToast.bind(r.tui)),
+      selectSession: throwing(r.tui.selectSession.bind(r.tui))
+    },
+    worktree: {
+      create: throwing(r.worktree.create.bind(r.worktree)),
+      remove: throwing(r.worktree.remove.bind(r.worktree)),
+      list: throwing(r.worktree.list.bind(r.worktree)),
+      reset: throwing(r.worktree.reset.bind(r.worktree))
+    }
+  };
+}
+
 // src/util.ts
 var NAME_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
 var counter = 0;
@@ -12490,26 +15480,26 @@ function markDelivered(db, messageId) {
 }
 
 // src/recovery.ts
-async function recoverStaleMembers(db, client) {
+async function recoverStaleMembers(db, client3) {
   const stale = db.query(`SELECT tm.session_id FROM team_member tm
      JOIN team t ON tm.team_id = t.id
      WHERE tm.status = 'busy' AND t.status = 'active'`).all();
   const result = db.run(`UPDATE team_member SET status = 'error', execution_status = 'idle', time_updated = ?
      WHERE status = 'busy'
        AND team_id IN (SELECT id FROM team WHERE status = 'active')`, [Date.now()]);
-  if (client) {
+  if (client3) {
     for (const member of stale) {
       try {
-        await client.session.abort({ path: { id: member.session_id } });
+        await client3.session.abort({ sessionID: member.session_id });
       } catch {}
     }
   }
   return { interrupted: result.changes };
 }
-async function recoverOrphanedWorktrees(db, client) {
+async function recoverOrphanedWorktrees(db, client3) {
   let removed = 0;
   try {
-    const worktrees = await client.worktree.list();
+    const worktrees = await client3.worktree.list();
     if (!worktrees.data)
       return { removed: 0 };
     const activeWorktrees = new Set(db.query(`SELECT tm.worktree_dir FROM team_member tm
@@ -12521,14 +15511,14 @@ async function recoverOrphanedWorktrees(db, client) {
       if (activeWorktrees.has(wt.directory))
         continue;
       try {
-        await client.worktree.remove({ worktreeRemoveInput: { directory: wt.directory } });
+        await client3.worktree.remove({ worktreeRemoveInput: { directory: wt.directory } });
         removed++;
       } catch {}
     }
   } catch {}
   return { removed };
 }
-async function recoverUndeliveredMessages(db, client, registry2) {
+async function recoverUndeliveredMessages(db, client3, registry2) {
   const teams = db.query("SELECT id, lead_session_id FROM team WHERE status = 'active'").all();
   let redelivered = 0;
   for (const team of teams) {
@@ -12546,9 +15536,9 @@ async function recoverUndeliveredMessages(db, client, registry2) {
       if (!recipientSessionId)
         continue;
       try {
-        await client.session.promptAsync({
-          path: { id: recipientSessionId },
-          body: { parts: [{ type: "text", text: `[Recovered team message from ${msg.from_name}]: ${msg.content}` }] }
+        await client3.session.promptAsync({
+          sessionID: recipientSessionId,
+          parts: [{ type: "text", text: `[Recovered team message from ${msg.from_name}]: ${msg.content}` }]
         });
         markDelivered(db, msg.id);
         redelivered++;
@@ -12697,10 +15687,10 @@ function formatMessage(type, data) {
       return `${data.memberName} shut down`;
   }
 }
-async function notifyTeamEvent(client, type, data) {
+async function notifyTeamEvent(client3, type, data) {
   const config2 = TOAST_CONFIG[type];
   try {
-    await client.tui.showToast({
+    await client3.tui.showToast({
       title: "Team",
       message: formatMessage(type, data),
       variant: config2.variant,
@@ -12708,14 +15698,14 @@ async function notifyTeamEvent(client, type, data) {
     });
   } catch {}
 }
-async function notifyWorkingProgress(client, db, teamId) {
+async function notifyWorkingProgress(client3, db, teamId) {
   const members = db.query("SELECT name, status FROM team_member WHERE team_id = ? ORDER BY time_created ASC").all(teamId);
   if (members.length === 0)
     return;
   const busy = members.filter((m) => m.status === "busy");
   try {
     if (busy.length === 0) {
-      await client.tui.showToast({
+      await client3.tui.showToast({
         title: "Team",
         message: "All teammates finished",
         variant: "success",
@@ -12723,7 +15713,7 @@ async function notifyWorkingProgress(client, db, teamId) {
       });
     } else {
       const names = busy.map((m) => m.name).join(", ");
-      await client.tui.showToast({
+      await client3.tui.showToast({
         title: "Team",
         message: `Working: ${names} (${busy.length}/${members.length})`,
         variant: "info",
@@ -12763,6 +15753,8 @@ function buildLeadSystemPrompt(db, teamId) {
     "",
     "Teammates work asynchronously and message you when done.",
     "Do NOT poll team_status or team_tasks_list repeatedly \u2014 wait for messages.",
+    "Spawn teammates ONE at a time \u2014 do not send multiple team_spawn calls in a single response.",
+    "After each team_spawn, verify the output confirms the spawn succeeded before spawning the next.",
     "After spawning teammates, tell the user what you've set up and wait.",
     "When all teammates finish, summarize results and suggest next steps."
   ].join(`
@@ -12838,7 +15830,6 @@ async function executeTeamCreate(deps, args, sessionId) {
 }
 
 // src/tools/team-spawn.ts
-import path2 from "path";
 async function executeTeamSpawn(deps, args, sessionId) {
   const nameError = validateMemberName(args.name);
   if (nameError)
@@ -12858,7 +15849,7 @@ async function executeTeamSpawn(deps, args, sessionId) {
   if (useWorktree) {
     const worktreeName = `ensemble-${teamInfo.teamName}-${args.name}`;
     try {
-      const result = await deps.client.worktree.create({ name: worktreeName });
+      const result = await deps.client.worktree.create({ worktreeCreateInput: { name: worktreeName } });
       if (result.data) {
         worktreeDir = result.data.directory;
         worktreeBranch = result.data.branch;
@@ -12874,15 +15865,21 @@ async function executeTeamSpawn(deps, args, sessionId) {
       } catch {}
     }
   }
-  const createOpts = {
-    body: { parentID: sessionId, title: `${args.name} (@${args.agent} teammate)` }
-  };
-  if (worktreeDir) {
-    createOpts.directory = worktreeDir;
-  }
+  const isReadOnly = args.agent === "plan" || args.agent === "explore";
+  const TEAM_TOOLS = ["team_message", "team_broadcast", "team_tasks_list", "team_tasks_add", "team_tasks_complete", "team_claim"];
+  const permission = isReadOnly ? [
+    { permission: "edit", pattern: "*", action: "deny" },
+    { permission: "bash", pattern: "*", action: "deny" },
+    ...TEAM_TOOLS.map((t) => ({ permission: t, pattern: "*", action: "allow" }))
+  ] : undefined;
   let childSessionId;
   try {
-    const createResult = await deps.client.session.create(createOpts);
+    const createResult = await deps.client.session.create({
+      parentID: sessionId,
+      title: `${args.name} (@${args.agent} teammate)`,
+      ...permission ? { permission } : {},
+      ...worktreeDir ? { directory: worktreeDir } : {}
+    });
     childSessionId = createResult.data?.id;
   } catch (err) {
     if (worktreeDir) {
@@ -12916,16 +15913,6 @@ async function executeTeamSpawn(deps, args, sessionId) {
     context.push("", "IMPORTANT: You are in PLAN MODE.", "Read and explore the codebase, then send your implementation plan to the lead via team_message.", "Do NOT write or modify any files until the lead approves your plan.", "Wait for the lead's approval message before proceeding with implementation.");
   }
   context.push("", "Tools available to you:", "- team_message: send a message to the lead or another teammate", "- team_broadcast: send a message to all team members", "- team_tasks_list: view the shared team task board", "- team_tasks_add: add tasks to the shared board", "- team_tasks_complete: mark a task complete on the shared board", "- team_claim: claim a pending task from the shared board", "", "When you finish your task:", "1. If you claimed a task, mark it complete using team_tasks_complete.", "2. Send ONE message to the lead with your findings using team_message.", "3. STOP. Do not send follow-up confirmations, status updates, or 'standing by' messages.", "", "If you are blocked, send ONE message to the lead describing the specific blocker.", "", "Your plain text output is NOT visible to the team. You MUST use team_message to communicate.");
-  try {
-    const agentsPath = path2.join(deps.directory, "AGENTS.md");
-    const file2 = Bun.file(agentsPath);
-    if (await file2.exists()) {
-      const content = await file2.text();
-      const truncated = content.length > 2000 ? content.slice(0, 2000) + `
-...(truncated)` : content;
-      context.push("", "Project guidelines (from AGENTS.md):", truncated);
-    }
-  } catch {}
   context.push("", "Your task:", args.prompt);
   if (args.claim_task) {
     context.push("", `You have been assigned task ${args.claim_task}. Mark it complete when done.`);
@@ -12934,14 +15921,15 @@ async function executeTeamSpawn(deps, args, sessionId) {
 `);
   try {
     await deps.client.session.promptAsync({
-      path: { id: childSessionId },
-      body: { parts: [{ type: "text", text: contextStr }] }
+      sessionID: childSessionId,
+      parts: [{ type: "text", text: contextStr }],
+      agent: args.agent
     });
   } catch (err) {
     deps.db.run("DELETE FROM team_member WHERE team_id = ? AND name = ?", [teamInfo.teamId, args.name]);
     deps.registry.unregister(childSessionId);
     try {
-      await deps.client.session.abort({ path: { id: childSessionId } });
+      await deps.client.session.abort({ sessionID: childSessionId });
     } catch {}
     if (worktreeDir) {
       try {
@@ -13000,8 +15988,8 @@ async function executeTeamMessage(deps, args, sessionId) {
     deliveryText = `[Team message from ${senderName}]: ${messageText}`;
   }
   await deps.client.session.promptAsync({
-    path: { id: recipientSessionId },
-    body: { parts: [{ type: "text", text: deliveryText }] }
+    sessionID: recipientSessionId,
+    parts: [{ type: "text", text: deliveryText }]
   });
   markDelivered(deps.db, msgId);
   return `Message sent to ${args.to}.`;
@@ -13034,8 +16022,8 @@ async function executeTeamBroadcast(deps, args, sessionId) {
   for (const recipient of recipients) {
     try {
       await deps.client.session.promptAsync({
-        path: { id: recipient.sessionId },
-        body: { parts: [{ type: "text", text: `[Team broadcast from ${senderName}]: ${args.text}` }] }
+        sessionID: recipient.sessionId,
+        parts: [{ type: "text", text: `[Team broadcast from ${senderName}]: ${args.text}` }]
       });
       delivered++;
     } catch {}
@@ -13077,13 +16065,11 @@ async function executeTeamShutdown(deps, args, sessionId) {
   }
   try {
     await deps.client.session.promptAsync({
-      path: { id: member.session_id },
-      body: {
-        parts: [{
-          type: "text",
-          text: `[Shutdown requested]: The lead has requested you shut down. Finish your current task, send your final findings to the lead via team_message, then stop.`
-        }]
-      }
+      sessionID: member.session_id,
+      parts: [{
+        type: "text",
+        text: `[Shutdown requested]: The lead has requested you shut down. Finish your current task, send your final findings to the lead via team_message, then stop.`
+      }]
     });
   } catch {}
   deps.db.run("UPDATE team_member SET status = 'shutdown_requested', time_updated = ? WHERE team_id = ? AND name = ?", [Date.now(), teamInfo.teamId, args.member]);
@@ -13091,7 +16077,7 @@ async function executeTeamShutdown(deps, args, sessionId) {
 }
 async function abortAndShutdown(deps, teamId, memberName, sessionId) {
   try {
-    await deps.client.session.abort({ path: { id: sessionId } });
+    await deps.client.session.abort({ sessionID: sessionId });
   } catch {}
   deps.db.run("UPDATE team_member SET status = 'shutdown', execution_status = 'idle', time_updated = ? WHERE team_id = ? AND name = ?", [Date.now(), teamId, memberName]);
 }
@@ -13112,7 +16098,7 @@ async function executeTeamCleanup(deps, args, sessionId) {
   if (args.force) {
     for (const member of active) {
       try {
-        await deps.client.session.abort({ path: { id: member.session_id } });
+        await deps.client.session.abort({ sessionID: member.session_id });
       } catch {}
     }
   }
@@ -13417,7 +16403,7 @@ class Watchdog {
     for (const member of stale) {
       this.db.run("UPDATE team_member SET status = 'error', execution_status = 'timed_out', time_updated = ? WHERE team_id = ? AND name = ?", [Date.now(), member.team_id, member.name]);
       try {
-        await this.client.session.abort({ path: { id: member.session_id } });
+        await this.client.session.abort({ sessionID: member.session_id });
       } catch {}
       try {
         await this.client.tui.showToast({
@@ -13455,21 +16441,22 @@ var DEFAULT_WATCHDOG_TTL_MS = 30 * 60 * 1000;
 var DEFAULT_WATCHDOG_CHECK_MS = 60 * 1000;
 var plugin = async (input) => {
   const dbPath = getDbPath();
-  mkdirSync(path3.dirname(dbPath), { recursive: true });
+  mkdirSync(path2.dirname(dbPath), { recursive: true });
   const db = createDb(dbPath);
   const registry2 = new MemberRegistry;
   const tracker = new DescendantTracker;
-  const client = input.client;
-  const deps = { db, registry: registry2, tracker, client, directory: input.directory };
-  const recovery = await recoverStaleMembers(db, client);
+  const rawClient = new OpencodeClient({ client: input.client._client });
+  const client3 = wrapThrowingClient(rawClient);
+  const deps = { db, registry: registry2, tracker, client: client3, directory: input.directory };
+  const recovery = await recoverStaleMembers(db, client3);
   if (recovery.interrupted > 0) {
     const members = db.query("SELECT tm.team_id, tm.name, tm.session_id FROM team_member tm JOIN team t ON tm.team_id = t.id WHERE t.status = 'active'").all();
     for (const m of members) {
       registry2.register(m.team_id, m.name, m.session_id);
     }
   }
-  recoverUndeliveredMessages(db, client, registry2).catch(() => {});
-  recoverOrphanedWorktrees(db, client).catch(() => {});
+  recoverUndeliveredMessages(db, client3, registry2).catch(() => {});
+  recoverOrphanedWorktrees(db, client3).catch(() => {});
   const rateLimitEnv = process.env.OPENCODE_ENSEMBLE_RATE_LIMIT;
   const rateLimitCapacity = rateLimitEnv === "0" ? 0 : parseInt(rateLimitEnv ?? "", 10) || DEFAULT_RATE_LIMIT_CAPACITY;
   const rateLimiter = new TokenBucket({
@@ -13481,7 +16468,7 @@ var plugin = async (input) => {
   const watchdogTtl = timeoutEnv === "0" ? 0 : parseInt(timeoutEnv ?? "", 10) || DEFAULT_WATCHDOG_TTL_MS;
   const watchdog = new Watchdog({
     db,
-    client,
+    client: client3,
     registry: registry2,
     ttlMs: watchdogTtl,
     checkIntervalMs: DEFAULT_WATCHDOG_CHECK_MS
@@ -13495,14 +16482,14 @@ var plugin = async (input) => {
         const transition = handleSessionStatusEvent(db, registry2, sessionID, statusType);
         if (transition) {
           if (transition.to === "shutdown") {
-            notifyTeamEvent(client, "shutdown", { memberName: transition.memberName });
+            notifyTeamEvent(client3, "shutdown", { memberName: transition.memberName });
           } else if (transition.to === "ready" && transition.from === "busy") {
-            notifyTeamEvent(client, "completed", { memberName: transition.memberName });
+            notifyTeamEvent(client3, "completed", { memberName: transition.memberName });
           } else if (transition.to === "error") {
-            notifyTeamEvent(client, "error", { memberName: transition.memberName });
+            notifyTeamEvent(client3, "error", { memberName: transition.memberName });
           } else if (transition.to === "retry") {
             try {
-              await client.tui.showToast({
+              await client3.tui.showToast({
                 title: "Team",
                 message: `${transition.memberName} is being rate-limited`,
                 variant: "warning",
@@ -13513,11 +16500,11 @@ var plugin = async (input) => {
             const entry = registry2.getBySession(sessionID);
             if (entry) {
               try {
-                await client.session.abort({ path: { id: sessionID } });
+                await client3.session.abort({ sessionID });
               } catch {}
             }
           }
-          await notifyWorkingProgress(client, db, transition.teamId);
+          await notifyWorkingProgress(client3, db, transition.teamId);
         }
       }
       if (event.type === "session.created") {