@codewithagents/openapi-server 1.9.0 → 1.10.0

package/dist/cli.cjs

@@ -18844,10 +18844,14 @@ function parseServerConfig(raw, base) {
   if (raw["input_schema"] !== void 0 && (typeof raw["input_schema"] !== "string" || !raw["input_schema"])) {
     throw new Error('"input_schema" must be a non-empty string path to your Zod schema file');
   }
+  if (raw["context_type"] !== void 0 && (typeof raw["context_type"] !== "string" || !raw["context_type"])) {
+    throw new Error('"context_type" must be a non-empty string TypeScript type name');
+  }
   return {
     ...base,
     framework,
-    input_schema: raw["input_schema"]
+    input_schema: raw["input_schema"],
+    context_type: raw["context_type"]
   };
 }
 async function loadConfigs2(cwd, configPath) {
@@ -18943,6 +18947,7 @@ function schemaToTsType(schema) {
   const s = schema;
   if (s.type === "number" || s.type === "integer") return "number";
   if (s.type === "boolean") return "boolean";
+  if (s.type === "array") return "string[]";
   return "string";
 }
 function getQueryParams(operation, spec) {
@@ -18969,6 +18974,8 @@ function getQueryParams(operation, spec) {
           key,
           tsType: schemaToTsType(propSchema)
         }));
+        const propFields = param.deepObjectProperties.map((p2) => `${p2.key}?: ${p2.tsType}`).join("; ");
+        param.tsType = `{ ${propFields} }`;
       }
     }
     if (!param.isDeepObject && schema !== void 0 && !isRef3(schema) && schema.type === "array" && resolvedExplode === false) {
@@ -19062,6 +19069,10 @@ function getBodyInfo(operation) {
     }
     return { typeName: void 0, contentType: "multipart/form-data", isSynthesized: false };
   }
+  const octetContent = content["application/octet-stream"];
+  if (octetContent !== void 0) {
+    return { typeName: void 0, contentType: "application/octet-stream", isSynthesized: false };
+  }
   return { typeName: void 0, contentType: "application/json", isSynthesized: false };
 }
 
