@gitterm/sdk 0.11.0 → 0.12.1

package/dist/direct/index.js

@@ -30,7 +30,7 @@ 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
+// ../../node_modules/.bun/@opencode+client@2.2.6+307d8a970cbb91e6/node_modules/@opencode/client/dist/chunks/contract-9rqn6x4v.js
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -46,7 +46,7 @@ var __export = (target, all) => {
     });
 };
 
-// ../../node_modules/.bun/@opencode+client@2.0.19+43902b222b0d7d3e/node_modules/@opencode/client/dist/chunks/rpc-runtime-frbwqjmf.js
+// ../../node_modules/.bun/@opencode+client@2.2.6+307d8a970cbb91e6/node_modules/@opencode/client/dist/chunks/contract-gecjxyvt.js
 var exports_shared_events = {};
 __export(exports_shared_events, {
   SharedEvents: () => exports_shared_events,
@@ -100,6 +100,8 @@ function make7(connect) {
           let started = false;
           let completion;
           let connection;
+          const types = options?.types?.length ? new Set(options.types) : undefined;
+          const selected = (value) => !types || value.type === "server.connected" || types.has(value.type);
           function finish(result, discard = true) {
             completion = result;
             if (discard)
@@ -125,6 +127,8 @@ function make7(connect) {
             push(value) {
               if (completion)
                 return;
+              if (!selected(value))
+                return;
               const request = pending.shift();
               if (request) {
                 request.resolve({ done: false, value });
@@ -186,8 +190,8 @@ function make7(connect) {
   };
 }
 
-// ../../node_modules/.bun/@opencode+client@2.0.19+43902b222b0d7d3e/node_modules/@opencode/client/dist/chunks/rpc-runtime-js54wxgp.js
-class ClientError2 extends Error {
+// ../../node_modules/.bun/@opencode+client@2.2.6+307d8a970cbb91e6/node_modules/@opencode/client/dist/chunks/contract-nwcpakzx.js
+class ClientError3 extends Error {
   reason;
   name = "ClientError";
   constructor(reason, options) {
@@ -197,13 +201,13 @@ class ClientError2 extends Error {
   }
 }
 
-// ../../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
+// ../../node_modules/.bun/@opencode+client@2.2.6+307d8a970cbb91e6/node_modules/@opencode/client/dist/chunks/contract-vxrn9xjg.js
+var exports_client4 = {};
+__export(exports_client4, {
+  make: () => make6
 });
 var maxSseEventBytes = 16 * 1024 * 1024;
-function make3(options) {
+function make6(options) {
   const fetch2 = options.fetch ?? globalThis.fetch;
   const prepare = (descriptor, requestOptions) => {
     const baseUrl = new URL(options.baseUrl);
@@ -236,7 +240,7 @@ function make3(options) {
       const prepared = prepare(descriptor, requestOptions);
       return await fetch2(prepared.url, prepared.init);
     } catch (cause) {
-      throw new ClientError2("Transport", { cause });
+      throw new ClientError3("Transport", { cause });
     }
   };
   const responseError = async (response, descriptor) => {
@@ -245,7 +249,7 @@ function make3(options) {
     try {
       await response.body?.cancel();
     } catch {}
-    throw new ClientError2("UnexpectedStatus", { cause: { status: response.status }, detail: String(response.status) });
+    throw new ClientError3("UnexpectedStatus", { cause: { status: response.status }, detail: String(response.status) });
   };
   const request = async (descriptor, requestOptions) => {
     const response = await execute(descriptor, requestOptions);
@@ -270,10 +274,10 @@ function make3(options) {
         try {
           await response.body?.cancel();
         } catch {}
-        throw new ClientError2("UnsupportedContentType", { detail: response.headers.get("content-type") });
+        throw new ClientError3("UnsupportedContentType", { detail: response.headers.get("content-type") });
       }
       if (response.body === null)
-        throw new ClientError2("MalformedResponse");
+        throw new ClientError3("MalformedResponse");
       const reader = response.body.getReader();
       const decoder = new TextDecoder;
       let buffer = "";
@@ -283,13 +287,13 @@ function make3(options) {
           try {
             next = await reader.read();
           } catch (cause) {
-            throw new ClientError2("Transport", { cause });
+            throw new ClientError3("Transport", { cause });
           }
           if (!next.done)
             requestOptions?.onActivity?.();
           buffer += decoder.decode(next.value, { stream: !next.done });
           if (buffer.length > maxSseEventBytes)
-            throw new ClientError2("SseEventTooLarge");
+            throw new ClientError3("SseEventTooLarge");
           const trailingCarriageReturn = !next.done && buffer.endsWith("\r");
           if (trailingCarriageReturn)
             buffer = buffer.slice(0, -1);
@@ -316,7 +320,7 @@ function make3(options) {
               try {
                 yield JSON.parse(data);
               } catch (cause) {
-                throw new ClientError2("MalformedResponse", { cause });
+                throw new ClientError3("MalformedResponse", { cause });
               }
             }
             boundary = buffer.indexOf(`
@@ -334,7 +338,7 @@ function make3(options) {
       }
     }
   });
-  return {
+  const client = {
     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),
@@ -352,7 +356,7 @@ function make3(options) {
         path: `/api/location`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions),
       reload: (requestOptions) => request({
@@ -369,7 +373,7 @@ function make3(options) {
         path: `/api/agent`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404, 503],
         empty: false
       }, requestOptions),
       get: (input, requestOptions) => request({
@@ -387,7 +391,15 @@ function make3(options) {
         path: `/api/plugin`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      gui: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/plugin/gui`,
+        query: { location: input["location"], id: input["id"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions),
       check: (input, requestOptions) => request({
@@ -396,7 +408,7 @@ function make3(options) {
         query: { location: input?.["location"] },
         body: { target: input?.["target"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions),
       update: (input, requestOptions) => request({
@@ -405,7 +417,7 @@ function make3(options) {
         query: { location: input["location"] },
         body: { targets: input["targets"] },
         successStatus: 204,
-        declaredStatuses: [400, 401, 503],
+        declaredStatuses: [400, 401, 404, 503],
         empty: true
       }, requestOptions)
     },
@@ -418,6 +430,7 @@ function make3(options) {
           order: input?.["order"],
           search: input?.["search"],
           parentID: input?.["parentID"],
+          archived: input?.["archived"],
           directory: input?.["directory"],
           project: input?.["project"],
           subpath: input?.["subpath"],
@@ -427,25 +440,12 @@ function make3(options) {
         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"],
@@ -454,23 +454,7 @@ function make3(options) {
           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],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions).then((value) => value.data),
       active: (requestOptions) => request({
@@ -521,7 +505,12 @@ function make3(options) {
       update: (input, requestOptions) => request({
         method: "PATCH",
         path: `/api/session/${encodeURIComponent(input.sessionID)}`,
-        body: { title: input["title"], metadata: input["metadata"], permissions: input["permissions"] },
+        body: {
+          title: input["title"],
+          metadata: input["metadata"],
+          permissions: input["permissions"],
+          archived: input["archived"]
+        },
         successStatus: 204,
         declaredStatuses: [400, 401, 404],
         empty: true
@@ -566,14 +555,6 @@ function make3(options) {
         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`,
@@ -605,13 +586,6 @@ function make3(options) {
         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",
@@ -675,32 +649,6 @@ function make3(options) {
           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`,
@@ -709,14 +657,6 @@ function make3(options) {
         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`,
@@ -775,6 +715,7 @@ function make3(options) {
         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
@@ -797,6 +738,493 @@ function make3(options) {
         empty: true
       }, requestOptions)
     },
+    experimental: {
+      session: {
+        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),
+        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),
+        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),
+        wait: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/wait`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 503],
+          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)
+          }
+        },
+        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)
+      },
+      generate: {
+        text: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/generate/text`,
+          body: { prompt: input["prompt"], model: input["model"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 422, 502, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        image: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/generate/image`,
+          body: {
+            model: input["model"],
+            prompt: input["prompt"],
+            images: input["images"],
+            n: input["n"],
+            aspect: input["aspect"],
+            resolution: input["resolution"]
+          },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 422, 502, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        decisions: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/generate/decisions`,
+          body: { model: input["model"], input: input["input"], questions: input["questions"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 422, 502, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data)
+      },
+      voice: {
+        models: (requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/voice/models`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        session: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/voice/session`,
+          body: { model: input["model"], session: input["session"], transport: input["transport"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data)
+      },
+      integration: {
+        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)
+        }
+      },
+      mcp: {
+        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),
+        client: {
+          token: (input, requestOptions) => request({
+            method: "POST",
+            path: `/api/experimental/client-mcp/token`,
+            query: { location: input["location"], name: input["name"] },
+            headers: { "x-opencode-ticket": input["x-opencode-ticket"] },
+            successStatus: 200,
+            declaredStatuses: [400, 401, 403, 404],
+            empty: false
+          }, requestOptions)
+        }
+      },
+      file: {
+        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),
+        watch: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/fs/watch`,
+          query: { location: input["location"] },
+          body: { path: input["path"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: true
+        }, requestOptions),
+        unwatch: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/experimental/fs/watch`,
+          query: { location: input["location"] },
+          body: { path: input["path"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      },
+      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"], title: input["title"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 501, 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)
+      },
+      media: {
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/media/${encodeURIComponent(input.hash)}`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false,
+          binary: true
+        }, requestOptions)
+      },
+      schedule: {
+        create: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/schedule`,
+          body: {
+            sessionID: input["sessionID"],
+            name: input["name"],
+            when: input["when"],
+            if: input["if"],
+            until: input["until"],
+            ends: input["ends"],
+            prompt: input["prompt"]
+          },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/schedule`,
+          query: { sessionID: input["sessionID"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/schedule/${encodeURIComponent(input.scheduleID)}`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        pause: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/schedule/${encodeURIComponent(input.scheduleID)}/pause`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        resume: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/schedule/${encodeURIComponent(input.scheduleID)}/resume`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        delete: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/experimental/schedule/${encodeURIComponent(input.scheduleID)}`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 403, 404],
+          empty: true
+        }, requestOptions)
+      },
+      artifacts: {
+        providers: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/artifacts/providers`,
+          query: { location: input?.["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404, 503],
+          empty: false
+        }, requestOptions),
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/artifacts`,
+          query: { location: input?.["location"], sessionID: input?.["sessionID"], provider: input?.["provider"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404, 503],
+          empty: false
+        }, requestOptions),
+        create: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/artifacts`,
+          query: { location: input["location"] },
+          body: {
+            title: input["title"],
+            files: input["files"],
+            entry: input["entry"],
+            provider: input["provider"],
+            sessionID: input["sessionID"]
+          },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404, 503],
+          empty: false
+        }, requestOptions),
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/artifacts/${encodeURIComponent(input.artifactID)}`,
+          query: { location: input["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404, 503],
+          empty: false
+        }, requestOptions),
+        update: (input, requestOptions) => request({
+          method: "PATCH",
+          path: `/api/experimental/artifacts/${encodeURIComponent(input.artifactID)}`,
+          query: { location: input["location"] },
+          body: {
+            title: input["title"],
+            files: input["files"],
+            entry: input["entry"],
+            sessionID: input["sessionID"]
+          },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404, 503],
+          empty: false
+        }, requestOptions),
+        delete: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/experimental/artifacts/${encodeURIComponent(input.artifactID)}`,
+          query: { location: input["location"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 403, 404, 503],
+          empty: true
+        }, requestOptions),
+        view: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/artifacts/${encodeURIComponent(input.artifactID)}/view/${encodePath(input.path)}`,
+          query: { location: input["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404, 503],
+          empty: false,
+          binary: true
+        }, requestOptions)
+      },
+      job: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/job`,
+          query: {
+            sessionID: input?.["sessionID"],
+            kind: input?.["kind"],
+            status: input?.["status"],
+            descendants: input?.["descendants"]
+          },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data)
+      },
+      migration: {
+        v1: {
+          status: (requestOptions) => request({
+            method: "GET",
+            path: `/api/experimental/migration/v1`,
+            successStatus: 200,
+            declaredStatuses: [400, 401],
+            empty: false
+          }, requestOptions)
+        }
+      },
+      usage: {
+        limits: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/usage/limits`,
+          query: { location: input?.["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions)
+      },
+      config: {
+        update: (input, requestOptions) => request({
+          method: "PATCH",
+          path: `/api/experimental/config`,
+          body: { shell: input["shell"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      }
+    },
     message: {
       list: (input, requestOptions) => request({
         method: "GET",
@@ -811,9 +1239,9 @@ function make3(options) {
       list: (input, requestOptions) => request({
         method: "GET",
         path: `/api/model`,
-        query: { location: input?.["location"] },
+        query: { location: input?.["location"], types: input?.["types"] },
         successStatus: 200,
-        declaredStatuses: [400, 401, 503],
+        declaredStatuses: [400, 401, 404, 503],
         empty: false
       }, requestOptions),
       default: (input, requestOptions) => request({
@@ -821,27 +1249,17 @@ function make3(options) {
         path: `/api/model/default`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401, 503],
+        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, 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],
+        declaredStatuses: [400, 401, 404, 503],
         empty: false
       }, requestOptions),
       get: (input, requestOptions) => request({
@@ -859,7 +1277,7 @@ function make3(options) {
         path: `/api/integration`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions),
       get: (input, requestOptions) => request({
@@ -870,17 +1288,6 @@ function make3(options) {
         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",
@@ -890,6 +1297,15 @@ function make3(options) {
           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: {
@@ -899,7 +1315,7 @@ function make3(options) {
           query: { location: input["location"] },
           body: { methodID: input["methodID"], answer: input["answer"], label: input["label"] },
           successStatus: 200,
-          declaredStatuses: [400, 401],
+          declaredStatuses: [400, 401, 404],
           empty: false
         }, requestOptions),
         status: (input, requestOptions) => request({
@@ -924,7 +1340,7 @@ function make3(options) {
           path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
           query: { location: input["location"] },
           successStatus: 204,
-          declaredStatuses: [400, 401],
+          declaredStatuses: [400, 401, 404],
           empty: true
         }, requestOptions)
       },
@@ -946,57 +1362,24 @@ function make3(options) {
           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,
+        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: true
+        empty: false
       }, requestOptions),
       resource: {
         catalog: (input, requestOptions) => request({
@@ -1004,12 +1387,27 @@ function make3(options) {
           path: `/api/mcp/resource`,
           query: { location: input?.["location"] },
           successStatus: 200,
-          declaredStatuses: [400, 401],
+          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)}`,
@@ -1034,7 +1432,14 @@ function make3(options) {
       }, requestOptions)
     },
     project: {
-      list: (requestOptions) => request({ method: "GET", path: `/api/project`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions),
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/project`,
+        query: { archived: input?.["archived"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
       update: (input, requestOptions) => request({
         method: "PATCH",
         path: `/api/project/${encodeURIComponent(input.projectID)}`,
@@ -1055,7 +1460,7 @@ function make3(options) {
         path: `/api/form`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions)
     },
@@ -1066,7 +1471,7 @@ function make3(options) {
           path: `/api/permission/request`,
           query: { location: input?.["location"] },
           successStatus: 200,
-          declaredStatuses: [400, 401],
+          declaredStatuses: [400, 401, 404],
           empty: false
         }, requestOptions)
       },
@@ -1076,7 +1481,15 @@ function make3(options) {
           path: `/api/permission/saved`,
           query: { projectID: input?.["projectID"] },
           successStatus: 200,
-          declaredStatuses: [400, 401],
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        update: (input, requestOptions) => request({
+          method: "PATCH",
+          path: `/api/permission/saved/${encodeURIComponent(input.id)}`,
+          body: { action: input["action"], resource: input["resource"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 409],
           empty: false
         }, requestOptions).then((value) => value.data),
         remove: (input, requestOptions) => request({
@@ -1141,7 +1554,7 @@ function make3(options) {
         path: `/api/fs/list`,
         query: { location: input?.["location"], path: input?.["path"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions),
       find: (input, requestOptions) => request({
@@ -1149,18 +1562,8 @@ function make3(options) {
         path: `/api/fs/find`,
         query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        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],
-        empty: false,
-        binaryBody: true
       }, requestOptions)
     },
     command: {
@@ -1169,7 +1572,7 @@ function make3(options) {
         path: `/api/command`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions)
     },
@@ -1179,7 +1582,7 @@ function make3(options) {
         path: `/api/skill`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions)
     },
@@ -1190,12 +1593,19 @@ function make3(options) {
         query: { location: input["location"] },
         body: { input: input["input"] },
         successStatus: 200,
-        declaredStatuses: [400, 401, 500],
+        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)
+      subscribe: (input, requestOptions) => sse({
+        method: "GET",
+        path: `/api/event`,
+        query: { types: input?.["types"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions)
     },
     pty: {
       list: (input, requestOptions) => request({
@@ -1203,7 +1613,7 @@ function make3(options) {
         path: `/api/pty`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions),
       create: (input, requestOptions) => request({
@@ -1218,7 +1628,7 @@ function make3(options) {
           env: input?.["env"]
         },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions),
       get: (input, requestOptions) => request({
@@ -1258,98 +1668,13 @@ function make3(options) {
         }, 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],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions),
       create: (input, requestOptions) => request({
@@ -1363,7 +1688,7 @@ function make3(options) {
           metadata: input["metadata"]
         },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions),
       get: (input, requestOptions) => request({
@@ -1387,7 +1712,7 @@ function make3(options) {
         path: `/api/shell/${encodeURIComponent(input.id)}`,
         query: { location: input["location"] },
         successStatus: 204,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: true
       }, requestOptions)
     },
@@ -1397,7 +1722,7 @@ function make3(options) {
         path: `/api/reference`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions)
     },
@@ -1442,12 +1767,20 @@ function make3(options) {
       }, 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],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions),
       base: (input, requestOptions) => request({
@@ -1455,7 +1788,7 @@ function make3(options) {
         path: `/api/vcs/base`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401, 503],
+        declaredStatuses: [400, 401, 404, 503],
         empty: false
       }, requestOptions),
       status: (input, requestOptions) => request({
@@ -1463,7 +1796,7 @@ function make3(options) {
         path: `/api/vcs/status`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         empty: false
       }, requestOptions),
       branch: {
@@ -1472,20 +1805,34 @@ function make3(options) {
           path: `/api/vcs/branch`,
           query: { location: input?.["location"], search: input?.["search"], limit: input?.["limit"] },
           successStatus: 200,
-          declaredStatuses: [400, 401],
+          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"] },
+        query: {
+          location: input["location"],
+          mode: input["mode"],
+          base: input["base"],
+          context: input["context"],
+          untracked: input["untracked"]
+        },
         successStatus: 200,
-        declaredStatuses: [400, 401, 503],
+        declaredStatuses: [400, 401, 404, 503],
         empty: false
       }, requestOptions)
     },
     debug: {
+      heapDump: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/debug/heap-dump`,
+        query: { directory: input?.["directory"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 500],
+        empty: false
+      }, requestOptions),
       location: {
         list: (requestOptions) => request({
           method: "GET",
@@ -1504,24 +1851,13 @@ function make3(options) {
         }, 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],
+        declaredStatuses: [400, 401, 404, 503],
         empty: false
       }, requestOptions),
       query: (input, requestOptions) => request({
@@ -1530,7 +1866,7 @@ function make3(options) {
         query: { location: input["location"] },
         body: { query: input["query"], providerID: input["providerID"] },
         successStatus: 200,
-        declaredStatuses: [400, 401, 503],
+        declaredStatuses: [400, 401, 404, 503],
         empty: false
       }, requestOptions)
     },
@@ -1540,20 +1876,80 @@ function make3(options) {
         path: `/api/config`,
         query: { location: input?.["location"] },
         successStatus: 200,
-        declaredStatuses: [400, 401],
+        declaredStatuses: [400, 401, 404],
         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
+      shells: (requestOptions) => request({
+        method: "GET",
+        path: `/api/config/shell`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
       }, requestOptions)
     }
   };
+  return {
+    ...client,
+    session: {
+      ...client.session,
+      stats: client.experimental.session.stats,
+      import: client.experimental.session.import,
+      export: client.experimental.session.export,
+      skill: client.experimental.session.skill,
+      wait: client.experimental.session.wait,
+      instructions: {
+        entry: {
+          list: client.experimental.session.instructions.entry.list,
+          put: client.experimental.session.instructions.entry.put,
+          remove: client.experimental.session.instructions.entry.remove
+        }
+      },
+      log: client.experimental.session.log
+    },
+    generate: {
+      text: client.experimental.generate.text,
+      image: client.experimental.generate.image,
+      decisions: client.experimental.generate.decisions
+    },
+    voice: {
+      models: client.experimental.voice.models,
+      session: client.experimental.voice.session
+    },
+    integration: {
+      ...client.integration,
+      wellknown: {
+        add: client.experimental.integration.wellknown.add
+      }
+    },
+    mcp: {
+      ...client.mcp,
+      add: client.experimental.mcp.add,
+      remove: client.experimental.mcp.remove,
+      connect: client.experimental.mcp.connect,
+      disconnect: client.experimental.mcp.disconnect,
+      client: {
+        token: client.experimental.mcp.client.token
+      }
+    },
+    file: {
+      ...client.file,
+      write: client.experimental.file.write,
+      watch: client.experimental.file.watch,
+      unwatch: client.experimental.file.unwatch
+    },
+    migration: {
+      v1: {
+        status: client.experimental.migration.v1.status
+      }
+    },
+    usage: {
+      limits: client.experimental.usage.limits
+    },
+    config: {
+      ...client.config,
+      update: client.experimental.config.update
+    }
+  };
 }
 function encodePath(value) {
   return value.split("/").map(encodeURIComponent).join("/");
@@ -1582,20 +1978,20 @@ async function json(response) {
     try {
       await response.body?.cancel();
     } catch {}
-    throw new ClientError2("UnsupportedContentType", { detail: response.headers.get("content-type") });
+    throw new ClientError3("UnsupportedContentType", { detail: response.headers.get("content-type") });
   }
   let text;
   try {
     text = await response.text();
   } catch (cause) {
-    throw new ClientError2("Transport", { cause });
+    throw new ClientError3("Transport", { cause });
   }
   if (text === "")
-    throw new ClientError2("MalformedResponse");
+    throw new ClientError3("MalformedResponse");
   try {
     return JSON.parse(text);
   } catch (cause) {
-    throw new ClientError2("MalformedResponse", { cause });
+    throw new ClientError3("MalformedResponse", { cause });
   }
 }
 function declared(body) {
@@ -1608,11 +2004,11 @@ 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
+// ../../node_modules/.bun/@opencode+client@2.2.6+307d8a970cbb91e6/node_modules/@opencode/client/dist/chunks/contract-sdjh9vmn.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
+// ../../node_modules/.bun/@opencode+client@2.2.6+307d8a970cbb91e6/node_modules/@opencode/client/dist/chunks/contract-xqwq6bgr.js
 function makeRpc2(raw, events) {
   return (definition) => {
     const subscribe = (name, options) => {
@@ -1687,15 +2083,15 @@ 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
+// ../../node_modules/.bun/@opencode+client@2.2.6+307d8a970cbb91e6/node_modules/@opencode/client/dist/chunks/contract-xby11z3y.js
+var exports_client3 = {};
+__export(exports_client3, {
+  OpenCode: () => exports_client3,
+  make: () => make5
 });
-function make2(options) {
-  const raw = make3(options);
-  const events = make7((signal, onActivity) => raw.event.subscribe({ signal, onActivity }));
+function make5(options) {
+  const raw = make6(options);
+  const events = make7((signal, onActivity) => raw.event.subscribe(undefined, { signal, onActivity }));
   return {
     ...raw,
     rpc: Object.assign(makeRpc2(raw, events), raw.rpc),
@@ -1722,7 +2118,7 @@ function authorizationHeader(password) {
 }
 function createOpencodeClient(target) {
   const send = target.fetch ?? fetch;
-  return exports_client.make({
+  return exports_client3.make({
     baseUrl: target.url,
     headers: { ...target.headers, ...authorizationHeader(target.password) },
     fetch: async (input, init) => {
@@ -1735,7 +2131,7 @@ function createOpencodeClient(target) {
   });
 }
 function unwrapClientError(error) {
-  return error instanceof ClientError2 && error.reason === "Transport" && error.cause !== undefined ? error.cause : error;
+  return error instanceof ClientError3 && error.reason === "Transport" && error.cause !== undefined ? error.cause : error;
 }
 async function call(operation) {
   try {
@@ -1773,11 +2169,10 @@ function asStringArray(value) {
 function parseModelRef(model) {
   if (!model)
     return;
-  const separator = model.indexOf("/");
-  if (separator <= 0 || separator === model.length - 1) {
-    throw new Error('model must use the "provider/model" format');
-  }
-  return { providerID: model.slice(0, separator), modelID: model.slice(separator + 1) };
+  const match = /^([^/#]+)\/([^#]+)(?:#([^#]+))?$/.exec(model);
+  if (!match)
+    throw new Error('model must use the "provider/model" format with an optional #variant');
+  return { providerID: match[1], modelID: match[2], ...match[3] ? { variant: match[3] } : {} };
 }
 function permissionTitle(permission, patterns) {
   return patterns.length > 0 ? `${permission}: ${patterns.join(", ")}` : permission;
@@ -1803,29 +2198,51 @@ function truncateToolOutput(value) {
 }
 
 // ../agent-runtime/src/v2.ts
+var MODEL_READY_MS = 30000;
 function createV2Runtime(target) {
   const client = createOpencodeClient(target);
   const options = () => requestTimeout(target.signal);
   async function switchSessionOptions(sessionID, agent, model) {
     const modelRef = parseModelRef(model);
     if (modelRef) {
-      await call(client.session.switchModel({ sessionID, model: { providerID: modelRef.providerID, id: modelRef.modelID } }, options()));
+      await call(client.session.switchModel({
+        sessionID,
+        model: {
+          providerID: modelRef.providerID,
+          id: modelRef.modelID,
+          variant: modelRef.variant
+        }
+      }, options()));
     }
     if (agent)
       await call(client.session.switchAgent({ sessionID, agent }, options()));
   }
+  async function modelReady(model) {
+    const deadline = Date.now() + MODEL_READY_MS;
+    for (;; ) {
+      const { data } = await call(client.model.list({ location: { directory: target.directory } }, options()));
+      if (data.some((entry) => entry.providerID === model.providerID && entry.id === model.modelID))
+        return;
+      if (Date.now() >= deadline)
+        throw new Error(`OpenCode does not offer ${model.providerID}/${model.modelID}; check the model ID and its credential`);
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+  }
   return {
     async createSession(input) {
       const modelRef = parseModelRef(input.model);
       const created = await call(client.session.create({
         title: input.title,
         agent: input.agent,
-        model: modelRef ? { providerID: modelRef.providerID, id: modelRef.modelID } : undefined,
+        model: modelRef ? { providerID: modelRef.providerID, id: modelRef.modelID, variant: modelRef.variant } : undefined,
         location: { directory: target.directory }
       }, options()));
       return { id: created.id, title: created.title ?? input.title ?? "Agent run" };
     },
     async prompt(input) {
+      const modelRef = parseModelRef(input.model);
+      if (modelRef)
+        await modelReady(modelRef);
       await switchSessionOptions(input.sessionId, input.agent, input.model);
       await call(client.session.prompt({
         sessionID: input.sessionId,
@@ -2542,9 +2959,29 @@ function directRunOperations(assertWorkspace, fetchImpl) {
   };
 }
 
-// src/direct/ascii.ts
+// src/direct/boat.ts
 import { BoxApi, Configuration, waitUntilReady } from "@asciidev/box-sdk";
 
+// ../agent-runtime/src/opencode-config.ts
+function buildOpencodeConfig(input, extraPlugins = []) {
+  const config = { ...input };
+  const configured = Array.isArray(config.plugins) ? config.plugins : [];
+  const names = new Set(configured.map((entry) => typeof entry === "string" ? entry : entry?.package));
+  const plugins = [...configured, ...extraPlugins.filter((name) => !names.has(name))];
+  delete config.theme;
+  return {
+    $schema: "https://opencode.ai/config.json",
+    ...config,
+    ...plugins.length ? { plugins } : {}
+  };
+}
+function buildOpencodeCliConfig(input) {
+  return {
+    $schema: "https://opencode.ai/v2/cli.json",
+    theme: { name: typeof input?.theme === "string" ? input.theme : "opencode" }
+  };
+}
+
 // ../agent-runtime/src/github-auth.ts
 var GITHUB_AUTH_PATH = 'export PATH="$HOME/.gitterm/bin:$PATH"';
 var GITHUB_CLI_INSTRUCTIONS = `GitHub CLI authentication:
@@ -3114,22 +3551,13 @@ function buildDirectProvisioningPlan(input) {
       value: directModelAuth(credential)
     });
   }
-  const configuredPlugins = Array.isArray(input.opencode?.config?.plugin) ? input.opencode.config.plugin.filter((plugin) => typeof plugin === "string") : [];
-  const plugins = [...new Set([...configuredPlugins, ...input.opencode?.plugins ?? []])];
   const environmentVariables = { ...input.environmentVariables };
   delete environmentVariables.OPENCODE_SERVER_USERNAME;
   delete environmentVariables.GITTERM_DIRECT_PROVIDER;
-  const userPermission = input.opencode?.config?.permission && typeof input.opencode.config.permission === "object" && !Array.isArray(input.opencode.config.permission) ? input.opencode.config.permission : {};
   const config = {
-    $schema: "https://opencode.ai/config.json",
-    ...input.opencode?.config,
+    ...buildOpencodeConfig(input.opencode?.config, input.opencode?.plugins),
     ...input.models?.default ? { model: input.models.default } : {},
-    username: "Gitterm direct",
-    permission: {
-      external_directory: "allow",
-      ...userPermission
-    },
-    ...plugins.length ? { plugin: plugins } : {}
+    username: "Gitterm direct"
   };
   const github = githubAuthProvisioning(input.repo ? {
     url: input.repo,
@@ -3144,6 +3572,10 @@ function buildDirectProvisioningPlan(input) {
       path: "~/.config/opencode/opencode.json",
       contentBase64: base64(JSON.stringify(config))
     },
+    {
+      path: "~/.config/opencode/cli.json",
+      contentBase64: base64(JSON.stringify(buildOpencodeCliConfig(input.opencode?.config)))
+    },
     {
       path: "~/.config/opencode/AGENTS.md",
       contentBase64: base64(buildDirectGittermInstructions(input.additionalAgentInstructions))
@@ -3177,7 +3609,7 @@ function buildDirectProvisioningPlan(input) {
       files,
       environmentVariables: {
         ...environmentVariables,
-        OPENCODE_SERVER_PASSWORD: input.password
+        OPENCODE_PASSWORD: input.password
       },
       command: github ? githubAuthCommand(DIRECT_OPENCODE_COMMAND) : DIRECT_OPENCODE_COMMAND,
       port: DIRECT_OPENCODE_PORT
@@ -3288,7 +3720,7 @@ async function waitForDirectRuntime(runtime, timeoutMs = 60000) {
   throw new Error("Timed out waiting for the OpenCode runtime");
 }
 
-// src/direct/ascii.ts
+// src/direct/boat.ts
 var HOME = "/home/user";
 function serializeHandle(handle) {
   return JSON.stringify(handle);
@@ -3301,12 +3733,12 @@ function parseHandle(value) {
     }
     return handle;
   } catch {
-    throw new Error("Invalid Ascii Box direct workspace handle");
+    throw new Error("Invalid Boat direct workspace handle");
   }
 }
-function createAsciiDirectProvider(config) {
+function createBoatDirectProvider(config) {
   if (!config.apiKey.trim())
-    throw new Error("Ascii apiKey is required");
+    throw new Error("Boat apiKey is required");
   const client = new BoxApi(new Configuration({
     basePath: "https://ascii.dev/api/box/v1",
     accessToken: config.apiKey
@@ -3317,10 +3749,10 @@ function createAsciiDirectProvider(config) {
       commandRequest: { command, cwd, timeoutSeconds }
     });
     if (result.type !== "command.finished") {
-      throw new Error("Ascii Box command did not finish");
+      throw new Error("Boat command did not finish");
     }
     if (!result.success || result.exitCode !== 0) {
-      throw new Error(`Ascii Box command failed: ${result.stderr || result.stdout}`);
+      throw new Error(`Boat command failed: ${result.stderr || result.stdout}`);
     }
     return result.stdout;
   }
@@ -3332,7 +3764,7 @@ function createAsciiDirectProvider(config) {
     const output = await runCommand(handle.boxId, `host url ${handle.serve.port}`);
     const value = output.match(/https:\/\/\S+/)?.[0];
     if (!value) {
-      throw new Error(`Ascii Box did not return a hosted URL for port ${handle.serve.port}`);
+      throw new Error(`Boat did not return a hosted URL for port ${handle.serve.port}`);
     }
     const hosted = new URL(value);
     hosted.search = "";
@@ -3344,11 +3776,11 @@ function createAsciiDirectProvider(config) {
       headers: { Authorization: `Bearer ${config.apiKey}`, "X-Ascii-Confirm-Delete": boxId }
     });
     if (!response.ok && response.status !== 404) {
-      throw new Error(`Ascii Box deletion failed (${response.status})`);
+      throw new Error(`Boat deletion failed (${response.status})`);
     }
   }
   return {
-    name: "ascii",
+    name: "boat",
     capabilities: {
       persistence: "supported",
       recommendedLifecycle: "ephemeral",
@@ -4504,8 +4936,8 @@ function resolveProvider(provider) {
   if ("create" in provider)
     return provider;
   switch (provider.type) {
-    case "ascii":
-      return createAsciiDirectProvider(provider);
+    case "boat":
+      return createBoatDirectProvider(provider);
     case "daytona":
       return createDaytonaDirectProvider(provider);
     case "e2b":
@@ -4543,7 +4975,7 @@ function validateEnvironmentVariables(values) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
       throw new Error(`Invalid environment variable name: ${key}`);
     }
-    if (key === "OPENCODE_SERVER_PASSWORD" || key === "OPENCODE_SERVER_USERNAME" || key === "GITTERM_DIRECT_PROVIDER") {
+    if (key === "OPENCODE_PASSWORD" || key === "OPENCODE_SERVER_PASSWORD" || key === "OPENCODE_SERVER_USERNAME" || key === "GITTERM_DIRECT_PROVIDER") {
       throw new Error(`Environment variable ${key} is managed by Gitterm`);
     }
   }
@@ -4922,7 +5354,7 @@ ${status.log}` : ""}`);
   };
 }
 export {
-  createAsciiDirectProvider,
+  createBoatDirectProvider,
   createDaytonaDirectProvider,
   createDirectGittermClient,
   createE2BDirectProvider,