backeer-opencode 0.3.2 → 0.4.0

package/dist/backeer-permission.js

@@ -1,3 +1,1859 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/@opencode/client/dist/chunks/service-timing-9rqn6x4v.js
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __defProp2, __returnValue, __export2;
+var init_service_timing_9rqn6x4v = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-9rqn6x4v.js"() {
+    __defProp2 = Object.defineProperty;
+    __returnValue = (v) => v;
+    __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, {
+          get: all[name],
+          enumerable: true,
+          configurable: true,
+          set: __exportSetter.bind(all, name)
+        });
+    };
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-frbwqjmf.js
+function make7(connect) {
+  let current;
+  const capacity = 4096;
+  function stop2(connection) {
+    connection.connected = void 0;
+    connection.controller.abort();
+    if (current === connection)
+      current = void 0;
+  }
+  async function run(connection) {
+    let iterator;
+    let completion = {};
+    try {
+      if (connection.controller.signal.aborted)
+        return;
+      iterator = connect(connection.controller.signal, () => {
+        connection.subscribers.forEach((subscriber) => subscriber.activity?.());
+      })[Symbol.asyncIterator]();
+      while (!connection.controller.signal.aborted) {
+        const item = await iterator.next();
+        if (item.done || connection.controller.signal.aborted)
+          break;
+        if (item.value.type === "server.connected")
+          connection.connected = item.value;
+        connection.subscribers.forEach((subscriber) => subscriber.push(item.value));
+      }
+    } catch (error) {
+      completion = { error };
+    } finally {
+      stop2(connection);
+      try {
+        await iterator?.return?.();
+      } catch (error) {
+        if (!("error" in completion))
+          completion = { error };
+      }
+      connection.subscribers.forEach((subscriber) => subscriber.finish(completion));
+    }
+  }
+  return {
+    subscribe(options) {
+      return {
+        [Symbol.asyncIterator]() {
+          const pending = [];
+          const queued = [];
+          let started = false;
+          let completion;
+          let connection;
+          function finish(result, discard = true) {
+            completion = result;
+            if (discard)
+              queued.length = 0;
+            options?.signal?.removeEventListener("abort", abort);
+            if (connection?.subscribers.delete(subscriber) && !connection.subscribers.size)
+              stop2(connection);
+            pending.splice(0).forEach((request) => {
+              if ("error" in result)
+                request.reject(result.error);
+              else
+                request.resolve({ done: true, value: void 0 });
+            });
+          }
+          function abort() {
+            finish({});
+          }
+          const subscriber = {
+            activity: options?.onActivity,
+            finish(result) {
+              finish(result, false);
+            },
+            push(value) {
+              if (completion)
+                return;
+              const request = pending.shift();
+              if (request) {
+                request.resolve({ done: false, value });
+                return;
+              }
+              if (queued.length === capacity) {
+                finish({ error: new Error(`Event subscriber exceeded its ${capacity}-event capacity`) });
+                return;
+              }
+              queued.push(value);
+            }
+          };
+          function start() {
+            if (completion)
+              return;
+            const fresh = !current;
+            connection = current ?? {
+              controller: new AbortController(),
+              subscribers: /* @__PURE__ */ new Set()
+            };
+            current = connection;
+            connection.subscribers.add(subscriber);
+            if (connection.connected)
+              subscriber.push(connection.connected);
+            if (fresh)
+              run(connection);
+          }
+          return {
+            next() {
+              const value = queued.shift();
+              if (value)
+                return Promise.resolve({ done: false, value });
+              if (completion) {
+                if ("error" in completion)
+                  return Promise.reject(completion.error);
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              if (options?.signal?.aborted) {
+                abort();
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              const request = Promise.withResolvers();
+              pending.push(request);
+              if (!started) {
+                started = true;
+                options?.signal?.addEventListener("abort", abort, { once: true });
+                start();
+              }
+              return request.promise;
+            },
+            return() {
+              finish({});
+              return Promise.resolve({ done: true, value: void 0 });
+            }
+          };
+        }
+      };
+    }
+  };
+}
+var exports_shared_events;
+var init_service_timing_frbwqjmf = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-frbwqjmf.js"() {
+    init_service_timing_9rqn6x4v();
+    exports_shared_events = {};
+    __export2(exports_shared_events, {
+      SharedEvents: () => exports_shared_events,
+      make: () => make7
+    });
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-js54wxgp.js
+var ClientError2;
+var init_service_timing_js54wxgp = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-js54wxgp.js"() {
+    ClientError2 = class extends Error {
+      reason;
+      name = "ClientError";
+      constructor(reason, options) {
+        const detail = options?.detail ?? (options?.cause instanceof Error ? options.cause.message : void 0);
+        super(detail ? `${reason}: ${detail}` : reason, options);
+        this.reason = reason;
+      }
+    };
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-tbh3h57v.js
+function make3(options) {
+  const fetch2 = options.fetch ?? globalThis.fetch;
+  const prepare = (descriptor, requestOptions) => {
+    const baseUrl = new URL(options.baseUrl);
+    if (!baseUrl.pathname.endsWith("/"))
+      baseUrl.pathname += "/";
+    const url = new URL(descriptor.path.slice(1), baseUrl);
+    for (const [key, value] of Object.entries(descriptor.query ?? {}))
+      appendQuery(url.searchParams, key, value);
+    const headers = new Headers(options.headers);
+    for (const [key, value] of Object.entries(descriptor.headers ?? {})) {
+      if (value !== void 0 && value !== null)
+        headers.set(key, String(value));
+    }
+    for (const [key, value] of new Headers(requestOptions?.headers))
+      headers.set(key, value);
+    if (descriptor.body !== void 0 && !headers.has("content-type"))
+      headers.set("content-type", descriptor.binaryBody ? "application/octet-stream" : "application/json");
+    return {
+      url,
+      init: {
+        method: descriptor.method,
+        signal: requestOptions?.signal,
+        headers,
+        body: descriptor.body === void 0 ? void 0 : descriptor.binaryBody ? descriptor.body : JSON.stringify(descriptor.body)
+      }
+    };
+  };
+  const execute = async (descriptor, requestOptions) => {
+    try {
+      const prepared = prepare(descriptor, requestOptions);
+      return await fetch2(prepared.url, prepared.init);
+    } catch (cause) {
+      throw new ClientError2("Transport", { cause });
+    }
+  };
+  const responseError = async (response, descriptor) => {
+    if (descriptor.declaredStatuses.includes(response.status))
+      throw declared(await json(response));
+    try {
+      await response.body?.cancel();
+    } catch {
+    }
+    throw new ClientError2("UnexpectedStatus", { cause: { status: response.status }, detail: String(response.status) });
+  };
+  const request = async (descriptor, requestOptions) => {
+    const response = await execute(descriptor, requestOptions);
+    if (response.status !== descriptor.successStatus)
+      return responseError(response, descriptor);
+    if (descriptor.binary)
+      return new Uint8Array(await response.arrayBuffer());
+    if (descriptor.empty) {
+      try {
+        await response.body?.cancel();
+      } catch {
+      }
+      return;
+    }
+    return await json(response);
+  };
+  const sse = (descriptor, requestOptions) => ({
+    async *[Symbol.asyncIterator]() {
+      const response = await execute(descriptor, requestOptions);
+      if (response.status !== descriptor.successStatus)
+        await responseError(response, descriptor);
+      if (!isContentType(response, "text/event-stream")) {
+        try {
+          await response.body?.cancel();
+        } catch {
+        }
+        throw new ClientError2("UnsupportedContentType", { detail: response.headers.get("content-type") });
+      }
+      if (response.body === null)
+        throw new ClientError2("MalformedResponse");
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          let next;
+          try {
+            next = await reader.read();
+          } catch (cause) {
+            throw new ClientError2("Transport", { cause });
+          }
+          if (!next.done)
+            requestOptions?.onActivity?.();
+          buffer += decoder.decode(next.value, { stream: !next.done });
+          if (buffer.length > maxSseEventBytes)
+            throw new ClientError2("SseEventTooLarge");
+          const trailingCarriageReturn = !next.done && buffer.endsWith("\r");
+          if (trailingCarriageReturn)
+            buffer = buffer.slice(0, -1);
+          buffer = buffer.replaceAll(`\r
+`, `
+`).replaceAll("\r", `
+`);
+          if (trailingCarriageReturn)
+            buffer += "\r";
+          if (next.done && buffer !== "")
+            buffer += `
+
+`;
+          let boundary = buffer.indexOf(`
+
+`);
+          while (boundary >= 0) {
+            const block = buffer.slice(0, boundary);
+            buffer = buffer.slice(boundary + 2);
+            const data = block.split(`
+`).flatMap((line) => line.startsWith("data:") ? [line.slice(5).trimStart()] : []).join(`
+`);
+            if (data !== "") {
+              try {
+                yield JSON.parse(data);
+              } catch (cause) {
+                throw new ClientError2("MalformedResponse", { cause });
+              }
+            }
+            boundary = buffer.indexOf(`
+
+`);
+          }
+          if (next.done)
+            return;
+        }
+      } finally {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        reader.releaseLock();
+      }
+    }
+  });
+  return {
+    server: {
+      info: (requestOptions) => request({ method: "GET", path: `/api/info`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions),
+      pair: (requestOptions) => request({ method: "POST", path: `/api/pair`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions),
+      connect: (input, requestOptions) => request({
+        method: "GET",
+        path: `/auth/connect/${encodeURIComponent(input.code)}`,
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions)
+    },
+    location: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/location`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      reload: (requestOptions) => request({
+        method: "POST",
+        path: `/api/location/reload`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 503],
+        empty: true
+      }, requestOptions)
+    },
+    agent: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/agent`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/agent/${encodeURIComponent(input.agentID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    plugin: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/plugin`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      check: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/plugin/check`,
+        query: { location: input?.["location"] },
+        body: { target: input?.["target"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/plugin/update`,
+        query: { location: input["location"] },
+        body: { targets: input["targets"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: true
+      }, requestOptions)
+    },
+    session: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session`,
+        query: {
+          limit: input?.["limit"],
+          order: input?.["order"],
+          search: input?.["search"],
+          parentID: input?.["parentID"],
+          directory: input?.["directory"],
+          project: input?.["project"],
+          subpath: input?.["subpath"],
+          cursor: input?.["cursor"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      stats: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/experimental/session/stats`,
+        query: {
+          from: input?.["from"],
+          to: input?.["to"],
+          project: input?.["project"],
+          timezone: input?.["timezone"],
+          tools: input?.["tools"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session`,
+        body: {
+          id: input?.["id"],
+          parentID: input?.["parentID"],
+          title: input?.["title"],
+          agent: input?.["agent"],
+          model: input?.["model"],
+          location: input?.["location"],
+          metadata: input?.["metadata"],
+          permissions: input?.["permissions"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      import: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/session/import`,
+        body: { info: input["info"], messages: input["messages"], location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      export: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/export`,
+        query: { sanitize: input["sanitize"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      active: (requestOptions) => request({
+        method: "GET",
+        path: `/api/session/active`,
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      fork: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/fork`,
+        body: { before: input["before"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      switchAgent: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/agent`,
+        body: { agent: input["agent"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      switchModel: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/model`,
+        body: { model: input["model"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+        body: { title: input["title"], metadata: input["metadata"], permissions: input["permissions"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      move: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/move`,
+        body: { directory: input["directory"], delivery: input["delivery"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      prompt: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/prompt`,
+        body: {
+          id: input["id"],
+          text: input["text"],
+          files: input["files"],
+          agents: input["agents"],
+          skills: input["skills"],
+          metadata: input["metadata"],
+          delivery: input["delivery"],
+          resume: input["resume"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      command: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/command`,
+        body: {
+          name: input["name"],
+          text: input["text"],
+          files: input["files"],
+          agents: input["agents"],
+          skills: input["skills"],
+          delivery: input["delivery"]
+        },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: true
+      }, requestOptions),
+      skill: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/skill`,
+        body: { id: input["id"], resume: input["resume"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      synthetic: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/synthetic`,
+        body: {
+          id: input["id"],
+          text: input["text"],
+          description: input["description"],
+          metadata: input["metadata"],
+          delivery: input["delivery"],
+          resume: input["resume"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      shell: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/shell`,
+        body: { id: input["id"], command: input["command"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      compact: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/compact`,
+        body: { id: input["id"], delivery: input["delivery"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      wait: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/wait`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: true
+      }, requestOptions),
+      revert: {
+        stage: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/stage`,
+          body: { messageID: input["messageID"], files: input["files"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 409, 500],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        clear: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/revert`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409, 500],
+          empty: true
+        }, requestOptions),
+        commit: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/commit`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions)
+      },
+      context: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/context`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      diff: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/diff`,
+        query: { from: input["from"], to: input["to"], context: input["context"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      inbox: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox/${encodeURIComponent(input.inboxID)}`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions),
+        update: (input, requestOptions) => request({
+          method: "PATCH",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox/${encodeURIComponent(input.inboxID)}`,
+          body: { delivery: input["delivery"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions)
+      },
+      instructions: {
+        entry: {
+          list: (input, requestOptions) => request({
+            method: "GET",
+            path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/instructions/entries`,
+            successStatus: 200,
+            declaredStatuses: [400, 401, 404],
+            empty: false
+          }, requestOptions).then((value) => value.data),
+          put: (input, requestOptions) => request({
+            method: "PUT",
+            path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/instructions/entries/${encodeURIComponent(input.key)}`,
+            body: { value: input["value"] },
+            successStatus: 204,
+            declaredStatuses: [400, 401, 404, 413],
+            empty: true
+          }, requestOptions),
+          remove: (input, requestOptions) => request({
+            method: "DELETE",
+            path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/instructions/entries/${encodeURIComponent(input.key)}`,
+            successStatus: 204,
+            declaredStatuses: [400, 401, 404],
+            empty: true
+          }, requestOptions)
+        }
+      },
+      generate: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/generate`,
+        body: { prompt: input["prompt"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      log: (input, requestOptions) => sse({
+        method: "GET",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/log`,
+        query: { after: input["after"], follow: input["follow"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      interrupt: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/interrupt`,
+        query: { resume: input["resume"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      background: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/background`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      message: {
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data)
+      },
+      form: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        create: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
+          body: { id: input["id"], title: input["title"], metadata: input["metadata"], fields: input["fields"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        reply: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/reply`,
+          body: { answer: input["answer"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}`,
+          query: { message: input["message"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions)
+      },
+      environment: (input, requestOptions) => request({
+        method: "PUT",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/environment`,
+        body: { variables: input["variables"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      view: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/view`,
+        body: { idle: input["idle"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    },
+    message: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/message`,
+        query: { limit: input["limit"], order: input["order"], cursor: input["cursor"], type: input["type"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions)
+    },
+    model: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/model`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions),
+      default: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/model/default`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions)
+    },
+    generate: {
+      text: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/generate`,
+        body: { prompt: input["prompt"], model: input["model"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions).then((value) => value.data)
+    },
+    provider: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/provider`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/provider/${encodeURIComponent(input.providerID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions)
+    },
+    integration: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/integration`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/integration/${encodeURIComponent(input.integrationID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      wellknown: {
+        add: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/integration/wellknown`,
+          query: { location: input["location"] },
+          body: { url: input["url"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      },
+      connect: {
+        key: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/key`,
+          query: { location: input["location"] },
+          body: { key: input["key"], answer: input["answer"], label: input["label"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions),
+        external: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/external`,
+          query: { location: input["location"] },
+          body: { methodID: input["methodID"], answer: input["answer"], label: input["label"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      },
+      oauth: {
+        connect: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth`,
+          query: { location: input["location"] },
+          body: { methodID: input["methodID"], answer: input["answer"], label: input["label"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions),
+        status: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions),
+        complete: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}/complete`,
+          query: { location: input["location"] },
+          body: { code: input["code"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      },
+      command: {
+        connect: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command`,
+          query: { location: input["location"] },
+          body: { methodID: input["methodID"], label: input["label"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions),
+        status: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      }
+    },
+    mcp: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/mcp`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      add: (input, requestOptions) => request({
+        method: "PUT",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}`,
+        query: { location: input["location"] },
+        body: { config: input["config"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      connect: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}/connect`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      disconnect: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}/disconnect`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      resource: {
+        catalog: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/mcp/resource`,
+          query: { location: input?.["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions)
+      }
+    },
+    credential: {
+      list: (requestOptions) => request({ method: "GET", path: `/api/credential`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions).then((value) => value.data),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/credential`,
+        body: {
+          id: input["id"],
+          integrationID: input["integrationID"],
+          label: input["label"],
+          value: input["value"],
+          activate: input["activate"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
+        body: { label: input["label"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions),
+      activate: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/credential/${encodeURIComponent(input.credentialID)}/activate`,
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions)
+    },
+    project: {
+      list: (requestOptions) => request({ method: "GET", path: `/api/project`, successStatus: 200, declaredStatuses: [400, 401, 404], empty: false }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/project/${encodeURIComponent(input.projectID)}`,
+        body: {
+          canonical: input["canonical"],
+          name: input["name"],
+          icon: input["icon"],
+          commands: input["commands"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    form: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/form`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    permission: {
+      request: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/permission/request`,
+          query: { location: input?.["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions)
+      },
+      saved: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/permission/saved`,
+          query: { projectID: input?.["projectID"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        remove: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/permission/saved/${encodeURIComponent(input.id)}`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      },
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
+        body: {
+          id: input["id"],
+          action: input["action"],
+          resources: input["resources"],
+          save: input["save"],
+          metadata: input["metadata"],
+          source: input["source"],
+          agent: input["agent"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      reply: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}/reply`,
+        body: { decision: input["decision"], message: input["message"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    },
+    file: {
+      read: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/fs/read/${encodePath(input.path)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false,
+        binary: true
+      }, requestOptions),
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/fs/list`,
+        query: { location: input?.["location"], path: input?.["path"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      find: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/fs/find`,
+        query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      write: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/fs/write`,
+        query: { location: input["location"], path: input["path"] },
+        body: input["payload"],
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false,
+        binaryBody: true
+      }, requestOptions)
+    },
+    command: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/command`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    skill: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/skill`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    rpc: {
+      call: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/rpc/${encodeURIComponent(input.rpcID)}/${encodeURIComponent(input.method)}`,
+        query: { location: input["location"] },
+        body: { input: input["input"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions)
+    },
+    event: {
+      subscribe: (requestOptions) => sse({ method: "GET", path: `/api/event`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions)
+    },
+    pty: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/pty`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/pty`,
+        query: { location: input?.["location"] },
+        body: {
+          command: input?.["command"],
+          args: input?.["args"],
+          cwd: input?.["cwd"],
+          title: input?.["title"],
+          env: input?.["env"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PUT",
+        path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+        query: { location: input["location"] },
+        body: { title: input["title"], size: input["size"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      connect: {
+        token: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/pty/${encodeURIComponent(input.ptyID)}/connect-token`,
+          query: { location: input["location"] },
+          headers: { "x-opencode-ticket": input["x-opencode-ticket"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404],
+          empty: false
+        }, requestOptions)
+      }
+    },
+    experimental: {
+      persistentPty: {
+        read: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/terminal/read`,
+          query: { lines: input["lines"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/terminal`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        create: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/terminal`,
+          body: {
+            command: input["command"],
+            args: input["args"],
+            cwd: input["cwd"],
+            title: input["title"],
+            env: input["env"],
+            size: input["size"]
+          },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        shutdown: (requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/persistent-pty/shutdown`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 503],
+          empty: true
+        }, requestOptions),
+        handoff: (requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/persistent-pty/handoff`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions),
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        update: (input, requestOptions) => request({
+          method: "PUT",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+          body: { attachmentID: input["attachmentID"], size: input["size"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        snapshot: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}/snapshot`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        remove: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: true
+        }, requestOptions),
+        connectToken: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}/connect-token`,
+          headers: { "x-opencode-ticket": input["x-opencode-ticket"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data)
+      }
+    },
+    shell: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/shell`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/shell`,
+        query: { location: input["location"] },
+        body: {
+          command: input["command"],
+          cwd: input["cwd"],
+          timeout: input["timeout"],
+          metadata: input["metadata"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/shell/${encodeURIComponent(input.id)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      output: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/shell/${encodeURIComponent(input.id)}/output`,
+        query: { location: input["location"], cursor: input["cursor"], limit: input["limit"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/shell/${encodeURIComponent(input.id)}`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    },
+    reference: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/reference`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    worktree: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/worktree`,
+        query: { projectID: input["projectID"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/worktree`,
+        body: {
+          projectID: input["projectID"],
+          from: input["from"],
+          branch: input["branch"],
+          directory: input["directory"],
+          name: input["name"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/worktree`,
+        body: { projectID: input["projectID"], directory: input["directory"], force: input["force"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      refresh: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/worktree/refresh`,
+        body: { projectID: input["projectID"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    },
+    vcs: {
+      init: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/vcs/init`,
+        query: { location: input?.["location"], provider: input?.["provider"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404, 409, 501, 503],
+        empty: true
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      base: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/base`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions),
+      status: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/status`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      branch: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/vcs/branch`,
+          query: { location: input?.["location"], search: input?.["search"], limit: input?.["limit"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions)
+      },
+      diff: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/diff`,
+        query: { location: input["location"], mode: input["mode"], base: input["base"], context: input["context"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions)
+    },
+    debug: {
+      location: {
+        list: (requestOptions) => request({
+          method: "GET",
+          path: `/api/debug/location`,
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions),
+        evict: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/debug/location`,
+          query: { location: input?.["location"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401],
+          empty: true
+        }, requestOptions)
+      }
+    },
+    migration: {
+      v1: {
+        status: (requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/migration/v1`,
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions)
+      }
+    },
+    websearch: {
+      providers: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/websearch/provider`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions),
+      query: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/websearch`,
+        query: { location: input["location"] },
+        body: { query: input["query"], providerID: input["providerID"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions)
+    },
+    config: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/config`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      shells: (requestOptions) => request({
+        method: "GET",
+        path: `/api/config/shell`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/experimental/config`,
+        body: { shell: input["shell"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    }
+  };
+}
+function encodePath(value) {
+  return value.split("/").map(encodeURIComponent).join("/");
+}
+function appendQuery(params, key, value) {
+  if (value === void 0)
+    return;
+  if (value === null) {
+    params.append(key, "null");
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      appendQuery(params, key, item);
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [child, item] of Object.entries(value))
+      appendQuery(params, `${key}[${child}]`, item);
+    return;
+  }
+  params.append(key, String(value));
+}
+async function json(response) {
+  if (!isContentType(response, "application/json") && !response.headers.get("content-type")?.includes("+json")) {
+    try {
+      await response.body?.cancel();
+    } catch {
+    }
+    throw new ClientError2("UnsupportedContentType", { detail: response.headers.get("content-type") });
+  }
+  let text;
+  try {
+    text = await response.text();
+  } catch (cause) {
+    throw new ClientError2("Transport", { cause });
+  }
+  if (text === "")
+    throw new ClientError2("MalformedResponse");
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    throw new ClientError2("MalformedResponse", { cause });
+  }
+}
+function declared(body) {
+  const error = Object.assign(new Error(body.message ?? body.data?.message), body);
+  if (body._tag)
+    error.name = body._tag;
+  return error;
+}
+function isContentType(response, expected) {
+  return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === expected;
+}
+var exports_client2, maxSseEventBytes;
+var init_service_timing_tbh3h57v = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-tbh3h57v.js"() {
+    init_service_timing_js54wxgp();
+    init_service_timing_9rqn6x4v();
+    exports_client2 = {};
+    __export2(exports_client2, {
+      make: () => make3
+    });
+    maxSseEventBytes = 16 * 1024 * 1024;
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-vt9jbch8.js
+var isInvalidRequestError2, isUnauthorizedError2, isLocationNotFoundError2, isServiceUnavailableError2, isAgentNotFoundError2, isInvalidCursorError2, isSessionNotFoundError2, isConflictError2, isUnknownError2, isMessageNotFoundError2, isCommandNotFoundError2, isCommandExecutionError2, isSkillNotFoundError2, isSessionBusyError2, isInstructionEntryValueTooLargeError2, isFormNotFoundError2, isFormInvalidAnswerError2, isFormAlreadySettledError2, isProviderNotFoundError2, isIntegrationNotFoundError2, isIntegrationAttemptNotFoundError2, isIntegrationMethodNotFoundError2, isMcpServerNotFoundError2, isProjectNotFoundError2, isPermissionNotFoundError2, isFileNotFoundError2, isRpcError2, isRpcInternalError2, isPtyNotFoundError2, isForbiddenError2, isShellNotFoundError2, isWorktreeError2, isVcsInitNotSupportedError2;
+var init_service_timing_vt9jbch8 = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-vt9jbch8.js"() {
+    isInvalidRequestError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "InvalidRequestError";
+    isUnauthorizedError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "UnauthorizedError";
+    isLocationNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "LocationNotFoundError";
+    isServiceUnavailableError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ServiceUnavailableError";
+    isAgentNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "AgentNotFoundError";
+    isInvalidCursorError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "InvalidCursorError";
+    isSessionNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "SessionNotFoundError";
+    isConflictError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ConflictError";
+    isUnknownError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "UnknownError";
+    isMessageNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "MessageNotFoundError";
+    isCommandNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "CommandNotFoundError";
+    isCommandExecutionError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "CommandExecutionError";
+    isSkillNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "SkillNotFoundError";
+    isSessionBusyError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "SessionBusyError";
+    isInstructionEntryValueTooLargeError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "InstructionEntryValueTooLargeError";
+    isFormNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FormNotFoundError";
+    isFormInvalidAnswerError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FormInvalidAnswerError";
+    isFormAlreadySettledError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FormAlreadySettledError";
+    isProviderNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ProviderNotFoundError";
+    isIntegrationNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "IntegrationNotFoundError";
+    isIntegrationAttemptNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "IntegrationAttemptNotFoundError";
+    isIntegrationMethodNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "IntegrationMethodNotFoundError";
+    isMcpServerNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "McpServerNotFoundError";
+    isProjectNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ProjectNotFoundError";
+    isPermissionNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "PermissionNotFoundError";
+    isFileNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FileNotFoundError";
+    isRpcError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "RpcError";
+    isRpcInternalError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "RpcInternalError";
+    isPtyNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "PtyNotFoundError";
+    isForbiddenError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ForbiddenError";
+    isShellNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ShellNotFoundError";
+    isWorktreeError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "WorktreeError";
+    isVcsInitNotSupportedError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "VcsInitNotSupportedError";
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-1y4a697q.js
+function makeRpc2(raw, events) {
+  return (definition) => {
+    const subscribe = (name, options) => {
+      if (!Object.hasOwn(definition.events, name))
+        throw new Error(`Unknown RPC event: ${definition.id}.${name}`);
+      const type = eventType(definition, name);
+      return {
+        [Symbol.asyncIterator]() {
+          const controller = new AbortController();
+          const signal2 = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const iterator = (async function* () {
+            try {
+              for await (const published of events.subscribe({ signal: signal2 })) {
+                if (signal2.aborted)
+                  return;
+                if (published.type !== type)
+                  continue;
+                yield published;
+              }
+            } catch (error) {
+              if (!signal2.aborted)
+                throw error;
+            } finally {
+              controller.abort();
+            }
+          })();
+          return {
+            next: () => iterator.next(),
+            return: () => {
+              controller.abort();
+              return iterator.return();
+            }
+          };
+        }
+      };
+    };
+    return Object.assign(Object.fromEntries(Object.keys(definition.methods).map((name) => [
+      name,
+      async (input, options) => {
+        try {
+          const result = await raw.rpc.call({
+            rpcID: definition.id,
+            method: name,
+            input,
+            location: options?.location
+          }, { signal: options?.signal, headers: options?.headers });
+          return result.output;
+        } catch (error) {
+          if (!isRpcError2(error) && !isRpcInternalError2(error))
+            throw error;
+          throw error.data === void 0 ? { type: error.type, message: error.message } : { type: error.type, message: error.message, data: error.data };
+        }
+      }
+    ])), {
+      events: {
+        subscribe,
+        on: (name, handler, options) => {
+          const controller = new AbortController();
+          const signal2 = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const source = subscribe(name, { signal: signal2 });
+          (async () => {
+            for await (const event of source)
+              await handler(event);
+          })().catch((error) => console.error(error));
+          return () => controller.abort();
+        }
+      }
+    });
+  };
+}
+function eventType(definition, name) {
+  return `rpc.${definition.id}.${name}`;
+}
+var init_service_timing_1y4a697q = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-1y4a697q.js"() {
+    init_service_timing_vt9jbch8();
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-e4sc9kq6.js
+function make2(options) {
+  const raw = make3(options);
+  const events = make7((signal2, onActivity) => raw.event.subscribe({ signal: signal2, onActivity }));
+  return {
+    ...raw,
+    rpc: Object.assign(makeRpc2(raw, events), raw.rpc),
+    event: events
+  };
+}
+var exports_client;
+var init_service_timing_e4sc9kq6 = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-e4sc9kq6.js"() {
+    init_service_timing_frbwqjmf();
+    init_service_timing_tbh3h57v();
+    init_service_timing_1y4a697q();
+    init_service_timing_9rqn6x4v();
+    exports_client = {};
+    __export2(exports_client, {
+      OpenCode: () => exports_client,
+      make: () => make2
+    });
+  }
+});
+
+// node_modules/@opencode/client/dist/promise/index.js
+var promise_exports = {};
+__export(promise_exports, {
+  ClientError: () => ClientError2,
+  OpenCode: () => exports_client,
+  isAgentNotFoundError: () => isAgentNotFoundError2,
+  isCommandExecutionError: () => isCommandExecutionError2,
+  isCommandNotFoundError: () => isCommandNotFoundError2,
+  isConflictError: () => isConflictError2,
+  isFileNotFoundError: () => isFileNotFoundError2,
+  isForbiddenError: () => isForbiddenError2,
+  isFormAlreadySettledError: () => isFormAlreadySettledError2,
+  isFormInvalidAnswerError: () => isFormInvalidAnswerError2,
+  isFormNotFoundError: () => isFormNotFoundError2,
+  isInstructionEntryValueTooLargeError: () => isInstructionEntryValueTooLargeError2,
+  isIntegrationAttemptNotFoundError: () => isIntegrationAttemptNotFoundError2,
+  isIntegrationMethodNotFoundError: () => isIntegrationMethodNotFoundError2,
+  isIntegrationNotFoundError: () => isIntegrationNotFoundError2,
+  isInvalidCursorError: () => isInvalidCursorError2,
+  isInvalidRequestError: () => isInvalidRequestError2,
+  isLocationNotFoundError: () => isLocationNotFoundError2,
+  isMcpServerNotFoundError: () => isMcpServerNotFoundError2,
+  isMessageNotFoundError: () => isMessageNotFoundError2,
+  isPermissionNotFoundError: () => isPermissionNotFoundError2,
+  isProjectNotFoundError: () => isProjectNotFoundError2,
+  isProviderNotFoundError: () => isProviderNotFoundError2,
+  isPtyNotFoundError: () => isPtyNotFoundError2,
+  isRpcError: () => isRpcError2,
+  isRpcInternalError: () => isRpcInternalError2,
+  isServiceUnavailableError: () => isServiceUnavailableError2,
+  isSessionBusyError: () => isSessionBusyError2,
+  isSessionNotFoundError: () => isSessionNotFoundError2,
+  isShellNotFoundError: () => isShellNotFoundError2,
+  isSkillNotFoundError: () => isSkillNotFoundError2,
+  isUnauthorizedError: () => isUnauthorizedError2,
+  isUnknownError: () => isUnknownError2,
+  isVcsInitNotSupportedError: () => isVcsInitNotSupportedError2,
+  isWorktreeError: () => isWorktreeError2
+});
+var init_promise = __esm({
+  "node_modules/@opencode/client/dist/promise/index.js"() {
+    init_service_timing_e4sc9kq6();
+    init_service_timing_tbh3h57v();
+    init_service_timing_js54wxgp();
+    init_service_timing_1y4a697q();
+    init_service_timing_vt9jbch8();
+    init_service_timing_frbwqjmf();
+  }
+});
+
 // src/config.js
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -238,19 +2094,19 @@ function isRetryable(status) {
 function isAbortError(error) {
   return error instanceof Error && error.name === "AbortError";
 }
-function sleep(milliseconds, signal) {
+function sleep(milliseconds, signal2) {
   return new Promise((resolve2) => {
-    if (signal?.aborted) {
+    if (signal2?.aborted) {
       resolve2();
       return;
     }
     const timeout = setTimeout(done, milliseconds);
     function done() {
       clearTimeout(timeout);
-      signal?.removeEventListener("abort", done);
+      signal2?.removeEventListener("abort", done);
       resolve2();
     }
-    signal?.addEventListener("abort", done, { once: true });
+    signal2?.addEventListener("abort", done, { once: true });
   });
 }
 async function postJsonWithRetry(config, url, body, options = {}) {
@@ -493,7 +2349,7 @@ import { randomUUID } from "node:crypto";
 import { statSync } from "node:fs";
 
 // src/updates.js
-var PLUGIN_VERSION = "0.3.2";
+var PLUGIN_VERSION = "0.4.0";
 var PACKAGE_NAME = "backeer-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var CHECK_TIMEOUT_MS = 3e3;
@@ -524,7 +2380,8 @@ function isVersionNewer(latestValue, currentValue) {
 }
 function createUpdateChecker({
   fetchImplementation = globalThis.fetch,
-  now = () => Date.now()
+  now = () => Date.now(),
+  v2 = false
 } = {}) {
   let checkedAt = 0;
   let cachedResult;
@@ -554,7 +2411,7 @@ function createUpdateChecker({
         state: "available",
         currentVersion: PLUGIN_VERSION,
         latestVersion,
-        updateCommand: `opencode plugin ${PACKAGE_NAME}@${latestVersion} -g --force`
+        updateCommand: v2 ? `opencode plugin add ${PACKAGE_NAME}@${latestVersion}` : `opencode plugin ${PACKAGE_NAME}@${latestVersion} -g --force`
       };
     } catch {
       return { state: "unavailable", currentVersion: PLUGIN_VERSION };
@@ -1651,13 +3508,13 @@ function nextSseFrame(buffer) {
   }
   return { frame: buffer.slice(0, lfIndex), rest: buffer.slice(lfIndex + 2) };
 }
-async function consumeSse(response, state, onCommand, signal, reporter) {
+async function consumeSse(response, state, onCommand, signal2, reporter) {
   if (!response.body) throw new Error("Backeer command stream has no body");
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
   try {
-    while (!signal.aborted) {
+    while (!signal2.aborted) {
       const item = await reader.read();
       if (item.done) break;
       buffer += decoder.decode(item.value, { stream: true });
@@ -1686,7 +3543,7 @@ async function consumeSse(response, state, onCommand, signal, reporter) {
     });
   }
 }
-async function openCommandStream(config, state, signal, fetchImplementation) {
+async function openCommandStream(config, state, signal2, fetchImplementation) {
   const headers = {
     Accept: "text/event-stream",
     Authorization: `Bearer ${config.token}`
@@ -1694,7 +3551,7 @@ async function openCommandStream(config, state, signal, fetchImplementation) {
   if (state.lastEventID) headers["Last-Event-ID"] = state.lastEventID;
   const response = await fetchImplementation(config.commandStreamEndpoint, {
     headers,
-    signal
+    signal: signal2
   });
   if (!response.ok) {
     const responseBody = limit(await response.text(), 500);
@@ -1713,7 +3570,7 @@ async function consumeConnection({
   response,
   state,
   onCommand,
-  signal,
+  signal: signal2,
   reporter,
   now,
   stableConnectionMs,
@@ -1722,7 +3579,7 @@ async function consumeConnection({
   const connectedAt = now();
   const framesBeforeConnection = state.framesReceived;
   try {
-    await consumeSse(response, state, onCommand, signal, reporter);
+    await consumeSse(response, state, onCommand, signal2, reporter);
   } finally {
     const receivedFrame = state.framesReceived > framesBeforeConnection;
     if (receivedFrame || now() - connectedAt >= stableConnectionMs) onStable();
@@ -1743,7 +3600,7 @@ function streamErrorState(error, lastLoggedError, reconnectDelay, reporter) {
   };
 }
 async function runCommandStream(config, reporter, {
-  signal,
+  signal: signal2,
   hasPending,
   onCommand,
   fetchImplementation = fetch,
@@ -1754,19 +3611,19 @@ async function runCommandStream(config, reporter, {
   const state = { lastEventID: "", framesReceived: 0 };
   let reconnectDelay = 1e3;
   let lastLoggedError = "";
-  while (!signal.aborted && hasPending()) {
+  while (!signal2.aborted && hasPending()) {
     try {
       const response = await openCommandStream(
         config,
         state,
-        signal,
+        signal2,
         fetchImplementation
       );
       await consumeConnection({
         response,
         state,
         onCommand,
-        signal,
+        signal: signal2,
         reporter,
         now,
         stableConnectionMs,
@@ -1776,13 +3633,13 @@ async function runCommandStream(config, reporter, {
         }
       });
     } catch (error) {
-      if (signal.aborted || isAbortError(error)) return;
+      if (signal2.aborted || isAbortError(error)) return;
       const next = streamErrorState(error, lastLoggedError, reconnectDelay, reporter);
       reconnectDelay = next.reconnectDelay;
       lastLoggedError = next.lastLoggedError;
     }
-    if (!signal.aborted && hasPending()) {
-      await sleepImplementation(reconnectDelay, signal);
+    if (!signal2.aborted && hasPending()) {
+      await sleepImplementation(reconnectDelay, signal2);
       reconnectDelay = Math.min(reconnectDelay * 2, 6e4);
     }
   }
@@ -2070,7 +3927,7 @@ function createPermissionController({
 }
 
 // src/plugin.js
-async function BackeerPlugin({ client, directory }, options = {}) {
+async function BackeerPlugin({ client, directory, feedback, v2 = false }, options = {}) {
   const bootstrapReporter = createOpenCodeReporter(
     client,
     options.logLevel ?? process.env.BACKEER_LOG_LEVEL
@@ -2083,7 +3940,7 @@ async function BackeerPlugin({ client, directory }, options = {}) {
     return {};
   }
   const reporter = createOpenCodeReporter(client, config.logLevel);
-  const conversation = createConversationFeedback({ client, reporter });
+  const conversation = feedback ?? createConversationFeedback({ client, reporter });
   const permissionController = createPermissionController({
     config,
     reporter,
@@ -2101,7 +3958,7 @@ async function BackeerPlugin({ client, directory }, options = {}) {
   const permissionPublications = createDeliveryTracker();
   const questionPublications = createDeliveryTracker();
   const todoCompletions = createCompletionTracker();
-  const updateChecker = createUpdateChecker();
+  const updateChecker = createUpdateChecker({ v2 });
   const handleBackeerCommand = createBackeerCommandHandler({
     client,
     config,
@@ -2239,6 +4096,746 @@ async function BackeerPlugin({ client, directory }, options = {}) {
     }
   };
 }
+
+// src/opencode-v2-forms.js
+init_promise();
+
+// node_modules/@opencode/client/dist/chunks/service-timing-ve4aws36.js
+import { spawn } from "node:child_process";
+var stderrLimit = 8 * 1024;
+function spawnServiceContender2(command, args, env) {
+  const child = spawn(command, args, {
+    detached: true,
+    windowsHide: true,
+    stdio: ["ignore", "ignore", "pipe"],
+    env: { ...process.env, ...env }
+  });
+  let error;
+  let closed = false;
+  let stderr = Buffer.alloc(0);
+  const onStderr = (chunk) => {
+    const tail = chunk.subarray(-stderrLimit);
+    stderr = tail.length === stderrLimit ? Buffer.from(tail) : Buffer.concat([stderr.subarray(-(stderrLimit - tail.length)), tail]);
+  };
+  child.stderr?.on("data", onStderr);
+  if (child.stderr !== null && "unref" in child.stderr && typeof child.stderr.unref === "function")
+    child.stderr.unref();
+  child.once("error", (cause) => {
+    error = new Error("Failed to start server", { cause });
+  });
+  child.once("close", () => {
+    closed = true;
+  });
+  child.unref();
+  return {
+    child,
+    error: () => error,
+    closed: () => closed,
+    stderr: () => stderr.toString("utf8").trim(),
+    release: () => {
+      child.stderr?.off("data", onStderr);
+      child.stderr?.resume();
+      stderr = Buffer.alloc(0);
+    }
+  };
+}
+function contenderPool2(timing) {
+  const contenders = /* @__PURE__ */ new Set();
+  let failure;
+  let spawnDelay = timing.spawnDelay;
+  let lastSpawn = 0;
+  return {
+    failure: () => failure,
+    serviceAnswered() {
+      spawnDelay = timing.spawnDelay;
+    },
+    evict(pid) {
+      for (const item of contenders) {
+        if (item.child.pid === pid || contenderFinished2(item)) {
+          item.release();
+          contenders.delete(item);
+        }
+      }
+      failure = void 0;
+      lastSpawn = 0;
+    },
+    recruitNow() {
+      lastSpawn = Date.now() - spawnDelay;
+    },
+    reap() {
+      const finished = [...contenders].filter(contenderFinished2);
+      failure ??= finished.map(contenderFailure).find((error) => error !== void 0);
+      if (finished.some((item) => item.child.exitCode === 0))
+        spawnDelay = Math.min(spawnDelay * 2, timing.maxSpawnDelay);
+      finished.forEach((item) => contenders.delete(item));
+      return contenders.size === 0 ? failure : void 0;
+    },
+    shouldRecruit(registered2) {
+      if (lastSpawn === 0 && registered2)
+        lastSpawn = Date.now();
+      return failure === void 0 && contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay;
+    },
+    add(contender) {
+      contenders.add(contender);
+      lastSpawn = Date.now();
+    },
+    releaseAll() {
+      contenders.forEach((contender) => contender.release());
+    }
+  };
+}
+function contenderFailure(contender) {
+  const error = contender.error();
+  if (error !== void 0)
+    return error;
+  if (contender.child.exitCode !== null && contender.child.exitCode !== 0)
+    return startupError(`Server process exited with code ${contender.child.exitCode}`, contender.stderr());
+  if (contender.child.signalCode !== null)
+    return startupError(`Server process terminated by ${contender.child.signalCode}`, contender.stderr());
+  return;
+}
+function contenderFinished2(contender) {
+  return contender.error() !== void 0 || contender.closed();
+}
+function startupError(message, stderr) {
+  return new Error(stderr ? `${message}
+${stderr}` : message);
+}
+
+// node_modules/@opencode/client/dist/chunks/service-timing-xgnj2w4v.js
+var timings = /* @__PURE__ */ new WeakMap();
+var defaultEnsureTiming2 = {
+  pollInterval: 25,
+  requestTimeout: 2e3,
+  spawnDelay: 5e3,
+  maxSpawnDelay: 3e4,
+  promiseTimeout: 12e4,
+  stopPollInterval: 50,
+  stopPollAttempts: 100
+};
+function ensureTiming2(options) {
+  return timings.get(options) ?? defaultEnsureTiming2;
+}
+
+// node_modules/@opencode/client/dist/chunks/service-timing-sxt88q69.js
+function matchesVersion2(version, options) {
+  if (options.version === void 0)
+    return true;
+  if (version === void 0)
+    return false;
+  if (typeof options.version === "function")
+    return options.version(version);
+  return version === options.version;
+}
+
+// node_modules/@opencode/client/dist/chunks/service-timing-0rcx1gca.js
+init_service_timing_9rqn6x4v();
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+var exports_pty_handoff = {};
+__export2(exports_pty_handoff, {
+  PtyHandoff: () => exports_pty_handoff,
+  clear: () => clear2,
+  complete: () => complete2,
+  environment: () => environment2,
+  prepare: () => prepare2
+});
+async function prepare2(file, info, timeout) {
+  const existing = await read(file);
+  if (existing !== void 0 && existing.expiresAt > Date.now() && same(existing.source, info))
+    return;
+  const { OpenCode } = await Promise.resolve().then(() => (init_promise(), promise_exports));
+  const client = OpenCode.make({
+    baseUrl: info.url,
+    headers: info.password === void 0 ? void 0 : { authorization: "Basic " + Buffer.from(`opencode:${info.password}`).toString("base64") }
+  });
+  const handoff = await client.experimental.persistentPty.handoff({ signal: AbortSignal.timeout(timeout) }).then(parse).catch(async (cause) => {
+    const concurrent = await read(file);
+    if (concurrent !== void 0 && concurrent.expiresAt > Date.now() && same(concurrent.source, info))
+      return;
+    console.warn("Background service cannot hand off persistent terminals; shutting them down before replacement", cause);
+    await client.experimental.persistentPty.shutdown({ signal: AbortSignal.timeout(timeout) }).catch(() => {
+    });
+    return null;
+  });
+  if (handoff === void 0)
+    return;
+  await publish2(file, info, handoff).catch((cause) => console.warn("Failed to publish persistent terminal handoff", cause));
+}
+function parse(body) {
+  if (typeof body !== "object" || body === null || !("handoff" in body))
+    throw new Error("Invalid persistent terminal handoff response");
+  if (body.handoff === null)
+    return null;
+  if (!isHandoff(body.handoff) || body.handoff.expiresAt <= Date.now())
+    throw new Error("Invalid or expired persistent terminal handoff");
+  return body.handoff;
+}
+async function publish2(file, info, handoff) {
+  const temporary = `${file}.pty-handoff.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify({
+    source: { id: info.id, pid: info.pid, url: info.url },
+    handoff,
+    expiresAt: handoff?.expiresAt ?? Date.now() + 3e4
+  }), { mode: 384, flag: "wx" });
+  await rename(temporary, file + ".pty-handoff").finally(() => rm(temporary, { force: true }));
+}
+async function environment2(file, env) {
+  const record = await read(file);
+  const current = await readFile(file, "utf8").then((text) => JSON.parse(text)).catch(() => {
+    return;
+  });
+  const handoff = record !== void 0 && record.expiresAt > Date.now() && (current === void 0 || same(record.source, current)) ? record.handoff : void 0;
+  return { ...env, OPENCODE_PTY_HANDOFF: handoff == null ? void 0 : JSON.stringify(handoff) };
+}
+async function complete2(file, info) {
+  const record = await read(file);
+  if (record !== void 0 && !same(record.source, info))
+    await clear2(file);
+}
+async function clear2(file) {
+  await rm(file + ".pty-handoff", { force: true });
+}
+async function read(file) {
+  const value = await readFile(file + ".pty-handoff", "utf8").then((text) => JSON.parse(text)).catch(() => {
+    return;
+  });
+  if (typeof value !== "object" || value === null || !("source" in value) || !("handoff" in value))
+    return;
+  if (typeof value.source !== "object" || value.source === null)
+    return;
+  if (!("pid" in value.source) || typeof value.source.pid !== "number")
+    return;
+  if (!("url" in value.source) || typeof value.source.url !== "string")
+    return;
+  if ("id" in value.source && typeof value.source.id !== "string")
+    return;
+  if (value.handoff !== null && !isHandoff(value.handoff))
+    return;
+  if (!("expiresAt" in value) || typeof value.expiresAt !== "number" || !Number.isFinite(value.expiresAt))
+    return;
+  return {
+    source: {
+      id: "id" in value.source && typeof value.source.id === "string" ? value.source.id : void 0,
+      pid: value.source.pid,
+      url: value.source.url
+    },
+    handoff: value.handoff,
+    expiresAt: value.expiresAt
+  };
+}
+function same(left, right) {
+  return left.id === right.id && left.pid === right.pid && left.url === right.url;
+}
+function isHandoff(value) {
+  return typeof value === "object" && value !== null && "directory" in value && typeof value.directory === "string" && "instanceID" in value && typeof value.instanceID === "string" && "ticket" in value && typeof value.ticket === "string" && "expiresAt" in value && typeof value.expiresAt === "number" && Number.isFinite(value.expiresAt);
+}
+
+// node_modules/@opencode/client/dist/chunks/service-timing-8ye1ye6f.js
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+function decide2(service, options) {
+  if (!matchesVersion2(service.version, options))
+    return { _tag: "replace", pty: service.state === "ready" ? "handoff" : "clear" };
+  if (!service.compatible)
+    return fail("Background service uses an incompatible health protocol. Update this client or explicitly restart the service.");
+  if (service.state === "ready")
+    return { _tag: "reuse" };
+  if (service.state === "failed")
+    return fail("Background service failed to start");
+  return { _tag: "wait" };
+}
+function fail(message) {
+  return { _tag: "fail", error: new Error(message) };
+}
+function fallback2() {
+  return join2(process.env["XDG_STATE_HOME"] ?? join2(homedir2(), ".local", "state"), "opencode", "service.json");
+}
+function same2(left, right) {
+  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid;
+}
+async function probeResult2(info, timeout = defaultEnsureTiming2.requestTimeout) {
+  const endpoint = {
+    url: info.url,
+    auth: info.password === void 0 ? void 0 : { type: "basic", username: "opencode", password: info.password }
+  };
+  const signal2 = AbortSignal.timeout(timeout);
+  const result = await fetch(new URL("/api/info", info.url), { headers: headers2(endpoint), signal: signal2 }).then(async (response2) => ({
+    response: response2,
+    body: response2.status === 404 ? void 0 : await response2.json()
+  })).catch(() => {
+    return;
+  });
+  if (result === void 0)
+    return { service: void 0, timedOut: signal2.aborted };
+  const response = result.response;
+  if (response.status === 404)
+    return {
+      service: {
+        info,
+        endpoint,
+        version: info.version,
+        state: "ready",
+        compatible: false
+      },
+      timedOut: false
+    };
+  const serverInfo = decodeInfo(result.body);
+  if (serverInfo === void 0)
+    return { service: void 0, timedOut: false };
+  if (serverInfo.pid !== info.pid)
+    return { service: void 0, timedOut: false };
+  if (info.version !== void 0 && serverInfo.version !== info.version)
+    return { service: void 0, timedOut: false };
+  return {
+    service: {
+      info,
+      endpoint,
+      version: serverInfo.version,
+      state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
+      compatible: true
+    },
+    timedOut: false
+  };
+}
+function headers2(endpoint) {
+  if (endpoint.auth === void 0)
+    return;
+  return {
+    authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64")
+  };
+}
+function decodeInfo(input) {
+  if (typeof input !== "object" || input === null)
+    return;
+  if (!("version" in input) || typeof input.version !== "string")
+    return;
+  if (!("pid" in input) || typeof input.pid !== "number" || !Number.isInteger(input.pid) || input.pid < 0)
+    return;
+  return { version: input.version, pid: input.pid };
+}
+
+// node_modules/@opencode/client/dist/promise/service.js
+import { readFile as readFile2, rm as rm2 } from "node:fs/promises";
+async function discover(options = {}) {
+  const found = (await registered(options.file)).service;
+  if (found?.state !== "ready")
+    return;
+  if (!found.compatible)
+    return;
+  if (!matchesVersion2(found.version, options))
+    return;
+  return found.endpoint;
+}
+async function ensure(options = {}) {
+  const timing = ensureTiming2(options);
+  const deadline = Date.now() + timing.promiseTimeout;
+  const pool = contenderPool2(timing);
+  let timeouts;
+  let announced = false;
+  const announce = (reason, previousVersion) => {
+    if (announced)
+      return;
+    announced = true;
+    options.onStart?.(reason, previousVersion);
+  };
+  const spawnContender = async () => {
+    const [command, ...args] = options.command ?? ["opencode", "serve", "--service"];
+    if (command === void 0)
+      throw new Error("Missing service command");
+    try {
+      return spawnServiceContender2(command, args, await environment2(options.file ?? fallback2(), options.env));
+    } catch (cause) {
+      throw new Error("Failed to start server", { cause });
+    }
+  };
+  try {
+    while (true) {
+      if (Date.now() >= deadline)
+        throw pool.failure() ?? new Error("Timed out waiting for the background service to start");
+      const registration = await registered(options.file, timing.requestTimeout);
+      if (registration.timedOut && registration.info !== void 0) {
+        timeouts = {
+          info: registration.info,
+          count: timeouts !== void 0 && same2(timeouts.info, registration.info) ? timeouts.count + 1 : 1
+        };
+        if (timeouts.count >= 3) {
+          announce("missing");
+          console.warn("Background service is unresponsive; recovery cannot preserve persistent terminals");
+          await clear2(options.file ?? fallback2());
+          await terminate(registration.info, options, timing);
+          pool.evict(registration.info.pid);
+          pool.recruitNow();
+          timeouts = void 0;
+        }
+      } else
+        timeouts = void 0;
+      if (registration.service !== void 0) {
+        pool.serviceAnswered();
+        const service2 = registration.service;
+        const decision = decide2(service2, options);
+        if (decision._tag === "fail")
+          throw decision.error;
+        if (decision._tag === "reuse") {
+          await complete2(options.file ?? fallback2(), service2.info);
+          return service2.endpoint;
+        }
+        if (decision._tag === "replace") {
+          announce("version-mismatch", service2.version);
+          if (service2.state !== "ready")
+            console.warn("Background service is not ready; replacement cannot preserve persistent terminals");
+          await stop({ file: options.file, pty: decision.pty }).catch(() => {
+            return;
+          });
+          pool.evict(service2.info.pid);
+        }
+      } else {
+        const failed = pool.reap();
+        if (failed !== void 0)
+          throw failed;
+        if (pool.shouldRecruit(registration.info !== void 0)) {
+          announce("missing");
+          pool.add(await spawnContender());
+        }
+      }
+      await delay(timing.pollInterval);
+    }
+  } finally {
+    pool.releaseAll();
+  }
+}
+async function stop(options = {}) {
+  const info = await read2(options.file);
+  await (options.pty === "handoff" && info !== void 0 ? prepare2(options.file ?? fallback2(), info, defaultEnsureTiming2.requestTimeout) : clear2(options.file ?? fallback2())).catch((cause) => console.warn("Failed to prepare persistent terminals for replacement", cause));
+  if (info !== void 0)
+    await terminate(info, options, ensureTiming2(options));
+}
+async function read2(file) {
+  const text = await readFile2(file ?? fallback2(), "utf8").catch(() => {
+    return;
+  });
+  if (text === void 0)
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+async function registered(file, timeout) {
+  const info = await read2(file);
+  if (info === void 0)
+    return { info: void 0, service: void 0, timedOut: false };
+  return { info, ...await probeResult2(info, timeout) };
+}
+function signal(pid, name) {
+  try {
+    process.kill(pid, name);
+  } catch {
+  }
+}
+function stopped(pid) {
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function waitUntilStopped(pid, timing) {
+  for (let attempt = 0; attempt <= timing.stopPollAttempts; attempt++) {
+    if (stopped(pid))
+      return true;
+    if (attempt < timing.stopPollAttempts)
+      await delay(timing.stopPollInterval);
+  }
+  return false;
+}
+async function terminate(info, options, timing) {
+  const current = await read2(options.file);
+  if (current === void 0 || !same2(current, info))
+    return;
+  signal(info.pid, "SIGTERM");
+  if (!await waitUntilStopped(info.pid, timing)) {
+    signal(info.pid, "SIGKILL");
+    if (!await waitUntilStopped(info.pid, timing))
+      throw new Error(`Server process ${info.pid} is still running`);
+  }
+  const latest = await read2(options.file);
+  if (latest === void 0 || !same2(latest, info))
+    return;
+  await rm2(options.file ?? fallback2(), { force: true });
+}
+function delay(milliseconds) {
+  return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
+}
+var Service = { discover, ensure, stop, headers: headers2 };
+
+// src/opencode-v2-forms.js
+async function getFormApi(ctx, sessionID, { makeClient = exports_client.make } = {}) {
+  const endpoint = await Service.discover({ version: ctx.app.version });
+  if (!endpoint) {
+    throw new HttpError("Remote question replies require the OpenCode V2 shared service", 501);
+  }
+  const client = makeClient({ baseUrl: endpoint.url, headers: Service.headers(endpoint) });
+  let session;
+  try {
+    session = await client.session.get({ sessionID });
+  } catch {
+    throw new HttpError("The question session is not owned by the shared OpenCode service", 501);
+  }
+  if (session.location.directory !== ctx.location.directory) {
+    throw new HttpError("The question session belongs to another OpenCode location", 403);
+  }
+  return client.session.form;
+}
+
+// src/opencode-v2-client.js
+async function nativeReply(operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    const statuses = {
+      PermissionNotFoundError: 404,
+      SessionNotFoundError: 404,
+      FormNotFoundError: 404,
+      FormAlreadySettledError: 409,
+      FormInvalidAnswerError: 422
+    };
+    const status = statuses[error?._tag];
+    if (status) throw new HttpError(error.message || error._tag, status);
+    throw error;
+  }
+}
+function questionForm(form) {
+  return form?.metadata?.kind === "question" && typeof form.sessionID === "string" && form.sessionID !== "global" && Array.isArray(form.fields) && form.fields.length > 0 && form.fields.every(
+    (field) => ["string", "multiselect"].includes(field.type) && !field.hidden && !field.when?.length
+  );
+}
+function normalizeV2Event(event) {
+  const properties = event.data ?? {};
+  const normalized = { ...event, properties };
+  if (event.type === "form.created") {
+    const form = properties.form;
+    if (!questionForm(form)) return [];
+    return [{ ...normalized, type: "question.v2.asked", properties: {
+      id: form.id,
+      sessionID: form.sessionID,
+      questions: form.fields.map((field) => ({
+        header: field.title ?? form.title,
+        question: field.description ?? field.title ?? form.title,
+        options: (field.options ?? []).map((option) => ({
+          label: option.label,
+          description: option.description ?? ""
+        })),
+        multiple: field.type === "multiselect",
+        custom: field.custom === true || !field.options?.length
+      }))
+    } }];
+  }
+  if (event.type === "form.replied" || event.type === "form.cancelled") {
+    return [{ ...normalized, type: event.type === "form.replied" ? "question.v2.replied" : "question.v2.rejected" }];
+  }
+  if (event.type === "session.execution.started") {
+    return [{ ...normalized, type: "session.status", properties: {
+      ...properties,
+      status: { type: "busy" }
+    } }];
+  }
+  if (["session.execution.succeeded", "session.execution.interrupted"].includes(event.type)) {
+    return [
+      { ...normalized, type: "message.updated", properties: { info: {
+        role: "assistant",
+        sessionID: properties.sessionID,
+        id: event.id,
+        time: { completed: event.created },
+        error: event.type === "session.execution.interrupted"
+      } } },
+      { ...normalized, type: "session.idle" }
+    ];
+  }
+  if (event.type === "session.execution.failed") {
+    return [{ ...normalized, type: "session.error" }, { ...normalized, type: "session.idle" }];
+  }
+  if (event.type === "session.idle" || event.type === "session.status" && properties.status?.type === "idle") {
+    return [];
+  }
+  return [normalized];
+}
+function createV2Client(ctx, resolveFormApi = (sessionID) => getFormApi(ctx, sessionID)) {
+  return {
+    app: {
+      async log({ body }) {
+        console.error(JSON.stringify(body));
+      }
+    },
+    session: {
+      get: ({ path }) => ctx.session.get({ sessionID: path.id }),
+      prompt: ({ path, body }) => ctx.session.synthetic({
+        sessionID: path.id,
+        text: body.parts.map((part) => part.text).join("\n"),
+        resume: false
+      })
+    },
+    postSessionIdPermissionsPermissionId: ({ path, body }) => nativeReply(() => ctx.permission.reply({
+      sessionID: path.id,
+      requestID: path.permissionID,
+      decision: body.response
+    })),
+    v2: { session: { question: {
+      async reply({ sessionID, requestID, questionV2Reply }) {
+        const api = await resolveFormApi(sessionID);
+        const form = await nativeReply(() => api.get({ sessionID, formID: requestID }));
+        if (!questionForm(form)) throw new HttpError("Unsupported OpenCode question form", 422);
+        const answers = questionV2Reply.answers;
+        if (!Array.isArray(answers) || answers.length !== form.fields.length) {
+          throw new HttpError("Question answer count does not match the form", 422);
+        }
+        const answer = {};
+        form.fields.forEach((field, index) => {
+          const selections = answers[index];
+          if (!Array.isArray(selections) || selections.some((value) => typeof value !== "string")) {
+            throw new HttpError("Invalid question answer", 422);
+          }
+          const values = selections.map(
+            (label) => field.options?.find((option) => option.label === label)?.value ?? label
+          );
+          if (field.type === "multiselect") answer[field.key] = values;
+          else if (values.length === 1) answer[field.key] = values[0];
+          else if (values.length > 1) throw new HttpError("Single-choice question has multiple answers", 422);
+        });
+        return nativeReply(() => api.reply({ sessionID, formID: requestID, answer }));
+      },
+      async reject({ sessionID, requestID }) {
+        const api = await resolveFormApi(sessionID);
+        const form = await nativeReply(() => api.get({ sessionID, formID: requestID }));
+        if (!questionForm(form)) throw new HttpError("Unsupported OpenCode question form", 422);
+        return nativeReply(() => api.cancel({ sessionID, formID: requestID }));
+      }
+    } } },
+    async ownsEvent(event) {
+      if (event.location?.directory) return event.location.directory === ctx.location.directory;
+      const sessionID = event.data?.sessionID ?? event.data?.form?.sessionID;
+      if (!sessionID) return event.type === "installation.update-available";
+      if (sessionID === "global") return false;
+      try {
+        const session = await ctx.session.get({ sessionID });
+        return session.location?.directory === ctx.location.directory;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
+// src/opencode-v2.js
+function waitForReconnect(signal2, delay2) {
+  return new Promise((resolve2) => {
+    const finish = () => {
+      clearTimeout(timer);
+      signal2.removeEventListener("abort", finish);
+      resolve2();
+    };
+    const timer = setTimeout(finish, delay2);
+    signal2.addEventListener("abort", finish, { once: true });
+    if (signal2.aborted) finish();
+  });
+}
+async function setup(ctx) {
+  const client = createV2Client(ctx);
+  const reporter = createOpenCodeReporter(client, ctx.options?.logLevel ?? process.env.BACKEER_LOG_LEVEL);
+  const feedback = Object.fromEntries(
+    ["info", "success", "applied", "warning", "error"].map((kind) => [
+      kind,
+      () => {
+      }
+    ])
+  );
+  feedback.handle = () => {
+  };
+  feedback.dispose = () => {
+  };
+  const hooks = await BackeerPlugin({
+    client,
+    directory: ctx.location.directory,
+    feedback,
+    v2: true
+  }, { ...ctx.options, todos: false });
+  if (!hooks.event) return;
+  const controller = new AbortController();
+  let streamTask;
+  let cleanupTask;
+  const registrations = [];
+  function cleanup() {
+    cleanupTask ??= (async () => {
+      controller.abort();
+      await streamTask?.catch(() => {
+      });
+      await hooks.dispose();
+      await Promise.all(registrations.map((registration) => registration.dispose()));
+    })();
+    return cleanupTask;
+  }
+  try {
+    await ctx.command.transform((editor) => {
+      editor.add({
+        name: "backeer",
+        description: "Check, test, update, or manage Backeer",
+        async execute({ sessionID, prompt, delivery }) {
+          const output = { parts: [] };
+          await hooks["command.execute.before"]({
+            command: "backeer",
+            sessionID,
+            arguments: prompt.text
+          }, output);
+          if (output.parts.length) {
+            await ctx.session.prompt({
+              sessionID,
+              text: output.parts.map((part) => part.text).join("\n"),
+              delivery
+            });
+          }
+        }
+      });
+    }).then((registration) => registrations.push(registration));
+    registrations.push(await ctx.session.hook("prompt", async (event) => {
+      const output = { message: { id: event.messageID }, parts: [] };
+      await hooks["chat.message"]({ sessionID: event.sessionID }, output);
+      if (output.parts.length) {
+        event.prompt.text += `
+
+${output.parts.map((part) => part.text).join("\n")}`;
+      }
+    }));
+    streamTask = (async () => {
+      let delay2 = 1e3;
+      while (!controller.signal.aborted) {
+        try {
+          for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+            if (controller.signal.aborted) break;
+            if (!await client.ownsEvent(event)) continue;
+            delay2 = 1e3;
+            for (const normalized of normalizeV2Event(event)) {
+              await hooks.event({ event: normalized });
+            }
+          }
+        } catch (error) {
+          if (!controller.signal.aborted) reporter.error("OpenCode event stream disconnected", error);
+        }
+        if (!controller.signal.aborted) {
+          await waitForReconnect(controller.signal, delay2);
+          delay2 = Math.min(delay2 * 2, 3e4);
+        }
+      }
+    })();
+    return cleanup;
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+
+// src/index.js
+var index_default = { id: "backeer-opencode", setup, server: BackeerPlugin };
 export {
-  BackeerPlugin as default
+  index_default as default
 };