@@ -19152,6 +19163,11 @@ function collectOperations(spec) {
       const queryParams = getQueryParams(operation, spec);
       const bodyInfo = getBodyInfo(operation);
       const returnInfo = getReturnInfo(operation);
+      if (returnInfo.typeName === void 0 && !returnInfo.isVoid && returnInfo.primitiveType === void 0) {
+        console.warn(
+          `${methodName} (${method.toUpperCase()} ${path}): response type is unknown, no named response schema could be resolved from the spec. Add a named $ref response schema to get a typed return type and enable runtime validation.`
+        );
+      }
       operations.push({
         methodName,
         httpMethod: method,
@@ -19165,7 +19181,7 @@ function collectOperations(spec) {
   }
   return operations;
 }
-function buildMethodSignature(op) {
+function buildMethodSignature(op, options) {
   const args = [];
   for (const p of op.pathParams) {
     args.push(`${sanitizeOperationId2(p)}: string`);
@@ -19180,11 +19196,14 @@ function buildMethodSignature(op) {
     const paramsToken = allOptional ? "params?" : "params";
     args.push(`${paramsToken}: { ${fields} }`);
   }
+  if (options?.contextType !== void 0) {
+    args.push("ctx: Ctx");
+  }
   const returnType = buildReturnType(op.returnInfo);
   const argStr = args.join(", ");
   return `${op.methodName}(${argStr}): ${returnType}`;
 }
-function generateService(spec) {
+function generateService(spec, options) {
   const serviceName = deriveServiceName(spec);
   const operations = collectOperations(spec);
   const importTypes = /* @__PURE__ */ new Set();
@@ -19204,10 +19223,11 @@ function generateService(spec) {
     lines.push(`import type { ${sortedImports.join(", ")} } from './models.js'`);
     lines.push("");
   }
-  lines.push(`export interface ${serviceName} {`);
+  const interfaceDecl = options?.contextType !== void 0 ? `export interface ${serviceName}<Ctx = never> {` : `export interface ${serviceName} {`;
+  lines.push(interfaceDecl);
   for (const op of operations) {
     lines.push(`  /** ${op.httpMethod.toUpperCase()} ${op.path} */`);
-    lines.push(`  ${buildMethodSignature(op)}`);
+    lines.push(`  ${buildMethodSignature(op, options)}`);
   }
   lines.push("}");
   lines.push("");
@@ -19272,7 +19292,7 @@ function queryParamDeepObjectZodBase(param) {
   return `z.object({ ${propFields.join(", ")} })`;
 }
 function queryParamNumberZodBase(param) {
-  let base = "z.number()";
+  let base = "z.coerce.number()";
   if (param.minimum !== void 0) base += `.min(${param.minimum})`;
   if (param.maximum !== void 0) base += `.max(${param.maximum})`;
   if (param.exclusiveMinimum !== void 0) base += `.gt(${param.exclusiveMinimum})`;
@@ -19338,6 +19358,19 @@ function getPathParamValidations(operation, spec, rawPathParamNames) {
   }
   return result;
 }
+function cookieParamZodExpr(param) {
+  let base;
+  if (param.enum !== void 0 && param.enum.length > 0) {
+    const members = param.enum.map((v) => JSON.stringify(v)).join(", ");
+    base = `z.enum([${members}])`;
+  } else {
+    base = "z.string()";
+  }
+  if (param.minLength !== void 0) base += `.min(${param.minLength})`;
+  if (param.maxLength !== void 0) base += `.max(${param.maxLength})`;
+  if (param.pattern !== void 0) base += `.regex(/${param.pattern}/)`;
+  return param.required ? base : `${base}.optional()`;
+}
 function getHeaderParams(operation, spec) {
   const parameters = operation.parameters;
   if (parameters === void 0) return [];
@@ -19361,6 +19394,29 @@ function getHeaderParams(operation, spec) {
   }
   return result;
 }
+function getCookieParams(operation, spec) {
+  const parameters = operation.parameters;
+  if (parameters === void 0) return [];
+  const result = [];
+  for (const p of parameters) {
+    const resolved = resolveParam(p, spec);
+    if (resolved === void 0 || resolved.in !== "cookie") continue;
+    const param = {
+      rawName: resolved.name,
+      required: resolved.required === true
+    };
+    const schema = resolved.schema;
+    if (schema !== void 0 && !isRef3(schema)) {
+      const s = schema;
+      if (Array.isArray(s.enum)) param.enum = s.enum;
+      if (typeof s.minLength === "number") param.minLength = s.minLength;
+      if (typeof s.maxLength === "number") param.maxLength = s.maxLength;
+      if (typeof s.pattern === "string") param.pattern = s.pattern;
+    }
+    result.push(param);
+  }
+  return result;
+}
 function queryParamHasConstraints(q) {
   const constraintFields = [
     q.enum,
@@ -19410,7 +19466,7 @@ function emitPathValidation(lines, validations, indent, framework) {
     if (framework === "hono") {
       access = `c.req.param(${JSON.stringify(v.rawName)})`;
     } else if (framework === "express") {
-      access = `req.params[${JSON.stringify(v.rawName)}]`;
+      access = `req.params[${JSON.stringify(v.rawName)}] as string`;
     } else {
       access = /[^a-zA-Z0-9_$]/.test(v.rawName) ? `req.params[${JSON.stringify(v.rawName)}]` : `req.params.${v.rawName}`;
     }
@@ -19433,13 +19489,14 @@ function emitHeaderValidation(lines, headerParams, indent, framework) {
   }).join(",\n");
   const rawFields = headerParams.map((h) => {
     const key = JSON.stringify(h.rawName);
+    const lookupKey = JSON.stringify(h.rawName.toLowerCase());
     let access;
     if (framework === "hono") {
       access = `c.req.header(${key})`;
     } else if (framework === "express") {
-      access = `req.headers[${key}] as string | undefined`;
+      access = `req.headers[${lookupKey}] as string | undefined`;
     } else {
-      access = `req.headers[${key}]`;
+      access = `req.headers[${lookupKey}]`;
     }
     return `${fieldIndent}${key}: ${access}`;
   }).join(",\n");
@@ -19450,6 +19507,33 @@ function emitHeaderValidation(lines, headerParams, indent, framework) {
   lines.push(rawFields);
   lines.push(`${inner}})`);
 }
+function emitCookieValidation(lines, cookieParams, indent, framework) {
+  const inner = `${indent}  `;
+  const fieldIndent = `${indent}    `;
+  const schemaFields = cookieParams.map((ck) => {
+    const key = JSON.stringify(ck.rawName);
+    const expr = cookieParamZodExpr(ck);
+    return `${fieldIndent}${key}: ${expr}`;
+  }).join(",\n");
+  const rawFields = cookieParams.map((ck) => {
+    const key = JSON.stringify(ck.rawName);
+    let access;
+    if (framework === "hono") {
+      access = `getCookie(c, ${key})`;
+    } else if (framework === "express") {
+      access = `req.cookies[${key}] as string | undefined`;
+    } else {
+      access = `req.cookies[${key}]`;
+    }
+    return `${fieldIndent}${key}: ${access}`;
+  }).join(",\n");
+  lines.push(`${inner}// Validate request cookies: returns 422 with Zod issues on failure`);
+  lines.push(`${inner}const _ckv = z.object({`);
+  lines.push(schemaFields);
+  lines.push(`${inner}}).safeParse({`);
+  lines.push(rawFields);
+  lines.push(`${inner}})`);
+}
 function response200IsVoid(resp) {
   if (isRef3(resp)) return false;
   const r = resp;
@@ -19514,6 +19598,34 @@ function getResponseStatus(operation, httpMethod) {
   }
   return httpMethod === "delete" ? { status: 204, isVoid: true, responseContentType: "application/json" } : { status: 200, isVoid: false, responseContentType: "application/json" };
 }
+function getResponseTypeName(operation) {
+  const responses = operation.responses;
+  if (responses === void 0) return void 0;
+  const priority = ["200", "201", ...Object.keys(responses).filter(
+    (k) => /^2\d\d$/.test(k) && k !== "200" && k !== "201" && k !== "204"
+  )];
+  for (const code of priority) {
+    const response = responses[code];
+    if (response === void 0 || isRef3(response)) continue;
+    const resp = response;
+    const content = resp.content;
+    if (content === void 0) continue;
+    const jsonContent = content["application/json"];
+    if (jsonContent === void 0 || jsonContent.schema === void 0) continue;
+    const schema = jsonContent.schema;
+    if (isRef3(schema)) {
+      return { typeName: refToName(schema.$ref), isArray: false };
+    }
+    const s = schema;
+    if (s.type === "array" && s.items !== void 0 && isRef3(s.items)) {
+      return {
+        typeName: refToName(s.items.$ref),
+        isArray: true
+      };
+    }
+  }
+  return void 0;
+}
 function collectOperations2(spec) {
   const paths = spec.paths;
   if (paths === void 0) return [];
@@ -19527,8 +19639,10 @@ function collectOperations2(spec) {
       const pathParamValidations = getPathParamValidations(operation, spec, pathParams);
       const queryParams = getQueryParams(operation, spec);
       const headerParams = getHeaderParams(operation, spec);
+      const cookieParams = getCookieParams(operation, spec);
       const bodyInfo = getBodyInfo(operation);
       const responseStatus = getResponseStatus(operation, method);
+      const responseTypeInfo = getResponseTypeName(operation);
       operations.push({
         methodName,
         httpMethod: method,
@@ -19538,8 +19652,11 @@ function collectOperations2(spec) {
         pathParamValidations,
         queryParams,
         headerParams,
+        cookieParams,
         bodyInfo,
-        responseStatus
+        responseStatus,
+        responseTypeName: responseTypeInfo?.typeName,
+        responseIsArray: responseTypeInfo?.isArray
       });
     }
   }
@@ -19564,13 +19681,27 @@ function collectUsedSchemaNames(operations, schemaNames) {
   }
   return used;
 }
+function collectUsedResponseSchemaNames(operations, schemaNames) {
+  const used = /* @__PURE__ */ new Set();
+  for (const op of operations) {
+    if (op.responseTypeName === void 0) continue;
+    if (op.responseStatus.isMultiStatus === true) continue;
+    const schemaName = `${op.responseTypeName}Schema`;
+    if (schemaNames.has(schemaName)) used.add(schemaName);
+  }
+  return used;
+}
 function collectGeneratorSetup(operations, options) {
   const sortedBodyTypes = collectSortedBodyTypes(operations);
   const usedSchemaNames = options?.schemaNames !== void 0 ? collectUsedSchemaNames(operations, options.schemaNames) : /* @__PURE__ */ new Set();
-  const needsZod = usedSchemaNames.size > 0 && options?.schemaImportPath !== void 0 || operationsNeedZodForParams(operations);
-  return { sortedBodyTypes, usedSchemaNames, needsZod };
+  const usedResponseSchemaNames = options?.schemaNames !== void 0 ? collectUsedResponseSchemaNames(operations, options.schemaNames) : /* @__PURE__ */ new Set();
+  const hasArrayResponseSchema = usedResponseSchemaNames.size > 0 && operations.some(
+    (op) => op.responseIsArray === true && op.responseTypeName !== void 0 && usedResponseSchemaNames.has(`${op.responseTypeName}Schema`)
+  );
+  const needsZod = usedSchemaNames.size > 0 && options?.schemaImportPath !== void 0 || operationsNeedZodForParams(operations) || usedResponseSchemaNames.size > 0 && options?.schemaImportPath !== void 0 && hasArrayResponseSchema;
+  return { sortedBodyTypes, usedSchemaNames, usedResponseSchemaNames, needsZod };
 }
-function buildRouteHandler(op, indent, schemaNames) {
+function buildRouteHandler(op, indent, schemaNames, contextType) {
   const lines = [];
   lines.push(`${indent}app.${op.httpMethod}(${JSON.stringify(op.honoPath)}, async (c) => {`);
   if (op.pathParamValidations.length > 0) {
@@ -19628,6 +19759,14 @@ function buildRouteHandler(op, indent, schemaNames) {
     );
     lines.push(`${indent}  }`);
   }
+  if (op.cookieParams.length > 0) {
+    emitCookieValidation(lines, op.cookieParams, indent, "hono");
+    lines.push(`${indent}  if (!_ckv.success) {`);
+    lines.push(
+      `${indent}    return c.json({ error: 'Invalid request cookies', issues: _ckv.error.issues }, 422)`
+    );
+    lines.push(`${indent}  }`);
+  }
   let bodyVarName = "body";
   if (op.bodyInfo !== void 0) {
     const typeDecl = op.bodyInfo.typeName !== void 0 && !op.bodyInfo.isSynthesized ? op.bodyInfo.typeName : "unknown";
@@ -19665,7 +19804,7 @@ function buildRouteHandler(op, indent, schemaNames) {
         `${indent}    return c.json({ error: 'Invalid request body', issues: parseResult.error.issues }, 422)`
       );
       lines.push(`${indent}  }`);
-      lines.push(`${indent}  const validatedBody = parseResult.data`);
+      lines.push(`${indent}  const validatedBody = parseResult.data as ${typeDecl}`);
       bodyVarName = "validatedBody";
     }
   }
@@ -19677,7 +19816,10 @@ function buildRouteHandler(op, indent, schemaNames) {
     serviceArgs.push(bodyVarName);
   }
   if (op.queryParams.length > 0) {
-    serviceArgs.push("params");
+    serviceArgs.push(queryParamsNeedValidation(op.queryParams) ? "_qv.data" : "params");
+  }
+  if (contextType !== void 0) {
+    serviceArgs.push("c");
   }
   const serviceCall = `service.${op.methodName}(${serviceArgs.join(", ")})`;
   lines.push(`${indent}  try {`);
@@ -19721,7 +19863,7 @@ function buildRouteHandler(op, indent, schemaNames) {
   lines.push(`${indent}})`);
   return lines.join("\n");
 }
-function buildExpressRouteHandler(op, indent, schemaNames) {
+function buildExpressRouteHandler(op, indent, schemaNames, contextType) {
   const lines = [];
   lines.push(
     `${indent}router.${op.httpMethod}(${JSON.stringify(op.honoPath)}, async (req: Request, res: Response) => {`
@@ -19771,6 +19913,14 @@ function buildExpressRouteHandler(op, indent, schemaNames) {
     );
     lines.push(`${indent}  }`);
   }
+  if (op.cookieParams.length > 0) {
+    emitCookieValidation(lines, op.cookieParams, indent, "express");
+    lines.push(`${indent}  if (!_ckv.success) {`);
+    lines.push(
+      `${indent}    return void res.status(422).json({ error: 'Invalid request cookies', issues: _ckv.error.issues })`
+    );
+    lines.push(`${indent}  }`);
+  }
   let bodyVarName = "body";
   if (op.bodyInfo !== void 0) {
     if (op.bodyInfo.contentType === "multipart/form-data") {
@@ -19789,7 +19939,8 @@ function buildExpressRouteHandler(op, indent, schemaNames) {
           `${indent}    return void res.status(422).json({ error: 'Invalid request body', issues: parseResult.error.issues })`
         );
         lines.push(`${indent}  }`);
-        lines.push(`${indent}  const validatedBody = parseResult.data`);
+        const typeDecl = op.bodyInfo.typeName !== void 0 && !op.bodyInfo.isSynthesized ? op.bodyInfo.typeName : "unknown";
+        lines.push(`${indent}  const validatedBody = parseResult.data as ${typeDecl}`);
         bodyVarName = "validatedBody";
       } else {
         const typeAnnotation = op.bodyInfo.typeName !== void 0 && !op.bodyInfo.isSynthesized ? ` as ${op.bodyInfo.typeName}` : "";
@@ -19799,13 +19950,16 @@ function buildExpressRouteHandler(op, indent, schemaNames) {
   }
   const serviceArgs = [];
   for (const p of op.pathParams) {
-    serviceArgs.push(`req.params['${p}']!`);
+    serviceArgs.push(`(req.params['${p}'] as string)`);
   }
   if (op.bodyInfo !== void 0) {
     serviceArgs.push(bodyVarName);
   }
   if (op.queryParams.length > 0) {
-    serviceArgs.push("params");
+    serviceArgs.push(queryParamsNeedValidation(op.queryParams) ? "_qv.data" : "params");
+  }
+  if (contextType !== void 0) {
+    serviceArgs.push("req");
   }
   const serviceCall = `service.${op.methodName}(${serviceArgs.join(", ")})`;
   lines.push(`${indent}  try {`);
@@ -19847,7 +20001,25 @@ function buildExpressRouteHandler(op, indent, schemaNames) {
   lines.push(`${indent}})`);
   return lines.join("\n");
 }
-function buildFastifyRouteHandler(op, indent, schemaNames) {
+function buildFastifyRouteOptions(op, schemaNames) {
+  const parts = [];
+  const responseSchemaExpr = buildFastifyResponseSchemaExpr(op, schemaNames);
+  if (responseSchemaExpr !== void 0) {
+    parts.push(`schema: { response: { ${op.responseStatus.status}: ${responseSchemaExpr} } }`);
+  }
+  parts.push(`config: { operationId: '${op.methodName}' }`);
+  return `{ ${parts.join(", ")} }`;
+}
+function buildFastifyResponseSchemaExpr(op, schemaNames) {
+  if (schemaNames === void 0) return void 0;
+  if (op.responseTypeName === void 0) return void 0;
+  if (op.responseStatus.isMultiStatus === true) return void 0;
+  if (op.responseStatus.isVoid) return void 0;
+  const schemaName = `${op.responseTypeName}Schema`;
+  if (!schemaNames.has(schemaName)) return void 0;
+  return op.responseIsArray === true ? `z.array(${schemaName})` : schemaName;
+}
+function buildFastifyRouteHandler(op, indent, schemaNames, contextType) {
   const lines = [];
   const genericParts = [];
   if (op.queryParams.length > 0) {
@@ -19877,13 +20049,14 @@ function buildFastifyRouteHandler(op, indent, schemaNames) {
     genericParts.push(`Params: { ${paramFields} }`);
   }
   const generic = genericParts.length > 0 ? `<{ ${genericParts.join("; ")} }>` : "";
+  const routeOpts = buildFastifyRouteOptions(op, schemaNames);
   lines.push(
-    `${indent}app.${op.httpMethod}${generic}(${JSON.stringify(op.honoPath)}, async (req, reply) => {`
+    `${indent}app.${op.httpMethod}${generic}(${JSON.stringify(op.honoPath)}, ${routeOpts}, async (req, reply) => {`
   );
   if (op.pathParamValidations.length > 0) {
     emitPathValidation(lines, op.pathParamValidations, indent, "fastify");
     lines.push(`${indent}  if (!_pv.success) {`);
-    lines.push(`${indent}    return reply.status(422).send({`);
+    lines.push(`${indent}    return (reply as FastifyReply).status(422).send({`);
     lines.push(`${indent}      error: 'Invalid path parameters',`);
     lines.push(`${indent}      issues: _pv.error.issues,`);
     lines.push(`${indent}    })`);
@@ -19918,6 +20091,9 @@ function buildFastifyRouteHandler(op, indent, schemaNames) {
         const delim = JSON.stringify(delimiterChar(q.delimiterStyle));
         return `    ${q.name}: typeof _dq['${q.rawName}'] === 'string' ? _dq['${q.rawName}']!.split(${delim}) : undefined`;
       }
+      if (q.tsType === "boolean") {
+        return hasDeepOrDelimited ? `    ${q.name}: _dq['${q.rawName}'] === 'true'` : `    ${q.name}: (req.query.${q.name} as unknown as string) === 'true'`;
+      }
       return hasDeepOrDelimited ? `    ${q.name}: _dq['${q.rawName}']` : `    ${q.name}: req.query.${q.name}`;
     }).join(",\n");
     lines.push(`${indent}  const params = {`);
@@ -19926,7 +20102,7 @@ function buildFastifyRouteHandler(op, indent, schemaNames) {
     if (queryParamsNeedValidation(op.queryParams)) {
       emitQueryValidation(lines, op.queryParams, indent);
       lines.push(`${indent}  if (!_qv.success) {`);
-      lines.push(`${indent}    return reply.status(422).send({`);
+      lines.push(`${indent}    return (reply as FastifyReply).status(422).send({`);
       lines.push(`${indent}      error: 'Invalid query parameters',`);
       lines.push(`${indent}      issues: _qv.error.issues,`);
       lines.push(`${indent}    })`);
@@ -19936,17 +20112,30 @@ function buildFastifyRouteHandler(op, indent, schemaNames) {
   if (op.headerParams.length > 0) {
     emitHeaderValidation(lines, op.headerParams, indent, "fastify");
     lines.push(`${indent}  if (!_hv.success) {`);
-    lines.push(`${indent}    return reply.status(422).send({`);
+    lines.push(`${indent}    return (reply as FastifyReply).status(422).send({`);
     lines.push(`${indent}      error: 'Invalid request headers',`);
     lines.push(`${indent}      issues: _hv.error.issues,`);
     lines.push(`${indent}    })`);
     lines.push(`${indent}  }`);
   }
+  if (op.cookieParams.length > 0) {
+    emitCookieValidation(lines, op.cookieParams, indent, "fastify");
+    lines.push(`${indent}  if (!_ckv.success) {`);
+    lines.push(`${indent}    return (reply as FastifyReply).status(422).send({`);
+    lines.push(`${indent}      error: 'Invalid request cookies',`);
+    lines.push(`${indent}      issues: _ckv.error.issues,`);
+    lines.push(`${indent}    })`);
+    lines.push(`${indent}  }`);
+  }
   let bodyVarName = "req.body";
   if (op.bodyInfo !== void 0) {
     if (op.bodyInfo.contentType === "multipart/form-data") {
       lines.push(
-        `${indent}  // multipart/form-data: assumes @fastify/multipart plugin has populated req.body.`
+        `${indent}  // multipart/form-data: requires @fastify/multipart registered with { attachFieldsToBody: true }.`
+      );
+    } else if (op.bodyInfo.contentType === "application/octet-stream") {
+      lines.push(
+        `${indent}  // application/octet-stream: req.body is a Buffer from the registered content-type parser.`
       );
     } else {
       const schemaName = op.bodyInfo.typeName !== void 0 ? `${op.bodyInfo.typeName}Schema` : void 0;
@@ -19956,10 +20145,12 @@ function buildFastifyRouteHandler(op, indent, schemaNames) {
         lines.push(`${indent}  const parseResult = ${schemaName}.safeParse(req.body)`);
         lines.push(`${indent}  if (!parseResult.success) {`);
         lines.push(
-          `${indent}    return reply.status(422).send({ error: 'Invalid request body', issues: parseResult.error.issues })`
+          `${indent}    return (reply as FastifyReply).status(422).send({ error: 'Invalid request body', issues: parseResult.error.issues })`
         );
         lines.push(`${indent}  }`);
-        bodyVarName = "parseResult.data";
+        const bodyCastType = op.bodyInfo.typeName !== void 0 && !op.bodyInfo.isSynthesized ? op.bodyInfo.typeName : "unknown";
+        lines.push(`${indent}  const validatedBody = parseResult.data as ${bodyCastType}`);
+        bodyVarName = "validatedBody";
       }
     }
   }
@@ -19971,7 +20162,10 @@ function buildFastifyRouteHandler(op, indent, schemaNames) {
     serviceArgs.push(bodyVarName);
   }
   if (op.queryParams.length > 0) {
-    serviceArgs.push("params");
+    serviceArgs.push(queryParamsNeedValidation(op.queryParams) ? "_qv.data" : "params");
+  }
+  if (contextType !== void 0) {
+    serviceArgs.push("req");
   }
   const serviceCall = `service.${op.methodName}(${serviceArgs.join(", ")})`;
   lines.push(`${indent}  try {`);
@@ -19994,14 +20188,14 @@ function buildFastifyRouteHandler(op, indent, schemaNames) {
       lines.push(`${indent}    return reply.status(${op.responseStatus.status}).type('application/octet-stream').send(Buffer.from(await ${serviceCall}))`);
     }
   } else if (op.responseStatus.status === 200) {
-    lines.push(`${indent}    return ${serviceCall}`);
+    lines.push(`${indent}    return await ${serviceCall}`);
   } else {
     lines.push(`${indent}    reply.status(${op.responseStatus.status})`);
-    lines.push(`${indent}    return ${serviceCall}`);
+    lines.push(`${indent}    return await ${serviceCall}`);
   }
   lines.push(`${indent}  } catch (err) {`);
   lines.push(`${indent}    if (err instanceof HttpError) {`);
-  lines.push(`${indent}      return reply.status(err.status).send({ error: err.message })`);
+  lines.push(`${indent}      return (reply as FastifyReply).status(err.status).send({ error: err.message })`);
   lines.push(`${indent}    }`);
   lines.push(`${indent}    throw err`);
   lines.push(`${indent}  }`);
@@ -20023,6 +20217,7 @@ function operationsNeedZodForParams(operations) {
     if (op.pathParamValidations.length > 0) return true;
     if (queryParamsNeedValidation(op.queryParams)) return true;
     if (op.headerParams.length > 0) return true;
+    if (op.cookieParams.length > 0) return true;
   }
   return false;
 }
@@ -20041,6 +20236,8 @@ function generateExpressRouter(spec, options) {
   if (sortedBodyTypes.length > 0) {
     lines.push(`import type { ${sortedBodyTypes.join(", ")} } from './models.js'`);
   }
+  const ctx = options?.contextType;
+  const serviceRef = ctx !== void 0 ? `${serviceName}<${ctx}>` : serviceName;
   lines.push(`import type { ${serviceName} } from './service.js'`);
   if (needsZod) {
     lines.push(`import { z } from 'zod'`);
@@ -20052,11 +20249,11 @@ function generateExpressRouter(spec, options) {
   lines.push("");
   for (const l of httpErrorClassLines()) lines.push(l);
   lines.push("");
-  lines.push(`export function createRouter(service: ${serviceName}): Router {`);
+  lines.push(`export function createRouter(service: ${serviceRef}): Router {`);
   lines.push("  const router = Router()");
   lines.push("");
   for (const op of operations) {
-    lines.push(buildExpressRouteHandler(op, "  ", options?.schemaNames));
+    lines.push(buildExpressRouteHandler(op, "  ", options?.schemaNames, ctx));
     lines.push("");
   }
   lines.push("  return router");
@@ -20070,11 +20267,26 @@ function generateExpressRouter(spec, options) {
 function generateFastifyRouter(spec, options) {
   const serviceName = deriveServiceName(spec);
   const operations = collectOperations2(spec);
-  const { sortedBodyTypes, usedSchemaNames, needsZod } = collectGeneratorSetup(operations, options);
+  const { sortedBodyTypes, usedSchemaNames, usedResponseSchemaNames, needsZod } = collectGeneratorSetup(operations, options);
+  const allUsedSchemaNames = /* @__PURE__ */ new Set([...usedSchemaNames, ...usedResponseSchemaNames]);
+  const hasOctetStreamRequestBody = operations.some(
+    (op) => op.bodyInfo?.contentType === "application/octet-stream"
+  );
   const lines = [];
   lines.push("// This file is auto-generated. Do not edit manually.");
+  lines.push(
+    "// Fastify natively parses only application/json and text/plain request bodies."
+  );
+  lines.push(
+    "// For application/x-www-form-urlencoded bodies, register @fastify/formbody before this router."
+  );
+  lines.push(
+    "// For multipart/form-data bodies, register @fastify/multipart with { attachFieldsToBody: true } before this router."
+  );
   lines.push("");
-  lines.push("import type { FastifyInstance } from 'fastify'");
+  const ctx = options?.contextType;
+  const serviceRef = ctx !== void 0 ? `${serviceName}<${ctx}>` : serviceName;
+  lines.push("import type { FastifyInstance, FastifyReply } from 'fastify'");
   if (sortedBodyTypes.length > 0) {
     lines.push(`import type { ${sortedBodyTypes.join(", ")} } from './models.js'`);
   }
@@ -20082,17 +20294,41 @@ function generateFastifyRouter(spec, options) {
   if (needsZod) {
     lines.push(`import { z } from 'zod'`);
   }
-  if (usedSchemaNames.size > 0 && options?.schemaImportPath !== void 0) {
-    const sortedUsedSchemas = Array.from(usedSchemaNames).sort();
+  if (allUsedSchemaNames.size > 0 && options?.schemaImportPath !== void 0) {
+    const sortedUsedSchemas = Array.from(allUsedSchemaNames).sort();
     lines.push(`import { ${sortedUsedSchemas.join(", ")} } from '${options.schemaImportPath}'`);
   }
   lines.push("");
+  lines.push("declare module 'fastify' {");
+  lines.push("  interface FastifyContextConfig {");
+  lines.push("    operationId?: string");
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
   for (const l of httpErrorClassLines()) lines.push(l);
   lines.push("");
-  lines.push(`export function createRouter(app: FastifyInstance, service: ${serviceName}): void {`);
+  lines.push(`export function createRouter(app: FastifyInstance, service: ${serviceRef}): void {`);
+  if (hasOctetStreamRequestBody) {
+    lines.push(
+      "  app.addContentTypeParser('application/octet-stream', { parseAs: 'buffer' }, (req, body, done) => done(null, body))"
+    );
+  }
+  if (usedResponseSchemaNames.size > 0 && options?.schemaImportPath !== void 0) {
+    lines.push("  app.setSerializerCompiler(({ schema }) => {");
+    lines.push(
+      "    if (schema !== null && typeof schema === 'object' && 'parse' in schema) {"
+    );
+    lines.push(
+      "      const zodSchema = schema as { parse: (data: unknown) => unknown }"
+    );
+    lines.push("      return (data: unknown) => JSON.stringify(zodSchema.parse(data))");
+    lines.push("    }");
+    lines.push("    return (data: unknown) => JSON.stringify(data)");
+    lines.push("  })");
+  }
   for (const op of operations) {
     lines.push("");
-    lines.push(buildFastifyRouteHandler(op, "  ", options?.schemaNames));
+    lines.push(buildFastifyRouteHandler(op, "  ", options?.schemaNames, ctx));
   }
   lines.push("}");
   lines.push("");
@@ -20108,7 +20344,13 @@ function generateRouter(spec, options) {
   const lines = [];
   lines.push("// This file is auto-generated. Do not edit manually.");
   lines.push("");
+  const ctx = options?.contextType;
+  const serviceRef = ctx !== void 0 ? `${serviceName}<${ctx}>` : serviceName;
+  const needsGetCookie = operations.some((op) => op.cookieParams.length > 0);
   lines.push("import { Hono } from 'hono'");
+  if (needsGetCookie) {
+    lines.push("import { getCookie } from 'hono/cookie'");
+  }
   if (sortedBodyTypes.length > 0) {
     lines.push(`import type { ${sortedBodyTypes.join(", ")} } from './models.js'`);
   }
@@ -20123,11 +20365,11 @@ function generateRouter(spec, options) {
   lines.push("");
   for (const l of httpErrorClassLines()) lines.push(l);
   lines.push("");
-  lines.push(`export function createRouter(service: ${serviceName}): Hono {`);
+  lines.push(`export function createRouter(service: ${serviceRef}): Hono {`);
   lines.push("  const app = new Hono()");
   lines.push("");
   for (const op of operations) {
-    lines.push(buildRouteHandler(op, "  ", options?.schemaNames));
+    lines.push(buildRouteHandler(op, "  ", options?.schemaNames, ctx));
     lines.push("");
   }
   lines.push("  return app");
@@ -20157,9 +20399,14 @@ async function generateOne(cwd, config, label) {
   const prefix = label !== void 0 ? `[${label}] ` : "";
   console.log(`${prefix}Parsing spec: ${inputPath}`);
   const spec = await parseSpec(inputPath);
-  const generatedFiles = [generateService(spec)];
+  const serviceOptions = config.context_type !== void 0 ? { contextType: config.context_type } : void 0;
+  const generatedFiles = [generateService(spec, serviceOptions)];
   if (framework !== "none") {
-    generatedFiles.push(buildRouterFile(spec, framework));
+    generatedFiles.push(
+      buildRouterFile(spec, framework, {
+        contextType: config.context_type
+      })
+    );
   }
   console.log(`${prefix}Writing output to: ${outputDir}`);
   await (0, import_promises2.mkdir)(outputDir, { recursive: true });
@@ -20192,7 +20439,8 @@ async function generateSchemaEnhancedRouter(cwd, config, spec, framework, output
   const schemaImportPathJs = schemaImportPath.replace(/\.ts$/, ".js");
   const routerFile = buildRouterFile(spec, framework, {
     schemaNames: exportedSchemas,
-    schemaImportPath: schemaImportPathJs
+    schemaImportPath: schemaImportPathJs,
+    contextType: config.context_type
   });
   const routerPath = (0, import_node_path2.join)(outputDir, routerFile.filename);
   await (0, import_promises2.writeFile)(routerPath, await formatTs(routerFile.content, routerPath), "utf-8");