@gitterm/sdk 0.6.0 → 0.7.0

package/dist/direct/index.js

@@ -30,7 +30,1678 @@ function normalizeQuestion(question) {
   }
   return changed ? { ...question, options, custom } : question;
 }
+// ../../node_modules/.bun/@opencode+client@2.0.19+43902b222b0d7d3e/node_modules/@opencode/client/dist/chunks/rpc-runtime-9rqn6x4v.js
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// ../../node_modules/.bun/@opencode+client@2.0.19+43902b222b0d7d3e/node_modules/@opencode/client/dist/chunks/rpc-runtime-frbwqjmf.js
+var exports_shared_events = {};
+__export(exports_shared_events, {
+  SharedEvents: () => exports_shared_events,
+  make: () => make7
+});
+function make7(connect) {
+  let current;
+  const capacity = 4096;
+  function stop(connection) {
+    connection.connected = undefined;
+    connection.controller.abort();
+    if (current === connection)
+      current = undefined;
+  }
+  async function run(connection) {
+    let iterator;
+    let completion = {};
+    try {
+      if (connection.controller.signal.aborted)
+        return;
+      iterator = connect(connection.controller.signal, () => {
+        connection.subscribers.forEach((subscriber) => subscriber.activity?.());
+      })[Symbol.asyncIterator]();
+      while (!connection.controller.signal.aborted) {
+        const item = await iterator.next();
+        if (item.done || connection.controller.signal.aborted)
+          break;
+        if (item.value.type === "server.connected")
+          connection.connected = item.value;
+        connection.subscribers.forEach((subscriber) => subscriber.push(item.value));
+      }
+    } catch (error) {
+      completion = { error };
+    } finally {
+      stop(connection);
+      try {
+        await iterator?.return?.();
+      } catch (error) {
+        if (!("error" in completion))
+          completion = { error };
+      }
+      connection.subscribers.forEach((subscriber) => subscriber.finish(completion));
+    }
+  }
+  return {
+    subscribe(options) {
+      return {
+        [Symbol.asyncIterator]() {
+          const pending = [];
+          const queued = [];
+          let started = false;
+          let completion;
+          let connection;
+          function finish(result, discard = true) {
+            completion = result;
+            if (discard)
+              queued.length = 0;
+            options?.signal?.removeEventListener("abort", abort);
+            if (connection?.subscribers.delete(subscriber) && !connection.subscribers.size)
+              stop(connection);
+            pending.splice(0).forEach((request) => {
+              if ("error" in result)
+                request.reject(result.error);
+              else
+                request.resolve({ done: true, value: undefined });
+            });
+          }
+          function abort() {
+            finish({});
+          }
+          const subscriber = {
+            activity: options?.onActivity,
+            finish(result) {
+              finish(result, false);
+            },
+            push(value) {
+              if (completion)
+                return;
+              const request = pending.shift();
+              if (request) {
+                request.resolve({ done: false, value });
+                return;
+              }
+              if (queued.length === capacity) {
+                finish({ error: new Error(`Event subscriber exceeded its ${capacity}-event capacity`) });
+                return;
+              }
+              queued.push(value);
+            }
+          };
+          function start() {
+            if (completion)
+              return;
+            const fresh = !current;
+            connection = current ?? {
+              controller: new AbortController,
+              subscribers: new Set
+            };
+            current = connection;
+            connection.subscribers.add(subscriber);
+            if (connection.connected)
+              subscriber.push(connection.connected);
+            if (fresh)
+              run(connection);
+          }
+          return {
+            next() {
+              const value = queued.shift();
+              if (value)
+                return Promise.resolve({ done: false, value });
+              if (completion) {
+                if ("error" in completion)
+                  return Promise.reject(completion.error);
+                return Promise.resolve({ done: true, value: undefined });
+              }
+              if (options?.signal?.aborted) {
+                abort();
+                return Promise.resolve({ done: true, value: undefined });
+              }
+              const request = Promise.withResolvers();
+              pending.push(request);
+              if (!started) {
+                started = true;
+                options?.signal?.addEventListener("abort", abort, { once: true });
+                start();
+              }
+              return request.promise;
+            },
+            return() {
+              finish({});
+              return Promise.resolve({ done: true, value: undefined });
+            }
+          };
+        }
+      };
+    }
+  };
+}
+
+// ../../node_modules/.bun/@opencode+client@2.0.19+43902b222b0d7d3e/node_modules/@opencode/client/dist/chunks/rpc-runtime-js54wxgp.js
+class ClientError2 extends Error {
+  reason;
+  name = "ClientError";
+  constructor(reason, options) {
+    const detail = options?.detail ?? (options?.cause instanceof Error ? options.cause.message : undefined);
+    super(detail ? `${reason}: ${detail}` : reason, options);
+    this.reason = reason;
+  }
+}
+
+// ../../node_modules/.bun/@opencode+client@2.0.19+43902b222b0d7d3e/node_modules/@opencode/client/dist/chunks/rpc-runtime-h9cy5hnk.js
+var exports_client2 = {};
+__export(exports_client2, {
+  make: () => make3
+});
+var maxSseEventBytes = 16 * 1024 * 1024;
+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 !== undefined && value !== null)
+        headers.set(key, String(value));
+    }
+    for (const [key, value] of new Headers(requestOptions?.headers))
+      headers.set(key, value);
+    if (descriptor.body !== undefined && !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 === undefined ? undefined : 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],
+        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],
+        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],
+        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],
+        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, 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"],
+          title: input?.["title"],
+          agent: input?.["agent"],
+          model: input?.["model"],
+          location: input?.["location"],
+          metadata: input?.["metadata"],
+          permissions: input?.["permissions"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        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)}`,
+          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, 503],
+        empty: false
+      }, requestOptions),
+      default: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/model/default`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 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, 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, 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],
+        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],
+          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)
+      },
+      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],
+          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],
+          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],
+          empty: true
+        }, requestOptions)
+      }
+    },
+    mcp: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/mcp`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        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],
+        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],
+          empty: false
+        }, requestOptions)
+      }
+    },
+    credential: {
+      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], 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],
+        empty: false
+      }, requestOptions)
+    },
+    permission: {
+      request: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/permission/request`,
+          query: { location: input?.["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions)
+      },
+      saved: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/permission/saved`,
+          query: { projectID: input?.["projectID"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          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],
+          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],
+        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],
+        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],
+        empty: false,
+        binaryBody: true
+      }, requestOptions)
+    },
+    command: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/command`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions)
+    },
+    skill: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/skill`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        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, 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],
+        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],
+        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],
+        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],
+        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],
+        empty: true
+      }, requestOptions)
+    },
+    reference: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/reference`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        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: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      base: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/base`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 503],
+        empty: false
+      }, requestOptions),
+      status: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/status`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        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],
+          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, 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, 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, 503],
+        empty: false
+      }, requestOptions)
+    },
+    config: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/config`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      shells: (requestOptions) => request({ method: "GET", path: `/api/config/shell`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/experimental/config`,
+        body: { shell: input["shell"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions)
+    }
+  };
+}
+function encodePath(value) {
+  return value.split("/").map(encodeURIComponent).join("/");
+}
+function appendQuery(params, key, value) {
+  if (value === undefined)
+    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;
+}
+
+// ../../node_modules/.bun/@opencode+client@2.0.19+43902b222b0d7d3e/node_modules/@opencode/client/dist/chunks/rpc-runtime-4tveyqeh.js
+var isRpcError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "RpcError";
+var isRpcInternalError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "RpcInternalError";
+
+// ../../node_modules/.bun/@opencode+client@2.0.19+43902b222b0d7d3e/node_modules/@opencode/client/dist/chunks/rpc-runtime-1tbj6z39.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 signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const iterator = async function* () {
+            try {
+              for await (const published of events.subscribe({ signal })) {
+                if (signal.aborted)
+                  return;
+                if (published.type !== type)
+                  continue;
+                yield published;
+              }
+            } catch (error) {
+              if (!signal.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 === undefined ? { 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 signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const source = subscribe(name, { signal });
+          (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}`;
+}
+
+// ../../node_modules/.bun/@opencode+client@2.0.19+43902b222b0d7d3e/node_modules/@opencode/client/dist/chunks/rpc-runtime-gc472t4a.js
+var exports_client = {};
+__export(exports_client, {
+  OpenCode: () => exports_client,
+  make: () => make2
+});
+function make2(options) {
+  const raw = make3(options);
+  const events = make7((signal, onActivity) => raw.event.subscribe({ signal, onActivity }));
+  return {
+    ...raw,
+    rpc: Object.assign(makeRpc2(raw, events), raw.rpc),
+    event: events
+  };
+}
 // ../agent-runtime/src/http.ts
 class RuntimeHttpError extends Error {
   status;
@@ -49,138 +1720,44 @@ function isSessionNotFound(error) {
 function authorizationHeader(password) {
   return password ? { authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}` } : {};
 }
-function runtimeUrl(target, path) {
-  const url = new URL(`${target.url.replace(/\/$/, "")}${path}`);
-  if (target.directory && !url.searchParams.has("location")) {
-    url.searchParams.set("location", JSON.stringify({ directory: target.directory }));
-  }
-  return url.toString();
-}
-function createRuntimeHttp(target) {
-  const headers = { ...target.headers, ...authorizationHeader(target.password) };
-  async function send(path, init = {}) {
-    const { json, ...rest } = init;
-    const response = await (target.fetch ?? fetch)(runtimeUrl(target, path), {
-      ...rest,
-      headers: {
-        accept: "application/json",
-        ...json === undefined ? {} : { "content-type": "application/json" },
-        ...headers,
-        ...rest.headers
-      },
-      body: json === undefined ? rest.body : JSON.stringify(json),
-      signal: rest.signal ?? (target.signal ? AbortSignal.any([target.signal, AbortSignal.timeout(15000)]) : AbortSignal.timeout(15000))
-    });
-    if (!response.ok) {
+function createOpencodeClient(target) {
+  const send = target.fetch ?? fetch;
+  return exports_client.make({
+    baseUrl: target.url,
+    headers: { ...target.headers, ...authorizationHeader(target.password) },
+    fetch: async (input, init) => {
+      const response = await send(input, init);
+      if (response.ok)
+        return response;
       const body = await response.text().catch(() => "");
-      let tag = null;
-      try {
-        const parsed = JSON.parse(body);
-        tag = typeof parsed._tag === "string" ? parsed._tag : typeof parsed.name === "string" ? parsed.name : null;
-      } catch {}
-      throw new RuntimeHttpError(response.status, body, tag);
-    }
-    return response;
-  }
-  return {
-    send,
-    async json(path, init) {
-      const response = await send(path, init);
-      const text = await response.text();
-      return text ? JSON.parse(text) : undefined;
+      throw new RuntimeHttpError(response.status, body, errorTag(body));
     }
-  };
-}
-async function* readServerSentEvents(url, init) {
-  const response = await (init.fetch ?? fetch)(url, {
-    headers: { accept: "text/event-stream", ...init.headers },
-    signal: init.signal
   });
-  if (!response.ok || !response.body) {
-    await response.body?.cancel().catch(() => {
-      return;
-    });
-    throw new RuntimeHttpError(response.status, "", null);
-  }
-  const reader = response.body.getReader();
-  const onAbort = () => {
-    reader.cancel().catch(() => {});
-  };
-  init.signal.addEventListener("abort", onAbort, { once: true });
-  const decoder = new TextDecoder;
-  let buffer = "";
-  let data = [];
-  let event = null;
+}
+function unwrapClientError(error) {
+  return error instanceof ClientError2 && error.reason === "Transport" && error.cause !== undefined ? error.cause : error;
+}
+async function call(operation) {
   try {
-    init.signal.throwIfAborted();
-    yield { event: "open", data: "" };
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done)
-        break;
-      buffer += decoder.decode(value, { stream: true });
-      let newline = buffer.indexOf(`
-`);
-      while (newline >= 0) {
-        let line = buffer.slice(0, newline);
-        buffer = buffer.slice(newline + 1);
-        newline = buffer.indexOf(`
-`);
-        if (line.endsWith("\r"))
-          line = line.slice(0, -1);
-        if (line === "") {
-          if (data.length > 0)
-            yield { event, data: data.join(`
-`) };
-          data = [];
-          event = null;
-          continue;
-        }
-        if (line.startsWith(":"))
-          continue;
-        const colon = line.indexOf(":");
-        const field = colon === -1 ? line : line.slice(0, colon);
-        let fieldValue = colon === -1 ? "" : line.slice(colon + 1);
-        if (fieldValue.startsWith(" "))
-          fieldValue = fieldValue.slice(1);
-        if (field === "data")
-          data.push(fieldValue);
-        else if (field === "event")
-          event = fieldValue;
-      }
-    }
-    init.signal.throwIfAborted();
-  } finally {
-    init.signal.removeEventListener("abort", onAbort);
-    await reader.cancel().catch(() => {
-      return;
-    });
+    return await operation;
+  } catch (error) {
+    throw unwrapClientError(error);
   }
 }
-async function* signalStream(target, path, parse, signal) {
-  const stream = readServerSentEvents(runtimeUrl(target, path), {
-    headers: { ...target.headers, ...authorizationHeader(target.password) },
-    signal,
-    fetch: target.fetch
-  });
-  for await (const item of stream) {
-    if (item.event === "open") {
-      yield { type: "connected" };
-      continue;
-    }
-    const raw = parseEventData(item.data);
-    const parsed = raw && parse(raw);
-    if (parsed)
-      yield parsed;
-  }
+function requestTimeout(signal, timeoutMs = 15000) {
+  return {
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs)
+  };
 }
-function parseEventData(data) {
+function errorTag(body) {
   try {
-    const parsed = JSON.parse(data);
-    return parsed && typeof parsed === "object" ? parsed : null;
-  } catch {
-    return null;
-  }
+    const parsed = JSON.parse(body);
+    if (typeof parsed._tag === "string")
+      return parsed._tag;
+    if (typeof parsed.name === "string")
+      return parsed.name;
+  } catch {}
+  return null;
 }
 function asRecord(value) {
   return value && typeof value === "object" ? value : {};
@@ -226,63 +1803,51 @@ function truncateToolOutput(value) {
 }
 
 // ../agent-runtime/src/v2.ts
-function session(sessionId) {
-  return `/api/session/${encodeURIComponent(sessionId)}`;
-}
 function createV2Runtime(target) {
-  const http = createRuntimeHttp(target);
-  async function switchSessionOptions(sessionId, agent, model) {
+  const client = createOpencodeClient(target);
+  const options = () => requestTimeout(target.signal);
+  async function switchSessionOptions(sessionID, agent, model) {
     const modelRef = parseModelRef(model);
     if (modelRef) {
-      await http.send(`${session(sessionId)}/model`, {
-        method: "POST",
-        json: { model: { providerID: modelRef.providerID, id: modelRef.modelID } }
-      });
-    }
-    if (agent) {
-      await http.send(`${session(sessionId)}/agent`, { method: "POST", json: { agent } });
+      await call(client.session.switchModel({ sessionID, model: { providerID: modelRef.providerID, id: modelRef.modelID } }, options()));
     }
+    if (agent)
+      await call(client.session.switchAgent({ sessionID, agent }, options()));
   }
   return {
     async createSession(input) {
       const modelRef = parseModelRef(input.model);
-      const created = await http.json("/api/session", {
-        method: "POST",
-        json: {
-          title: input.title,
-          agent: input.agent,
-          model: modelRef ? { providerID: modelRef.providerID, id: modelRef.modelID } : undefined,
-          location: { directory: target.directory }
-        }
-      });
-      return { id: created.data.id, title: created.data.title ?? input.title ?? "Agent run" };
+      const created = await call(client.session.create({
+        title: input.title,
+        agent: input.agent,
+        model: modelRef ? { providerID: modelRef.providerID, id: modelRef.modelID } : undefined,
+        location: { directory: target.directory }
+      }, options()));
+      return { id: created.id, title: created.title ?? input.title ?? "Agent run" };
     },
     async prompt(input) {
       await switchSessionOptions(input.sessionId, input.agent, input.model);
-      await http.send(`${session(input.sessionId)}/prompt`, {
-        method: "POST",
-        json: { id: input.messageId, text: input.prompt }
-      });
+      await call(client.session.prompt({ sessionID: input.sessionId, id: input.messageId, text: input.prompt }, options()));
     },
-    async abort(sessionId) {
-      await http.send(`${session(sessionId)}/interrupt`, { method: "POST", json: {} });
+    async abort(sessionID) {
+      await call(client.session.interrupt({ sessionID }, options()));
     },
-    async deleteSession(sessionId) {
-      await http.send(session(sessionId), { method: "DELETE" });
+    async deleteSession(sessionID) {
+      await call(client.session.remove({ sessionID }, options()));
     },
-    async snapshot(sessionId, messageId) {
+    async snapshot(sessionID, messageId) {
       try {
-        await http.send(session(sessionId));
+        await call(client.session.get({ sessionID }, options()));
       } catch (error) {
         if (isSessionNotFound(error))
           return missingSessionSnapshot();
         throw error;
       }
       const [active, messages, permissions, forms] = await Promise.all([
-        http.json("/api/session/active"),
-        listMessages(sessionId),
-        http.json(`${session(sessionId)}/permission`),
-        http.json(`${session(sessionId)}/form`)
+        call(client.session.active(options())),
+        listMessages(sessionID),
+        call(client.permission.list({ sessionID }, options())),
+        call(client.session.form.list({ sessionID }, options()))
       ]);
       const runMessages = selectRunMessages(messages, messageId);
       const userIndex = messages.findIndex((message) => message.id === messageId);
@@ -294,7 +1859,7 @@ function createV2Runtime(target) {
       return {
         sessionExists: true,
         superseded,
-        busy: sessionId in asRecord(active.data),
+        busy: sessionID in active,
         retry: Boolean(assistant?.retry) && assistantTime.completed == null,
         messages: runMessages.map(normalizeMessage),
         finalText: finalText || null,
@@ -306,49 +1871,51 @@ function createV2Runtime(target) {
             message: asString(assistantError.message) ?? "Agent request failed"
           } : null
         },
-        pendingInputs: superseded ? [] : [
-          ...(permissions.data ?? []).map(asRecord).map(permissionRequest),
-          ...(forms.data ?? []).map(asRecord).map(formRequest)
-        ]
+        pendingInputs: superseded ? [] : [...permissions.map(permissionRequest), ...forms.map(formRequest)]
       };
     },
-    subscribe: (signal) => signalStream(target, "/api/event", parseV2Signal, signal),
-    async replyPermission(sessionId, requestId, reply) {
-      await http.send(`${session(sessionId)}/permission/${encodeURIComponent(requestId)}/reply`, {
-        method: "POST",
-        json: { reply }
-      });
+    async* subscribe(signal) {
+      try {
+        for await (const event of client.event.subscribe({ signal })) {
+          if (event.type === "server.connected") {
+            yield { type: "connected" };
+            continue;
+          }
+          const parsed = parseV2Signal(event);
+          if (parsed)
+            yield parsed;
+        }
+        signal.throwIfAborted();
+      } catch (error) {
+        throw unwrapClientError(error);
+      }
+    },
+    async replyPermission(sessionID, requestID, decision) {
+      await call(client.permission.reply({ sessionID, requestID, decision }, options()));
     },
-    async replyQuestion(sessionId, request, answers) {
+    async replyQuestion(sessionID, request, answers) {
       const answer = {};
       request.questions.forEach((question, index) => {
         const selected = (answers[index] ?? []).map((label) => optionValue(question, label));
         answer[question.key] = question.multiple ? selected : selected[0] ?? "";
       });
-      await http.send(`${session(sessionId)}/form/${encodeURIComponent(request.id)}/reply`, {
-        method: "POST",
-        json: { answer }
-      });
+      await call(client.session.form.reply({ sessionID, formID: request.id, answer }, options()));
     },
-    async rejectQuestion(sessionId, requestId) {
-      await http.send(`${session(sessionId)}/form/${encodeURIComponent(requestId)}/cancel`, {
-        method: "POST",
-        json: {}
-      });
+    async rejectQuestion(sessionID, formID) {
+      await call(client.session.form.cancel({ sessionID, formID }, options()));
     }
   };
-  async function listMessages(sessionId) {
-    const pageSize = 200;
+  async function listMessages(sessionID) {
+    const limit = 200;
     const messages = [];
-    let query = `?order=asc&limit=${pageSize}`;
+    let cursor;
     while (true) {
-      const page = await http.json(`${session(sessionId)}/message${query}`);
-      const items = page.data ?? [];
-      messages.push(...items.map(asRecord));
-      const next = page.cursor?.next ?? null;
-      if (!next || items.length < pageSize)
+      const page = await call(client.message.list(cursor ? { sessionID, cursor, limit } : { sessionID, order: "asc", limit }, options()));
+      messages.push(...page.data);
+      const next = page.cursor.next ?? null;
+      if (!next || page.data.length < limit)
         break;
-      query = `?cursor=${encodeURIComponent(next)}&limit=${pageSize}`;
+      cursor = next;
     }
     return messages;
   }
@@ -970,11 +2537,6 @@ function directRunOperations(assertWorkspace, fetchImpl) {
   };
 }
 
-// src/direct/client.ts
-import {
-  createOpencodeClient as createOpencodeV2Client
-} from "@opencode-ai/sdk/v2";
-
 // src/direct/ascii.ts
 import { BoxApi, Configuration, waitUntilReady } from "@asciidev/box-sdk";
 
@@ -2951,35 +4513,6 @@ function resolveProvider(provider) {
       return createVercelDirectProvider(provider);
   }
 }
-function createAuthClient(workspace, fetchImpl) {
-  const authorization = workspace.runtime.password ? `Basic ${Buffer.from(`opencode:${workspace.runtime.password}`).toString("base64")}` : undefined;
-  return createOpencodeV2Client({
-    fetch: fetchImpl,
-    baseUrl: workspace.runtime.url,
-    directory: workspace.runtime.directory,
-    headers: {
-      ...workspace.runtime.headers,
-      ...authorization ? { Authorization: authorization } : {}
-    }
-  });
-}
-function errorMessage(error) {
-  if (!error)
-    return "OpenCode request failed";
-  if (typeof error === "string")
-    return error;
-  if (typeof error === "object" && "data" in error) {
-    const data = error.data;
-    if (typeof data?.message === "string")
-      return data.message;
-  }
-  if (typeof error === "object" && "message" in error) {
-    const message = error.message;
-    if (typeof message === "string")
-      return message;
-  }
-  return error instanceof Error ? error.message : JSON.stringify(error);
-}
 function authStatus(status) {
   const common = {
     createdAt: Number(status.time.created),
@@ -3034,14 +4567,20 @@ function setupRunner(commands) {
 }
 function createDirectGittermClient(options) {
   const provider = resolveProvider(options.provider);
-  const authClient = (workspace) => createAuthClient(workspace, options.fetch);
-  const http = (workspace) => createRuntimeHttp({
+  const opencode = (workspace) => createOpencodeClient({
     url: workspace.runtime.url,
-    directory: workspace.runtime.directory,
     password: workspace.runtime.password ?? null,
     headers: workspace.runtime.headers,
     fetch: options.fetch
   });
+  const location = (workspace) => ({ directory: workspace.runtime.directory });
+  async function request(operation) {
+    try {
+      return await call(operation(requestTimeout()));
+    } catch (error) {
+      throw directError(error);
+    }
+  }
   function assertWorkspace(workspace) {
     if (workspace.provider !== provider.name) {
       throw new GittermError("BAD_REQUEST", `Workspace belongs to ${workspace.provider}, not ${provider.name}`);
@@ -3055,22 +4594,26 @@ function createDirectGittermClient(options) {
   }
   async function getAuthStatus(attempt, workspace) {
     assertAuthAttempt(attempt, workspace);
-    const result = await authClient(workspace).v2.integration.attempt.status({
-      attemptID: attempt.id
-    });
-    if (result.error || !result.data)
-      throw new Error(errorMessage(result.error));
-    return authStatus(result.data.data);
+    const result = await request((requestOptions) => opencode(workspace).integration.oauth.status({
+      integrationID: attempt.integrationId,
+      attemptID: attempt.id,
+      location: location(workspace)
+    }, requestOptions));
+    return authStatus(result.data);
   }
   async function startPty(workspace, command, title) {
-    return http(workspace).json("/api/pty", {
-      method: "POST",
-      json: { command: "bash", args: ["-lc", command], cwd: workspace.runtime.directory, title }
-    });
+    return request((requestOptions) => opencode(workspace).pty.create({
+      location: location(workspace),
+      command: "bash",
+      args: ["-lc", command],
+      cwd: workspace.runtime.directory,
+      title
+    }, requestOptions));
   }
   async function setupFile(workspace, name) {
     try {
-      return (await (await http(workspace).send(`/api/fs/read/${SETUP_DIR}/${name}`)).text()).trim();
+      const bytes = await call(opencode(workspace).file.read({ path: `${SETUP_DIR}/${name}`, location: location(workspace) }, requestTimeout()));
+      return new TextDecoder().decode(bytes).trim();
     } catch (error) {
       if (error instanceof RuntimeHttpError && error.status === 404)
         return null;
@@ -3125,45 +4668,37 @@ function createDirectGittermClient(options) {
         if (credential.source !== "apiKey")
           throw new GittermError("BAD_REQUEST", "Use connectOAuth() for OAuth credential rotation, or inject an OAuth bundle when creating the workspace");
         directModelAuth(credential);
-        await http(workspace).send(`/api/integration/${encodeURIComponent(providerName)}/connect/key`, { method: "POST", json: { key: credential.apiKey } });
+        await request((requestOptions) => opencode(workspace).integration.connect.key({ integrationID: providerName, key: credential.apiKey, location: location(workspace) }, requestOptions));
       },
       async list(workspace) {
         assertWorkspace(workspace);
-        const result = await authClient(workspace).v2.integration.list();
-        if (result.error || !result.data)
-          throw new Error(errorMessage(result.error));
-        return result.data.data;
+        const result = await request((requestOptions) => opencode(workspace).integration.list({ location: location(workspace) }, requestOptions));
+        return result.data;
       },
       async get(workspace, integrationId) {
         assertWorkspace(workspace);
-        const result = await authClient(workspace).v2.integration.get({
-          integrationID: integrationId
-        });
-        if (result.error || !result.data)
-          throw new Error(errorMessage(result.error));
-        return result.data.data;
+        const result = await request((requestOptions) => opencode(workspace).integration.get({ integrationID: integrationId, location: location(workspace) }, requestOptions));
+        return result.data;
       },
       async connectKey(input) {
         assertWorkspace(input.workspace);
-        const result = await authClient(input.workspace).v2.integration.connect.key({
+        await request((requestOptions) => opencode(input.workspace).integration.connect.key({
           integrationID: input.integrationId,
           key: input.key,
-          label: input.label
-        });
-        if (result.error)
-          throw new Error(errorMessage(result.error));
+          label: input.label,
+          location: location(input.workspace)
+        }, requestOptions));
       },
       async connectOAuth(input) {
         assertWorkspace(input.workspace);
-        const result = await authClient(input.workspace).v2.integration.connect.oauth({
+        const result = await request((requestOptions) => opencode(input.workspace).integration.oauth.connect({
           integrationID: input.integrationId,
           methodID: input.methodId,
-          inputs: input.inputs ?? {},
-          label: input.label
-        });
-        if (result.error || !result.data)
-          throw new Error(errorMessage(result.error));
-        const attempt = result.data.data;
+          answer: input.inputs,
+          label: input.label,
+          location: location(input.workspace)
+        }, requestOptions));
+        const attempt = result.data;
         return {
           id: attempt.attemptID,
           workspaceId: input.workspace.id,
@@ -3184,12 +4719,12 @@ function createDirectGittermClient(options) {
           throw new Error("Only code-based OAuth attempts are completed manually");
         if (!code.trim())
           throw new Error("OAuth authorization code is required");
-        const result = await authClient(workspace).v2.integration.attempt.complete({
+        await request((requestOptions) => opencode(workspace).integration.oauth.complete({
+          integrationID: attempt.integrationId,
           attemptID: attempt.id,
-          code
-        });
-        if (result.error)
-          throw new Error(errorMessage(result.error));
+          code,
+          location: location(workspace)
+        }, requestOptions));
       },
       async wait(attempt, workspace, wait = {}) {
         assertAuthAttempt(attempt, workspace);
@@ -3212,11 +4747,11 @@ function createDirectGittermClient(options) {
       },
       async cancel(attempt, workspace) {
         assertAuthAttempt(attempt, workspace);
-        const result = await authClient(workspace).v2.integration.attempt.cancel({
-          attemptID: attempt.id
-        });
-        if (result.error)
-          throw new Error(errorMessage(result.error));
+        await request((requestOptions) => opencode(workspace).integration.oauth.cancel({
+          integrationID: attempt.integrationId,
+          attemptID: attempt.id,
+          location: location(workspace)
+        }, requestOptions));
       }
     },
     workspaces: {