alchemylab-opencode 1.0.6 → 1.0.7

package/dist/{chunk-UWZSRZHA.js → chunk-23UYOGZG.js}

@@ -14,7 +14,10 @@ import {
   Vcs,
   WorkspaceInfo,
   Worktree
-} from "./chunk-MCWTARFP.js";
+} from "./chunk-TASPMBUL.js";
+import {
+  toOpenAPISchema
+} from "./chunk-3AF5MXLF.js";
 import {
   Agent,
   Command,
@@ -45,7 +48,7 @@ import {
   ToolRegistry,
   WorkspaceID,
   fn
-} from "./chunk-DSPC5QIG.js";
+} from "./chunk-SM6WZDN6.js";
 import {
   Account,
   AccountID,
@@ -57,7 +60,7 @@ import {
   ModelsDev,
   OrgID,
   TuiEvent
-} from "./chunk-CYXMV3J3.js";
+} from "./chunk-LU5XVQUD.js";
 import {
   BusEvent,
   Database,
@@ -89,13 +92,530 @@ import {
 import {
   withStatics
 } from "./chunk-BI5OUHTQ.js";
+import {
+  toJsonSchema
+} from "./chunk-VL3RSEZ2.js";
 import {
   __callDispose,
   __using
 } from "./chunk-HORZKFCR.js";
 
+// node_modules/@hono/standard-validator/dist/index.js
+import { validator } from "hono/validator";
+var RESTRICTED_DATA_FIELDS = { header: ["cookie"] };
+function sanitizeIssues(issues, vendor, target) {
+  if (!(target in RESTRICTED_DATA_FIELDS)) return issues;
+  const restrictedFields = RESTRICTED_DATA_FIELDS[target] || [];
+  if (vendor === "arktype") return sanitizeArktypeIssues(issues, restrictedFields);
+  if (vendor === "valibot") return sanitizeValibotIssues(issues, restrictedFields);
+  return issues;
+}
+function sanitizeArktypeIssues(issues, restrictedFields) {
+  return issues.map((issue) => {
+    if (issue && typeof issue === "object" && "data" in issue && typeof issue.data === "object" && issue.data !== null && !Array.isArray(issue.data)) {
+      const dataCopy = { ...issue.data };
+      for (const field of restrictedFields) delete dataCopy[field];
+      const sanitizedIssue = Object.create(Object.getPrototypeOf(issue));
+      Object.assign(sanitizedIssue, issue, { data: dataCopy });
+      return sanitizedIssue;
+    }
+    return issue;
+  });
+}
+function sanitizeValibotIssues(issues, restrictedFields) {
+  return issues.map((issue) => {
+    if (issue && typeof issue === "object" && "path" in issue && Array.isArray(issue.path)) {
+      for (const path of issue.path) if (typeof path === "object" && "input" in path && typeof path.input === "object" && path.input !== null && !Array.isArray(path.input)) for (const field of restrictedFields) delete path.input[field];
+    }
+    return issue;
+  });
+}
+var sValidator = (target, schema, hook) => validator(target, async (value, c) => {
+  const result = await schema["~standard"].validate(value);
+  if (hook) {
+    const hookResult = await hook(result.issues ? {
+      data: value,
+      error: result.issues,
+      success: false,
+      target
+    } : {
+      data: value,
+      success: true,
+      target
+    }, c);
+    if (hookResult) {
+      if (hookResult instanceof Response) return hookResult;
+      if ("response" in hookResult) return hookResult.response;
+    }
+  }
+  if (result.issues) {
+    const processedIssues = sanitizeIssues(result.issues, schema["~standard"].vendor, target);
+    return c.json({
+      data: value,
+      error: processedIssues,
+      success: false
+    }, 400);
+  }
+  return result.value;
+});
+
+// node_modules/hono-openapi/dist/index.js
+var uniqueSymbol = /* @__PURE__ */ Symbol("openapi");
+var ALLOWED_METHODS = [
+  "GET",
+  "PUT",
+  "POST",
+  "DELETE",
+  "OPTIONS",
+  "HEAD",
+  "PATCH",
+  "TRACE"
+];
+var toOpenAPIPath = (path) => path.split("/").map((x) => {
+  let tmp = x;
+  if (tmp.startsWith(":")) {
+    const match = tmp.match(/^:([^{?]+)(?:{(.+)})?(\?)?$/);
+    if (match) {
+      const paramName = match[1];
+      tmp = `{${paramName}}`;
+    } else {
+      tmp = tmp.slice(1, tmp.length);
+      if (tmp.endsWith("?")) tmp = tmp.slice(0, -1);
+      tmp = `{${tmp}}`;
+    }
+  }
+  return tmp;
+}).join("/");
+var capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
+var generateOperationId = (route) => {
+  let operationId = route.method.toLowerCase();
+  if (route.path === "/") return `${operationId}Index`;
+  for (const segment of route.path.split("/")) {
+    if (segment.charCodeAt(0) === 123) {
+      operationId += `By${capitalize(segment.slice(1, -1))}`;
+    } else {
+      operationId += capitalize(segment);
+    }
+  }
+  return operationId;
+};
+var paramKey = (param) => "$ref" in param ? param.$ref : `${param.in} ${param.name}`;
+function mergeParameters(...params) {
+  const merged = params.flatMap((x) => x ?? []).reduce((acc, param) => {
+    acc.set(paramKey(param), param);
+    return acc;
+  }, /* @__PURE__ */ new Map());
+  return Array.from(merged.values());
+}
+var specsByPathContext = /* @__PURE__ */ new Map();
+function getPathContext(path) {
+  const context = [];
+  for (const [key, data] of specsByPathContext) {
+    if (data && path.match(key)) {
+      context.push(data);
+    }
+  }
+  return context;
+}
+function clearSpecsContext() {
+  specsByPathContext.clear();
+}
+function mergeSpecs(route, ...specs) {
+  return specs.reduce(
+    (prev, spec) => {
+      if (!spec || !prev) return prev;
+      for (const [key, value] of Object.entries(spec)) {
+        if (value == null) continue;
+        if (key in prev && (typeof value === "object" || typeof value === "function" && key === "operationId")) {
+          if (Array.isArray(value)) {
+            const values = [...prev[key] ?? [], ...value];
+            if (key === "tags") {
+              prev[key] = Array.from(new Set(values));
+            } else if (key === "parameters") {
+              prev[key] = mergeParameters(values);
+            } else {
+              prev[key] = values;
+            }
+          } else if (typeof value === "function") {
+            prev[key] = value(route);
+          } else {
+            if (key === "parameters") {
+              prev[key] = mergeParameters(prev[key], value);
+            } else {
+              prev[key] = {
+                ...prev[key],
+                ...value
+              };
+            }
+          }
+        } else {
+          prev[key] = value;
+        }
+      }
+      return prev;
+    },
+    {
+      operationId: generateOperationId(route)
+    }
+  );
+}
+function registerSchemaPath({
+  route,
+  specs,
+  paths
+}) {
+  const path = toOpenAPIPath(route.path);
+  const method = route.method.toLowerCase();
+  if (method === "all") {
+    if (!specs) return;
+    if (specsByPathContext.has(path)) {
+      const prev = specsByPathContext.get(path) ?? {};
+      specsByPathContext.set(path, mergeSpecs(route, prev, specs));
+    } else {
+      specsByPathContext.set(path, specs);
+    }
+  } else {
+    const pathContext = getPathContext(path);
+    if (!(path in paths)) {
+      paths[path] = {};
+    }
+    if (paths[path]) {
+      paths[path][method] = mergeSpecs(
+        route,
+        ...pathContext,
+        paths[path]?.[method],
+        specs
+      );
+    }
+  }
+}
+function removeExcludedPaths(paths, ctx) {
+  const { exclude, excludeStaticFile } = ctx.options;
+  const newPaths = {};
+  const _exclude = Array.isArray(exclude) ? exclude : [exclude];
+  for (const [key, value] of Object.entries(paths)) {
+    if (value == null) continue;
+    const isExplicitlyExcluded = _exclude.some((x) => {
+      if (typeof x === "string") return key === x;
+      return x.test(key);
+    });
+    if (isExplicitlyExcluded) continue;
+    const isWildcardWithoutParameters = key.includes("*") && !key.includes("{");
+    if (isWildcardWithoutParameters) continue;
+    if (excludeStaticFile) {
+      const hasPathParameters = key.includes("{");
+      const lastSegment = key.split("/").pop() || "";
+      const looksLikeStaticFile = lastSegment.includes(".");
+      const shouldExcludeAsStaticFile = !hasPathParameters && looksLikeStaticFile;
+      if (shouldExcludeAsStaticFile) continue;
+    }
+    for (const method of Object.keys(value)) {
+      const schema = value[method];
+      if (schema == null) continue;
+      if (key.includes("{")) {
+        schema.parameters = schema.parameters ? [...schema.parameters] : [];
+        const pathParameters = key.split("/").filter(
+          (x) => x.startsWith("{") && !schema.parameters.find(
+            (params) => params.in === "path" && params.name === x.slice(1, x.length - 1)
+          )
+        );
+        for (const param of pathParameters) {
+          const paramName = param.slice(1, param.length - 1);
+          const index = schema.parameters.findIndex(
+            (x) => {
+              if ("$ref" in x) {
+                const pos = x.$ref.split("/").pop();
+                if (pos) {
+                  const param2 = ctx.components.parameters?.[pos];
+                  if (param2 && !("$ref" in param2)) {
+                    return param2.in === "path" && param2.name === paramName;
+                  }
+                }
+                return false;
+              }
+              return x.in === "path" && x.name === paramName;
+            }
+          );
+          if (index === -1) {
+            schema.parameters.push({
+              schema: { type: "string" },
+              in: "path",
+              name: paramName,
+              required: true
+            });
+          }
+        }
+      }
+      if (!schema.responses) {
+        schema.responses = {
+          200: {}
+        };
+      }
+    }
+    newPaths[key] = value;
+  }
+  return newPaths;
+}
+var DEFAULT_OPTIONS = {
+  documentation: {},
+  excludeStaticFile: true,
+  exclude: [],
+  excludeMethods: ["OPTIONS"],
+  excludeTags: []
+};
+function openAPIRouteHandler(hono, options) {
+  let specs;
+  return async (c) => {
+    if (specs) return c.json(specs);
+    specs = await generateSpecs(hono, options, c);
+    return c.json(specs);
+  };
+}
+async function generateSpecs(hono, options = DEFAULT_OPTIONS, c) {
+  const ctx = {
+    components: {},
+    // @ts-expect-error
+    options: {
+      ...DEFAULT_OPTIONS,
+      ...options
+    }
+  };
+  const _documentation = ctx.options.documentation ?? {};
+  clearSpecsContext();
+  const paths = await generatePaths(hono, ctx);
+  for (const path in paths) {
+    for (const method in paths[path]) {
+      const isHidden = getHiddenValue({
+        valueOrFunc: paths[path][method]?.hide,
+        method,
+        path,
+        c
+      });
+      if (isHidden) {
+        paths[path][method] = void 0;
+      }
+    }
+  }
+  const components = mergeComponentsObjects(
+    _documentation.components,
+    ctx.components
+  );
+  return {
+    openapi: "3.1.0",
+    ..._documentation,
+    tags: _documentation.tags?.filter(
+      (tag) => !ctx.options.excludeTags?.includes(tag?.name)
+    ),
+    info: {
+      title: "Hono Documentation",
+      description: "Development documentation",
+      version: "0.0.0",
+      ..._documentation.info
+    },
+    paths: {
+      ...removeExcludedPaths(paths, ctx),
+      ..._documentation.paths
+    },
+    components
+  };
+}
+async function generatePaths(hono, ctx) {
+  const paths = {};
+  for (const route of hono.routes) {
+    const middlewareHandler = route.handler[uniqueSymbol];
+    if (!middlewareHandler) {
+      if (ctx.options.includeEmptyPaths) {
+        registerSchemaPath({
+          route,
+          paths
+        });
+      }
+      continue;
+    }
+    const routeMethod = route.method;
+    if (routeMethod !== "ALL") {
+      if (ctx.options.excludeMethods?.includes(routeMethod)) {
+        continue;
+      }
+      if (!ALLOWED_METHODS.includes(routeMethod)) {
+        continue;
+      }
+    }
+    const defaultOptionsForThisMethod = ctx.options.defaultOptions?.[routeMethod];
+    const { schema: routeSpecs, components = {} } = await getSpec(
+      middlewareHandler,
+      defaultOptionsForThisMethod
+    );
+    ctx.components = mergeComponentsObjects(ctx.components, components);
+    registerSchemaPath({
+      route,
+      specs: routeSpecs,
+      paths
+    });
+  }
+  return paths;
+}
+function getHiddenValue(options) {
+  const { valueOrFunc, c, method, path } = options;
+  if (valueOrFunc != null) {
+    if (typeof valueOrFunc === "boolean") {
+      return valueOrFunc;
+    }
+    if (typeof valueOrFunc === "function") {
+      return valueOrFunc({ c, method, path });
+    }
+  }
+  return false;
+}
+async function getSpec(middlewareHandler, defaultOptions) {
+  if ("spec" in middlewareHandler) {
+    let components = {};
+    const tmp = {
+      ...defaultOptions,
+      ...middlewareHandler.spec,
+      responses: {
+        ...defaultOptions?.responses,
+        ...middlewareHandler.spec.responses
+      }
+    };
+    if (tmp.responses) {
+      for (const key of Object.keys(tmp.responses)) {
+        const response2 = tmp.responses[key];
+        if (!response2 || !("content" in response2)) continue;
+        for (const contentKey of Object.keys(response2.content ?? {})) {
+          const raw = response2.content?.[contentKey];
+          if (!raw) continue;
+          if (raw.schema && "toOpenAPISchema" in raw.schema) {
+            const result2 = await raw.schema.toOpenAPISchema();
+            raw.schema = result2.schema;
+            if (result2.components) {
+              components = mergeComponentsObjects(
+                components,
+                result2.components
+              );
+            }
+          }
+        }
+      }
+    }
+    return { schema: tmp, components };
+  }
+  const result = await middlewareHandler.toOpenAPISchema();
+  const docs = defaultOptions ?? {};
+  if (middlewareHandler.target === "form" || middlewareHandler.target === "json") {
+    const media = middlewareHandler.options?.media ?? middlewareHandler.target === "json" ? "application/json" : "multipart/form-data";
+    if (!docs.requestBody || !("content" in docs.requestBody) || !docs.requestBody.content) {
+      docs.requestBody = {
+        content: {
+          [media]: {
+            schema: result.schema
+          }
+        }
+      };
+    } else {
+      docs.requestBody.content[media] = {
+        schema: result.schema
+      };
+    }
+  } else {
+    let parameters = [];
+    if ("$ref" in result.schema) {
+      const ref = result.schema.$ref;
+      const pos = ref.split("/").pop();
+      if (pos && result.components?.schemas?.[pos]) {
+        const schema = result.components.schemas[pos];
+        const newParameters = generateParameters(
+          middlewareHandler.target,
+          schema
+        )[0];
+        if (!result.components.parameters) {
+          result.components.parameters = {};
+        }
+        result.components.parameters[pos] = newParameters;
+        delete result.components.schemas[pos];
+        parameters.push({
+          $ref: `#/components/parameters/${pos}`
+        });
+      }
+    } else {
+      parameters = generateParameters(middlewareHandler.target, result.schema);
+    }
+    docs.parameters = parameters;
+  }
+  return { schema: docs, components: result.components };
+}
+function generateParameters(target, schema) {
+  const parameters = [];
+  for (const [key, value] of Object.entries(schema.properties ?? {})) {
+    const def = {
+      in: target === "param" ? "path" : target,
+      name: key,
+      // @ts-expect-error
+      schema: value
+    };
+    const isRequired = schema.required?.includes(key);
+    if (isRequired) {
+      def.required = true;
+    }
+    if (def.schema && "description" in def.schema && def.schema.description) {
+      def.description = def.schema.description;
+      def.schema.description = void 0;
+    }
+    parameters.push(def);
+  }
+  return parameters;
+}
+function mergeComponentsObjects(...components) {
+  return components.reduce(
+    (prev, component, index) => {
+      if (component == null || index === 0) return prev;
+      if (prev.schemas && Object.keys(prev.schemas).length > 0 || component.schemas && Object.keys(component.schemas).length > 0) {
+        prev.schemas = {
+          ...prev.schemas,
+          ...component.schemas
+        };
+      }
+      if (prev.parameters && Object.keys(prev.parameters).length > 0 || component.parameters && Object.keys(component.parameters).length > 0) {
+        prev.parameters = {
+          ...prev.parameters,
+          ...component.parameters
+        };
+      }
+      return prev;
+    },
+    components[0] ?? {}
+  );
+}
+function resolver(schema, userDefinedOptions) {
+  return {
+    vendor: schema["~standard"].vendor,
+    validate: schema["~standard"].validate,
+    toJSONSchema: (customOptions) => toJsonSchema(schema, { ...userDefinedOptions, ...customOptions }),
+    toOpenAPISchema: (customOptions) => toOpenAPISchema(schema, { ...userDefinedOptions, ...customOptions })
+  };
+}
+function validator2(target, schema, hook, options) {
+  const middleware = sValidator(target, schema, hook);
+  return Object.assign(middleware, {
+    [uniqueSymbol]: {
+      target,
+      ...resolver(schema, options),
+      options
+    }
+  });
+}
+function describeRoute(spec) {
+  const middleware = async (_c, next) => {
+    await next();
+  };
+  return Object.assign(middleware, {
+    [uniqueSymbol]: {
+      spec
+    }
+  });
+}
+
 // packages/opencode/src/server/server.ts
-import { describeRoute as describeRoute16, generateSpecs, validator as validator15, resolver as resolver17, openAPIRouteHandler } from "hono-openapi";
 import { Hono as Hono17 } from "hono";
 import { compress } from "hono/compress";
 import { cors } from "hono/cors";
@@ -106,7 +626,7 @@ import { createNodeWebSocket as createNodeWebSocket2 } from "@hono/node-ws";
 
 // packages/opencode/src/control-plane/adaptors/index.ts
 var ADAPTORS = {
-  worktree: lazy(async () => (await import("./worktree-6GGDLADY.js")).WorktreeAdaptor)
+  worktree: lazy(async () => (await import("./worktree-3GUHT2P7.js")).WorktreeAdaptor)
 };
 function getAdaptor(type) {
   return ADAPTORS[type]();
@@ -440,7 +960,6 @@ var ServerProxy;
 })(ServerProxy || (ServerProxy = {}));
 
 // packages/opencode/src/server/instance.ts
-import { describeRoute as describeRoute14, resolver as resolver15, validator as validator13 } from "hono-openapi";
 import { Hono as Hono15 } from "hono";
 import { proxy } from "hono/proxy";
 import z19 from "zod";
@@ -448,7 +967,6 @@ import { createHash } from "node:crypto";
 
 // packages/opencode/src/server/routes/tui.ts
 import { Hono as Hono2 } from "hono";
-import { describeRoute, validator, resolver as resolver2 } from "hono-openapi";
 import z3 from "zod";
 
 // packages/opencode/src/util/queue.ts
@@ -470,7 +988,6 @@ var AsyncQueue = class {
 };
 
 // packages/opencode/src/server/error.ts
-import { resolver } from "hono-openapi";
 import z2 from "zod";
 var ERRORS = {
   400: {
@@ -520,7 +1037,7 @@ var TuiControlRoutes = new Hono2().get(
         description: "Next TUI request",
         content: {
           "application/json": {
-            schema: resolver2(TuiRequest)
+            schema: resolver(TuiRequest)
           }
         }
       }
@@ -541,13 +1058,13 @@ var TuiControlRoutes = new Hono2().get(
         description: "Response submitted successfully",
         content: {
           "application/json": {
-            schema: resolver2(z3.boolean())
+            schema: resolver(z3.boolean())
           }
         }
       }
     }
   }),
-  validator("json", z3.any()),
+  validator2("json", z3.any()),
   async (c) => {
     const body = c.req.valid("json");
     response.push(body);
@@ -566,14 +1083,14 @@ var TuiRoutes = lazy(
           description: "Prompt processed successfully",
           content: {
             "application/json": {
-              schema: resolver2(z3.boolean())
+              schema: resolver(z3.boolean())
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator("json", TuiEvent.PromptAppend.properties),
+    validator2("json", TuiEvent.PromptAppend.properties),
     async (c) => {
       await Bus.publish(TuiEvent.PromptAppend, c.req.valid("json"));
       return c.json(true);
@@ -589,7 +1106,7 @@ var TuiRoutes = lazy(
           description: "Help dialog opened successfully",
           content: {
             "application/json": {
-              schema: resolver2(z3.boolean())
+              schema: resolver(z3.boolean())
             }
           }
         }
@@ -612,7 +1129,7 @@ var TuiRoutes = lazy(
           description: "Session dialog opened successfully",
           content: {
             "application/json": {
-              schema: resolver2(z3.boolean())
+              schema: resolver(z3.boolean())
             }
           }
         }
@@ -635,7 +1152,7 @@ var TuiRoutes = lazy(
           description: "Theme dialog opened successfully",
           content: {
             "application/json": {
-              schema: resolver2(z3.boolean())
+              schema: resolver(z3.boolean())
             }
           }
         }
@@ -658,7 +1175,7 @@ var TuiRoutes = lazy(
           description: "Model dialog opened successfully",
           content: {
             "application/json": {
-              schema: resolver2(z3.boolean())
+              schema: resolver(z3.boolean())
             }
           }
         }
@@ -681,7 +1198,7 @@ var TuiRoutes = lazy(
           description: "Prompt submitted successfully",
           content: {
             "application/json": {
-              schema: resolver2(z3.boolean())
+              schema: resolver(z3.boolean())
             }
           }
         }
@@ -704,7 +1221,7 @@ var TuiRoutes = lazy(
           description: "Prompt cleared successfully",
           content: {
             "application/json": {
-              schema: resolver2(z3.boolean())
+              schema: resolver(z3.boolean())
             }
           }
         }
@@ -727,14 +1244,14 @@ var TuiRoutes = lazy(
           description: "Command executed successfully",
           content: {
             "application/json": {
-              schema: resolver2(z3.boolean())
+              schema: resolver(z3.boolean())
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator("json", z3.object({ command: z3.string() })),
+    validator2("json", z3.object({ command: z3.string() })),
     async (c) => {
       const command = c.req.valid("json").command;
       await Bus.publish(TuiEvent.CommandExecute, {
@@ -768,13 +1285,13 @@ var TuiRoutes = lazy(
           description: "Toast notification shown successfully",
           content: {
             "application/json": {
-              schema: resolver2(z3.boolean())
+              schema: resolver(z3.boolean())
             }
           }
         }
       }
     }),
-    validator("json", TuiEvent.ToastShow.properties),
+    validator2("json", TuiEvent.ToastShow.properties),
     async (c) => {
       await Bus.publish(TuiEvent.ToastShow, c.req.valid("json"));
       return c.json(true);
@@ -790,14 +1307,14 @@ var TuiRoutes = lazy(
           description: "Event published successfully",
           content: {
             "application/json": {
-              schema: resolver2(z3.boolean())
+              schema: resolver(z3.boolean())
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator(
+    validator2(
       "json",
       z3.union(
         Object.values(TuiEvent).map((def) => {
@@ -826,14 +1343,14 @@ var TuiRoutes = lazy(
           description: "Session selected successfully",
           content: {
             "application/json": {
-              schema: resolver2(z3.boolean())
+              schema: resolver(z3.boolean())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator("json", TuiEvent.SessionSelect.properties),
+    validator2("json", TuiEvent.SessionSelect.properties),
     async (c) => {
       const { sessionID } = c.req.valid("json");
       await Session.get(sessionID);
@@ -845,13 +1362,11 @@ var TuiRoutes = lazy(
 
 // packages/opencode/src/server/routes/question.ts
 import { Hono as Hono3 } from "hono";
-import { describeRoute as describeRoute2, validator as validator2 } from "hono-openapi";
-import { resolver as resolver3 } from "hono-openapi";
 import z4 from "zod";
 var QuestionRoutes = lazy(
   () => new Hono3().get(
     "/",
-    describeRoute2({
+    describeRoute({
       summary: "List pending questions",
       description: "Get all pending question requests across all sessions.",
       operationId: "question.list",
@@ -860,7 +1375,7 @@ var QuestionRoutes = lazy(
           description: "List of pending questions",
           content: {
             "application/json": {
-              schema: resolver3(Question.Request.array())
+              schema: resolver(Question.Request.array())
             }
           }
         }
@@ -872,7 +1387,7 @@ var QuestionRoutes = lazy(
     }
   ).post(
     "/:requestID/reply",
-    describeRoute2({
+    describeRoute({
       summary: "Reply to question request",
       description: "Provide answers to a question request from the AI assistant.",
       operationId: "question.reply",
@@ -881,7 +1396,7 @@ var QuestionRoutes = lazy(
           description: "Question answered successfully",
           content: {
             "application/json": {
-              schema: resolver3(z4.boolean())
+              schema: resolver(z4.boolean())
             }
           }
         },
@@ -906,7 +1421,7 @@ var QuestionRoutes = lazy(
     }
   ).post(
     "/:requestID/reject",
-    describeRoute2({
+    describeRoute({
       summary: "Reject question request",
       description: "Reject a question request from the AI assistant.",
       operationId: "question.reject",
@@ -915,7 +1430,7 @@ var QuestionRoutes = lazy(
           description: "Question rejected successfully",
           content: {
             "application/json": {
-              schema: resolver3(z4.boolean())
+              schema: resolver(z4.boolean())
             }
           }
         },
@@ -938,12 +1453,11 @@ var QuestionRoutes = lazy(
 
 // packages/opencode/src/server/routes/permission.ts
 import { Hono as Hono4 } from "hono";
-import { describeRoute as describeRoute3, validator as validator3, resolver as resolver4 } from "hono-openapi";
 import z5 from "zod";
 var PermissionRoutes = lazy(
   () => new Hono4().post(
     "/:requestID/reply",
-    describeRoute3({
+    describeRoute({
       summary: "Respond to permission request",
       description: "Approve or deny a permission request from the AI assistant.",
       operationId: "permission.reply",
@@ -952,20 +1466,20 @@ var PermissionRoutes = lazy(
           description: "Permission processed successfully",
           content: {
             "application/json": {
-              schema: resolver4(z5.boolean())
+              schema: resolver(z5.boolean())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator3(
+    validator2(
       "param",
       z5.object({
         requestID: PermissionID.zod
       })
     ),
-    validator3("json", z5.object({ reply: Permission.Reply, message: z5.string().optional() })),
+    validator2("json", z5.object({ reply: Permission.Reply, message: z5.string().optional() })),
     async (c) => {
       const params = c.req.valid("param");
       const json = c.req.valid("json");
@@ -978,7 +1492,7 @@ var PermissionRoutes = lazy(
     }
   ).get(
     "/",
-    describeRoute3({
+    describeRoute({
       summary: "List pending permissions",
       description: "Get all pending permission requests across all sessions.",
       operationId: "permission.list",
@@ -987,7 +1501,7 @@ var PermissionRoutes = lazy(
           description: "List of pending permissions",
           content: {
             "application/json": {
-              schema: resolver4(Permission.Request.array())
+              schema: resolver(Permission.Request.array())
             }
           }
         }
@@ -1002,13 +1516,11 @@ var PermissionRoutes = lazy(
 
 // packages/opencode/src/server/routes/project.ts
 import { Hono as Hono5 } from "hono";
-import { describeRoute as describeRoute4, validator as validator4 } from "hono-openapi";
-import { resolver as resolver5 } from "hono-openapi";
 import z6 from "zod";
 var ProjectRoutes = lazy(
   () => new Hono5().get(
     "/",
-    describeRoute4({
+    describeRoute({
       summary: "List all projects",
       description: "Get a list of projects that have been opened with OpenCode.",
       operationId: "project.list",
@@ -1017,7 +1529,7 @@ var ProjectRoutes = lazy(
           description: "List of projects",
           content: {
             "application/json": {
-              schema: resolver5(Project.Info.array())
+              schema: resolver(Project.Info.array())
             }
           }
         }
@@ -1029,7 +1541,7 @@ var ProjectRoutes = lazy(
     }
   ).get(
     "/current",
-    describeRoute4({
+    describeRoute({
       summary: "Get current project",
       description: "Retrieve the currently active project that OpenCode is working with.",
       operationId: "project.current",
@@ -1038,7 +1550,7 @@ var ProjectRoutes = lazy(
           description: "Current project information",
           content: {
             "application/json": {
-              schema: resolver5(Project.Info)
+              schema: resolver(Project.Info)
             }
           }
         }
@@ -1049,7 +1561,7 @@ var ProjectRoutes = lazy(
     }
   ).post(
     "/git/init",
-    describeRoute4({
+    describeRoute({
       summary: "Initialize git repository",
       description: "Create a git repository for the current project and return the refreshed project info.",
       operationId: "project.initGit",
@@ -1058,7 +1570,7 @@ var ProjectRoutes = lazy(
           description: "Project information after git initialization",
           content: {
             "application/json": {
-              schema: resolver5(Project.Info)
+              schema: resolver(Project.Info)
             }
           }
         }
@@ -1082,7 +1594,7 @@ var ProjectRoutes = lazy(
     }
   ).patch(
     "/:projectID",
-    describeRoute4({
+    describeRoute({
       summary: "Update project",
       description: "Update project properties such as name, icon, and commands.",
       operationId: "project.update",
@@ -1091,15 +1603,15 @@ var ProjectRoutes = lazy(
           description: "Updated project information",
           content: {
             "application/json": {
-              schema: resolver5(Project.Info)
+              schema: resolver(Project.Info)
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator4("param", z6.object({ projectID: ProjectID.zod })),
-    validator4("json", Project.UpdateInput.omit({ projectID: true })),
+    validator2("param", z6.object({ projectID: ProjectID.zod })),
+    validator2("json", Project.UpdateInput.omit({ projectID: true })),
     async (c) => {
       const projectID = c.req.valid("param").projectID;
       const body = c.req.valid("json");
@@ -1112,13 +1624,12 @@ var ProjectRoutes = lazy(
 // packages/opencode/src/server/routes/session.ts
 import { Hono as Hono6 } from "hono";
 import { stream } from "hono/streaming";
-import { describeRoute as describeRoute5, validator as validator5, resolver as resolver6 } from "hono-openapi";
 import z7 from "zod";
 var log = Log.create({ service: "server" });
 var SessionRoutes = lazy(
   () => new Hono6().get(
     "/",
-    describeRoute5({
+    describeRoute({
       summary: "List sessions",
       description: "Get a list of all OpenCode sessions, sorted by most recently updated.",
       operationId: "session.list",
@@ -1127,13 +1638,13 @@ var SessionRoutes = lazy(
           description: "List of sessions",
           content: {
             "application/json": {
-              schema: resolver6(Session.Info.array())
+              schema: resolver(Session.Info.array())
             }
           }
         }
       }
     }),
-    validator5(
+    validator2(
       "query",
       z7.object({
         directory: z7.string().optional().meta({ description: "Filter sessions by project directory" }),
@@ -1159,7 +1670,7 @@ var SessionRoutes = lazy(
     }
   ).get(
     "/status",
-    describeRoute5({
+    describeRoute({
       summary: "Get session status",
       description: "Retrieve the current status of all sessions, including active, idle, and completed states.",
       operationId: "session.status",
@@ -1168,7 +1679,7 @@ var SessionRoutes = lazy(
           description: "Get session status",
           content: {
             "application/json": {
-              schema: resolver6(z7.record(z7.string(), SessionStatus.Info))
+              schema: resolver(z7.record(z7.string(), SessionStatus.Info))
             }
           }
         },
@@ -1181,7 +1692,7 @@ var SessionRoutes = lazy(
     }
   ).get(
     "/:sessionID",
-    describeRoute5({
+    describeRoute({
       summary: "Get session",
       description: "Retrieve detailed information about a specific OpenCode session.",
       tags: ["Session"],
@@ -1191,14 +1702,14 @@ var SessionRoutes = lazy(
           description: "Get session",
           content: {
             "application/json": {
-              schema: resolver6(Session.Info)
+              schema: resolver(Session.Info)
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: Session.get.schema
@@ -1212,7 +1723,7 @@ var SessionRoutes = lazy(
     }
   ).get(
     "/:sessionID/children",
-    describeRoute5({
+    describeRoute({
       summary: "Get session children",
       tags: ["Session"],
       description: "Retrieve all child sessions that were forked from the specified parent session.",
@@ -1222,14 +1733,14 @@ var SessionRoutes = lazy(
           description: "List of children",
           content: {
             "application/json": {
-              schema: resolver6(Session.Info.array())
+              schema: resolver(Session.Info.array())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: Session.children.schema
@@ -1242,7 +1753,7 @@ var SessionRoutes = lazy(
     }
   ).get(
     "/:sessionID/todo",
-    describeRoute5({
+    describeRoute({
       summary: "Get session todos",
       description: "Retrieve the todo list associated with a specific session, showing tasks and action items.",
       operationId: "session.todo",
@@ -1251,14 +1762,14 @@ var SessionRoutes = lazy(
           description: "Todo list",
           content: {
             "application/json": {
-              schema: resolver6(Todo.Info.array())
+              schema: resolver(Todo.Info.array())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
@@ -1271,7 +1782,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/",
-    describeRoute5({
+    describeRoute({
       summary: "Create session",
       description: "Create a new OpenCode session for interacting with AI assistants and managing conversations.",
       operationId: "session.create",
@@ -1281,13 +1792,13 @@ var SessionRoutes = lazy(
           description: "Successfully created session",
           content: {
             "application/json": {
-              schema: resolver6(Session.Info)
+              schema: resolver(Session.Info)
             }
           }
         }
       }
     }),
-    validator5("json", Session.create.schema.optional()),
+    validator2("json", Session.create.schema.optional()),
     async (c) => {
       const body = c.req.valid("json") ?? {};
       const session = await Session.create(body);
@@ -1295,7 +1806,7 @@ var SessionRoutes = lazy(
     }
   ).delete(
     "/:sessionID",
-    describeRoute5({
+    describeRoute({
       summary: "Delete session",
       description: "Delete a session and permanently remove all associated data, including messages and history.",
       operationId: "session.delete",
@@ -1304,14 +1815,14 @@ var SessionRoutes = lazy(
           description: "Successfully deleted session",
           content: {
             "application/json": {
-              schema: resolver6(z7.boolean())
+              schema: resolver(z7.boolean())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: Session.remove.schema
@@ -1324,7 +1835,7 @@ var SessionRoutes = lazy(
     }
   ).patch(
     "/:sessionID",
-    describeRoute5({
+    describeRoute({
       summary: "Update session",
       description: "Update properties of an existing session, such as title or other metadata.",
       operationId: "session.update",
@@ -1333,20 +1844,20 @@ var SessionRoutes = lazy(
           description: "Successfully updated session",
           content: {
             "application/json": {
-              schema: resolver6(Session.Info)
+              schema: resolver(Session.Info)
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
       })
     ),
-    validator5(
+    validator2(
       "json",
       z7.object({
         title: z7.string().optional(),
@@ -1369,7 +1880,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/init",
-    describeRoute5({
+    describeRoute({
       summary: "Initialize session",
       description: "Analyze the current application and create an AGENTS.md file with project-specific agent configurations.",
       operationId: "session.init",
@@ -1378,20 +1889,20 @@ var SessionRoutes = lazy(
           description: "200",
           content: {
             "application/json": {
-              schema: resolver6(z7.boolean())
+              schema: resolver(z7.boolean())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
       })
     ),
-    validator5("json", Session.initialize.schema.omit({ sessionID: true })),
+    validator2("json", Session.initialize.schema.omit({ sessionID: true })),
     async (c) => {
       const sessionID = c.req.valid("param").sessionID;
       const body = c.req.valid("json");
@@ -1400,7 +1911,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/fork",
-    describeRoute5({
+    describeRoute({
       summary: "Fork session",
       description: "Create a new session by forking an existing session at a specific message point.",
       operationId: "session.fork",
@@ -1409,19 +1920,19 @@ var SessionRoutes = lazy(
           description: "200",
           content: {
             "application/json": {
-              schema: resolver6(Session.Info)
+              schema: resolver(Session.Info)
             }
           }
         }
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: Session.fork.schema.shape.sessionID
       })
     ),
-    validator5("json", Session.fork.schema.omit({ sessionID: true })),
+    validator2("json", Session.fork.schema.omit({ sessionID: true })),
     async (c) => {
       const sessionID = c.req.valid("param").sessionID;
       const body = c.req.valid("json");
@@ -1430,7 +1941,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/abort",
-    describeRoute5({
+    describeRoute({
       summary: "Abort session",
       description: "Abort an active session and stop any ongoing AI processing or command execution.",
       operationId: "session.abort",
@@ -1439,14 +1950,14 @@ var SessionRoutes = lazy(
           description: "Aborted session",
           content: {
             "application/json": {
-              schema: resolver6(z7.boolean())
+              schema: resolver(z7.boolean())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
@@ -1458,7 +1969,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/share",
-    describeRoute5({
+    describeRoute({
       summary: "Share session",
       description: "Create a shareable link for a session, allowing others to view the conversation.",
       operationId: "session.share",
@@ -1467,14 +1978,14 @@ var SessionRoutes = lazy(
           description: "Successfully shared session",
           content: {
             "application/json": {
-              schema: resolver6(Session.Info)
+              schema: resolver(Session.Info)
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
@@ -1488,7 +1999,7 @@ var SessionRoutes = lazy(
     }
   ).get(
     "/:sessionID/diff",
-    describeRoute5({
+    describeRoute({
       summary: "Get message diff",
       description: "Get the file changes (diff) that resulted from a specific user message in the session.",
       operationId: "session.diff",
@@ -1497,19 +2008,19 @@ var SessionRoutes = lazy(
           description: "Successfully retrieved diff",
           content: {
             "application/json": {
-              schema: resolver6(Snapshot.FileDiff.array())
+              schema: resolver(Snapshot.FileDiff.array())
             }
           }
         }
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionSummary.DiffInput.shape.sessionID
       })
     ),
-    validator5(
+    validator2(
       "query",
       z7.object({
         messageID: SessionSummary.DiffInput.shape.messageID
@@ -1526,7 +2037,7 @@ var SessionRoutes = lazy(
     }
   ).delete(
     "/:sessionID/share",
-    describeRoute5({
+    describeRoute({
       summary: "Unshare session",
       description: "Remove the shareable link for a session, making it private again.",
       operationId: "session.unshare",
@@ -1535,14 +2046,14 @@ var SessionRoutes = lazy(
           description: "Successfully unshared session",
           content: {
             "application/json": {
-              schema: resolver6(Session.Info)
+              schema: resolver(Session.Info)
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: Session.unshare.schema
@@ -1556,7 +2067,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/summarize",
-    describeRoute5({
+    describeRoute({
       summary: "Summarize session",
       description: "Generate a concise summary of the session using AI compaction to preserve key information.",
       operationId: "session.summarize",
@@ -1565,20 +2076,20 @@ var SessionRoutes = lazy(
           description: "Summarized session",
           content: {
             "application/json": {
-              schema: resolver6(z7.boolean())
+              schema: resolver(z7.boolean())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
       })
     ),
-    validator5(
+    validator2(
       "json",
       z7.object({
         providerID: ProviderID.zod,
@@ -1614,7 +2125,7 @@ var SessionRoutes = lazy(
     }
   ).get(
     "/:sessionID/message",
-    describeRoute5({
+    describeRoute({
       summary: "Get session messages",
       description: "Retrieve all messages in a session, including user prompts and AI responses.",
       operationId: "session.messages",
@@ -1623,20 +2134,20 @@ var SessionRoutes = lazy(
           description: "List of messages",
           content: {
             "application/json": {
-              schema: resolver6(MessageV2.WithParts.array())
+              schema: resolver(MessageV2.WithParts.array())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
       })
     ),
-    validator5(
+    validator2(
       "query",
       z7.object({
         limit: z7.coerce.number().int().min(0).optional().meta({ description: "Maximum number of messages to return" }),
@@ -1687,7 +2198,7 @@ var SessionRoutes = lazy(
     }
   ).get(
     "/:sessionID/message/:messageID",
-    describeRoute5({
+    describeRoute({
       summary: "Get message",
       description: "Retrieve a specific message from a session by its message ID.",
       operationId: "session.message",
@@ -1696,7 +2207,7 @@ var SessionRoutes = lazy(
           description: "Message",
           content: {
             "application/json": {
-              schema: resolver6(
+              schema: resolver(
                 z7.object({
                   info: MessageV2.Info,
                   parts: MessageV2.Part.array()
@@ -1708,7 +2219,7 @@ var SessionRoutes = lazy(
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod,
@@ -1725,7 +2236,7 @@ var SessionRoutes = lazy(
     }
   ).delete(
     "/:sessionID/message/:messageID",
-    describeRoute5({
+    describeRoute({
       summary: "Delete message",
       description: "Permanently delete a specific message (and all of its parts) from a session. This does not revert any file changes that may have been made while processing the message.",
       operationId: "session.deleteMessage",
@@ -1734,14 +2245,14 @@ var SessionRoutes = lazy(
           description: "Successfully deleted message",
           content: {
             "application/json": {
-              schema: resolver6(z7.boolean())
+              schema: resolver(z7.boolean())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod,
@@ -1759,7 +2270,7 @@ var SessionRoutes = lazy(
     }
   ).delete(
     "/:sessionID/message/:messageID/part/:partID",
-    describeRoute5({
+    describeRoute({
       description: "Delete a part from a message",
       operationId: "part.delete",
       responses: {
@@ -1767,14 +2278,14 @@ var SessionRoutes = lazy(
           description: "Successfully deleted part",
           content: {
             "application/json": {
-              schema: resolver6(z7.boolean())
+              schema: resolver(z7.boolean())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod,
@@ -1793,7 +2304,7 @@ var SessionRoutes = lazy(
     }
   ).patch(
     "/:sessionID/message/:messageID/part/:partID",
-    describeRoute5({
+    describeRoute({
       description: "Update a part in a message",
       operationId: "part.update",
       responses: {
@@ -1801,14 +2312,14 @@ var SessionRoutes = lazy(
           description: "Successfully updated part",
           content: {
             "application/json": {
-              schema: resolver6(MessageV2.Part)
+              schema: resolver(MessageV2.Part)
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod,
@@ -1816,7 +2327,7 @@ var SessionRoutes = lazy(
         partID: PartID.zod
       })
     ),
-    validator5("json", MessageV2.Part),
+    validator2("json", MessageV2.Part),
     async (c) => {
       const params = c.req.valid("param");
       const body = c.req.valid("json");
@@ -1830,7 +2341,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/message",
-    describeRoute5({
+    describeRoute({
       summary: "Send message",
       description: "Create and send a new message to a session, streaming the AI response.",
       operationId: "session.prompt",
@@ -1839,7 +2350,7 @@ var SessionRoutes = lazy(
           description: "Created message",
           content: {
             "application/json": {
-              schema: resolver6(
+              schema: resolver(
                 z7.object({
                   info: MessageV2.Assistant,
                   parts: MessageV2.Part.array()
@@ -1851,13 +2362,13 @@ var SessionRoutes = lazy(
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
       })
     ),
-    validator5("json", SessionPrompt.PromptInput.omit({ sessionID: true })),
+    validator2("json", SessionPrompt.PromptInput.omit({ sessionID: true })),
     async (c) => {
       c.status(200);
       c.header("Content-Type", "application/json");
@@ -1870,7 +2381,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/prompt_async",
-    describeRoute5({
+    describeRoute({
       summary: "Send async message",
       description: "Create and send a new message to a session asynchronously, starting the session if needed and returning immediately.",
       operationId: "session.prompt_async",
@@ -1881,13 +2392,13 @@ var SessionRoutes = lazy(
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
       })
     ),
-    validator5("json", SessionPrompt.PromptInput.omit({ sessionID: true })),
+    validator2("json", SessionPrompt.PromptInput.omit({ sessionID: true })),
     async (c) => {
       c.status(202);
       return stream(c, async () => {
@@ -1904,7 +2415,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/command",
-    describeRoute5({
+    describeRoute({
       summary: "Send command",
       description: "Send a new command to a session for execution by the AI assistant.",
       operationId: "session.command",
@@ -1913,7 +2424,7 @@ var SessionRoutes = lazy(
           description: "Created message",
           content: {
             "application/json": {
-              schema: resolver6(
+              schema: resolver(
                 z7.object({
                   info: MessageV2.Assistant,
                   parts: MessageV2.Part.array()
@@ -1925,13 +2436,13 @@ var SessionRoutes = lazy(
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
       })
     ),
-    validator5("json", SessionPrompt.CommandInput.omit({ sessionID: true })),
+    validator2("json", SessionPrompt.CommandInput.omit({ sessionID: true })),
     async (c) => {
       const sessionID = c.req.valid("param").sessionID;
       const body = c.req.valid("json");
@@ -1940,7 +2451,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/shell",
-    describeRoute5({
+    describeRoute({
       summary: "Run shell command",
       description: "Execute a shell command within the session context and return the AI's response.",
       operationId: "session.shell",
@@ -1949,20 +2460,20 @@ var SessionRoutes = lazy(
           description: "Created message",
           content: {
             "application/json": {
-              schema: resolver6(MessageV2.Assistant)
+              schema: resolver(MessageV2.Assistant)
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
       })
     ),
-    validator5("json", SessionPrompt.ShellInput.omit({ sessionID: true })),
+    validator2("json", SessionPrompt.ShellInput.omit({ sessionID: true })),
     async (c) => {
       const sessionID = c.req.valid("param").sessionID;
       const body = c.req.valid("json");
@@ -1971,7 +2482,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/revert",
-    describeRoute5({
+    describeRoute({
       summary: "Revert message",
       description: "Revert a specific message in a session, undoing its effects and restoring the previous state.",
       operationId: "session.revert",
@@ -1980,20 +2491,20 @@ var SessionRoutes = lazy(
           description: "Updated session",
           content: {
             "application/json": {
-              schema: resolver6(Session.Info)
+              schema: resolver(Session.Info)
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
       })
     ),
-    validator5("json", SessionRevert.RevertInput.omit({ sessionID: true })),
+    validator2("json", SessionRevert.RevertInput.omit({ sessionID: true })),
     async (c) => {
       const sessionID = c.req.valid("param").sessionID;
       log.info("revert", c.req.valid("json"));
@@ -2005,7 +2516,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/unrevert",
-    describeRoute5({
+    describeRoute({
       summary: "Restore reverted messages",
       description: "Restore all previously reverted messages in a session.",
       operationId: "session.unrevert",
@@ -2014,14 +2525,14 @@ var SessionRoutes = lazy(
           description: "Updated session",
           content: {
             "application/json": {
-              schema: resolver6(Session.Info)
+              schema: resolver(Session.Info)
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod
@@ -2034,7 +2545,7 @@ var SessionRoutes = lazy(
     }
   ).post(
     "/:sessionID/permissions/:permissionID",
-    describeRoute5({
+    describeRoute({
       summary: "Respond to permission",
       deprecated: true,
       description: "Approve or deny a permission request from the AI assistant.",
@@ -2044,21 +2555,21 @@ var SessionRoutes = lazy(
           description: "Permission processed successfully",
           content: {
             "application/json": {
-              schema: resolver6(z7.boolean())
+              schema: resolver(z7.boolean())
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator5(
+    validator2(
       "param",
       z7.object({
         sessionID: SessionID.zod,
         permissionID: PermissionID.zod
       })
     ),
-    validator5("json", z7.object({ response: Permission.Reply })),
+    validator2("json", z7.object({ response: Permission.Reply })),
     async (c) => {
       const params = c.req.valid("param");
       Permission.reply({
@@ -2072,7 +2583,6 @@ var SessionRoutes = lazy(
 
 // packages/opencode/src/server/routes/pty.ts
 import { Hono as Hono7 } from "hono";
-import { describeRoute as describeRoute6, validator as validator6, resolver as resolver7 } from "hono-openapi";
 import z10 from "zod";
 
 // packages/opencode/src/pty/index.ts
@@ -2412,7 +2922,7 @@ var Pty;
 function PtyRoutes(upgradeWebSocket2) {
   return new Hono7().get(
     "/",
-    describeRoute6({
+    describeRoute({
       summary: "List PTY sessions",
       description: "Get a list of all active pseudo-terminal (PTY) sessions managed by OpenCode.",
       operationId: "pty.list",
@@ -2421,7 +2931,7 @@ function PtyRoutes(upgradeWebSocket2) {
           description: "List of sessions",
           content: {
             "application/json": {
-              schema: resolver7(Pty.Info.array())
+              schema: resolver(Pty.Info.array())
             }
           }
         }
@@ -2432,7 +2942,7 @@ function PtyRoutes(upgradeWebSocket2) {
     }
   ).post(
     "/",
-    describeRoute6({
+    describeRoute({
       summary: "Create PTY session",
       description: "Create a new pseudo-terminal (PTY) session for running shell commands and processes.",
       operationId: "pty.create",
@@ -2441,21 +2951,21 @@ function PtyRoutes(upgradeWebSocket2) {
           description: "Created session",
           content: {
             "application/json": {
-              schema: resolver7(Pty.Info)
+              schema: resolver(Pty.Info)
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator6("json", Pty.CreateInput),
+    validator2("json", Pty.CreateInput),
     async (c) => {
       const info = await Pty.create(c.req.valid("json"));
       return c.json(info);
     }
   ).get(
     "/:ptyID",
-    describeRoute6({
+    describeRoute({
       summary: "Get PTY session",
       description: "Retrieve detailed information about a specific pseudo-terminal (PTY) session.",
       operationId: "pty.get",
@@ -2464,14 +2974,14 @@ function PtyRoutes(upgradeWebSocket2) {
           description: "Session info",
           content: {
             "application/json": {
-              schema: resolver7(Pty.Info)
+              schema: resolver(Pty.Info)
             }
           }
         },
         ...errors(404)
       }
     }),
-    validator6("param", z10.object({ ptyID: PtyID.zod })),
+    validator2("param", z10.object({ ptyID: PtyID.zod })),
     async (c) => {
       const info = await Pty.get(c.req.valid("param").ptyID);
       if (!info) {
@@ -2481,7 +2991,7 @@ function PtyRoutes(upgradeWebSocket2) {
     }
   ).put(
     "/:ptyID",
-    describeRoute6({
+    describeRoute({
       summary: "Update PTY session",
       description: "Update properties of an existing pseudo-terminal (PTY) session.",
       operationId: "pty.update",
@@ -2490,22 +3000,22 @@ function PtyRoutes(upgradeWebSocket2) {
           description: "Updated session",
           content: {
             "application/json": {
-              schema: resolver7(Pty.Info)
+              schema: resolver(Pty.Info)
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator6("param", z10.object({ ptyID: PtyID.zod })),
-    validator6("json", Pty.UpdateInput),
+    validator2("param", z10.object({ ptyID: PtyID.zod })),
+    validator2("json", Pty.UpdateInput),
     async (c) => {
       const info = await Pty.update(c.req.valid("param").ptyID, c.req.valid("json"));
       return c.json(info);
     }
   ).delete(
     "/:ptyID",
-    describeRoute6({
+    describeRoute({
       summary: "Remove PTY session",
       description: "Remove and terminate a specific pseudo-terminal (PTY) session.",
       operationId: "pty.remove",
@@ -2514,21 +3024,21 @@ function PtyRoutes(upgradeWebSocket2) {
           description: "Session removed",
           content: {
             "application/json": {
-              schema: resolver7(z10.boolean())
+              schema: resolver(z10.boolean())
             }
           }
         },
         ...errors(404)
       }
     }),
-    validator6("param", z10.object({ ptyID: PtyID.zod })),
+    validator2("param", z10.object({ ptyID: PtyID.zod })),
     async (c) => {
       await Pty.remove(c.req.valid("param").ptyID);
       return c.json(true);
     }
   ).get(
     "/:ptyID/connect",
-    describeRoute6({
+    describeRoute({
       summary: "Connect to PTY session",
       description: "Establish a WebSocket connection to interact with a pseudo-terminal (PTY) session in real-time.",
       operationId: "pty.connect",
@@ -2537,14 +3047,14 @@ function PtyRoutes(upgradeWebSocket2) {
           description: "Connected session",
           content: {
             "application/json": {
-              schema: resolver7(z10.boolean())
+              schema: resolver(z10.boolean())
             }
           }
         },
         ...errors(404)
       }
     }),
-    validator6("param", z10.object({ ptyID: PtyID.zod })),
+    validator2("param", z10.object({ ptyID: PtyID.zod })),
     upgradeWebSocket2(async (c) => {
       const id = PtyID.zod.parse(c.req.param("ptyID"));
       const cursor = (() => {
@@ -2598,12 +3108,11 @@ function PtyRoutes(upgradeWebSocket2) {
 
 // packages/opencode/src/server/routes/mcp.ts
 import { Hono as Hono8 } from "hono";
-import { describeRoute as describeRoute7, validator as validator7, resolver as resolver8 } from "hono-openapi";
 import z11 from "zod";
 var McpRoutes = lazy(
   () => new Hono8().get(
     "/",
-    describeRoute7({
+    describeRoute({
       summary: "Get MCP status",
       description: "Get the status of all Model Context Protocol (MCP) servers.",
       operationId: "mcp.status",
@@ -2612,7 +3121,7 @@ var McpRoutes = lazy(
           description: "MCP server status",
           content: {
             "application/json": {
-              schema: resolver8(z11.record(z11.string(), MCP.Status))
+              schema: resolver(z11.record(z11.string(), MCP.Status))
             }
           }
         }
@@ -2623,7 +3132,7 @@ var McpRoutes = lazy(
     }
   ).post(
     "/",
-    describeRoute7({
+    describeRoute({
       summary: "Add MCP server",
       description: "Dynamically add a new Model Context Protocol (MCP) server to the system.",
       operationId: "mcp.add",
@@ -2632,14 +3141,14 @@ var McpRoutes = lazy(
           description: "MCP server added successfully",
           content: {
             "application/json": {
-              schema: resolver8(z11.record(z11.string(), MCP.Status))
+              schema: resolver(z11.record(z11.string(), MCP.Status))
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator7(
+    validator2(
       "json",
       z11.object({
         name: z11.string(),
@@ -2653,7 +3162,7 @@ var McpRoutes = lazy(
     }
   ).post(
     "/:name/auth",
-    describeRoute7({
+    describeRoute({
       summary: "Start MCP OAuth",
       description: "Start OAuth authentication flow for a Model Context Protocol (MCP) server.",
       operationId: "mcp.auth.start",
@@ -2662,7 +3171,7 @@ var McpRoutes = lazy(
           description: "OAuth flow started",
           content: {
             "application/json": {
-              schema: resolver8(
+              schema: resolver(
                 z11.object({
                   authorizationUrl: z11.string().describe("URL to open in browser for authorization")
                 })
@@ -2684,7 +3193,7 @@ var McpRoutes = lazy(
     }
   ).post(
     "/:name/auth/callback",
-    describeRoute7({
+    describeRoute({
       summary: "Complete MCP OAuth",
       description: "Complete OAuth authentication for a Model Context Protocol (MCP) server using the authorization code.",
       operationId: "mcp.auth.callback",
@@ -2693,14 +3202,14 @@ var McpRoutes = lazy(
           description: "OAuth authentication completed",
           content: {
             "application/json": {
-              schema: resolver8(MCP.Status)
+              schema: resolver(MCP.Status)
             }
           }
         },
         ...errors(400, 404)
       }
     }),
-    validator7(
+    validator2(
       "json",
       z11.object({
         code: z11.string().describe("Authorization code from OAuth callback")
@@ -2714,7 +3223,7 @@ var McpRoutes = lazy(
     }
   ).post(
     "/:name/auth/authenticate",
-    describeRoute7({
+    describeRoute({
       summary: "Authenticate MCP OAuth",
       description: "Start OAuth flow and wait for callback (opens browser)",
       operationId: "mcp.auth.authenticate",
@@ -2723,7 +3232,7 @@ var McpRoutes = lazy(
           description: "OAuth authentication completed",
           content: {
             "application/json": {
-              schema: resolver8(MCP.Status)
+              schema: resolver(MCP.Status)
             }
           }
         },
@@ -2741,7 +3250,7 @@ var McpRoutes = lazy(
     }
   ).delete(
     "/:name/auth",
-    describeRoute7({
+    describeRoute({
       summary: "Remove MCP OAuth",
       description: "Remove OAuth credentials for an MCP server",
       operationId: "mcp.auth.remove",
@@ -2750,7 +3259,7 @@ var McpRoutes = lazy(
           description: "OAuth credentials removed",
           content: {
             "application/json": {
-              schema: resolver8(z11.object({ success: z11.literal(true) }))
+              schema: resolver(z11.object({ success: z11.literal(true) }))
             }
           }
         },
@@ -2764,7 +3273,7 @@ var McpRoutes = lazy(
     }
   ).post(
     "/:name/connect",
-    describeRoute7({
+    describeRoute({
       description: "Connect an MCP server",
       operationId: "mcp.connect",
       responses: {
@@ -2772,13 +3281,13 @@ var McpRoutes = lazy(
           description: "MCP server connected successfully",
           content: {
             "application/json": {
-              schema: resolver8(z11.boolean())
+              schema: resolver(z11.boolean())
             }
           }
         }
       }
     }),
-    validator7("param", z11.object({ name: z11.string() })),
+    validator2("param", z11.object({ name: z11.string() })),
     async (c) => {
       const { name } = c.req.valid("param");
       await MCP.connect(name);
@@ -2786,7 +3295,7 @@ var McpRoutes = lazy(
     }
   ).post(
     "/:name/disconnect",
-    describeRoute7({
+    describeRoute({
       description: "Disconnect an MCP server",
       operationId: "mcp.disconnect",
       responses: {
@@ -2794,13 +3303,13 @@ var McpRoutes = lazy(
           description: "MCP server disconnected successfully",
           content: {
             "application/json": {
-              schema: resolver8(z11.boolean())
+              schema: resolver(z11.boolean())
             }
           }
         }
       }
     }),
-    validator7("param", z11.object({ name: z11.string() })),
+    validator2("param", z11.object({ name: z11.string() })),
     async (c) => {
       const { name } = c.req.valid("param");
       await MCP.disconnect(name);
@@ -2811,12 +3320,11 @@ var McpRoutes = lazy(
 
 // packages/opencode/src/server/routes/file.ts
 import { Hono as Hono9 } from "hono";
-import { describeRoute as describeRoute8, validator as validator8, resolver as resolver9 } from "hono-openapi";
 import z12 from "zod";
 var FileRoutes = lazy(
   () => new Hono9().get(
     "/find",
-    describeRoute8({
+    describeRoute({
       summary: "Find text",
       description: "Search for text patterns across files in the project using ripgrep.",
       operationId: "find.text",
@@ -2825,13 +3333,13 @@ var FileRoutes = lazy(
           description: "Matches",
           content: {
             "application/json": {
-              schema: resolver9(Ripgrep.Match.shape.data.array())
+              schema: resolver(Ripgrep.Match.shape.data.array())
             }
           }
         }
       }
     }),
-    validator8(
+    validator2(
       "query",
       z12.object({
         pattern: z12.string()
@@ -2848,7 +3356,7 @@ var FileRoutes = lazy(
     }
   ).get(
     "/find/file",
-    describeRoute8({
+    describeRoute({
       summary: "Find files",
       description: "Search for files or directories by name or pattern in the project directory.",
       operationId: "find.files",
@@ -2857,13 +3365,13 @@ var FileRoutes = lazy(
           description: "File paths",
           content: {
             "application/json": {
-              schema: resolver9(z12.string().array())
+              schema: resolver(z12.string().array())
             }
           }
         }
       }
     }),
-    validator8(
+    validator2(
       "query",
       z12.object({
         query: z12.string(),
@@ -2887,7 +3395,7 @@ var FileRoutes = lazy(
     }
   ).get(
     "/find/symbol",
-    describeRoute8({
+    describeRoute({
       summary: "Find symbols",
       description: "Search for workspace symbols like functions, classes, and variables using LSP.",
       operationId: "find.symbols",
@@ -2896,13 +3404,13 @@ var FileRoutes = lazy(
           description: "Symbols",
           content: {
             "application/json": {
-              schema: resolver9(LSP.Symbol.array())
+              schema: resolver(LSP.Symbol.array())
             }
           }
         }
       }
     }),
-    validator8(
+    validator2(
       "query",
       z12.object({
         query: z12.string()
@@ -2913,7 +3421,7 @@ var FileRoutes = lazy(
     }
   ).get(
     "/file",
-    describeRoute8({
+    describeRoute({
       summary: "List files",
       description: "List files and directories in a specified path.",
       operationId: "file.list",
@@ -2922,13 +3430,13 @@ var FileRoutes = lazy(
           description: "Files and directories",
           content: {
             "application/json": {
-              schema: resolver9(File.Node.array())
+              schema: resolver(File.Node.array())
             }
           }
         }
       }
     }),
-    validator8(
+    validator2(
       "query",
       z12.object({
         path: z12.string()
@@ -2941,7 +3449,7 @@ var FileRoutes = lazy(
     }
   ).get(
     "/file/content",
-    describeRoute8({
+    describeRoute({
       summary: "Read file",
       description: "Read the content of a specified file.",
       operationId: "file.read",
@@ -2950,13 +3458,13 @@ var FileRoutes = lazy(
           description: "File content",
           content: {
             "application/json": {
-              schema: resolver9(File.Content)
+              schema: resolver(File.Content)
             }
           }
         }
       }
     }),
-    validator8(
+    validator2(
       "query",
       z12.object({
         path: z12.string()
@@ -2969,7 +3477,7 @@ var FileRoutes = lazy(
     }
   ).get(
     "/file/status",
-    describeRoute8({
+    describeRoute({
       summary: "Get file status",
       description: "Get the git status of all files in the project.",
       operationId: "file.status",
@@ -2978,7 +3486,7 @@ var FileRoutes = lazy(
           description: "File status",
           content: {
             "application/json": {
-              schema: resolver9(File.Info.array())
+              schema: resolver(File.Info.array())
             }
           }
         }
@@ -2993,14 +3501,13 @@ var FileRoutes = lazy(
 
 // packages/opencode/src/server/routes/config.ts
 import { Hono as Hono10 } from "hono";
-import { describeRoute as describeRoute9, validator as validator9, resolver as resolver10 } from "hono-openapi";
 import z13 from "zod";
 import { mapValues } from "remeda";
 var log2 = Log.create({ service: "server" });
 var ConfigRoutes = lazy(
   () => new Hono10().get(
     "/",
-    describeRoute9({
+    describeRoute({
       summary: "Get configuration",
       description: "Retrieve the current OpenCode configuration settings and preferences.",
       operationId: "config.get",
@@ -3009,7 +3516,7 @@ var ConfigRoutes = lazy(
           description: "Get config info",
           content: {
             "application/json": {
-              schema: resolver10(Config.Info)
+              schema: resolver(Config.Info)
             }
           }
         }
@@ -3020,7 +3527,7 @@ var ConfigRoutes = lazy(
     }
   ).patch(
     "/",
-    describeRoute9({
+    describeRoute({
       summary: "Update configuration",
       description: "Update OpenCode configuration settings and preferences.",
       operationId: "config.update",
@@ -3029,14 +3536,14 @@ var ConfigRoutes = lazy(
           description: "Successfully updated config",
           content: {
             "application/json": {
-              schema: resolver10(Config.Info)
+              schema: resolver(Config.Info)
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator9("json", Config.Info),
+    validator2("json", Config.Info),
     async (c) => {
       const config = c.req.valid("json");
       await Config.update(config);
@@ -3044,7 +3551,7 @@ var ConfigRoutes = lazy(
     }
   ).get(
     "/providers",
-    describeRoute9({
+    describeRoute({
       summary: "List config providers",
       description: "Get a list of all configured AI providers and their default models.",
       operationId: "config.providers",
@@ -3053,7 +3560,7 @@ var ConfigRoutes = lazy(
           description: "List of providers",
           content: {
             "application/json": {
-              schema: resolver10(
+              schema: resolver(
                 z13.object({
                   providers: Provider.Info.array(),
                   default: z13.record(z13.string(), z13.string())
@@ -3084,7 +3591,6 @@ var ConfigRoutes = lazy(
 
 // packages/opencode/src/server/routes/experimental.ts
 import { Hono as Hono12 } from "hono";
-import { describeRoute as describeRoute11, validator as validator11, resolver as resolver12 } from "hono-openapi";
 import z16 from "zod";
 
 // packages/opencode/src/config/console-state.ts
@@ -3100,12 +3606,11 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 
 // packages/opencode/src/server/routes/workspace.ts
 import { Hono as Hono11 } from "hono";
-import { describeRoute as describeRoute10, resolver as resolver11, validator as validator10 } from "hono-openapi";
 import z15 from "zod";
 var WorkspaceRoutes = lazy(
   () => new Hono11().post(
     "/",
-    describeRoute10({
+    describeRoute({
       summary: "Create workspace",
       description: "Create a workspace for the current project.",
       operationId: "experimental.workspace.create",
@@ -3114,14 +3619,14 @@ var WorkspaceRoutes = lazy(
           description: "Workspace created",
           content: {
             "application/json": {
-              schema: resolver11(Workspace.Info)
+              schema: resolver(Workspace.Info)
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator10(
+    validator2(
       "json",
       Workspace.create.schema.omit({
         projectID: true
@@ -3137,7 +3642,7 @@ var WorkspaceRoutes = lazy(
     }
   ).get(
     "/",
-    describeRoute10({
+    describeRoute({
       summary: "List workspaces",
       description: "List all workspaces.",
       operationId: "experimental.workspace.list",
@@ -3146,7 +3651,7 @@ var WorkspaceRoutes = lazy(
           description: "Workspaces",
           content: {
             "application/json": {
-              schema: resolver11(z15.array(Workspace.Info))
+              schema: resolver(z15.array(Workspace.Info))
             }
           }
         }
@@ -3157,7 +3662,7 @@ var WorkspaceRoutes = lazy(
     }
   ).delete(
     "/:id",
-    describeRoute10({
+    describeRoute({
       summary: "Remove workspace",
       description: "Remove an existing workspace.",
       operationId: "experimental.workspace.remove",
@@ -3166,14 +3671,14 @@ var WorkspaceRoutes = lazy(
           description: "Workspace removed",
           content: {
             "application/json": {
-              schema: resolver11(Workspace.Info.optional())
+              schema: resolver(Workspace.Info.optional())
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator10(
+    validator2(
       "param",
       z15.object({
         id: Workspace.Info.shape.id
@@ -3205,7 +3710,7 @@ var ConsoleSwitchBody = z16.object({
 var ExperimentalRoutes = lazy(
   () => new Hono12().get(
     "/console",
-    describeRoute11({
+    describeRoute({
       summary: "Get active Console provider metadata",
       description: "Get the active Console org name and the set of provider IDs managed by that Console org.",
       operationId: "experimental.console.get",
@@ -3214,7 +3719,7 @@ var ExperimentalRoutes = lazy(
           description: "Active Console provider metadata",
           content: {
             "application/json": {
-              schema: resolver12(ConsoleState)
+              schema: resolver(ConsoleState)
             }
           }
         }
@@ -3229,7 +3734,7 @@ var ExperimentalRoutes = lazy(
     }
   ).get(
     "/console/orgs",
-    describeRoute11({
+    describeRoute({
       summary: "List switchable Console orgs",
       description: "Get the available Console orgs across logged-in accounts, including the current active org.",
       operationId: "experimental.console.listOrgs",
@@ -3238,7 +3743,7 @@ var ExperimentalRoutes = lazy(
           description: "Switchable Console orgs",
           content: {
             "application/json": {
-              schema: resolver12(ConsoleOrgList)
+              schema: resolver(ConsoleOrgList)
             }
           }
         }
@@ -3260,7 +3765,7 @@ var ExperimentalRoutes = lazy(
     }
   ).post(
     "/console/switch",
-    describeRoute11({
+    describeRoute({
       summary: "Switch active Console org",
       description: "Persist a new active Console account/org selection for the current local OpenCode state.",
       operationId: "experimental.console.switchOrg",
@@ -3269,13 +3774,13 @@ var ExperimentalRoutes = lazy(
           description: "Switch success",
           content: {
             "application/json": {
-              schema: resolver12(z16.boolean())
+              schema: resolver(z16.boolean())
             }
           }
         }
       }
     }),
-    validator11("json", ConsoleSwitchBody),
+    validator2("json", ConsoleSwitchBody),
     async (c) => {
       const body = c.req.valid("json");
       await Account.switchOrg(AccountID.make(body.accountID), OrgID.make(body.orgID));
@@ -3283,7 +3788,7 @@ var ExperimentalRoutes = lazy(
     }
   ).get(
     "/tool/ids",
-    describeRoute11({
+    describeRoute({
       summary: "List tool IDs",
       description: "Get a list of all available tool IDs, including both built-in tools and dynamically registered tools.",
       operationId: "tool.ids",
@@ -3292,7 +3797,7 @@ var ExperimentalRoutes = lazy(
           description: "Tool IDs",
           content: {
             "application/json": {
-              schema: resolver12(z16.array(z16.string()).meta({ ref: "ToolIDs" }))
+              schema: resolver(z16.array(z16.string()).meta({ ref: "ToolIDs" }))
             }
           }
         },
@@ -3304,7 +3809,7 @@ var ExperimentalRoutes = lazy(
     }
   ).get(
     "/tool",
-    describeRoute11({
+    describeRoute({
       summary: "List tools",
       description: "Get a list of available tools with their JSON schema parameters for a specific provider and model combination.",
       operationId: "tool.list",
@@ -3313,7 +3818,7 @@ var ExperimentalRoutes = lazy(
           description: "Tools",
           content: {
             "application/json": {
-              schema: resolver12(
+              schema: resolver(
                 z16.array(
                   z16.object({
                     id: z16.string(),
@@ -3328,7 +3833,7 @@ var ExperimentalRoutes = lazy(
         ...errors(400)
       }
     }),
-    validator11(
+    validator2(
       "query",
       z16.object({
         provider: z16.string(),
@@ -3349,7 +3854,7 @@ var ExperimentalRoutes = lazy(
     }
   ).route("/workspace", WorkspaceRoutes()).post(
     "/worktree",
-    describeRoute11({
+    describeRoute({
       summary: "Create worktree",
       description: "Create a new git worktree for the current project and run any configured startup scripts.",
       operationId: "worktree.create",
@@ -3358,14 +3863,14 @@ var ExperimentalRoutes = lazy(
           description: "Worktree created",
           content: {
             "application/json": {
-              schema: resolver12(Worktree.Info)
+              schema: resolver(Worktree.Info)
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator11("json", Worktree.CreateInput.optional()),
+    validator2("json", Worktree.CreateInput.optional()),
     async (c) => {
       const body = c.req.valid("json");
       const worktree = await Worktree.create(body);
@@ -3373,7 +3878,7 @@ var ExperimentalRoutes = lazy(
     }
   ).get(
     "/worktree",
-    describeRoute11({
+    describeRoute({
       summary: "List worktrees",
       description: "List all sandbox worktrees for the current project.",
       operationId: "worktree.list",
@@ -3382,7 +3887,7 @@ var ExperimentalRoutes = lazy(
           description: "List of worktree directories",
           content: {
             "application/json": {
-              schema: resolver12(z16.array(z16.string()))
+              schema: resolver(z16.array(z16.string()))
             }
           }
         }
@@ -3394,7 +3899,7 @@ var ExperimentalRoutes = lazy(
     }
   ).delete(
     "/worktree",
-    describeRoute11({
+    describeRoute({
       summary: "Remove worktree",
       description: "Remove a git worktree and delete its branch.",
       operationId: "worktree.remove",
@@ -3403,14 +3908,14 @@ var ExperimentalRoutes = lazy(
           description: "Worktree removed",
           content: {
             "application/json": {
-              schema: resolver12(z16.boolean())
+              schema: resolver(z16.boolean())
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator11("json", Worktree.RemoveInput),
+    validator2("json", Worktree.RemoveInput),
     async (c) => {
       const body = c.req.valid("json");
       await Worktree.remove(body);
@@ -3419,7 +3924,7 @@ var ExperimentalRoutes = lazy(
     }
   ).post(
     "/worktree/reset",
-    describeRoute11({
+    describeRoute({
       summary: "Reset worktree",
       description: "Reset a worktree branch to the primary default branch.",
       operationId: "worktree.reset",
@@ -3428,14 +3933,14 @@ var ExperimentalRoutes = lazy(
           description: "Worktree reset",
           content: {
             "application/json": {
-              schema: resolver12(z16.boolean())
+              schema: resolver(z16.boolean())
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator11("json", Worktree.ResetInput),
+    validator2("json", Worktree.ResetInput),
     async (c) => {
       const body = c.req.valid("json");
       await Worktree.reset(body);
@@ -3443,7 +3948,7 @@ var ExperimentalRoutes = lazy(
     }
   ).get(
     "/session",
-    describeRoute11({
+    describeRoute({
       summary: "List sessions",
       description: "Get a list of all OpenCode sessions across projects, sorted by most recently updated. Archived sessions are excluded by default.",
       operationId: "experimental.session.list",
@@ -3452,13 +3957,13 @@ var ExperimentalRoutes = lazy(
           description: "List of sessions",
           content: {
             "application/json": {
-              schema: resolver12(Session.GlobalInfo.array())
+              schema: resolver(Session.GlobalInfo.array())
             }
           }
         }
       }
     }),
-    validator11(
+    validator2(
       "query",
       z16.object({
         directory: z16.string().optional().meta({ description: "Filter sessions by project directory" }),
@@ -3494,7 +3999,7 @@ var ExperimentalRoutes = lazy(
     }
   ).get(
     "/resource",
-    describeRoute11({
+    describeRoute({
       summary: "Get MCP resources",
       description: "Get all available MCP resources from connected servers. Optionally filter by name.",
       operationId: "experimental.resource.list",
@@ -3503,7 +4008,7 @@ var ExperimentalRoutes = lazy(
           description: "MCP resources",
           content: {
             "application/json": {
-              schema: resolver12(z16.record(z16.string(), MCP.Resource))
+              schema: resolver(z16.record(z16.string(), MCP.Resource))
             }
           }
         }
@@ -3517,7 +4022,6 @@ var ExperimentalRoutes = lazy(
 
 // packages/opencode/src/server/routes/provider.ts
 import { Hono as Hono13 } from "hono";
-import { describeRoute as describeRoute12, validator as validator12, resolver as resolver13 } from "hono-openapi";
 import z18 from "zod";
 
 // packages/opencode/src/provider/auth.ts
@@ -3710,7 +4214,7 @@ var log3 = Log.create({ service: "server" });
 var ProviderRoutes = lazy(
   () => new Hono13().get(
     "/",
-    describeRoute12({
+    describeRoute({
       summary: "List providers",
       description: "Get a list of all available AI providers, including both available and connected ones.",
       operationId: "provider.list",
@@ -3719,7 +4223,7 @@ var ProviderRoutes = lazy(
           description: "List of providers",
           content: {
             "application/json": {
-              schema: resolver13(
+              schema: resolver(
                 z18.object({
                   all: ModelsDev.Provider.array(),
                   default: z18.record(z18.string(), z18.string()),
@@ -3755,7 +4259,7 @@ var ProviderRoutes = lazy(
     }
   ).get(
     "/auth",
-    describeRoute12({
+    describeRoute({
       summary: "Get provider auth methods",
       description: "Retrieve available authentication methods for all AI providers.",
       operationId: "provider.auth",
@@ -3764,7 +4268,7 @@ var ProviderRoutes = lazy(
           description: "Provider auth methods",
           content: {
             "application/json": {
-              schema: resolver13(z18.record(z18.string(), z18.array(ProviderAuth.Method)))
+              schema: resolver(z18.record(z18.string(), z18.array(ProviderAuth.Method)))
             }
           }
         }
@@ -3775,7 +4279,7 @@ var ProviderRoutes = lazy(
     }
   ).post(
     "/:providerID/oauth/authorize",
-    describeRoute12({
+    describeRoute({
       summary: "OAuth authorize",
       description: "Initiate OAuth authorization for a specific AI provider to get an authorization URL.",
       operationId: "provider.oauth.authorize",
@@ -3784,20 +4288,20 @@ var ProviderRoutes = lazy(
           description: "Authorization URL and method",
           content: {
             "application/json": {
-              schema: resolver13(ProviderAuth.Authorization.optional())
+              schema: resolver(ProviderAuth.Authorization.optional())
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator12(
+    validator2(
       "param",
       z18.object({
         providerID: ProviderID.zod.meta({ description: "Provider ID" })
       })
     ),
-    validator12(
+    validator2(
       "json",
       z18.object({
         method: z18.number().meta({ description: "Auth method index" }),
@@ -3816,7 +4320,7 @@ var ProviderRoutes = lazy(
     }
   ).post(
     "/:providerID/oauth/callback",
-    describeRoute12({
+    describeRoute({
       summary: "OAuth callback",
       description: "Handle the OAuth callback from a provider after user authorization.",
       operationId: "provider.oauth.callback",
@@ -3825,20 +4329,20 @@ var ProviderRoutes = lazy(
           description: "OAuth callback processed successfully",
           content: {
             "application/json": {
-              schema: resolver13(z18.boolean())
+              schema: resolver(z18.boolean())
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator12(
+    validator2(
       "param",
       z18.object({
         providerID: ProviderID.zod.meta({ description: "Provider ID" })
       })
     ),
-    validator12(
+    validator2(
       "json",
       z18.object({
         method: z18.number().meta({ description: "Auth method index" }),
@@ -3860,12 +4364,11 @@ var ProviderRoutes = lazy(
 
 // packages/opencode/src/server/routes/event.ts
 import { Hono as Hono14 } from "hono";
-import { describeRoute as describeRoute13, resolver as resolver14 } from "hono-openapi";
 import { streamSSE } from "hono/streaming";
 var log4 = Log.create({ service: "server" });
 var EventRoutes = () => new Hono14().get(
   "/event",
-  describeRoute13({
+  describeRoute({
     summary: "Subscribe to events",
     description: "Get events",
     operationId: "event.subscribe",
@@ -3874,7 +4377,7 @@ var EventRoutes = () => new Hono14().get(
         description: "Event stream",
         content: {
           "text/event-stream": {
-            schema: resolver14(BusEvent.payloads())
+            schema: resolver(BusEvent.payloads())
           }
         }
       }
@@ -3966,7 +4469,7 @@ var DEFAULT_CSP = "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; sty
 var csp = (hash = "") => `default-src 'self'; script-src 'self' 'wasm-unsafe-eval'${hash ? ` 'sha256-${hash}'` : ""}; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:`;
 var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler(log5)).route("/project", ProjectRoutes()).route("/pty", PtyRoutes(upgrade)).route("/config", ConfigRoutes()).route("/experimental", ExperimentalRoutes()).route("/session", SessionRoutes()).route("/permission", PermissionRoutes()).route("/question", QuestionRoutes()).route("/provider", ProviderRoutes()).route("/", FileRoutes()).route("/", EventRoutes()).route("/mcp", McpRoutes()).route("/tui", TuiRoutes()).post(
   "/instance/dispose",
-  describeRoute14({
+  describeRoute({
     summary: "Dispose instance",
     description: "Clean up and dispose the current OpenCode instance, releasing all resources.",
     operationId: "instance.dispose",
@@ -3975,7 +4478,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
         description: "Instance disposed",
         content: {
           "application/json": {
-            schema: resolver15(z19.boolean())
+            schema: resolver(z19.boolean())
           }
         }
       }
@@ -3987,7 +4490,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
   }
 ).get(
   "/path",
-  describeRoute14({
+  describeRoute({
     summary: "Get paths",
     description: "Retrieve the current working directory and related path information for the OpenCode instance.",
     operationId: "path.get",
@@ -3996,7 +4499,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
         description: "Path",
         content: {
           "application/json": {
-            schema: resolver15(
+            schema: resolver(
               z19.object({
                 home: z19.string(),
                 state: z19.string(),
@@ -4023,7 +4526,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
   }
 ).get(
   "/vcs",
-  describeRoute14({
+  describeRoute({
     summary: "Get VCS info",
     description: "Retrieve version control system (VCS) information for the current project, such as git branch.",
     operationId: "vcs.get",
@@ -4032,7 +4535,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
         description: "VCS info",
         content: {
           "application/json": {
-            schema: resolver15(Vcs.Info)
+            schema: resolver(Vcs.Info)
           }
         }
       }
@@ -4047,7 +4550,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
   }
 ).get(
   "/vcs/diff",
-  describeRoute14({
+  describeRoute({
     summary: "Get VCS diff",
     description: "Retrieve the current git diff for the working tree or against the default branch.",
     operationId: "vcs.diff",
@@ -4056,13 +4559,13 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
         description: "VCS diff",
         content: {
           "application/json": {
-            schema: resolver15(Snapshot.FileDiff.array())
+            schema: resolver(Snapshot.FileDiff.array())
           }
         }
       }
     }
   }),
-  validator13(
+  validator2(
     "query",
     z19.object({
       mode: Vcs.Mode
@@ -4073,7 +4576,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
   }
 ).get(
   "/command",
-  describeRoute14({
+  describeRoute({
     summary: "List commands",
     description: "Get a list of all available commands in the OpenCode system.",
     operationId: "command.list",
@@ -4082,7 +4585,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
         description: "List of commands",
         content: {
           "application/json": {
-            schema: resolver15(Command.Info.array())
+            schema: resolver(Command.Info.array())
           }
         }
       }
@@ -4094,7 +4597,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
   }
 ).get(
   "/agent",
-  describeRoute14({
+  describeRoute({
     summary: "List agents",
     description: "Get a list of all available AI agents in the OpenCode system.",
     operationId: "app.agents",
@@ -4103,7 +4606,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
         description: "List of agents",
         content: {
           "application/json": {
-            schema: resolver15(Agent.Info.array())
+            schema: resolver(Agent.Info.array())
           }
         }
       }
@@ -4115,7 +4618,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
   }
 ).get(
   "/skill",
-  describeRoute14({
+  describeRoute({
     summary: "List skills",
     description: "Get a list of all available skills in the OpenCode system.",
     operationId: "app.skills",
@@ -4124,7 +4627,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
         description: "List of skills",
         content: {
           "application/json": {
-            schema: resolver15(Skill.Info.array())
+            schema: resolver(Skill.Info.array())
           }
         }
       }
@@ -4136,7 +4639,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
   }
 ).get(
   "/lsp",
-  describeRoute14({
+  describeRoute({
     summary: "Get LSP status",
     description: "Get LSP server status",
     operationId: "lsp.status",
@@ -4145,7 +4648,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
         description: "LSP server status",
         content: {
           "application/json": {
-            schema: resolver15(LSP.Status.array())
+            schema: resolver(LSP.Status.array())
           }
         }
       }
@@ -4156,7 +4659,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
   }
 ).get(
   "/formatter",
-  describeRoute14({
+  describeRoute({
     summary: "Get formatter status",
     description: "Get formatter status",
     operationId: "formatter.status",
@@ -4165,7 +4668,7 @@ var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler
         description: "Formatter status",
         content: {
           "application/json": {
-            schema: resolver15(Format.Status.array())
+            schema: resolver(Format.Status.array())
           }
         }
       }
@@ -4299,7 +4802,6 @@ function WorkspaceRouterMiddleware(upgrade) {
 
 // packages/opencode/src/server/routes/global.ts
 import { Hono as Hono16 } from "hono";
-import { describeRoute as describeRoute15, resolver as resolver16, validator as validator14 } from "hono-openapi";
 import { streamSSE as streamSSE2 } from "hono/streaming";
 import z20 from "zod";
 var log6 = Log.create({ service: "server" });
@@ -4349,7 +4851,7 @@ async function streamEvents(c, subscribe) {
 var GlobalRoutes = lazy(
   () => new Hono16().get(
     "/health",
-    describeRoute15({
+    describeRoute({
       summary: "Get health",
       description: "Get health information about the OpenCode server.",
       operationId: "global.health",
@@ -4358,7 +4860,7 @@ var GlobalRoutes = lazy(
           description: "Health information",
           content: {
             "application/json": {
-              schema: resolver16(z20.object({ healthy: z20.literal(true), version: z20.string() }))
+              schema: resolver(z20.object({ healthy: z20.literal(true), version: z20.string() }))
             }
           }
         }
@@ -4369,7 +4871,7 @@ var GlobalRoutes = lazy(
     }
   ).get(
     "/event",
-    describeRoute15({
+    describeRoute({
       summary: "Get global events",
       description: "Subscribe to global events from the OpenCode system using server-sent events.",
       operationId: "global.event",
@@ -4378,7 +4880,7 @@ var GlobalRoutes = lazy(
           description: "Event stream",
           content: {
             "text/event-stream": {
-              schema: resolver16(
+              schema: resolver(
                 z20.object({
                   directory: z20.string(),
                   payload: BusEvent.payloads()
@@ -4406,7 +4908,7 @@ var GlobalRoutes = lazy(
     }
   ).get(
     "/sync-event",
-    describeRoute15({
+    describeRoute({
       summary: "Subscribe to global sync events",
       description: "Get global sync events",
       operationId: "global.sync-event.subscribe",
@@ -4415,7 +4917,7 @@ var GlobalRoutes = lazy(
           description: "Event stream",
           content: {
             "text/event-stream": {
-              schema: resolver16(
+              schema: resolver(
                 z20.object({
                   payload: SyncEvent.payloads()
                 }).meta({
@@ -4447,7 +4949,7 @@ var GlobalRoutes = lazy(
     }
   ).get(
     "/config",
-    describeRoute15({
+    describeRoute({
       summary: "Get global configuration",
       description: "Retrieve the current global OpenCode configuration settings and preferences.",
       operationId: "global.config.get",
@@ -4456,7 +4958,7 @@ var GlobalRoutes = lazy(
           description: "Get global config info",
           content: {
             "application/json": {
-              schema: resolver16(Config.Info)
+              schema: resolver(Config.Info)
             }
           }
         }
@@ -4467,7 +4969,7 @@ var GlobalRoutes = lazy(
     }
   ).patch(
     "/config",
-    describeRoute15({
+    describeRoute({
       summary: "Update global configuration",
       description: "Update global OpenCode configuration settings and preferences.",
       operationId: "global.config.update",
@@ -4476,14 +4978,14 @@ var GlobalRoutes = lazy(
           description: "Successfully updated global config",
           content: {
             "application/json": {
-              schema: resolver16(Config.Info)
+              schema: resolver(Config.Info)
             }
           }
         },
         ...errors(400)
       }
     }),
-    validator14("json", Config.Info),
+    validator2("json", Config.Info),
     async (c) => {
       const config = c.req.valid("json");
       const next = await Config.updateGlobal(config);
@@ -4491,7 +4993,7 @@ var GlobalRoutes = lazy(
     }
   ).post(
     "/dispose",
-    describeRoute15({
+    describeRoute({
       summary: "Dispose instance",
       description: "Clean up and dispose all OpenCode instances, releasing all resources.",
       operationId: "global.dispose",
@@ -4500,7 +5002,7 @@ var GlobalRoutes = lazy(
           description: "Global disposed",
           content: {
             "application/json": {
-              schema: resolver16(z20.boolean())
+              schema: resolver(z20.boolean())
             }
           }
         }
@@ -4519,7 +5021,7 @@ var GlobalRoutes = lazy(
     }
   ).post(
     "/upgrade",
-    describeRoute15({
+    describeRoute({
       summary: "Upgrade opencode",
       description: "Upgrade opencode to the specified version or latest if not specified.",
       operationId: "global.upgrade",
@@ -4528,7 +5030,7 @@ var GlobalRoutes = lazy(
           description: "Upgrade result",
           content: {
             "application/json": {
-              schema: resolver16(
+              schema: resolver(
                 z20.union([
                   z20.object({
                     success: z20.literal(true),
@@ -4546,7 +5048,7 @@ var GlobalRoutes = lazy(
         ...errors(400)
       }
     }),
-    validator14(
+    validator2(
       "json",
       z20.object({
         target: z20.string().optional()
@@ -4797,7 +5299,7 @@ var Server;
       return zipped(c, next);
     }).route("/global", GlobalRoutes()).put(
       "/auth/:providerID",
-      describeRoute16({
+      describeRoute({
         summary: "Set auth credentials",
         description: "Set authentication credentials",
         operationId: "auth.set",
@@ -4806,20 +5308,20 @@ var Server;
             description: "Successfully set authentication credentials",
             content: {
               "application/json": {
-                schema: resolver17(z21.boolean())
+                schema: resolver(z21.boolean())
               }
             }
           },
           ...errors(400)
         }
       }),
-      validator15(
+      validator2(
         "param",
         z21.object({
           providerID: ProviderID.zod
         })
       ),
-      validator15("json", Auth.Info.zod),
+      validator2("json", Auth.Info.zod),
       async (c) => {
         const providerID = c.req.valid("param").providerID;
         const info = c.req.valid("json");
@@ -4828,7 +5330,7 @@ var Server;
       }
     ).delete(
       "/auth/:providerID",
-      describeRoute16({
+      describeRoute({
         summary: "Remove auth credentials",
         description: "Remove authentication credentials",
         operationId: "auth.remove",
@@ -4837,14 +5339,14 @@ var Server;
             description: "Successfully removed authentication credentials",
             content: {
               "application/json": {
-                schema: resolver17(z21.boolean())
+                schema: resolver(z21.boolean())
               }
             }
           },
           ...errors(400)
         }
       }),
-      validator15(
+      validator2(
         "param",
         z21.object({
           providerID: ProviderID.zod
@@ -4868,7 +5370,7 @@ var Server;
         }
       })
     ).use(
-      validator15(
+      validator2(
         "query",
         z21.object({
           directory: z21.string().optional(),
@@ -4877,7 +5379,7 @@ var Server;
       )
     ).post(
       "/log",
-      describeRoute16({
+      describeRoute({
         summary: "Write log",
         description: "Write a log entry to the server logs with specified level and metadata.",
         operationId: "app.log",
@@ -4886,14 +5388,14 @@ var Server;
             description: "Log entry written successfully",
             content: {
               "application/json": {
-                schema: resolver17(z21.boolean())
+                schema: resolver(z21.boolean())
               }
             }
           },
           ...errors(400)
         }
       }),
-      validator15(
+      validator2(
         "json",
         z21.object({
           service: z21.string().meta({ description: "Service name for the log entry" }),
@@ -5022,4 +5524,4 @@ var Server;
 export {
   Server
 };
-//# sourceMappingURL=chunk-UWZSRZHA.js.map
+//# sourceMappingURL=chunk-23UYOGZG.js.map