feat: limit response parsing to values the SDK does not recognize

#651 conflated two things. Handling values the SDK does not recognize -- new
event types, action types, error codes, enum values -- was already on main
before it, and is what forward compatibility needs. What #651 added on top was
tolerance for payloads that are malformed rather than merely new: a list sent as
a scalar, an object sent as a string, a payload that is not an object.

That is not forward compatibility, it is a defect being swallowed. A null list
was already read as empty, so the new guards only caught genuinely broken data
and turned it into an empty list or None. Worse, catching exceptions around a
known variant meant one bad field silently downgraded a typed event to an
untyped DeepAttrDict, with nothing to tell the caller why the type changed.

Removes seam/parse.py, the isinstance guards in every from_dict, and the
exception handling around known variants. The unrecognized-discriminator
fallback that predates #651 is untouched, so unknown event types still yield a
DeepAttrDict, unknown error codes still fall back per item, and unknown enum
values still read as themselves.

SeamActionAttemptUnknownStatusError stays. The action attempt contract is
strict: waiting promises a succeeded attempt or a raise, and returning an
unrecognized status as a success reports something the SDK cannot vouch for.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01M2kJ4nGaM8imZCVMEKjmXA

Author: claude

codegen/layouts/partials/resource-dataclass.hbs

@@ -31,10 +31,8 @@
 {{#unless properties}}
 {{memberIndent}}    # pylint: disable=unused-argument
 {{/unless}}
-{{memberIndent}}    if not isinstance(d, dict):
-{{memberIndent}}        d = {}
 {{memberIndent}}    return cls(
 {{#each properties}}
-{{../memberIndent}}        {{pythonIdentifier name}}={{#if isRequiredObject}}_required_object_from_dict(cls.{{nestedClassName}}, d.get("{{name}}")){{else}}{{#if isObject}}_object_from_dict(cls.{{nestedClassName}}, d.get("{{name}}")){{else}}{{#if isDiscriminatedObjectList}}_discriminated_list_from_dict(d.get("{{name}}"), cls._{{nestedClassName}}Variants, "{{discriminator}}"){{else}}{{#if isObjectList}}_object_list_from_dict(cls.{{nestedClassName}}, d.get("{{name}}")){{else}}{{#if isDictParam}}_record_from_dict({{/if}}d.get("{{name}}", None){{#if isDictParam}}){{/if}}{{/if}}{{/if}}{{/if}}{{/if}},
+{{../memberIndent}}        {{pythonIdentifier name}}={{#if isRequiredObject}}cls.{{nestedClassName}}.from_dict(d.get("{{name}}") or {}){{else}}{{#if isObject}}cls.{{nestedClassName}}.from_dict(d.get("{{name}}")) if d.get("{{name}}") is not None else None{{else}}{{#if isDiscriminatedObjectList}}[_from_discriminated_dict(i, cls._{{nestedClassName}}Variants, "{{discriminator}}") for i in d.get("{{name}}") or []]{{else}}{{#if isObjectList}}[cls.{{nestedClassName}}.from_dict(i) for i in d.get("{{name}}") or []]{{else}}{{#if isDictParam}}DeepAttrDict({{/if}}d.get("{{name}}", None){{#if isDictParam}}){{/if}}{{/if}}{{/if}}{{/if}}{{/if}},
 {{/each}}
 {{memberIndent}}    )

codegen/layouts/resource.hbs

@@ -1,15 +1,17 @@
 from typing import Any, Dict, List, Literal, Optional, {{#if union.secondaryDiscriminator}}Tuple, {{/if}}Union{{#if union}}, cast{{/if}}
 from dataclasses import dataclass
 from ..deep_attr_dict import DeepAttrDict
-from ..parse import (
-    discriminated_list_from_dict as _discriminated_list_from_dict,
-    object_from_dict as _object_from_dict,
-    object_list_from_dict as _object_list_from_dict,
-    record_from_dict as _record_from_dict,
-    required_object_from_dict as _required_object_from_dict,
-)
 from ..resource_mapping import ResourceMapping
 
+{{#if hasDiscriminatedLists}}
+
+def _from_discriminated_dict(
+    d: Any, variants: Dict[str, Any], discriminator: str
+) -> Any:
+    variant = variants.get(d.get(discriminator))
+    return DeepAttrDict(d) if variant is None else variant.from_dict(d)
+{{/if}}
+
 {{#each classes}}
 {{> resource-dataclass}}
 
@@ -34,27 +36,11 @@ from ..resource_mapping import ResourceMapping
 def {{union.fromDictName}}(d: Any) -> {{union.className}}:
     """Deserialize a known {{union.discriminator}}{{#if union.secondaryDiscriminator}} and {{union.secondaryDiscriminator}}{{/if}} variant.
 
-    An unrecognized discriminator, or a known one whose payload does not
-    convert, returns ``DeepAttrDict`` so payloads from a newer API remain
-    readable. The static return type covers known variants.
+    Unknown discriminator values return ``DeepAttrDict`` so payloads from a
+    newer API remain readable. The static return type covers known variants.
     """
-    if not isinstance(d, dict):
-        return cast({{union.className}}, DeepAttrDict(d) if isinstance(d, dict) else d)
-{{#if union.secondaryDiscriminator}}
-    key = (d.get("{{union.discriminator}}"), d.get("{{union.secondaryDiscriminator}}"))
-    variant = (
-        {{union.variantsName}}.get(cast(Tuple[str, str], key))
-        if isinstance(key[0], str) and isinstance(key[1], str)
-        else None
-    )
-{{else}}
-    key = d.get("{{union.discriminator}}")
-    variant = {{union.variantsName}}.get(key) if isinstance(key, str) else None
-{{/if}}
+    variant = {{union.variantsName}}.get({{#if union.secondaryDiscriminator}}(d.get("{{union.discriminator}}"), d.get("{{union.secondaryDiscriminator}}")){{else}}d.get("{{union.discriminator}}"){{/if}})
     if variant is None:
         return cast({{union.className}}, DeepAttrDict(d))
-    try:
-        return variant.from_dict(d)
-    except Exception:  # pylint: disable=broad-exception-caught
-        return cast({{union.className}}, DeepAttrDict(d))
+    return variant.from_dict(d)
 {{/if}}