@typespec/http-client-python 0.35.1 → 0.37.0

package/emitter/test/browser-pyodide.test.ts

@@ -0,0 +1,25 @@
+import { strictEqual } from "assert";
+import { afterEach, describe, it, vi } from "vitest";
+
+const loadPyodide = vi.hoisted(() => vi.fn());
+
+vi.mock("../src/pyodide-loader.js", () => ({ loadPyodide }));
+
+describe("typespec-python: browser pyodide bootstrap", () => {
+  afterEach(() => {
+    delete (globalThis as any).window;
+    loadPyodide.mockReset();
+    vi.resetModules();
+  });
+
+  // Hosts like the TypeSpec playground import every available emitter up front. Booting Pyodide at
+  // module scope downloaded a full CPython WebAssembly runtime on every page load, which pushed the
+  // page past the per-tab memory budget on mobile browsers and prevented it from loading.
+  it("does not boot pyodide when the emitter is imported in a browser", async () => {
+    (globalThis as any).window = globalThis;
+
+    await import("../src/emitter.js");
+
+    strictEqual(loadPyodide.mock.calls.length, 0);
+  });
+});

package/emitter/test/streaming.test.ts

@@ -0,0 +1,155 @@
+import { strictEqual } from "assert";
+import { describe, it } from "vitest";
+import {
+  getStructuredStreamKind,
+  isStructuredStreamType,
+  partitionSSEEvents,
+} from "../src/http.js";
+
+describe("typespec-python: structured streaming", () => {
+  it("treats model and union payloads as structured", () => {
+    strictEqual(isStructuredStreamType({ kind: "model" } as any), true);
+    strictEqual(isStructuredStreamType({ kind: "union" } as any), true);
+  });
+
+  it("unwraps nullable payloads", () => {
+    strictEqual(isStructuredStreamType({ kind: "nullable", type: { kind: "model" } } as any), true);
+    strictEqual(
+      isStructuredStreamType({ kind: "nullable", type: { kind: "bytes" } } as any),
+      false,
+    );
+  });
+
+  it("treats bare byte/string payloads as unstructured", () => {
+    strictEqual(isStructuredStreamType({ kind: "bytes" } as any), false);
+    strictEqual(isStructuredStreamType({ kind: "string" } as any), false);
+  });
+
+  it("detects the stream protocol explicitly", () => {
+    strictEqual(getStructuredStreamKind({ sseMetadata: { events: [] } } as any), "sse");
+    strictEqual(
+      getStructuredStreamKind({
+        streamMetadata: { contentTypes: ["text/event-stream; charset=utf-8"] },
+      } as any),
+      "sse",
+    );
+    strictEqual(
+      getStructuredStreamKind({
+        streamMetadata: { contentTypes: ["application/jsonl"] },
+      } as any),
+      "jsonl",
+    );
+    strictEqual(
+      getStructuredStreamKind({
+        streamMetadata: { contentTypes: ["application/json"] },
+      } as any),
+      undefined,
+    );
+  });
+
+  describe("terminal-event partitioning", () => {
+    const identity = (payloadType: any) => payloadType;
+    const model = (name: string) => ({ kind: "model", name });
+    const constant = (value: string) => ({ kind: "constant", value });
+
+    it("keeps a nameless string-constant `[DONE]` as a drop-and-stop sentinel", () => {
+      const created = model("ResponseCreated");
+      const done = constant("[DONE]");
+      const { events, terminalEvent } = partitionSSEEvents(
+        [
+          {
+            eventType: "response.created",
+            isTerminalEvent: false,
+            type: created,
+            payloadType: created,
+          },
+          { eventType: undefined, isTerminalEvent: true, type: done, payloadType: done },
+        ] as any,
+        identity,
+      );
+      // The sentinel is NOT a dispatch event; it only sets `terminalEvent`.
+      strictEqual(terminalEvent, "[DONE]");
+      strictEqual(events.length, 1);
+      strictEqual(events[0].eventType, "response.created");
+      strictEqual(events[0].isTerminal, undefined);
+    });
+
+    it("keeps named / model `@terminalEvent`s in the dispatch table as yield-and-stop events", () => {
+      const created = model("ResponseCreated");
+      const completed = model("ResponseCompleted");
+      const errored = model("StreamError");
+      const { events, terminalEvent } = partitionSSEEvents(
+        [
+          {
+            eventType: "response.created",
+            isTerminalEvent: false,
+            type: created,
+            payloadType: created,
+          },
+          {
+            eventType: "response.completed",
+            isTerminalEvent: true,
+            type: completed,
+            payloadType: completed,
+          },
+          { eventType: "error", isTerminalEvent: true, type: errored, payloadType: errored },
+        ] as any,
+        identity,
+      );
+      // No bare sentinel: the two terminals carry payloads, so they stay in `events`.
+      strictEqual(terminalEvent, undefined);
+      strictEqual(events.length, 3);
+      strictEqual(events[0].isTerminal, undefined);
+      strictEqual(events[1].eventType, "response.completed");
+      strictEqual(events[1].isTerminal, true);
+      strictEqual(events[1].payloadType, completed);
+      strictEqual(events[2].eventType, "error");
+      strictEqual(events[2].isTerminal, true);
+      strictEqual(events[2].payloadType, errored);
+    });
+
+    it("supports a sentinel and named terminals together", () => {
+      const delta = model("ResponseDelta");
+      const completed = model("ResponseCompleted");
+      const done = constant("[DONE]");
+      const { events, terminalEvent } = partitionSSEEvents(
+        [
+          { eventType: "response.delta", isTerminalEvent: false, type: delta, payloadType: delta },
+          {
+            eventType: "response.completed",
+            isTerminalEvent: true,
+            type: completed,
+            payloadType: completed,
+          },
+          { eventType: undefined, isTerminalEvent: true, type: done, payloadType: done },
+        ] as any,
+        identity,
+      );
+      strictEqual(terminalEvent, "[DONE]");
+      strictEqual(events.length, 2);
+      strictEqual(events[0].isTerminal, undefined);
+      strictEqual(events[1].eventType, "response.completed");
+      strictEqual(events[1].isTerminal, true);
+    });
+
+    it("emits the payload metadata for event envelopes", () => {
+      const envelope = model("Envelope");
+      const payload = { kind: "string" };
+      const { events } = partitionSSEEvents(
+        [
+          {
+            eventType: "withEnvelope",
+            isTerminalEvent: false,
+            type: envelope,
+            payloadType: payload,
+            isEventEnvelope: true,
+            payloadContentType: "text/plain",
+          },
+        ] as any,
+        identity,
+      );
+      strictEqual(events[0].payloadType, payload);
+      strictEqual(events[0].payloadContentType, "text/plain");
+    });
+  });
+});

