Fix OpenAPI import to emit @cookie for cookie parameters (#10995)

OpenAPI import currently drops parameter location metadata for `in:
cookie`, producing undecorated parameters in generated TypeSpec. This
updates conversion so cookie parameters are emitted as HTTP cookie
parameters across OpenAPI 3.0/3.1/3.2 nullable forms.

- **Converter fix**
- Added `cookie` to supported parameter locations in the OpenAPI3
converter decorator mapping.
- Cookie parameters now generate `@cookie` the same way `query`,
`header`, and `path` already do.

- **Coverage updates**
- Extended parameter-location tests to include `cookie` in top-level
parameter conversion.
  - Added operation-level cookie tests covering:
    - OpenAPI 3.0: `nullable: true`
    - OpenAPI 3.1/3.2: `type: ["string", "null"]`
    - required vs optional parameter emission

- **Changelog**
  - Added a `fix` chronus entry for `@typespec/openapi3`.

```tsp
// before
@get op Widgets_get(session_id?: string | null): OkResponse;

// after
@get op Widgets_get(@cookie session_id?: string | null): OkResponse;
```

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: baywet <7905502+baywet@users.noreply.github.com>

Author: Copilot

.chronus/changes/fix-openapi3-import-cookie-parameters-2026-6-16.md

@@ -0,0 +1,7 @@
+---
+changeKind: fix
+packages:
+  - "@typespec/openapi3"
+---
+
+Fix OpenAPI import to emit `@cookie` decorators for cookie parameters, including nullable and type-null schema variants.

packages/openapi3/src/cli/actions/convert/utils/decorators.ts

@@ -13,7 +13,7 @@ import { stringLiteral } from "../generators/common.js";
 import { TSValue, TypeSpecDecorator, TypeSpecDirective } from "../interfaces.js";
 import type { Context } from "./context.js";
 
-const validLocations = ["header", "query", "path"];
+const validLocations = ["header", "query", "path", "cookie"];
 const extensionDecoratorName = "extension";
 
 export function getExtensions(element: Extensions): TypeSpecDecorator[] {

packages/openapi3/test/tsp-openapi3/parameters.test.ts

@@ -11,35 +11,38 @@ import {
 } from "./utils/tsp-for-openapi3.js";
 
 describe("converts top-level parameters", () => {
-  it.each(["query", "header", "path"] as const)(`Supports location: %s`, async (location) => {
-    const serviceNamespace = await tspForOpenAPI3({
-      parameters: {
-        Foo: {
-          name: "foo",
-          in: location,
-          required: true,
-          schema: {
-            type: "string",
+  it.each(["query", "header", "path", "cookie"] as const)(
+    `Supports location: %s`,
+    async (location) => {
+      const serviceNamespace = await tspForOpenAPI3({
+        parameters: {
+          Foo: {
+            name: "foo",
+            in: location,
+            required: true,
+            schema: {
+              type: "string",
+            },
           },
         },
-      },
-    });
+      });
 
-    const parametersNamespace = serviceNamespace.namespaces.get("Parameters");
-    assert(parametersNamespace, "Parameters namespace not found");
+      const parametersNamespace = serviceNamespace.namespaces.get("Parameters");
+      assert(parametersNamespace, "Parameters namespace not found");
 
-    const models = parametersNamespace.models;
+      const models = parametersNamespace.models;
 
-    /* model Foo { @<location> foo: string, } */
-    const Foo = models.get("Foo");
-    assert(Foo, "Foo model not found");
-    expect(Foo.properties.size).toBe(1);
-    expect(Foo.properties.get("foo")).toMatchObject({
-      optional: false,
-      type: { kind: "Scalar", name: "string" },
-      decorators: [{ definition: { name: `@${location}` } }],
-    });
-  });
+      /* model Foo { @<location> foo: string, } */
+      const Foo = models.get("Foo");
+      assert(Foo, "Foo model not found");
+      expect(Foo.properties.size).toBe(1);
+      expect(Foo.properties.get("foo")).toMatchObject({
+        optional: false,
+        type: { kind: "Scalar", name: "string" },
+        decorators: [{ definition: { name: `@${location}` } }],
+      });
+    },
+  );
 
   it(`Supports string schema constraints`, async () => {
     const serviceNamespace = await tspForOpenAPI3({
@@ -408,6 +411,71 @@ describe("header", () => {
   });
 });
 
+describe("cookie", () => {
+  it("renders @cookie for OpenAPI 3.0 nullable cookie parameters", async () => {
+    const tsp = await renderTypeSpecForOpenAPI3({
+      paths: {
+        "/widgets": {
+          get: {
+            operationId: "Widgets_get",
+            parameters: [
+              {
+                name: "session_id",
+                in: "cookie",
+                required: false,
+                explode: false,
+                schema: { type: "string", nullable: true },
+              },
+            ],
+            responses: {
+              "200": { description: "OK" },
+            },
+          },
+        },
+      },
+    });
+
+    expect(tsp).toContain('import "@typespec/http";');
+    expect(tsp).toContain("using Http;");
+    expect(tsp).toContain("@cookie session_id?: string | null");
+  });
+
+  it.each([
+    { openapi: "3.1.0", required: false, expected: "@cookie session_id?: string | null" },
+    { openapi: "3.2.0", required: true, expected: "@cookie session_id: string | null" },
+  ] as const)(
+    "renders @cookie for OpenAPI $openapi type-null cookie parameters",
+    async ({ openapi, required, expected }) => {
+      const tsp = await renderTypeSpecForOpenAPI3({
+        openapi: openapi as any,
+        paths: {
+          "/widgets": {
+            get: {
+              operationId: "Widgets_get",
+              parameters: [
+                {
+                  name: "session_id",
+                  in: "cookie",
+                  required,
+                  explode: false,
+                  schema: { type: ["string", "null"] as any },
+                },
+              ],
+              responses: {
+                "200": { description: "OK" },
+              },
+            },
+          },
+        },
+      });
+
+      expect(tsp).toContain('import "@typespec/http";');
+      expect(tsp).toContain("using Http;");
+      expect(tsp).toContain(expected);
+    },
+  );
+});
+
 describe("query", () => {
   it(`sets explode: true for default OpenAPI 3 parameter`, async () => {
     const serviceNamespace = await tspForOpenAPI3({