package/emitter/test/types.test.ts

@@ -0,0 +1,72 @@
+import type { SdkBuiltInType } from "@azure-tools/typespec-client-generator-core";
+import { deepStrictEqual } from "assert";
+import { describe, it } from "vitest";
+import type { PythonSdkContext } from "../src/lib.js";
+import { getType } from "../src/types.js";
+
+function createBuiltInType(
+  kind: SdkBuiltInType["kind"],
+  encode?: string,
+  wireType?: SdkBuiltInType,
+): SdkBuiltInType {
+  return {
+    kind,
+    name: kind,
+    crossLanguageDefinitionId: `TypeSpec.${kind}`,
+    decorators: [],
+    encode,
+    wireType,
+  };
+}
+
+function emitBuiltInType(type: SdkBuiltInType): Record<string, any> {
+  const context = {
+    __simpleTypesMap: new Map(),
+  } as PythonSdkContext;
+  return getType(context, type);
+}
+
+describe("typespec-python: built-in types", () => {
+  it("preserves boolean encoded as string", () => {
+    deepStrictEqual(
+      emitBuiltInType(createBuiltInType("boolean", "string", createBuiltInType("string"))),
+      {
+        type: "boolean",
+        encode: "string",
+      },
+    );
+  });
+
+  it.each(["safeint", "uint32", "uint8"] as const)(
+    "preserves %s encoded as string as an integer",
+    (kind) => {
+      deepStrictEqual(
+        emitBuiltInType(createBuiltInType(kind, "string", createBuiltInType("string"))),
+        {
+          type: "integer",
+          encode: "string",
+        },
+      );
+    },
+  );
+
+  it.each(["base64", "base64url"] as const)("preserves bytes encoded as %s", (encode) => {
+    deepStrictEqual(
+      emitBuiltInType(createBuiltInType("bytes", encode, createBuiltInType("string"))),
+      {
+        type: "bytes",
+        encode,
+      },
+    );
+  });
+
+  it("falls back to the wire type for a custom encoding", () => {
+    deepStrictEqual(
+      emitBuiltInType(createBuiltInType("string", "abc", createBuiltInType("int32"))),
+      {
+        type: "integer",
+        encode: "abc",
+      },
+    );
+  });
+});

package/emitter/test/{external-process.test.ts → yaml-utils.test.ts}

@@ -1,9 +1,9 @@
 import { ok, strictEqual } from "assert";
 import { load } from "js-yaml";
 import { describe, it } from "vitest";
-import { dumpCodeModelToYaml } from "../src/external-process.js";
+import { dumpCodeModelToYaml } from "../src/yaml-utils.js";
 
-describe("typespec-python: external-process", () => {
+describe("typespec-python: yaml-utils", () => {
   // The Python generator parses the emitted YAML with PyYAML (YAML 1.1), where a plain
   // scalar such as `2020_01_01` is interpreted as the integer `20200101`. js-yaml dumps
   // using YAML 1.2 rules and would otherwise leave such string scalars unquoted, so we

package/eng/scripts/ci/dev_requirements.txt

@@ -7,6 +7,6 @@ colorama==0.4.6
 debugpy==1.8.2
 pytest==9.0.3
 coverage==7.6.1
-black==24.4.0
+black==26.3.1
 ptvsd==4.3.2
 types-PyYAML==6.0.12.8

package/eng/scripts/ci/regenerate-common.ts

@@ -320,7 +320,7 @@ export const EMITTER_OPTIONS: Record<string, Record<string, string> | Record<str
     {
       "package-name": "typetest-model-usage-typeddictonly",
       namespace: "typetest.model.usage.typeddictonly",
-      "models-mode": "typeddict",
+      "models-mode": "none",
     },
   ],
   "type/model/visibility": [

package/eng/scripts/ci/regenerate.ts

@@ -20,13 +20,12 @@ import pc from "picocolors";
 import { fileURLToPath } from "url";
 import { parseArgs } from "util";
 
+import type { RegenerateContext, RegenerateFlags } from "./regenerate-common.js";
 import {
   buildTaskGroups,
   cleanGeneratedCode,
   getSubdirectories,
   preprocess,
-  RegenerateContext,
-  RegenerateFlags,
   runParallel,
 } from "./regenerate-common.js";
 

package/eng/scripts/ci/run-tests.ts

@@ -1,5 +1,6 @@
 /* eslint-disable no-console */
-import { ChildProcess, spawn } from "child_process";
+import type { ChildProcess } from "child_process";
+import { spawn } from "child_process";
 import fs from "fs";
 import { cpus } from "os";
 import { dirname, join } from "path";

package/eng/scripts/ci/run_pylint.py

@@ -52,6 +52,7 @@ def _single_dir_pylint(mod):
     # narrow as possible: only this package, only the offending check.
     per_package_disables = {
         "azure-client-generator-core-exact-name": ["client-incorrect-naming-convention"],
+        "azure-resource-manager-operation-templates": ["too-many-statements"],
     }
     extra_disables = per_package_disables.get(mod.name)
     if extra_disables:

package/eng/scripts/setup/system-requirements.ts

@@ -1,4 +1,5 @@
-import { ChildProcess, spawn, SpawnOptions } from "child_process";
+import type { ChildProcess, SpawnOptions } from "child_process";
+import { spawn } from "child_process";
 
 /*
  * Copied from @autorest/system-requirements

package/generator/build/lib/pygen/__init__.py

@@ -12,7 +12,7 @@ from abc import ABC, abstractmethod
 from typing import Any, Iterator, Optional, Union
 
 import yaml
-from .utils import TYPESPEC_PACKAGE_MODE, VALID_PACKAGE_MODE
+from .utils import TYPESPEC_PACKAGE_MODE, VALID_PACKAGE_MODE, is_typeddict_only
 
 from ._version import VERSION
 
@@ -36,6 +36,7 @@ class OptionsDict(MutableMapping):
         "low-level-client": False,
         "no-async": False,
         "no-namespace-folders": False,
+        "generate-typeddict": True,
         "polymorphic-examples": 5,
         "validate-versioning": True,
         "version-tolerant": True,
@@ -45,10 +46,20 @@ class OptionsDict(MutableMapping):
 
     def __init__(self, options: Optional[dict[str, Any]] = None) -> None:
         self._data = options.copy() if options else {}
+        # 'models-mode: typeddict' is deprecated. Represent it internally as 'none' models-mode with
+        # TypedDict generation enabled, so the rest of the codebase reasons in terms of models-mode
+        # plus the generate-typeddict flag.
+        if self._data.get("models-mode") == "typeddict":
+            self._data["generate-typeddict"] = True
         for key in list(self._data):
             self._data[key] = self._validate_and_transform(key, self._data[key])
         self._validate_combinations()
 
+    @property
+    def generate_typeddict_only(self) -> bool:
+        """Whether this is TypedDict-only generation ('models-mode: none' + TypedDicts)."""
+        return is_typeddict_only(self)
+
     def __getitem__(self, key: str) -> Any:  # pylint: disable=too-many-return-statements
         if key == "head-as-boolean" and self.get("azure-arm"):
             # override to always true if azure-arm is set
@@ -167,14 +178,22 @@ class OptionsDict(MutableMapping):
         if key == "builders-visibility" and value not in ["public", "hidden", "embedded"]:
             raise ValueError("The value of --builders-visibility must be either 'public', 'hidden', or 'embedded'")
 
+        if key == "models-mode" and value == "typeddict":
+            # Deprecated: keep accepting it for back-compat but store it as 'none' (falsy) with
+            # TypedDict generation enabled (see OptionsDict.__init__ and generate_typeddict_only).
+            _LOGGER.warning(
+                "'models-mode: typeddict' is deprecated. Use 'models-mode: none' with "
+                "'generate-typeddict: true' (the default) instead."
+            )
+            value = False
+
         if key == "models-mode" and value == "none":
             value = False  # switch to falsy value for easier code writing
 
-        if key == "models-mode" and value not in ["msrest", "dpg", "typeddict", False]:
+        if key == "models-mode" and value not in ["msrest", "dpg", False]:
             raise ValueError(
-                "--models-mode can only be 'msrest', 'dpg', 'typeddict', or 'none'. "
-                "Pass in 'msrest' if you want msrest models, 'typeddict' for TypedDict models, or "
-                "'none' if you don't want any."
+                "--models-mode can only be 'dpg' or 'none'. "
+                "Pass in 'dpg' for DPG models, or 'none' if you don't want any."
             )
         if key == "package-mode":
             if (

package/generator/build/lib/pygen/codegen/models/__init__.py

@@ -169,7 +169,9 @@ def build_type(yaml_data: dict[str, Any], code_model: CodeModel) -> BaseType:
         # need to special case model to avoid recursion
         if yaml_data["base"] == "typeddict":
             model_type = TypedDictModelType  # type: ignore
-        elif yaml_data["base"] == "json" or not code_model.options["models-mode"]:
+        elif yaml_data["base"] == "json" or (
+            not code_model.options["models-mode"] and not code_model.generate_typeddict_only
+        ):
             model_type = JSONModelType
         elif yaml_data["base"] == "dpg":
             model_type = DPGModelType  # type: ignore

package/generator/build/lib/pygen/codegen/models/code_model.py

@@ -17,6 +17,7 @@ from .operation_group import OperationGroup
 from .utils import NamespaceType
 from .._utils import DEFAULT_HEADER_TEXT, DEFAULT_LICENSE_DESCRIPTION
 from ... import OptionsDict
+from ...utils import is_typeddict_only
 
 
 def _is_legacy(options) -> bool:
@@ -89,7 +90,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         self.clients: list[Client] = [
             Client.from_yaml(client_yaml_data, self) for client_yaml_data in yaml_data["clients"]
         ]
-        if self.options["models-mode"] and self.model_types:
+        if (self.options["models-mode"] or self.generate_typeddict_only) and self.model_types:
             self.sort_model_types()
         self.named_unions: list[CombinedType] = [
             t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
@@ -174,6 +175,11 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def get_unique_types_alias(self, serialize_namespace: str, imported_namespace: str) -> str:
         return self._get_unique_import_alias(serialize_namespace, imported_namespace, "types")
 
+    @property
+    def generate_typeddict_only(self) -> bool:
+        """Whether this is TypedDict-only generation ('models-mode: none' + TypedDicts)."""
+        return is_typeddict_only(self.options)
+
     @property
     def client_namespace_types(self) -> dict[str, ClientNamespaceType]:
         if not self._client_namespace_types:
@@ -273,12 +279,22 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             self.need_utils_utils(async_mode, client_namespace)
             or self.need_utils_serialization
             or self.options["models-mode"] == "dpg"
+            or self.has_structured_stream
         )
 
     @property
     def need_utils_serialization(self) -> bool:
         return not self.options["client-side-validation"]
 
+    @property
+    def has_structured_stream(self) -> bool:
+        return any(
+            op.has_structured_stream_response
+            for client in self.clients
+            for og in client.operation_groups
+            for op in og.operations
+        )
+
     def need_utils_utils(self, async_mode: bool, client_namespace: str) -> bool:
         return (
             self.need_utils_form_data(async_mode, client_namespace)
@@ -389,22 +405,26 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def _sort_model_types_helper(
         self,
         current: ModelType,
-        seen_schema_names: set[str],
+        seen_schema_keys: set[tuple[str, str]],
         seen_schema_yaml_ids: set[int],
     ):
         if current.id in seen_schema_yaml_ids:
             return []
-        if current.name in seen_schema_names:
-            raise ValueError(f"We have already generated a schema with name {current.name}")
+        current_schema_key = (current.client_namespace, current.name)
+        if current_schema_key in seen_schema_keys:
+            raise ValueError(
+                f"We have already generated a schema with name {current.name} "
+                f"in namespace {current.client_namespace}"
+            )
         ancestors = [current]
         if current.parents:
             for parent in current.parents:
                 if parent.id in seen_schema_yaml_ids:
                     continue
-                seen_schema_names.add(current.name)
+                seen_schema_keys.add(current_schema_key)
                 seen_schema_yaml_ids.add(current.id)
-                ancestors = self._sort_model_types_helper(parent, seen_schema_names, seen_schema_yaml_ids) + ancestors
-        seen_schema_names.add(current.name)
+                ancestors = self._sort_model_types_helper(parent, seen_schema_keys, seen_schema_yaml_ids) + ancestors
+        seen_schema_keys.add(current_schema_key)
         seen_schema_yaml_ids.add(current.id)
         return ancestors
 
@@ -414,11 +434,11 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         :return: None
         :rtype: None
         """
-        seen_schema_names: set[str] = set()
+        seen_schema_keys: set[tuple[str, str]] = set()
         seen_schema_yaml_ids: set[int] = set()
         sorted_object_schemas: list[ModelType] = []
         for schema in sorted(self.model_types, key=lambda x: x.name.lower()):
-            sorted_object_schemas.extend(self._sort_model_types_helper(schema, seen_schema_names, seen_schema_yaml_ids))
+            sorted_object_schemas.extend(self._sort_model_types_helper(schema, seen_schema_keys, seen_schema_yaml_ids))
         self.model_types = sorted_object_schemas
 
     @property

package/generator/build/lib/pygen/codegen/models/enum_type.py

@@ -40,7 +40,7 @@ class EnumValue(BaseType):
 
     def type_annotation(self, **kwargs: Any) -> str:
         """The python type used for type annotation"""
-        if self.code_model.options["models-mode"] == "typeddict":
+        if self.code_model.generate_typeddict_only:
             # A single constant enum value must be
             # annotated with its literal value directly (e.g. ``Literal["red"]``).
             return f"Literal[{self.value_type.get_declaration(self.value)}]"
@@ -83,7 +83,7 @@ class EnumValue(BaseType):
         file_import = FileImport(self.code_model)
         file_import.merge(self.value_type.imports(**kwargs))
         file_import.add_submodule_import("typing", "Literal", ImportType.STDLIB, TypingSection.REGULAR)
-        if self.code_model.options["models-mode"] == "typeddict":
+        if self.code_model.generate_typeddict_only:
             # In typeddict mode the enums module (``_enums.py``) is never generated
             return file_import
         serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
@@ -176,7 +176,7 @@ class EnumType(BaseType):
 
     @property
     def is_typeddict_mode(self) -> bool:
-        return self.code_model.options["models-mode"] == "typeddict"
+        return self.code_model.generate_typeddict_only
 
     def type_annotation(self, **kwargs: Any) -> str:
         """The python type used for type annotation
@@ -184,7 +184,7 @@ class EnumType(BaseType):
         :return: The type annotation for this schema
         :rtype: str
         """
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             if self.is_typeddict_mode:
                 # In typeddict mode, enums are Literal aliases defined in types.py
                 serialize_namespace_type = kwargs.get("serialize_namespace_type")
@@ -203,6 +203,10 @@ class EnumType(BaseType):
                 model_alias = self.code_model.get_unique_models_alias(serialize_namespace, self.client_namespace)
                 module_name = f"{model_alias}."
             file_name = f"{self.code_model.enums_filename}." if self.internal else ""
+            if serialize_namespace_type == NamespaceType.TYPES_FILE:
+                # In types.py the enum symbol is imported directly (bare name), so no ``_enums.``
+                # module prefix even for internal enums — the prefix would be an undefined name.
+                file_name = ""
             model_name = module_name + file_name + self.name
             # we don't need quoted annotation in operation files, and need it in model folder files.
             if not kwargs.get("is_operation_file", False):
@@ -221,13 +225,13 @@ class EnumType(BaseType):
         return self.value_type.get_declaration(value)
 
     def docstring_text(self, **kwargs: Any) -> str:
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             return self.name
         return self.value_type.type_annotation(**kwargs)
 
     def docstring_type(self, **kwargs: Any) -> str:
         """The python type used for RST syntax input and type annotation."""
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             type_annotation = self.value_type.type_annotation(**kwargs)
             enum_type_annotation = f"{self.client_namespace}.models.{self.name}"
             return f"{type_annotation} or ~{enum_type_annotation}"
@@ -261,7 +265,7 @@ class EnumType(BaseType):
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.merge(self.value_type.imports(**kwargs))
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             if self.is_typeddict_mode:
                 # In typeddict mode, enums are Literal aliases in types.py — no Union needed
                 serialize_namespace_type = kwargs.get("serialize_namespace_type")
@@ -305,9 +309,17 @@ class EnumType(BaseType):
                         typing_section=TypingSection.REGULAR,
                     )
                 elif serialize_namespace_type == NamespaceType.TYPES_FILE:
-                    # Import enum name directly to avoid dotted forward refs in TypedDict annotations
+                    # Import the enum symbol directly to avoid dotted forward refs in TypedDict
+                    # annotations. Internal enums are not re-exported from the public ``models``
+                    # package, so import them from the private ``_enums`` submodule instead — the
+                    # bare-symbol import (rather than the ``_enums`` module) also avoids name
+                    # collisions when internal enums come from several sibling namespaces.
+                    module_name = f"models.{self.code_model.enums_filename}" if self.internal else "models"
+                    enums_module = self.code_model.get_relative_import_path(
+                        serialize_namespace, self.client_namespace, module_name=module_name
+                    )
                     file_import.add_submodule_import(
-                        f"{relative_path}models" if relative_path != "." else ".models",
+                        enums_module,
                         self.name,
                         ImportType.LOCAL,
                         typing_section=TypingSection.TYPING,

package/generator/build/lib/pygen/codegen/models/list_type.py

@@ -38,6 +38,7 @@ class ListType(BaseType):
             self.code_model.options["version-tolerant"]
             and self.element_type.is_xml
             and not self.code_model.options["models-mode"]
+            and not self.code_model.generate_typeddict_only
         ):
             # this means we're version tolerant XML, we just return the XML element
             return self.element_type.type_annotation(**kwargs)

package/generator/build/lib/pygen/codegen/models/model_type.py

@@ -77,9 +77,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes, too-
         self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
         self.usage: int = self.yaml_data.get("usage", UsageFlags.Input.value | UsageFlags.Output.value)
         self.client_namespace: str = self.yaml_data.get("clientNamespace", code_model.namespace)
-        self.is_typed_dict_only: bool = (
-            self.yaml_data.get("typedDictOnly", False) or code_model.options["models-mode"] == "typeddict"
-        )
+        self.is_typed_dict_only: bool = self.yaml_data.get("typedDictOnly", False) or code_model.generate_typeddict_only
 
     @property
     def is_usage_output(self) -> bool:

package/generator/build/lib/pygen/codegen/models/operation.py

@@ -104,6 +104,11 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             else self.has_stream_response
         )
 
+    @property
+    def has_structured_stream_response(self) -> bool:
+        """Whether any success response is a structured (JSONL / SSE) stream returning Stream[T]."""
+        return any(getattr(r, "is_structured_stream", False) for r in self.responses)
+
     @property
     def has_form_data_body(self):
         return self.parameters.has_form_data_body
@@ -334,7 +339,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             file_import.merge(
                 response.imports(async_mode=async_mode, need_import_iobase=self.need_import_iobase, **kwargs)
             )
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             for exception in self.exceptions:
                 file_import.merge(exception.imports(async_mode=async_mode, **kwargs))
 
@@ -506,7 +511,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
 
     @property
     def has_stream_response(self) -> bool:
-        return any(r.is_stream_response for r in self.responses)
+        return any(r.is_stream_response or r.is_structured_stream for r in self.responses)
 
     @classmethod
     def get_request_builder(cls, yaml_data: dict[str, Any], client: "Client"):
@@ -552,7 +557,12 @@ class Operation(OperationBase[Response]):
                 "distributed_trace_async",
                 ImportType.SDKCORE,
             )
-        if self.has_response_body and not self.has_optional_return_type and not self.code_model.options["models-mode"]:
+        if (
+            self.has_response_body
+            and not self.has_optional_return_type
+            and not self.code_model.options["models-mode"]
+            and not self.code_model.generate_typeddict_only
+        ):
             file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
 
         return file_import