ommlds 0.0.0.dev496__py3-none-any.whl → 0.0.0.dev498__py3-none-any.whl

ommlds/minichain/_dataclasses.py

@@ -1156,6 +1156,7 @@ def _process_dataclass__b4a9277b8c9559fb4e325a8c35bc504f30ab2294():
         ('ommlds.minichain.chat.tools.execution', 'ToolFn.Output'),
         ('ommlds.minichain.chat.tools.execution', 'ToolFn.RawKwargsInput'),
         ('ommlds.minichain.chat.tools.execution', 'ToolFn.RawStringOutput'),
+        ('ommlds.minichain.metadata', 'MetadataContainerDataclass'),
     ),
 )
 def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
@@ -2302,38 +2303,26 @@ def _process_dataclass__35363258df752d37be526c05a33a4e10963d6e84():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('_metadata', 'ns')), EqPlan(fields=('_metadata', 'ns')), FrozenPlan(fields=('_meta"
-        "data', 'ns'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'ns'), cache=Fals"
-        "e), InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), defau"
-        "lt=OpRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType."
-        "INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='ns'"
-        ", annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=F"
-        "alse, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_par"
-        "ams=('ns',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), vali"
-        "date_fns=()), ReprPlan(fields=(ReprPlan.Field(name='_metadata', kw_only=True, fn=OpRef(name='repr.fns.0.fn')),"
-        " ReprPlan.Field(name='ns', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('key',)), EqPlan(fields=('key',)), HashPlan(action='set_none', fields=None, cache="
+        "None), InitPlan(fields=(InitPlan.Field(name='key', annotation=OpRef(name='init.fields.0.annotation'), default="
+        "None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=No"
+        "ne, check_type=None),), self_param='self', std_params=('key',), kw_only_params=(), frozen=False, slots=False, "
+        "post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=Fals"
+        "e, fn=None),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='0f33bd4feb26aa84d3ce09fc68cea42d08f0a4ff',
+    plan_repr_sha1='7e1881cd893ea68089f1fe26ad810799dd14a0d5',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
-        '__dataclass__init__fields__0__default',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__repr__fns__0__fn',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.anthropic.chat', 'NamespaceContent'),
+        ('ommlds.minichain.backends.impls.anthropic.chat', 'PlaceholderContentMissingError'),
     ),
 )
-def _process_dataclass__0f33bd4feb26aa84d3ce09fc68cea42d08f0a4ff():
+def _process_dataclass__7e1881cd893ea68089f1fe26ad810799dd14a0d5():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
-        __dataclass__init__fields__0__default,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__repr__fns__0__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2352,8 +2341,7 @@ def _process_dataclass__0f33bd4feb26aa84d3ce09fc68cea42d08f0a4ff():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                _metadata=self._metadata,
-                ns=self.ns,
+                key=self.key,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2367,8 +2355,7 @@ def _process_dataclass__0f33bd4feb26aa84d3ce09fc68cea42d08f0a4ff():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self._metadata == other._metadata and
-                self.ns == other.ns
+                self.key == other.key
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2376,60 +2363,13 @@ def _process_dataclass__0f33bd4feb26aa84d3ce09fc68cea42d08f0a4ff():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__eq__', __eq__)
 
-        __dataclass___setattr_frozen_fields = {
-            '_metadata',
-            'ns',
-        }
-
-        def __setattr__(self, name, value):
-            if (
-                type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
-            super(__dataclass__cls, self).__setattr__(name, value)
-
-        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
-        if '__setattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__setattr__', __setattr__)
-
-        __dataclass___delattr_frozen_fields = {
-            '_metadata',
-            'ns',
-        }
-
-        def __delattr__(self, name):
-            if (
-                type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
-            super(__dataclass__cls, self).__delattr__(name)
-
-        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
-        if '__delattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__delattr__', __delattr__)
-
-        def __hash__(self):
-            return hash((
-                self._metadata,
-                self.ns,
-            ))
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
+        setattr(__dataclass__cls, '__hash__', None)
 
         def __init__(
             self,
-            ns: __dataclass__init__fields__1__annotation,
-            *,
-            _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            key: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            _metadata = __dataclass__init__fields__0__coerce(_metadata)
-            __dataclass__object_setattr(self, '_metadata', _metadata)
-            __dataclass__object_setattr(self, 'ns', ns)
+            self.key = key
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2439,9 +2379,7 @@ def _process_dataclass__0f33bd4feb26aa84d3ce09fc68cea42d08f0a4ff():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
-            parts.append(f"ns={self.ns!r}")
+            parts.append(f"key={self.key!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2458,38 +2396,27 @@ def _process_dataclass__0f33bd4feb26aa84d3ce09fc68cea42d08f0a4ff():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('_metadata', 'k')), EqPlan(fields=('_metadata', 'k')), FrozenPlan(fields=('_metada"
-        "ta', 'k'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'k'), cache=False), "
-        "InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=O"
-        "pRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
-        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='k', ann"
-        "otation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False,"
-        " field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=("
-        "'k',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_f"
-        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='_metadata', kw_only=True, fn=OpRef(name='repr.fns.0.fn')), ReprP"
-        "lan.Field(name='k', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('spec',)), EqPlan(fields=('spec',)), FrozenPlan(fields=('spec',), allow_dynamic_du"
+        "nder_attrs=False), HashPlan(action='add', fields=('spec',), cache=False), InitPlan(fields=(InitPlan.Field(name"
+        "='spec', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ove"
+        "rride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self',"
+        " std_params=('spec',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
+        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='spec', kw_only=False, fn=None),), id=False, terse=False, def"
+        "ault_fn=None)))"
     ),
-    plan_repr_sha1='1cc33387d7e697b5a516373c8733717d303ca7dc',
+    plan_repr_sha1='7e3901d21ea09aa23ed5fbe10c0b3872163af79f',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
-        '__dataclass__init__fields__0__default',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__repr__fns__0__fn',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.anthropic.chat', 'PlaceholderContent'),
+        ('ommlds.minichain.backends.impls.anthropic.chat', 'Tool'),
     ),
 )
-def _process_dataclass__1cc33387d7e697b5a516373c8733717d303ca7dc():
+def _process_dataclass__7e3901d21ea09aa23ed5fbe10c0b3872163af79f():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
-        __dataclass__init__fields__0__default,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__repr__fns__0__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2508,8 +2435,7 @@ def _process_dataclass__1cc33387d7e697b5a516373c8733717d303ca7dc():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                _metadata=self._metadata,
-                k=self.k,
+                spec=self.spec,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2523,8 +2449,7 @@ def _process_dataclass__1cc33387d7e697b5a516373c8733717d303ca7dc():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self._metadata == other._metadata and
-                self.k == other.k
+                self.spec == other.spec
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2533,8 +2458,7 @@ def _process_dataclass__1cc33387d7e697b5a516373c8733717d303ca7dc():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            '_metadata',
-            'k',
+            'spec',
         }
 
         def __setattr__(self, name, value):
@@ -2551,8 +2475,7 @@ def _process_dataclass__1cc33387d7e697b5a516373c8733717d303ca7dc():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            '_metadata',
-            'k',
+            'spec',
         }
 
         def __delattr__(self, name):
@@ -2570,8 +2493,7 @@ def _process_dataclass__1cc33387d7e697b5a516373c8733717d303ca7dc():
 
         def __hash__(self):
             return hash((
-                self._metadata,
-                self.k,
+                self.spec,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -2579,13 +2501,9 @@ def _process_dataclass__1cc33387d7e697b5a516373c8733717d303ca7dc():
 
         def __init__(
             self,
-            k: __dataclass__init__fields__1__annotation,
-            *,
-            _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            spec: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            _metadata = __dataclass__init__fields__0__coerce(_metadata)
-            __dataclass__object_setattr(self, '_metadata', _metadata)
-            __dataclass__object_setattr(self, 'k', k)
+            __dataclass__object_setattr(self, 'spec', spec)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2595,9 +2513,7 @@ def _process_dataclass__1cc33387d7e697b5a516373c8733717d303ca7dc():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
-            parts.append(f"k={self.k!r}")
+            parts.append(f"spec={self.spec!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2614,22 +2530,23 @@ def _process_dataclass__1cc33387d7e697b5a516373c8733717d303ca7dc():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('key',)), EqPlan(fields=('key',)), HashPlan(action='set_none', fields=None, cache="
-        "None), InitPlan(fields=(InitPlan.Field(name='key', annotation=OpRef(name='init.fields.0.annotation'), default="
-        "None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=No"
-        "ne, check_type=None),), self_param='self', std_params=('key',), kw_only_params=(), frozen=False, slots=False, "
-        "post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=Fals"
-        "e, fn=None),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('deltas',)), EqPlan(fields=('deltas',)), FrozenPlan(fields=('deltas',), allow_dyna"
+        "mic_dunder_attrs=False), HashPlan(action='add', fields=('deltas',), cache=False), InitPlan(fields=(InitPlan.Fi"
+        "eld(name='deltas', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init"
+        "=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_par"
+        "am='self', std_params=('deltas',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fn"
+        "s=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='deltas', kw_only=False, fn=None),), id=False, te"
+        "rse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='7e1881cd893ea68089f1fe26ad810799dd14a0d5',
+    plan_repr_sha1='1003b02dad553d007500114656708fbdf6d2db2e',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.anthropic.chat', 'PlaceholderContentMissingError'),
+        ('ommlds.minichain.backends.impls.anthropic.stream', 'AiChoiceDeltas'),
     ),
 )
-def _process_dataclass__7e1881cd893ea68089f1fe26ad810799dd14a0d5():
+def _process_dataclass__1003b02dad553d007500114656708fbdf6d2db2e():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -2652,7 +2569,7 @@ def _process_dataclass__7e1881cd893ea68089f1fe26ad810799dd14a0d5():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                key=self.key,
+                deltas=self.deltas,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2666,7 +2583,7 @@ def _process_dataclass__7e1881cd893ea68089f1fe26ad810799dd14a0d5():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.key == other.key
+                self.deltas == other.deltas
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2674,13 +2591,53 @@ def _process_dataclass__7e1881cd893ea68089f1fe26ad810799dd14a0d5():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__eq__', __eq__)
 
-        setattr(__dataclass__cls, '__hash__', None)
+        __dataclass___setattr_frozen_fields = {
+            'deltas',
+        }
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___setattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
+            super(__dataclass__cls, self).__setattr__(name, value)
+
+        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
+        if '__setattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__setattr__', __setattr__)
+
+        __dataclass___delattr_frozen_fields = {
+            'deltas',
+        }
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___delattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
+            super(__dataclass__cls, self).__delattr__(name)
+
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
+        def __hash__(self):
+            return hash((
+                self.deltas,
+            ))
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
-            key: __dataclass__init__fields__0__annotation,
+            deltas: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            self.key = key
+            __dataclass__object_setattr(self, 'deltas', deltas)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2690,7 +2647,7 @@ def _process_dataclass__7e1881cd893ea68089f1fe26ad810799dd14a0d5():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"key={self.key!r}")
+            parts.append(f"deltas={self.deltas!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2707,23 +2664,23 @@ def _process_dataclass__7e1881cd893ea68089f1fe26ad810799dd14a0d5():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('spec',)), EqPlan(fields=('spec',)), FrozenPlan(fields=('spec',), allow_dynamic_du"
-        "nder_attrs=False), HashPlan(action='add', fields=('spec',), cache=False), InitPlan(fields=(InitPlan.Field(name"
-        "='spec', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ove"
-        "rride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self',"
-        " std_params=('spec',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
-        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='spec', kw_only=False, fn=None),), id=False, terse=False, def"
-        "ault_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('choices',)), EqPlan(fields=('choices',)), FrozenPlan(fields=('choices',), allow_d"
+        "ynamic_dunder_attrs=False), HashPlan(action='add', fields=('choices',), cache=False), InitPlan(fields=(InitPla"
+        "n.Field(name='choices', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None,"
+        " init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), sel"
+        "f_param='self', std_params=('choices',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, i"
+        "nit_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='choices', kw_only=False, fn=None),), id=Fa"
+        "lse, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='7e3901d21ea09aa23ed5fbe10c0b3872163af79f',
+    plan_repr_sha1='4f63c0632d5deeaaca3a2cac8b16c190d46387cd',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.anthropic.chat', 'Tool'),
+        ('ommlds.minichain.backends.impls.anthropic.stream', 'AiChoicesDeltas'),
     ),
 )
-def _process_dataclass__7e3901d21ea09aa23ed5fbe10c0b3872163af79f():
+def _process_dataclass__4f63c0632d5deeaaca3a2cac8b16c190d46387cd():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -2746,7 +2703,7 @@ def _process_dataclass__7e3901d21ea09aa23ed5fbe10c0b3872163af79f():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                spec=self.spec,
+                choices=self.choices,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2760,7 +2717,7 @@ def _process_dataclass__7e3901d21ea09aa23ed5fbe10c0b3872163af79f():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.spec == other.spec
+                self.choices == other.choices
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2769,7 +2726,7 @@ def _process_dataclass__7e3901d21ea09aa23ed5fbe10c0b3872163af79f():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'spec',
+            'choices',
         }
 
         def __setattr__(self, name, value):
@@ -2786,7 +2743,7 @@ def _process_dataclass__7e3901d21ea09aa23ed5fbe10c0b3872163af79f():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'spec',
+            'choices',
         }
 
         def __delattr__(self, name):
@@ -2804,7 +2761,7 @@ def _process_dataclass__7e3901d21ea09aa23ed5fbe10c0b3872163af79f():
 
         def __hash__(self):
             return hash((
-                self.spec,
+                self.choices,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -2812,9 +2769,9 @@ def _process_dataclass__7e3901d21ea09aa23ed5fbe10c0b3872163af79f():
 
         def __init__(
             self,
-            spec: __dataclass__init__fields__0__annotation,
+            choices: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'spec', spec)
+            __dataclass__object_setattr(self, 'choices', choices)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2824,275 +2781,7 @@ def _process_dataclass__7e3901d21ea09aa23ed5fbe10c0b3872163af79f():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"spec={self.spec!r}")
-            return (
-                f"{self.__class__.__qualname__}("
-                f"{', '.join(parts)}"
-                f")"
-            )
-
-        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
-        if '__repr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__repr__', __repr__)
-
-    return _process_dataclass
-
-
-@_register(
-    plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('deltas',)), EqPlan(fields=('deltas',)), FrozenPlan(fields=('deltas',), allow_dyna"
-        "mic_dunder_attrs=False), HashPlan(action='add', fields=('deltas',), cache=False), InitPlan(fields=(InitPlan.Fi"
-        "eld(name='deltas', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init"
-        "=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_par"
-        "am='self', std_params=('deltas',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fn"
-        "s=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='deltas', kw_only=False, fn=None),), id=False, te"
-        "rse=False, default_fn=None)))"
-    ),
-    plan_repr_sha1='1003b02dad553d007500114656708fbdf6d2db2e',
-    op_ref_idents=(
-        '__dataclass__init__fields__0__annotation',
-    ),
-    cls_names=(
-        ('ommlds.minichain.backends.impls.anthropic.stream', 'AiChoiceDeltas'),
-    ),
-)
-def _process_dataclass__1003b02dad553d007500114656708fbdf6d2db2e():
-    def _process_dataclass(
-        *,
-        __dataclass__cls,
-        __dataclass__init__fields__0__annotation,
-        __dataclass__FieldFnValidationError,  # noqa
-        __dataclass__FieldTypeValidationError,  # noqa
-        __dataclass__FnValidationError,  # noqa
-        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
-        __dataclass__FunctionType=types.FunctionType,  # noqa
-        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
-        __dataclass__MISSING=dataclasses.MISSING,  # noqa
-        __dataclass__None=None,  # noqa
-        __dataclass__TypeError=TypeError,  # noqa
-        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
-        __dataclass__isinstance=isinstance,  # noqa
-        __dataclass__object_setattr=object.__setattr__,  # noqa
-        __dataclass__property=property,  # noqa
-    ):
-        def __copy__(self):
-            if self.__class__ is not __dataclass__cls:
-                raise TypeError(self)
-            return __dataclass__cls(  # noqa
-                deltas=self.deltas,
-            )
-
-        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
-        if '__copy__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__copy__', __copy__)
-
-        def __eq__(self, other):
-            if self is other:
-                return True
-            if self.__class__ is not other.__class__:
-                return NotImplemented
-            return (
-                self.deltas == other.deltas
-            )
-
-        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
-        if '__eq__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__eq__', __eq__)
-
-        __dataclass___setattr_frozen_fields = {
-            'deltas',
-        }
-
-        def __setattr__(self, name, value):
-            if (
-                type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
-            super(__dataclass__cls, self).__setattr__(name, value)
-
-        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
-        if '__setattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__setattr__', __setattr__)
-
-        __dataclass___delattr_frozen_fields = {
-            'deltas',
-        }
-
-        def __delattr__(self, name):
-            if (
-                type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
-            super(__dataclass__cls, self).__delattr__(name)
-
-        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
-        if '__delattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__delattr__', __delattr__)
-
-        def __hash__(self):
-            return hash((
-                self.deltas,
-            ))
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
-        def __init__(
-            self,
-            deltas: __dataclass__init__fields__0__annotation,
-        ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'deltas', deltas)
-
-        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
-        if '__init__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__init__', __init__)
-
-        @__dataclass___recursive_repr()
-        def __repr__(self):
-            parts = []
-            parts.append(f"deltas={self.deltas!r}")
-            return (
-                f"{self.__class__.__qualname__}("
-                f"{', '.join(parts)}"
-                f")"
-            )
-
-        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
-        if '__repr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__repr__', __repr__)
-
-    return _process_dataclass
-
-
-@_register(
-    plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('choices',)), EqPlan(fields=('choices',)), FrozenPlan(fields=('choices',), allow_d"
-        "ynamic_dunder_attrs=False), HashPlan(action='add', fields=('choices',), cache=False), InitPlan(fields=(InitPla"
-        "n.Field(name='choices', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None,"
-        " init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), sel"
-        "f_param='self', std_params=('choices',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, i"
-        "nit_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='choices', kw_only=False, fn=None),), id=Fa"
-        "lse, terse=False, default_fn=None)))"
-    ),
-    plan_repr_sha1='4f63c0632d5deeaaca3a2cac8b16c190d46387cd',
-    op_ref_idents=(
-        '__dataclass__init__fields__0__annotation',
-    ),
-    cls_names=(
-        ('ommlds.minichain.backends.impls.anthropic.stream', 'AiChoicesDeltas'),
-    ),
-)
-def _process_dataclass__4f63c0632d5deeaaca3a2cac8b16c190d46387cd():
-    def _process_dataclass(
-        *,
-        __dataclass__cls,
-        __dataclass__init__fields__0__annotation,
-        __dataclass__FieldFnValidationError,  # noqa
-        __dataclass__FieldTypeValidationError,  # noqa
-        __dataclass__FnValidationError,  # noqa
-        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
-        __dataclass__FunctionType=types.FunctionType,  # noqa
-        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
-        __dataclass__MISSING=dataclasses.MISSING,  # noqa
-        __dataclass__None=None,  # noqa
-        __dataclass__TypeError=TypeError,  # noqa
-        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
-        __dataclass__isinstance=isinstance,  # noqa
-        __dataclass__object_setattr=object.__setattr__,  # noqa
-        __dataclass__property=property,  # noqa
-    ):
-        def __copy__(self):
-            if self.__class__ is not __dataclass__cls:
-                raise TypeError(self)
-            return __dataclass__cls(  # noqa
-                choices=self.choices,
-            )
-
-        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
-        if '__copy__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__copy__', __copy__)
-
-        def __eq__(self, other):
-            if self is other:
-                return True
-            if self.__class__ is not other.__class__:
-                return NotImplemented
-            return (
-                self.choices == other.choices
-            )
-
-        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
-        if '__eq__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__eq__', __eq__)
-
-        __dataclass___setattr_frozen_fields = {
-            'choices',
-        }
-
-        def __setattr__(self, name, value):
-            if (
-                type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
-            super(__dataclass__cls, self).__setattr__(name, value)
-
-        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
-        if '__setattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__setattr__', __setattr__)
-
-        __dataclass___delattr_frozen_fields = {
-            'choices',
-        }
-
-        def __delattr__(self, name):
-            if (
-                type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
-            super(__dataclass__cls, self).__delattr__(name)
-
-        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
-        if '__delattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__delattr__', __delattr__)
-
-        def __hash__(self):
-            return hash((
-                self.choices,
-            ))
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
-        def __init__(
-            self,
-            choices: __dataclass__init__fields__0__annotation,
-        ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'choices', choices)
-
-        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
-        if '__init__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__init__', __init__)
-
-        @__dataclass___recursive_repr()
-        def __repr__(self):
-            parts = []
-            parts.append(f"choices={self.choices!r}")
+            parts.append(f"choices={self.choices!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -3274,6 +2963,8 @@ def _process_dataclass__8a0c9fe2c4d9f2351ede8bd96b873d4507e2617b():
     ),
     cls_names=(
         ('ommlds.minichain.backends.impls.anthropic.stream', 'ContentAiDelta'),
+        ('ommlds.minichain.backends.impls.mistral', 'ContentOriginal'),
+        ('ommlds.minichain.backends.impls.mistral', 'MessageOriginal'),
     ),
 )
 def _process_dataclass__236614658d6f97131f18c84f79eabfe1f3abcc04():
@@ -4406,16 +4097,605 @@ def _process_dataclass__9a7ab73f68edd197196f8d58344e8bb2b4962d7f():
         '__dataclass__repr__fns__0__fn',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.huggingface.configs', 'HuggingfaceHubToken'),
-        ('ommlds.minichain.standard', 'ApiKey'),
+        ('ommlds.minichain.backends.impls.huggingface.configs', 'HuggingfaceHubToken'),
+        ('ommlds.minichain.standard', 'ApiKey'),
+    ),
+)
+def _process_dataclass__663f7924a951e0a39befa6d9c0c541bbf2575506():
+    def _process_dataclass(
+        *,
+        __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__repr__fns__0__fn,
+        __dataclass__FieldFnValidationError,  # noqa
+        __dataclass__FieldTypeValidationError,  # noqa
+        __dataclass__FnValidationError,  # noqa
+        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
+        __dataclass__FunctionType=types.FunctionType,  # noqa
+        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
+        __dataclass__MISSING=dataclasses.MISSING,  # noqa
+        __dataclass__None=None,  # noqa
+        __dataclass__TypeError=TypeError,  # noqa
+        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
+        __dataclass__isinstance=isinstance,  # noqa
+        __dataclass__object_setattr=object.__setattr__,  # noqa
+        __dataclass__property=property,  # noqa
+    ):
+        def __copy__(self):
+            if self.__class__ is not __dataclass__cls:
+                raise TypeError(self)
+            return __dataclass__cls(  # noqa
+                v=self.v,
+            )
+
+        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
+        if '__copy__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__copy__', __copy__)
+
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.v == other.v
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
+        __dataclass___setattr_frozen_fields = {
+            'v',
+        }
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___setattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
+            super(__dataclass__cls, self).__setattr__(name, value)
+
+        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
+        if '__setattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__setattr__', __setattr__)
+
+        __dataclass___delattr_frozen_fields = {
+            'v',
+        }
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___delattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
+            super(__dataclass__cls, self).__delattr__(name)
+
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
+        def __hash__(self):
+            return hash((
+                self.v,
+            ))
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
+        def __init__(
+            self,
+            v: __dataclass__init__fields__0__annotation,
+        ) -> __dataclass__None:
+            __dataclass__object_setattr(self, 'v', v)
+
+        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
+        if '__init__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__init__', __init__)
+
+        @__dataclass___recursive_repr()
+        def __repr__(self):
+            parts = []
+            if (s := __dataclass__repr__fns__0__fn(self.v)) is not None:
+                parts.append(f"{s}")
+            return (
+                f"{self.__class__.__qualname__}("
+                f"{', '.join(parts)}"
+                f")"
+            )
+
+        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
+        if '__repr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__repr__', __repr__)
+
+    return _process_dataclass
+
+
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=('ms',)), EqPlan(fields=('ms',)), FrozenPlan(fields=('ms',), allow_dynamic_dunder_a"
+        "ttrs=False), HashPlan(action='add', fields=('ms',), cache=False), InitPlan(fields=(InitPlan.Field(name='ms', a"
+        "nnotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=Fals"
+        "e, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_param"
+        "s=('ms',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), "
+        "ReprPlan(fields=(ReprPlan.Field(name='ms', kw_only=False, fn=None),), id=False, terse=False, default_fn=None))"
+        ")"
+    ),
+    plan_repr_sha1='8c235aee49850ebae268d668bebad09ed68eee50',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+    ),
+    cls_names=(
+        ('ommlds.minichain.backends.impls.mistral', 'AiChoice'),
+    ),
+)
+def _process_dataclass__8c235aee49850ebae268d668bebad09ed68eee50():
+    def _process_dataclass(
+        *,
+        __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__FieldFnValidationError,  # noqa
+        __dataclass__FieldTypeValidationError,  # noqa
+        __dataclass__FnValidationError,  # noqa
+        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
+        __dataclass__FunctionType=types.FunctionType,  # noqa
+        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
+        __dataclass__MISSING=dataclasses.MISSING,  # noqa
+        __dataclass__None=None,  # noqa
+        __dataclass__TypeError=TypeError,  # noqa
+        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
+        __dataclass__isinstance=isinstance,  # noqa
+        __dataclass__object_setattr=object.__setattr__,  # noqa
+        __dataclass__property=property,  # noqa
+    ):
+        def __copy__(self):
+            if self.__class__ is not __dataclass__cls:
+                raise TypeError(self)
+            return __dataclass__cls(  # noqa
+                ms=self.ms,
+            )
+
+        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
+        if '__copy__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__copy__', __copy__)
+
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.ms == other.ms
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
+        __dataclass___setattr_frozen_fields = {
+            'ms',
+        }
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___setattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
+            super(__dataclass__cls, self).__setattr__(name, value)
+
+        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
+        if '__setattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__setattr__', __setattr__)
+
+        __dataclass___delattr_frozen_fields = {
+            'ms',
+        }
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___delattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
+            super(__dataclass__cls, self).__delattr__(name)
+
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
+        def __hash__(self):
+            return hash((
+                self.ms,
+            ))
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
+        def __init__(
+            self,
+            ms: __dataclass__init__fields__0__annotation,
+        ) -> __dataclass__None:
+            __dataclass__object_setattr(self, 'ms', ms)
+
+        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
+        if '__init__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__init__', __init__)
+
+        @__dataclass___recursive_repr()
+        def __repr__(self):
+            parts = []
+            parts.append(f"ms={self.ms!r}")
+            return (
+                f"{self.__class__.__qualname__}("
+                f"{', '.join(parts)}"
+                f")"
+            )
+
+        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
+        if '__repr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__repr__', __repr__)
+
+    return _process_dataclass
+
+
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=('_metadata', 'c')), EqPlan(fields=('_metadata', 'c')), FrozenPlan(fields=('_metada"
+        "ta', 'c'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'c'), cache=False), "
+        "InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=O"
+        "pRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
+        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='c', ann"
+        "otation=OpRef(name='init.fields.1.annotation'), default=OpRef(name='init.fields.1.default'), default_factory=N"
+        "one, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), "
+        "self_param='self', std_params=('c',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_param"
+        "s=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='c', kw_only=False, fn=OpRef(name="
+        "'repr.fns.1.fn')),), id=False, terse=False, default_fn=None)))"
+    ),
+    plan_repr_sha1='72c59dbd029af1f55a739e4e5f92cc62c0cecb75',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__coerce',
+        '__dataclass__init__fields__0__default',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__1__default',
+        '__dataclass__repr__fns__1__fn',
+    ),
+    cls_names=(
+        ('ommlds.minichain.backends.impls.mistral', 'AiMessage'),
+    ),
+)
+def _process_dataclass__72c59dbd029af1f55a739e4e5f92cc62c0cecb75():
+    def _process_dataclass(
+        *,
+        __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__coerce,
+        __dataclass__init__fields__0__default,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__1__default,
+        __dataclass__repr__fns__1__fn,
+        __dataclass__FieldFnValidationError,  # noqa
+        __dataclass__FieldTypeValidationError,  # noqa
+        __dataclass__FnValidationError,  # noqa
+        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
+        __dataclass__FunctionType=types.FunctionType,  # noqa
+        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
+        __dataclass__MISSING=dataclasses.MISSING,  # noqa
+        __dataclass__None=None,  # noqa
+        __dataclass__TypeError=TypeError,  # noqa
+        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
+        __dataclass__isinstance=isinstance,  # noqa
+        __dataclass__object_setattr=object.__setattr__,  # noqa
+        __dataclass__property=property,  # noqa
+    ):
+        def __copy__(self):
+            if self.__class__ is not __dataclass__cls:
+                raise TypeError(self)
+            return __dataclass__cls(  # noqa
+                _metadata=self._metadata,
+                c=self.c,
+            )
+
+        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
+        if '__copy__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__copy__', __copy__)
+
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self._metadata == other._metadata and
+                self.c == other.c
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
+        __dataclass___setattr_frozen_fields = {
+            '_metadata',
+            'c',
+        }
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___setattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
+            super(__dataclass__cls, self).__setattr__(name, value)
+
+        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
+        if '__setattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__setattr__', __setattr__)
+
+        __dataclass___delattr_frozen_fields = {
+            '_metadata',
+            'c',
+        }
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___delattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
+            super(__dataclass__cls, self).__delattr__(name)
+
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
+        def __hash__(self):
+            return hash((
+                self._metadata,
+                self.c,
+            ))
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
+        def __init__(
+            self,
+            c: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
+            *,
+            _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+        ) -> __dataclass__None:
+            _metadata = __dataclass__init__fields__0__coerce(_metadata)
+            __dataclass__object_setattr(self, '_metadata', _metadata)
+            __dataclass__object_setattr(self, 'c', c)
+
+        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
+        if '__init__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__init__', __init__)
+
+        @__dataclass___recursive_repr()
+        def __repr__(self):
+            parts = []
+            if (s := __dataclass__repr__fns__1__fn(self.c)) is not None:
+                parts.append(f"c={s}")
+            return (
+                f"{self.__class__.__qualname__}("
+                f"{', '.join(parts)}"
+                f")"
+            )
+
+        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
+        if '__repr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__repr__', __repr__)
+
+    return _process_dataclass
+
+
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=('_metadata',)), EqPlan(fields=('_metadata',)), FrozenPlan(fields=('_metadata',), a"
+        "llow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata',), cache=False), InitPlan(fields="
+        "(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init."
+        "fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpR"
+        "ef(name='init.fields.0.coerce'), validate=None, check_type=None),), self_param='self', std_params=(), kw_only_"
+        "params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPla"
+        "n(fields=(), id=False, terse=False, default_fn=None)))"
+    ),
+    plan_repr_sha1='9e1d955ccb433717c9538685d2a5ad412ce027f5',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__coerce',
+        '__dataclass__init__fields__0__default',
+    ),
+    cls_names=(
+        ('ommlds.minichain.backends.impls.mistral', 'AnyAiMessage'),
+        ('ommlds.minichain.backends.impls.mistral', 'AnyUserMessage'),
+        ('ommlds.minichain.backends.impls.mistral', 'CompositeContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'DynamicContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'Message'),
+        ('ommlds.minichain.backends.impls.mistral', 'RecursiveContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'StandardContent'),
+    ),
+)
+def _process_dataclass__9e1d955ccb433717c9538685d2a5ad412ce027f5():
+    def _process_dataclass(
+        *,
+        __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__coerce,
+        __dataclass__init__fields__0__default,
+        __dataclass__FieldFnValidationError,  # noqa
+        __dataclass__FieldTypeValidationError,  # noqa
+        __dataclass__FnValidationError,  # noqa
+        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
+        __dataclass__FunctionType=types.FunctionType,  # noqa
+        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
+        __dataclass__MISSING=dataclasses.MISSING,  # noqa
+        __dataclass__None=None,  # noqa
+        __dataclass__TypeError=TypeError,  # noqa
+        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
+        __dataclass__isinstance=isinstance,  # noqa
+        __dataclass__object_setattr=object.__setattr__,  # noqa
+        __dataclass__property=property,  # noqa
+    ):
+        def __copy__(self):
+            if self.__class__ is not __dataclass__cls:
+                raise TypeError(self)
+            return __dataclass__cls(  # noqa
+                _metadata=self._metadata,
+            )
+
+        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
+        if '__copy__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__copy__', __copy__)
+
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self._metadata == other._metadata
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
+        __dataclass___setattr_frozen_fields = {
+            '_metadata',
+        }
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___setattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
+            super(__dataclass__cls, self).__setattr__(name, value)
+
+        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
+        if '__setattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__setattr__', __setattr__)
+
+        __dataclass___delattr_frozen_fields = {
+            '_metadata',
+        }
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___delattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
+            super(__dataclass__cls, self).__delattr__(name)
+
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
+        def __hash__(self):
+            return hash((
+                self._metadata,
+            ))
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
+        def __init__(
+            self,
+            *,
+            _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+        ) -> __dataclass__None:
+            _metadata = __dataclass__init__fields__0__coerce(_metadata)
+            __dataclass__object_setattr(self, '_metadata', _metadata)
+
+        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
+        if '__init__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__init__', __init__)
+
+        @__dataclass___recursive_repr()
+        def __repr__(self):
+            parts = []
+            return (
+                f"{self.__class__.__qualname__}("
+                f"{', '.join(parts)}"
+                f")"
+            )
+
+        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
+        if '__repr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__repr__', __repr__)
+
+    return _process_dataclass
+
+
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=('_metadata', 's', 'lang')), EqPlan(fields=('_metadata', 's', 'lang')), FrozenPlan("
+        "fields=('_metadata', 's', 'lang'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadat"
+        "a', 's', 'lang'), cache=False), InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init."
+        "fields.0.annotation'), default=OpRef(name='init.fields.0.default'), default_factory=None, init=True, override="
+        "False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=Non"
+        "e), InitPlan.Field(name='s', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory="
+        "None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), "
+        "InitPlan.Field(name='lang', annotation=OpRef(name='init.fields.2.annotation'), default=OpRef(name='init.fields"
+        ".2.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, val"
+        "idate=None, check_type=None)), self_param='self', std_params=('s',), kw_only_params=('_metadata', 'lang'), fro"
+        "zen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(n"
+        "ame='s', kw_only=False, fn=None), ReprPlan.Field(name='lang', kw_only=True, fn=None)), id=False, terse=False, "
+        "default_fn=None)))"
+    ),
+    plan_repr_sha1='1084ab06a48ea8a3ee231cb5371a8312352e8665',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__coerce',
+        '__dataclass__init__fields__0__default',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__2__annotation',
+        '__dataclass__init__fields__2__default',
+    ),
+    cls_names=(
+        ('ommlds.minichain.backends.impls.mistral', 'BlockCodeContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'CodeContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'InlineCodeContent'),
     ),
 )
-def _process_dataclass__663f7924a951e0a39befa6d9c0c541bbf2575506():
+def _process_dataclass__1084ab06a48ea8a3ee231cb5371a8312352e8665():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__repr__fns__0__fn,
+        __dataclass__init__fields__0__coerce,
+        __dataclass__init__fields__0__default,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__2__annotation,
+        __dataclass__init__fields__2__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -4434,7 +4714,9 @@ def _process_dataclass__663f7924a951e0a39befa6d9c0c541bbf2575506():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                v=self.v,
+                _metadata=self._metadata,
+                s=self.s,
+                lang=self.lang,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -4448,7 +4730,9 @@ def _process_dataclass__663f7924a951e0a39befa6d9c0c541bbf2575506():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.v == other.v
+                self._metadata == other._metadata and
+                self.s == other.s and
+                self.lang == other.lang
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -4457,7 +4741,9 @@ def _process_dataclass__663f7924a951e0a39befa6d9c0c541bbf2575506():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'v',
+            '_metadata',
+            's',
+            'lang',
         }
 
         def __setattr__(self, name, value):
@@ -4474,7 +4760,9 @@ def _process_dataclass__663f7924a951e0a39befa6d9c0c541bbf2575506():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'v',
+            '_metadata',
+            's',
+            'lang',
         }
 
         def __delattr__(self, name):
@@ -4492,7 +4780,9 @@ def _process_dataclass__663f7924a951e0a39befa6d9c0c541bbf2575506():
 
         def __hash__(self):
             return hash((
-                self.v,
+                self._metadata,
+                self.s,
+                self.lang,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -4500,9 +4790,15 @@ def _process_dataclass__663f7924a951e0a39befa6d9c0c541bbf2575506():
 
         def __init__(
             self,
-            v: __dataclass__init__fields__0__annotation,
+            s: __dataclass__init__fields__1__annotation,
+            *,
+            _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            lang: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'v', v)
+            _metadata = __dataclass__init__fields__0__coerce(_metadata)
+            __dataclass__object_setattr(self, '_metadata', _metadata)
+            __dataclass__object_setattr(self, 's', s)
+            __dataclass__object_setattr(self, 'lang', lang)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -4512,8 +4808,8 @@ def _process_dataclass__663f7924a951e0a39befa6d9c0c541bbf2575506():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self.v)) is not None:
-                parts.append(f"{s}")
+            parts.append(f"s={self.s!r}")
+            parts.append(f"lang={self.lang!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -4530,27 +4826,38 @@ def _process_dataclass__663f7924a951e0a39befa6d9c0c541bbf2575506():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('ms',)), EqPlan(fields=('ms',)), FrozenPlan(fields=('ms',), allow_dynamic_dunder_a"
-        "ttrs=False), HashPlan(action='add', fields=('ms',), cache=False), InitPlan(fields=(InitPlan.Field(name='ms', a"
-        "nnotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=Fals"
-        "e, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_param"
-        "s=('ms',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), "
-        "ReprPlan(fields=(ReprPlan.Field(name='ms', kw_only=False, fn=None),), id=False, terse=False, default_fn=None))"
-        ")"
+        "Plans(tup=(CopyPlan(fields=('_metadata', 'l')), EqPlan(fields=('_metadata', 'l')), FrozenPlan(fields=('_metada"
+        "ta', 'l'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'l'), cache=False), "
+        "InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=O"
+        "pRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
+        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='l', ann"
+        "otation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False,"
+        " field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=("
+        "'l',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_f"
+        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='l', kw_only=False, fn=None),), id=False, terse=False, default_fn"
+        "=None)))"
     ),
-    plan_repr_sha1='8c235aee49850ebae268d668bebad09ed68eee50',
+    plan_repr_sha1='a2e975e22d97a4d134241bb5fd72c882b2f11f5b',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__coerce',
+        '__dataclass__init__fields__0__default',
+        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'AiChoice'),
+        ('ommlds.minichain.backends.impls.mistral', 'BlockContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'InlineContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'SequenceContent'),
     ),
 )
-def _process_dataclass__8c235aee49850ebae268d668bebad09ed68eee50():
+def _process_dataclass__a2e975e22d97a4d134241bb5fd72c882b2f11f5b():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__coerce,
+        __dataclass__init__fields__0__default,
+        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -4569,7 +4876,8 @@ def _process_dataclass__8c235aee49850ebae268d668bebad09ed68eee50():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                ms=self.ms,
+                _metadata=self._metadata,
+                l=self.l,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -4583,7 +4891,8 @@ def _process_dataclass__8c235aee49850ebae268d668bebad09ed68eee50():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.ms == other.ms
+                self._metadata == other._metadata and
+                self.l == other.l
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -4592,7 +4901,8 @@ def _process_dataclass__8c235aee49850ebae268d668bebad09ed68eee50():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'ms',
+            '_metadata',
+            'l',
         }
 
         def __setattr__(self, name, value):
@@ -4609,7 +4919,8 @@ def _process_dataclass__8c235aee49850ebae268d668bebad09ed68eee50():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'ms',
+            '_metadata',
+            'l',
         }
 
         def __delattr__(self, name):
@@ -4627,7 +4938,8 @@ def _process_dataclass__8c235aee49850ebae268d668bebad09ed68eee50():
 
         def __hash__(self):
             return hash((
-                self.ms,
+                self._metadata,
+                self.l,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -4635,9 +4947,13 @@ def _process_dataclass__8c235aee49850ebae268d668bebad09ed68eee50():
 
         def __init__(
             self,
-            ms: __dataclass__init__fields__0__annotation,
+            l: __dataclass__init__fields__1__annotation,
+            *,
+            _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'ms', ms)
+            _metadata = __dataclass__init__fields__0__coerce(_metadata)
+            __dataclass__object_setattr(self, '_metadata', _metadata)
+            __dataclass__object_setattr(self, 'l', l)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -4647,7 +4963,7 @@ def _process_dataclass__8c235aee49850ebae268d668bebad09ed68eee50():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"ms={self.ms!r}")
+            parts.append(f"l={self.l!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -4664,31 +4980,34 @@ def _process_dataclass__8c235aee49850ebae268d668bebad09ed68eee50():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('_metadata', 'c')), EqPlan(fields=('_metadata', 'c')), FrozenPlan(fields=('_metada"
-        "ta', 'c'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'c'), cache=False), "
+        "Plans(tup=(CopyPlan(fields=('_metadata', 's')), EqPlan(fields=('_metadata', 's')), FrozenPlan(fields=('_metada"
+        "ta', 's'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 's'), cache=False), "
         "InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=O"
         "pRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
-        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='c', ann"
-        "otation=OpRef(name='init.fields.1.annotation'), default=OpRef(name='init.fields.1.default'), default_factory=N"
-        "one, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), "
-        "self_param='self', std_params=('c',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_param"
-        "s=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='c', kw_only=False, fn=OpRef(name="
-        "'repr.fns.1.fn')),), id=False, terse=False, default_fn=None)))"
+        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='s', ann"
+        "otation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False,"
+        " field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=("
+        "'s',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_f"
+        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='s', kw_only=False, fn=None),), id=False, terse=False, default_fn"
+        "=None)))"
     ),
-    plan_repr_sha1='72c59dbd029af1f55a739e4e5f92cc62c0cecb75',
+    plan_repr_sha1='e28bbe95a5e6fa9335be8f6fa393bd08862be998',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__0__default',
         '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__1__default',
-        '__dataclass__repr__fns__1__fn',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'AiMessage'),
+        ('ommlds.minichain.backends.impls.mistral', 'BoldContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'BoldItalicContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'EmphasisContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'ItalicContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'MarkdownContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'TextContent'),
     ),
 )
-def _process_dataclass__72c59dbd029af1f55a739e4e5f92cc62c0cecb75():
+def _process_dataclass__e28bbe95a5e6fa9335be8f6fa393bd08862be998():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -4696,8 +5015,6 @@ def _process_dataclass__72c59dbd029af1f55a739e4e5f92cc62c0cecb75():
         __dataclass__init__fields__0__coerce,
         __dataclass__init__fields__0__default,
         __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__1__default,
-        __dataclass__repr__fns__1__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -4717,7 +5034,7 @@ def _process_dataclass__72c59dbd029af1f55a739e4e5f92cc62c0cecb75():
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
                 _metadata=self._metadata,
-                c=self.c,
+                s=self.s,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -4732,7 +5049,7 @@ def _process_dataclass__72c59dbd029af1f55a739e4e5f92cc62c0cecb75():
                 return NotImplemented
             return (
                 self._metadata == other._metadata and
-                self.c == other.c
+                self.s == other.s
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -4742,7 +5059,7 @@ def _process_dataclass__72c59dbd029af1f55a739e4e5f92cc62c0cecb75():
 
         __dataclass___setattr_frozen_fields = {
             '_metadata',
-            'c',
+            's',
         }
 
         def __setattr__(self, name, value):
@@ -4760,7 +5077,7 @@ def _process_dataclass__72c59dbd029af1f55a739e4e5f92cc62c0cecb75():
 
         __dataclass___delattr_frozen_fields = {
             '_metadata',
-            'c',
+            's',
         }
 
         def __delattr__(self, name):
@@ -4779,7 +5096,7 @@ def _process_dataclass__72c59dbd029af1f55a739e4e5f92cc62c0cecb75():
         def __hash__(self):
             return hash((
                 self._metadata,
-                self.c,
+                self.s,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -4787,13 +5104,13 @@ def _process_dataclass__72c59dbd029af1f55a739e4e5f92cc62c0cecb75():
 
         def __init__(
             self,
-            c: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
+            s: __dataclass__init__fields__1__annotation,
             *,
             _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
         ) -> __dataclass__None:
             _metadata = __dataclass__init__fields__0__coerce(_metadata)
             __dataclass__object_setattr(self, '_metadata', _metadata)
-            __dataclass__object_setattr(self, 'c', c)
+            __dataclass__object_setattr(self, 's', s)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -4803,8 +5120,7 @@ def _process_dataclass__72c59dbd029af1f55a739e4e5f92cc62c0cecb75():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__1__fn(self.c)) is not None:
-                parts.append(f"c={s}")
+            parts.append(f"s={self.s!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -4821,33 +5137,32 @@ def _process_dataclass__72c59dbd029af1f55a739e4e5f92cc62c0cecb75():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('_metadata',)), EqPlan(fields=('_metadata',)), FrozenPlan(fields=('_metadata',), a"
-        "llow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata',), cache=False), InitPlan(fields="
-        "(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init."
-        "fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpR"
-        "ef(name='init.fields.0.coerce'), validate=None, check_type=None),), self_param='self', std_params=(), kw_only_"
-        "params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPla"
-        "n(fields=(), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('type', 'values')), EqPlan(fields=('type', 'values')), FrozenPlan(fields=('type', "
+        "'values'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('type', 'values'), cache=False), "
+        "InitPlan(fields=(InitPlan.Field(name='type', annotation=OpRef(name='init.fields.0.annotation'), default=None, "
+        "default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, ch"
+        "eck_type=None), InitPlan.Field(name='values', annotation=OpRef(name='init.fields.1.annotation'), default=None,"
+        " default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, c"
+        "heck_type=None)), self_param='self', std_params=('type', 'values'), kw_only_params=(), frozen=True, slots=Fals"
+        "e, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='type', kw_only="
+        "False, fn=None), ReprPlan.Field(name='values', kw_only=False, fn=None)), id=False, terse=True, default_fn=None"
+        ")))"
     ),
-    plan_repr_sha1='9e1d955ccb433717c9538685d2a5ad412ce027f5',
+    plan_repr_sha1='922e75739507bda9dce73a0d3dc05534b1cc9ae5',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
-        '__dataclass__init__fields__0__default',
+        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'AnyAiMessage'),
-        ('ommlds.minichain.backends.impls.mistral', 'AnyUserMessage'),
-        ('ommlds.minichain.backends.impls.mistral', 'Message'),
+        ('ommlds.minichain.backends.impls.mistral', 'EnumToolDtype'),
     ),
 )
-def _process_dataclass__9e1d955ccb433717c9538685d2a5ad412ce027f5():
+def _process_dataclass__922e75739507bda9dce73a0d3dc05534b1cc9ae5():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
-        __dataclass__init__fields__0__default,
+        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -4866,7 +5181,8 @@ def _process_dataclass__9e1d955ccb433717c9538685d2a5ad412ce027f5():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                _metadata=self._metadata,
+                type=self.type,
+                values=self.values,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -4880,7 +5196,8 @@ def _process_dataclass__9e1d955ccb433717c9538685d2a5ad412ce027f5():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self._metadata == other._metadata
+                self.type == other.type and
+                self.values == other.values
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -4889,7 +5206,8 @@ def _process_dataclass__9e1d955ccb433717c9538685d2a5ad412ce027f5():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            '_metadata',
+            'type',
+            'values',
         }
 
         def __setattr__(self, name, value):
@@ -4906,7 +5224,8 @@ def _process_dataclass__9e1d955ccb433717c9538685d2a5ad412ce027f5():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            '_metadata',
+            'type',
+            'values',
         }
 
         def __delattr__(self, name):
@@ -4924,7 +5243,8 @@ def _process_dataclass__9e1d955ccb433717c9538685d2a5ad412ce027f5():
 
         def __hash__(self):
             return hash((
-                self._metadata,
+                self.type,
+                self.values,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -4932,11 +5252,11 @@ def _process_dataclass__9e1d955ccb433717c9538685d2a5ad412ce027f5():
 
         def __init__(
             self,
-            *,
-            _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            type: __dataclass__init__fields__0__annotation,
+            values: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            _metadata = __dataclass__init__fields__0__coerce(_metadata)
-            __dataclass__object_setattr(self, '_metadata', _metadata)
+            __dataclass__object_setattr(self, 'type', type)
+            __dataclass__object_setattr(self, 'values', values)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -4946,6 +5266,8 @@ def _process_dataclass__9e1d955ccb433717c9538685d2a5ad412ce027f5():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
+            parts.append(f"{self.type!r}")
+            parts.append(f"{self.values!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -4962,33 +5284,29 @@ def _process_dataclass__9e1d955ccb433717c9538685d2a5ad412ce027f5():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('_metadata', 'l')), EqPlan(fields=('_metadata', 'l')), FrozenPlan(fields=('_metada"
-        "ta', 'l'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'l'), cache=False), "
+        "Plans(tup=(CopyPlan(fields=('_metadata', 'i')), EqPlan(fields=('_metadata', 'i')), FrozenPlan(fields=('_metada"
+        "ta', 'i'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'i'), cache=False), "
         "InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=O"
         "pRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
-        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='l', ann"
+        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='i', ann"
         "otation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False,"
         " field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=("
-        "'l',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_f"
-        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='_metadata', kw_only=True, fn=OpRef(name='repr.fns.0.fn')), ReprP"
-        "lan.Field(name='l', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "'i',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_f"
+        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='i', kw_only=False, fn=None),), id=False, terse=False, default_fn"
+        "=None)))"
     ),
-    plan_repr_sha1='281796d144299e91ab063fdfbfabe3f0e8e89f9d',
+    plan_repr_sha1='887228244e97e7d09085da1386353f1085809224',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__0__default',
         '__dataclass__init__fields__1__annotation',
-        '__dataclass__repr__fns__0__fn',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'BlockContent'),
-        ('ommlds.minichain.backends.impls.mistral', 'InlineContent'),
-        ('ommlds.minichain.backends.impls.mistral', 'ItemListContent'),
-        ('ommlds.minichain.backends.impls.mistral', 'SequenceContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'ImageContent'),
     ),
 )
-def _process_dataclass__281796d144299e91ab063fdfbfabe3f0e8e89f9d():
+def _process_dataclass__887228244e97e7d09085da1386353f1085809224():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -4996,7 +5314,6 @@ def _process_dataclass__281796d144299e91ab063fdfbfabe3f0e8e89f9d():
         __dataclass__init__fields__0__coerce,
         __dataclass__init__fields__0__default,
         __dataclass__init__fields__1__annotation,
-        __dataclass__repr__fns__0__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -5016,7 +5333,7 @@ def _process_dataclass__281796d144299e91ab063fdfbfabe3f0e8e89f9d():
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
                 _metadata=self._metadata,
-                l=self.l,
+                i=self.i,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -5031,7 +5348,7 @@ def _process_dataclass__281796d144299e91ab063fdfbfabe3f0e8e89f9d():
                 return NotImplemented
             return (
                 self._metadata == other._metadata and
-                self.l == other.l
+                self.i == other.i
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -5041,7 +5358,7 @@ def _process_dataclass__281796d144299e91ab063fdfbfabe3f0e8e89f9d():
 
         __dataclass___setattr_frozen_fields = {
             '_metadata',
-            'l',
+            'i',
         }
 
         def __setattr__(self, name, value):
@@ -5059,7 +5376,7 @@ def _process_dataclass__281796d144299e91ab063fdfbfabe3f0e8e89f9d():
 
         __dataclass___delattr_frozen_fields = {
             '_metadata',
-            'l',
+            'i',
         }
 
         def __delattr__(self, name):
@@ -5078,7 +5395,7 @@ def _process_dataclass__281796d144299e91ab063fdfbfabe3f0e8e89f9d():
         def __hash__(self):
             return hash((
                 self._metadata,
-                self.l,
+                self.i,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -5086,13 +5403,13 @@ def _process_dataclass__281796d144299e91ab063fdfbfabe3f0e8e89f9d():
 
         def __init__(
             self,
-            l: __dataclass__init__fields__1__annotation,
+            i: __dataclass__init__fields__1__annotation,
             *,
             _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
         ) -> __dataclass__None:
             _metadata = __dataclass__init__fields__0__coerce(_metadata)
             __dataclass__object_setattr(self, '_metadata', _metadata)
-            __dataclass__object_setattr(self, 'l', l)
+            __dataclass__object_setattr(self, 'i', i)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -5102,9 +5419,7 @@ def _process_dataclass__281796d144299e91ab063fdfbfabe3f0e8e89f9d():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
-            parts.append(f"l={self.l!r}")
+            parts.append(f"i={self.i!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -5121,21 +5436,21 @@ def _process_dataclass__281796d144299e91ab063fdfbfabe3f0e8e89f9d():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('_metadata', 's', 'lang')), EqPlan(fields=('_metadata', 's', 'lang')), FrozenPlan("
-        "fields=('_metadata', 's', 'lang'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadat"
-        "a', 's', 'lang'), cache=False), InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init."
-        "fields.0.annotation'), default=OpRef(name='init.fields.0.default'), default_factory=None, init=True, override="
-        "False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=Non"
-        "e), InitPlan.Field(name='s', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory="
-        "None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), "
-        "InitPlan.Field(name='lang', annotation=OpRef(name='init.fields.2.annotation'), default=OpRef(name='init.fields"
-        ".2.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, val"
-        "idate=None, check_type=None)), self_param='self', std_params=('s',), kw_only_params=('_metadata', 'lang'), fro"
-        "zen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(n"
-        "ame='_metadata', kw_only=True, fn=OpRef(name='repr.fns.0.fn')), ReprPlan.Field(name='s', kw_only=False, fn=Non"
-        "e), ReprPlan.Field(name='lang', kw_only=True, fn=None)), id=False, terse=False, default_fn=None)))"
-    ),
-    plan_repr_sha1='9193db962fdc440396655ef40965237c763fe790',
+        "Plans(tup=(CopyPlan(fields=('_metadata', 'l', 'style')), EqPlan(fields=('_metadata', 'l', 'style')), FrozenPla"
+        "n(fields=('_metadata', 'l', 'style'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_meta"
+        "data', 'l', 'style'), cache=False), InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='i"
+        "nit.fields.0.annotation'), default=OpRef(name='init.fields.0.default'), default_factory=None, init=True, overr"
+        "ide=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type"
+        "=None), InitPlan.Field(name='l', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_fact"
+        "ory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=Non"
+        "e), InitPlan.Field(name='style', annotation=OpRef(name='init.fields.2.annotation'), default=OpRef(name='init.f"
+        "ields.2.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None"
+        ", validate=None, check_type=None)), self_param='self', std_params=('l',), kw_only_params=('_metadata', 'style'"
+        "), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.F"
+        "ield(name='l', kw_only=False, fn=None), ReprPlan.Field(name='style', kw_only=True, fn=None)), id=False, terse="
+        "False, default_fn=None)))"
+    ),
+    plan_repr_sha1='5df7f02aa96ac5e3dd094d829580f887801535df',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__coerce',
@@ -5143,13 +5458,12 @@ def _process_dataclass__281796d144299e91ab063fdfbfabe3f0e8e89f9d():
         '__dataclass__init__fields__1__annotation',
         '__dataclass__init__fields__2__annotation',
         '__dataclass__init__fields__2__default',
-        '__dataclass__repr__fns__0__fn',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'CodeContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'ItemListContent'),
     ),
 )
-def _process_dataclass__9193db962fdc440396655ef40965237c763fe790():
+def _process_dataclass__5df7f02aa96ac5e3dd094d829580f887801535df():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -5159,7 +5473,6 @@ def _process_dataclass__9193db962fdc440396655ef40965237c763fe790():
         __dataclass__init__fields__1__annotation,
         __dataclass__init__fields__2__annotation,
         __dataclass__init__fields__2__default,
-        __dataclass__repr__fns__0__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -5179,8 +5492,8 @@ def _process_dataclass__9193db962fdc440396655ef40965237c763fe790():
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
                 _metadata=self._metadata,
-                s=self.s,
-                lang=self.lang,
+                l=self.l,
+                style=self.style,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -5195,8 +5508,8 @@ def _process_dataclass__9193db962fdc440396655ef40965237c763fe790():
                 return NotImplemented
             return (
                 self._metadata == other._metadata and
-                self.s == other.s and
-                self.lang == other.lang
+                self.l == other.l and
+                self.style == other.style
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -5206,8 +5519,8 @@ def _process_dataclass__9193db962fdc440396655ef40965237c763fe790():
 
         __dataclass___setattr_frozen_fields = {
             '_metadata',
-            's',
-            'lang',
+            'l',
+            'style',
         }
 
         def __setattr__(self, name, value):
@@ -5225,8 +5538,8 @@ def _process_dataclass__9193db962fdc440396655ef40965237c763fe790():
 
         __dataclass___delattr_frozen_fields = {
             '_metadata',
-            's',
-            'lang',
+            'l',
+            'style',
         }
 
         def __delattr__(self, name):
@@ -5244,9 +5557,9 @@ def _process_dataclass__9193db962fdc440396655ef40965237c763fe790():
 
         def __hash__(self):
             return hash((
-                self._metadata,
-                self.s,
-                self.lang,
+                self._metadata,
+                self.l,
+                self.style,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -5254,15 +5567,15 @@ def _process_dataclass__9193db962fdc440396655ef40965237c763fe790():
 
         def __init__(
             self,
-            s: __dataclass__init__fields__1__annotation,
+            l: __dataclass__init__fields__1__annotation,
             *,
             _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
-            lang: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
+            style: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
         ) -> __dataclass__None:
             _metadata = __dataclass__init__fields__0__coerce(_metadata)
             __dataclass__object_setattr(self, '_metadata', _metadata)
-            __dataclass__object_setattr(self, 's', s)
-            __dataclass__object_setattr(self, 'lang', lang)
+            __dataclass__object_setattr(self, 'l', l)
+            __dataclass__object_setattr(self, 'style', style)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -5272,10 +5585,8 @@ def _process_dataclass__9193db962fdc440396655ef40965237c763fe790():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
-            parts.append(f"s={self.s!r}")
-            parts.append(f"lang={self.lang!r}")
+            parts.append(f"l={self.l!r}")
+            parts.append(f"style={self.style!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -5292,35 +5603,36 @@ def _process_dataclass__9193db962fdc440396655ef40965237c763fe790():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('_metadata',)), EqPlan(fields=('_metadata',)), FrozenPlan(fields=('_metadata',), a"
-        "llow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata',), cache=False), InitPlan(fields="
-        "(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init."
-        "fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpR"
-        "ef(name='init.fields.0.coerce'), validate=None, check_type=None),), self_param='self', std_params=(), kw_only_"
-        "params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPla"
-        "n(fields=(ReprPlan.Field(name='_metadata', kw_only=True, fn=OpRef(name='repr.fns.0.fn')),), id=False, terse=Fa"
-        "lse, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('_metadata', 'v')), EqPlan(fields=('_metadata', 'v')), FrozenPlan(fields=('_metada"
+        "ta', 'v'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'v'), cache=False), "
+        "InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=O"
+        "pRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
+        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='v', ann"
+        "otation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False,"
+        " field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=("
+        "'v',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_f"
+        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='v', kw_only=False, fn=None),), id=False, terse=False, default_fn"
+        "=None)))"
     ),
-    plan_repr_sha1='bcf6088fdeff32c671aa2e5e0810822079fcba71',
+    plan_repr_sha1='90ff130b5cc55aa45421dac2fda5e67df528bc46',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__0__default',
-        '__dataclass__repr__fns__0__fn',
+        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'DynamicContent'),
-        ('ommlds.minichain.backends.impls.mistral', 'StandardContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'JsonContent'),
     ),
 )
-def _process_dataclass__bcf6088fdeff32c671aa2e5e0810822079fcba71():
+def _process_dataclass__90ff130b5cc55aa45421dac2fda5e67df528bc46():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
         __dataclass__init__fields__0__coerce,
         __dataclass__init__fields__0__default,
-        __dataclass__repr__fns__0__fn,
+        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -5340,6 +5652,7 @@ def _process_dataclass__bcf6088fdeff32c671aa2e5e0810822079fcba71():
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
                 _metadata=self._metadata,
+                v=self.v,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -5353,7 +5666,8 @@ def _process_dataclass__bcf6088fdeff32c671aa2e5e0810822079fcba71():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self._metadata == other._metadata
+                self._metadata == other._metadata and
+                self.v == other.v
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -5363,6 +5677,7 @@ def _process_dataclass__bcf6088fdeff32c671aa2e5e0810822079fcba71():
 
         __dataclass___setattr_frozen_fields = {
             '_metadata',
+            'v',
         }
 
         def __setattr__(self, name, value):
@@ -5380,6 +5695,7 @@ def _process_dataclass__bcf6088fdeff32c671aa2e5e0810822079fcba71():
 
         __dataclass___delattr_frozen_fields = {
             '_metadata',
+            'v',
         }
 
         def __delattr__(self, name):
@@ -5398,6 +5714,7 @@ def _process_dataclass__bcf6088fdeff32c671aa2e5e0810822079fcba71():
         def __hash__(self):
             return hash((
                 self._metadata,
+                self.v,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -5405,11 +5722,13 @@ def _process_dataclass__bcf6088fdeff32c671aa2e5e0810822079fcba71():
 
         def __init__(
             self,
+            v: __dataclass__init__fields__1__annotation,
             *,
             _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
         ) -> __dataclass__None:
             _metadata = __dataclass__init__fields__0__coerce(_metadata)
             __dataclass__object_setattr(self, '_metadata', _metadata)
+            __dataclass__object_setattr(self, 'v', v)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -5419,8 +5738,7 @@ def _process_dataclass__bcf6088fdeff32c671aa2e5e0810822079fcba71():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
+            parts.append(f"v={self.v!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -5437,32 +5755,43 @@ def _process_dataclass__bcf6088fdeff32c671aa2e5e0810822079fcba71():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('type', 'values')), EqPlan(fields=('type', 'values')), FrozenPlan(fields=('type', "
-        "'values'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('type', 'values'), cache=False), "
-        "InitPlan(fields=(InitPlan.Field(name='type', annotation=OpRef(name='init.fields.0.annotation'), default=None, "
-        "default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, ch"
-        "eck_type=None), InitPlan.Field(name='values', annotation=OpRef(name='init.fields.1.annotation'), default=None,"
-        " default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, c"
-        "heck_type=None)), self_param='self', std_params=('type', 'values'), kw_only_params=(), frozen=True, slots=Fals"
-        "e, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='type', kw_only="
-        "False, fn=None), ReprPlan.Field(name='values', kw_only=False, fn=None)), id=False, terse=True, default_fn=None"
-        ")))"
+        "Plans(tup=(CopyPlan(fields=('_metadata', 'url', 'title')), EqPlan(fields=('_metadata', 'url', 'title')), Froze"
+        "nPlan(fields=('_metadata', 'url', 'title'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=("
+        "'_metadata', 'url', 'title'), cache=False), InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef"
+        "(name='init.fields.0.annotation'), default=OpRef(name='init.fields.0.default'), default_factory=None, init=Tru"
+        "e, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, ch"
+        "eck_type=None), InitPlan.Field(name='url', annotation=OpRef(name='init.fields.1.annotation'), default=None, de"
+        "fault_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, chec"
+        "k_type=None), InitPlan.Field(name='title', annotation=OpRef(name='init.fields.2.annotation'), default=OpRef(na"
+        "me='init.fields.2.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, c"
+        "oerce=None, validate=None, check_type=None)), self_param='self', std_params=('url', 'title'), kw_only_params=("
+        "'_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields"
+        "=(ReprPlan.Field(name='url', kw_only=False, fn=None), ReprPlan.Field(name='title', kw_only=False, fn=None)), i"
+        "d=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='922e75739507bda9dce73a0d3dc05534b1cc9ae5',
+    plan_repr_sha1='dd73f8dc509bd85224b58b6ca188966c37d6566c',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__coerce',
+        '__dataclass__init__fields__0__default',
         '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__2__annotation',
+        '__dataclass__init__fields__2__default',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'EnumToolDtype'),
+        ('ommlds.minichain.backends.impls.mistral', 'LinkContent'),
     ),
 )
-def _process_dataclass__922e75739507bda9dce73a0d3dc05534b1cc9ae5():
+def _process_dataclass__dd73f8dc509bd85224b58b6ca188966c37d6566c():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__coerce,
+        __dataclass__init__fields__0__default,
         __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__2__annotation,
+        __dataclass__init__fields__2__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -5481,8 +5810,9 @@ def _process_dataclass__922e75739507bda9dce73a0d3dc05534b1cc9ae5():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                type=self.type,
-                values=self.values,
+                _metadata=self._metadata,
+                url=self.url,
+                title=self.title,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -5496,8 +5826,9 @@ def _process_dataclass__922e75739507bda9dce73a0d3dc05534b1cc9ae5():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.type == other.type and
-                self.values == other.values
+                self._metadata == other._metadata and
+                self.url == other.url and
+                self.title == other.title
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -5506,8 +5837,9 @@ def _process_dataclass__922e75739507bda9dce73a0d3dc05534b1cc9ae5():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'type',
-            'values',
+            '_metadata',
+            'url',
+            'title',
         }
 
         def __setattr__(self, name, value):
@@ -5524,8 +5856,9 @@ def _process_dataclass__922e75739507bda9dce73a0d3dc05534b1cc9ae5():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'type',
-            'values',
+            '_metadata',
+            'url',
+            'title',
         }
 
         def __delattr__(self, name):
@@ -5543,8 +5876,9 @@ def _process_dataclass__922e75739507bda9dce73a0d3dc05534b1cc9ae5():
 
         def __hash__(self):
             return hash((
-                self.type,
-                self.values,
+                self._metadata,
+                self.url,
+                self.title,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -5552,11 +5886,15 @@ def _process_dataclass__922e75739507bda9dce73a0d3dc05534b1cc9ae5():
 
         def __init__(
             self,
-            type: __dataclass__init__fields__0__annotation,
-            values: __dataclass__init__fields__1__annotation,
+            url: __dataclass__init__fields__1__annotation,
+            title: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
+            *,
+            _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'type', type)
-            __dataclass__object_setattr(self, 'values', values)
+            _metadata = __dataclass__init__fields__0__coerce(_metadata)
+            __dataclass__object_setattr(self, '_metadata', _metadata)
+            __dataclass__object_setattr(self, 'url', url)
+            __dataclass__object_setattr(self, 'title', title)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -5566,8 +5904,8 @@ def _process_dataclass__922e75739507bda9dce73a0d3dc05534b1cc9ae5():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"{self.type!r}")
-            parts.append(f"{self.values!r}")
+            parts.append(f"url={self.url!r}")
+            parts.append(f"title={self.title!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -5584,38 +5922,31 @@ def _process_dataclass__922e75739507bda9dce73a0d3dc05534b1cc9ae5():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('_metadata', 'i')), EqPlan(fields=('_metadata', 'i')), FrozenPlan(fields=('_metada"
-        "ta', 'i'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'i'), cache=False), "
-        "InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=O"
-        "pRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
-        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='i', ann"
-        "otation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False,"
-        " field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=("
-        "'i',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_f"
-        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='_metadata', kw_only=True, fn=OpRef(name='repr.fns.0.fn')), ReprP"
-        "lan.Field(name='i', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('key', 'value')), EqPlan(fields=('key', 'value')), FrozenPlan(fields=('key', 'valu"
+        "e'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('key', 'value'), cache=False), InitPlan"
+        "(fields=(InitPlan.Field(name='key', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_f"
+        "actory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type="
+        "None), InitPlan.Field(name='value', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_f"
+        "actory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type="
+        "None)), self_param='self', std_params=('key', 'value'), kw_only_params=(), frozen=True, slots=False, post_init"
+        "_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=False, fn=Non"
+        "e), ReprPlan.Field(name='value', kw_only=False, fn=None)), id=False, terse=True, default_fn=None)))"
     ),
-    plan_repr_sha1='9e4a59d711dc872608ff0daa695c75db9383f39a',
+    plan_repr_sha1='2ded8afb50edd07329da6b7055981919a83dec56',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
-        '__dataclass__init__fields__0__default',
         '__dataclass__init__fields__1__annotation',
-        '__dataclass__repr__fns__0__fn',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'ImageContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'MappingToolDtype'),
     ),
 )
-def _process_dataclass__9e4a59d711dc872608ff0daa695c75db9383f39a():
+def _process_dataclass__2ded8afb50edd07329da6b7055981919a83dec56():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
-        __dataclass__init__fields__0__default,
         __dataclass__init__fields__1__annotation,
-        __dataclass__repr__fns__0__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -5634,8 +5965,8 @@ def _process_dataclass__9e4a59d711dc872608ff0daa695c75db9383f39a():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                _metadata=self._metadata,
-                i=self.i,
+                key=self.key,
+                value=self.value,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -5649,8 +5980,8 @@ def _process_dataclass__9e4a59d711dc872608ff0daa695c75db9383f39a():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self._metadata == other._metadata and
-                self.i == other.i
+                self.key == other.key and
+                self.value == other.value
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -5659,8 +5990,8 @@ def _process_dataclass__9e4a59d711dc872608ff0daa695c75db9383f39a():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            '_metadata',
-            'i',
+            'key',
+            'value',
         }
 
         def __setattr__(self, name, value):
@@ -5677,8 +6008,8 @@ def _process_dataclass__9e4a59d711dc872608ff0daa695c75db9383f39a():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            '_metadata',
-            'i',
+            'key',
+            'value',
         }
 
         def __delattr__(self, name):
@@ -5696,8 +6027,8 @@ def _process_dataclass__9e4a59d711dc872608ff0daa695c75db9383f39a():
 
         def __hash__(self):
             return hash((
-                self._metadata,
-                self.i,
+                self.key,
+                self.value,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -5705,13 +6036,11 @@ def _process_dataclass__9e4a59d711dc872608ff0daa695c75db9383f39a():
 
         def __init__(
             self,
-            i: __dataclass__init__fields__1__annotation,
-            *,
-            _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            key: __dataclass__init__fields__0__annotation,
+            value: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            _metadata = __dataclass__init__fields__0__coerce(_metadata)
-            __dataclass__object_setattr(self, '_metadata', _metadata)
-            __dataclass__object_setattr(self, 'i', i)
+            __dataclass__object_setattr(self, 'key', key)
+            __dataclass__object_setattr(self, 'value', value)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -5721,9 +6050,8 @@ def _process_dataclass__9e4a59d711dc872608ff0daa695c75db9383f39a():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
-            parts.append(f"i={self.i!r}")
+            parts.append(f"{self.key!r}")
+            parts.append(f"{self.value!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -5740,30 +6068,29 @@ def _process_dataclass__9e4a59d711dc872608ff0daa695c75db9383f39a():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('_metadata', 'v')), EqPlan(fields=('_metadata', 'v')), FrozenPlan(fields=('_metada"
-        "ta', 'v'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'v'), cache=False), "
-        "InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=O"
-        "pRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
-        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='v', ann"
-        "otation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False,"
-        " field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=("
-        "'v',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_f"
-        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='_metadata', kw_only=True, fn=OpRef(name='repr.fns.0.fn')), ReprP"
-        "lan.Field(name='v', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('_metadata', 'ns')), EqPlan(fields=('_metadata', 'ns')), FrozenPlan(fields=('_meta"
+        "data', 'ns'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'ns'), cache=Fals"
+        "e), InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), defau"
+        "lt=OpRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType."
+        "INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='ns'"
+        ", annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=F"
+        "alse, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_par"
+        "ams=('ns',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), vali"
+        "date_fns=()), ReprPlan(fields=(ReprPlan.Field(name='ns', kw_only=False, fn=None),), id=False, terse=False, def"
+        "ault_fn=None)))"
     ),
-    plan_repr_sha1='296d7a1dff0c5084e83cbfd2ddd0e7460f1ea2c0',
+    plan_repr_sha1='362e74460eb8dcd41c81a6fd7a74399eff62060c',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__0__default',
         '__dataclass__init__fields__1__annotation',
-        '__dataclass__repr__fns__0__fn',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'JsonContent'),
+        ('ommlds.minichain.backends.impls.mistral', 'NamespaceContent'),
     ),
 )
-def _process_dataclass__296d7a1dff0c5084e83cbfd2ddd0e7460f1ea2c0():
+def _process_dataclass__362e74460eb8dcd41c81a6fd7a74399eff62060c():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -5771,7 +6098,6 @@ def _process_dataclass__296d7a1dff0c5084e83cbfd2ddd0e7460f1ea2c0():
         __dataclass__init__fields__0__coerce,
         __dataclass__init__fields__0__default,
         __dataclass__init__fields__1__annotation,
-        __dataclass__repr__fns__0__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -5791,7 +6117,7 @@ def _process_dataclass__296d7a1dff0c5084e83cbfd2ddd0e7460f1ea2c0():
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
                 _metadata=self._metadata,
-                v=self.v,
+                ns=self.ns,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -5806,7 +6132,7 @@ def _process_dataclass__296d7a1dff0c5084e83cbfd2ddd0e7460f1ea2c0():
                 return NotImplemented
             return (
                 self._metadata == other._metadata and
-                self.v == other.v
+                self.ns == other.ns
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -5816,7 +6142,7 @@ def _process_dataclass__296d7a1dff0c5084e83cbfd2ddd0e7460f1ea2c0():
 
         __dataclass___setattr_frozen_fields = {
             '_metadata',
-            'v',
+            'ns',
         }
 
         def __setattr__(self, name, value):
@@ -5834,7 +6160,7 @@ def _process_dataclass__296d7a1dff0c5084e83cbfd2ddd0e7460f1ea2c0():
 
         __dataclass___delattr_frozen_fields = {
             '_metadata',
-            'v',
+            'ns',
         }
 
         def __delattr__(self, name):
@@ -5853,7 +6179,7 @@ def _process_dataclass__296d7a1dff0c5084e83cbfd2ddd0e7460f1ea2c0():
         def __hash__(self):
             return hash((
                 self._metadata,
-                self.v,
+                self.ns,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -5861,13 +6187,13 @@ def _process_dataclass__296d7a1dff0c5084e83cbfd2ddd0e7460f1ea2c0():
 
         def __init__(
             self,
-            v: __dataclass__init__fields__1__annotation,
+            ns: __dataclass__init__fields__1__annotation,
             *,
             _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
         ) -> __dataclass__None:
             _metadata = __dataclass__init__fields__0__coerce(_metadata)
             __dataclass__object_setattr(self, '_metadata', _metadata)
-            __dataclass__object_setattr(self, 'v', v)
+            __dataclass__object_setattr(self, 'ns', ns)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -5877,9 +6203,7 @@ def _process_dataclass__296d7a1dff0c5084e83cbfd2ddd0e7460f1ea2c0():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
-            parts.append(f"v={self.v!r}")
+            parts.append(f"ns={self.ns!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -5896,31 +6220,27 @@ def _process_dataclass__296d7a1dff0c5084e83cbfd2ddd0e7460f1ea2c0():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('key', 'value')), EqPlan(fields=('key', 'value')), FrozenPlan(fields=('key', 'valu"
-        "e'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('key', 'value'), cache=False), InitPlan"
-        "(fields=(InitPlan.Field(name='key', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_f"
-        "actory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type="
-        "None), InitPlan.Field(name='value', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_f"
-        "actory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type="
-        "None)), self_param='self', std_params=('key', 'value'), kw_only_params=(), frozen=True, slots=False, post_init"
-        "_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=False, fn=Non"
-        "e), ReprPlan.Field(name='value', kw_only=False, fn=None)), id=False, terse=True, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('type',)), EqPlan(fields=('type',)), FrozenPlan(fields=('type',), allow_dynamic_du"
+        "nder_attrs=False), HashPlan(action='add', fields=('type',), cache=False), InitPlan(fields=(InitPlan.Field(name"
+        "='type', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ove"
+        "rride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self',"
+        " std_params=('type',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
+        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='type', kw_only=False, fn=None),), id=False, terse=True, defa"
+        "ult_fn=None)))"
     ),
-    plan_repr_sha1='2ded8afb50edd07329da6b7055981919a83dec56',
+    plan_repr_sha1='1d0b04d8ebb0bdb077bc9721fb19aafcadf99422',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'MappingToolDtype'),
+        ('ommlds.minichain.backends.impls.mistral', 'NullableToolDtype'),
     ),
 )
-def _process_dataclass__2ded8afb50edd07329da6b7055981919a83dec56():
+def _process_dataclass__1d0b04d8ebb0bdb077bc9721fb19aafcadf99422():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -5939,8 +6259,7 @@ def _process_dataclass__2ded8afb50edd07329da6b7055981919a83dec56():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                key=self.key,
-                value=self.value,
+                type=self.type,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -5954,8 +6273,7 @@ def _process_dataclass__2ded8afb50edd07329da6b7055981919a83dec56():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.key == other.key and
-                self.value == other.value
+                self.type == other.type
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -5964,8 +6282,7 @@ def _process_dataclass__2ded8afb50edd07329da6b7055981919a83dec56():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'key',
-            'value',
+            'type',
         }
 
         def __setattr__(self, name, value):
@@ -5982,8 +6299,7 @@ def _process_dataclass__2ded8afb50edd07329da6b7055981919a83dec56():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'key',
-            'value',
+            'type',
         }
 
         def __delattr__(self, name):
@@ -6001,8 +6317,7 @@ def _process_dataclass__2ded8afb50edd07329da6b7055981919a83dec56():
 
         def __hash__(self):
             return hash((
-                self.key,
-                self.value,
+                self.type,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -6010,11 +6325,9 @@ def _process_dataclass__2ded8afb50edd07329da6b7055981919a83dec56():
 
         def __init__(
             self,
-            key: __dataclass__init__fields__0__annotation,
-            value: __dataclass__init__fields__1__annotation,
+            type: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'key', key)
-            __dataclass__object_setattr(self, 'value', value)
+            __dataclass__object_setattr(self, 'type', type)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -6024,8 +6337,7 @@ def _process_dataclass__2ded8afb50edd07329da6b7055981919a83dec56():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"{self.key!r}")
-            parts.append(f"{self.value!r}")
+            parts.append(f"{self.type!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -6042,23 +6354,23 @@ def _process_dataclass__2ded8afb50edd07329da6b7055981919a83dec56():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('type',)), EqPlan(fields=('type',)), FrozenPlan(fields=('type',), allow_dynamic_du"
-        "nder_attrs=False), HashPlan(action='add', fields=('type',), cache=False), InitPlan(fields=(InitPlan.Field(name"
-        "='type', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ove"
-        "rride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self',"
-        " std_params=('type',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
-        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='type', kw_only=False, fn=None),), id=False, terse=True, defa"
-        "ult_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('fields',)), EqPlan(fields=('fields',)), FrozenPlan(fields=('fields',), allow_dyna"
+        "mic_dunder_attrs=False), HashPlan(action='add', fields=('fields',), cache=False), InitPlan(fields=(InitPlan.Fi"
+        "eld(name='fields', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init"
+        "=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_par"
+        "am='self', std_params=('fields',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fn"
+        "s=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='fields', kw_only=False, fn=None),), id=False, te"
+        "rse=True, default_fn=None)))"
     ),
-    plan_repr_sha1='1d0b04d8ebb0bdb077bc9721fb19aafcadf99422',
+    plan_repr_sha1='178374af8c25e44a33c44ece98db0c96fe041247',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'NullableToolDtype'),
+        ('ommlds.minichain.backends.impls.mistral', 'ObjectToolDtype'),
     ),
 )
-def _process_dataclass__1d0b04d8ebb0bdb077bc9721fb19aafcadf99422():
+def _process_dataclass__178374af8c25e44a33c44ece98db0c96fe041247():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -6081,7 +6393,7 @@ def _process_dataclass__1d0b04d8ebb0bdb077bc9721fb19aafcadf99422():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                type=self.type,
+                fields=self.fields,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -6095,7 +6407,7 @@ def _process_dataclass__1d0b04d8ebb0bdb077bc9721fb19aafcadf99422():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.type == other.type
+                self.fields == other.fields
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -6104,7 +6416,7 @@ def _process_dataclass__1d0b04d8ebb0bdb077bc9721fb19aafcadf99422():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'type',
+            'fields',
         }
 
         def __setattr__(self, name, value):
@@ -6121,7 +6433,7 @@ def _process_dataclass__1d0b04d8ebb0bdb077bc9721fb19aafcadf99422():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'type',
+            'fields',
         }
 
         def __delattr__(self, name):
@@ -6139,7 +6451,7 @@ def _process_dataclass__1d0b04d8ebb0bdb077bc9721fb19aafcadf99422():
 
         def __hash__(self):
             return hash((
-                self.type,
+                self.fields,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -6147,9 +6459,9 @@ def _process_dataclass__1d0b04d8ebb0bdb077bc9721fb19aafcadf99422():
 
         def __init__(
             self,
-            type: __dataclass__init__fields__0__annotation,
+            fields: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'type', type)
+            __dataclass__object_setattr(self, 'fields', fields)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -6159,7 +6471,7 @@ def _process_dataclass__1d0b04d8ebb0bdb077bc9721fb19aafcadf99422():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"{self.type!r}")
+            parts.append(f"{self.fields!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -6176,27 +6488,36 @@ def _process_dataclass__1d0b04d8ebb0bdb077bc9721fb19aafcadf99422():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('fields',)), EqPlan(fields=('fields',)), FrozenPlan(fields=('fields',), allow_dyna"
-        "mic_dunder_attrs=False), HashPlan(action='add', fields=('fields',), cache=False), InitPlan(fields=(InitPlan.Fi"
-        "eld(name='fields', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init"
-        "=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_par"
-        "am='self', std_params=('fields',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fn"
-        "s=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='fields', kw_only=False, fn=None),), id=False, te"
-        "rse=True, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('_metadata', 'k')), EqPlan(fields=('_metadata', 'k')), FrozenPlan(fields=('_metada"
+        "ta', 'k'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 'k'), cache=False), "
+        "InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=O"
+        "pRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
+        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='k', ann"
+        "otation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False,"
+        " field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=("
+        "'k',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_f"
+        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='k', kw_only=False, fn=None),), id=False, terse=False, default_fn"
+        "=None)))"
     ),
-    plan_repr_sha1='178374af8c25e44a33c44ece98db0c96fe041247',
+    plan_repr_sha1='e2f3beaac46614f603d669e9c497bb0979815a5c',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__coerce',
+        '__dataclass__init__fields__0__default',
+        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'ObjectToolDtype'),
+        ('ommlds.minichain.backends.impls.mistral', 'PlaceholderContent'),
     ),
 )
-def _process_dataclass__178374af8c25e44a33c44ece98db0c96fe041247():
+def _process_dataclass__e2f3beaac46614f603d669e9c497bb0979815a5c():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__coerce,
+        __dataclass__init__fields__0__default,
+        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -6215,7 +6536,8 @@ def _process_dataclass__178374af8c25e44a33c44ece98db0c96fe041247():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                fields=self.fields,
+                _metadata=self._metadata,
+                k=self.k,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -6229,7 +6551,8 @@ def _process_dataclass__178374af8c25e44a33c44ece98db0c96fe041247():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.fields == other.fields
+                self._metadata == other._metadata and
+                self.k == other.k
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -6238,7 +6561,8 @@ def _process_dataclass__178374af8c25e44a33c44ece98db0c96fe041247():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'fields',
+            '_metadata',
+            'k',
         }
 
         def __setattr__(self, name, value):
@@ -6255,7 +6579,8 @@ def _process_dataclass__178374af8c25e44a33c44ece98db0c96fe041247():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'fields',
+            '_metadata',
+            'k',
         }
 
         def __delattr__(self, name):
@@ -6273,7 +6598,8 @@ def _process_dataclass__178374af8c25e44a33c44ece98db0c96fe041247():
 
         def __hash__(self):
             return hash((
-                self.fields,
+                self._metadata,
+                self.k,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -6281,9 +6607,13 @@ def _process_dataclass__178374af8c25e44a33c44ece98db0c96fe041247():
 
         def __init__(
             self,
-            fields: __dataclass__init__fields__0__annotation,
+            k: __dataclass__init__fields__1__annotation,
+            *,
+            _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'fields', fields)
+            _metadata = __dataclass__init__fields__0__coerce(_metadata)
+            __dataclass__object_setattr(self, '_metadata', _metadata)
+            __dataclass__object_setattr(self, 'k', k)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -6293,7 +6623,7 @@ def _process_dataclass__178374af8c25e44a33c44ece98db0c96fe041247():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"{self.fields!r}")
+            parts.append(f"k={self.k!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -6453,22 +6783,21 @@ def _process_dataclass__b7657835eed1f3e17dbdae82eb197181dd5862db():
         "ame='body', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, "
         "override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self"
         "', std_params=('body',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_"
-        "fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='_metadata', kw_only=True, fn=OpRef(name='repr."
-        "fns.0.fn')), ReprPlan.Field(name='body', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='body', kw_only=False, fn=None),), id=False, te"
+        "rse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='613cd3748f4063b004e2ac171fbf7e4248333e6b',
+    plan_repr_sha1='ef0fad925bba9f189d06f3ca8625366af9abb8a5',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__0__default',
         '__dataclass__init__fields__1__annotation',
-        '__dataclass__repr__fns__0__fn',
     ),
     cls_names=(
         ('ommlds.minichain.backends.impls.mistral', 'QuoteContent'),
     ),
 )
-def _process_dataclass__613cd3748f4063b004e2ac171fbf7e4248333e6b():
+def _process_dataclass__ef0fad925bba9f189d06f3ca8625366af9abb8a5():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -6476,7 +6805,6 @@ def _process_dataclass__613cd3748f4063b004e2ac171fbf7e4248333e6b():
         __dataclass__init__fields__0__coerce,
         __dataclass__init__fields__0__default,
         __dataclass__init__fields__1__annotation,
-        __dataclass__repr__fns__0__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -6582,8 +6910,6 @@ def _process_dataclass__613cd3748f4063b004e2ac171fbf7e4248333e6b():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
             parts.append(f"body={self.body!r}")
             return (
                 f"{self.__class__.__qualname__}("
@@ -6601,34 +6927,33 @@ def _process_dataclass__613cd3748f4063b004e2ac171fbf7e4248333e6b():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('_metadata', 'header', 'body')), EqPlan(fields=('_metadata', 'header', 'body')), F"
-        "rozenPlan(fields=('_metadata', 'header', 'body'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fi"
-        "elds=('_metadata', 'header', 'body'), cache=False), InitPlan(fields=(InitPlan.Field(name='_metadata', annotati"
+        "Plans(tup=(CopyPlan(fields=('_metadata', 'body', 'header')), EqPlan(fields=('_metadata', 'body', 'header')), F"
+        "rozenPlan(fields=('_metadata', 'body', 'header'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fi"
+        "elds=('_metadata', 'body', 'header'), cache=False), InitPlan(fields=(InitPlan.Field(name='_metadata', annotati"
         "on=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init.fields.0.default'), default_factory=None, "
         "init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate="
-        "None, check_type=None), InitPlan.Field(name='header', annotation=OpRef(name='init.fields.1.annotation'), defau"
-        "lt=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate"
-        "=None, check_type=None), InitPlan.Field(name='body', annotation=OpRef(name='init.fields.2.annotation'), defaul"
+        "None, check_type=None), InitPlan.Field(name='body', annotation=OpRef(name='init.fields.1.annotation'), default"
+        "=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=N"
+        "one, check_type=None), InitPlan.Field(name='header', annotation=OpRef(name='init.fields.2.annotation'), defaul"
         "t=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate="
-        "None, check_type=None)), self_param='self', std_params=('header', 'body'), kw_only_params=('_metadata',), froz"
+        "None, check_type=None)), self_param='self', std_params=('body',), kw_only_params=('_metadata', 'header'), froz"
         "en=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(na"
-        "me='_metadata', kw_only=True, fn=OpRef(name='repr.fns.0.fn')), ReprPlan.Field(name='header', kw_only=False, fn"
-        "=None), ReprPlan.Field(name='body', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "me='body', kw_only=False, fn=None), ReprPlan.Field(name='header', kw_only=True, fn=None)), id=False, terse=Fal"
+        "se, default_fn=None)))"
     ),
-    plan_repr_sha1='0fa4877e6cac6410b1b210697166cb95c606490e',
+    plan_repr_sha1='80e9c0b4a83a9a6095585d8dd172aec53d34d1f2',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__0__default',
         '__dataclass__init__fields__1__annotation',
         '__dataclass__init__fields__2__annotation',
-        '__dataclass__repr__fns__0__fn',
     ),
     cls_names=(
         ('ommlds.minichain.backends.impls.mistral', 'SectionContent'),
     ),
 )
-def _process_dataclass__0fa4877e6cac6410b1b210697166cb95c606490e():
+def _process_dataclass__80e9c0b4a83a9a6095585d8dd172aec53d34d1f2():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -6637,7 +6962,6 @@ def _process_dataclass__0fa4877e6cac6410b1b210697166cb95c606490e():
         __dataclass__init__fields__0__default,
         __dataclass__init__fields__1__annotation,
         __dataclass__init__fields__2__annotation,
-        __dataclass__repr__fns__0__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -6657,8 +6981,8 @@ def _process_dataclass__0fa4877e6cac6410b1b210697166cb95c606490e():
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
                 _metadata=self._metadata,
-                header=self.header,
                 body=self.body,
+                header=self.header,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -6673,8 +6997,8 @@ def _process_dataclass__0fa4877e6cac6410b1b210697166cb95c606490e():
                 return NotImplemented
             return (
                 self._metadata == other._metadata and
-                self.header == other.header and
-                self.body == other.body
+                self.body == other.body and
+                self.header == other.header
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -6684,8 +7008,8 @@ def _process_dataclass__0fa4877e6cac6410b1b210697166cb95c606490e():
 
         __dataclass___setattr_frozen_fields = {
             '_metadata',
-            'header',
             'body',
+            'header',
         }
 
         def __setattr__(self, name, value):
@@ -6703,8 +7027,8 @@ def _process_dataclass__0fa4877e6cac6410b1b210697166cb95c606490e():
 
         __dataclass___delattr_frozen_fields = {
             '_metadata',
-            'header',
             'body',
+            'header',
         }
 
         def __delattr__(self, name):
@@ -6723,8 +7047,8 @@ def _process_dataclass__0fa4877e6cac6410b1b210697166cb95c606490e():
         def __hash__(self):
             return hash((
                 self._metadata,
-                self.header,
                 self.body,
+                self.header,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -6732,15 +7056,15 @@ def _process_dataclass__0fa4877e6cac6410b1b210697166cb95c606490e():
 
         def __init__(
             self,
-            header: __dataclass__init__fields__1__annotation,
-            body: __dataclass__init__fields__2__annotation,
+            body: __dataclass__init__fields__1__annotation,
             *,
             _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            header: __dataclass__init__fields__2__annotation,
         ) -> __dataclass__None:
             _metadata = __dataclass__init__fields__0__coerce(_metadata)
             __dataclass__object_setattr(self, '_metadata', _metadata)
-            __dataclass__object_setattr(self, 'header', header)
             __dataclass__object_setattr(self, 'body', body)
+            __dataclass__object_setattr(self, 'header', header)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -6750,10 +7074,8 @@ def _process_dataclass__0fa4877e6cac6410b1b210697166cb95c606490e():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
-            parts.append(f"header={self.header!r}")
             parts.append(f"body={self.body!r}")
+            parts.append(f"header={self.header!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -7066,24 +7388,23 @@ def _process_dataclass__5cf06a8666aafbd9f13b7cc116ca35266a2043de():
         "pe=None), InitPlan.Field(name='body', annotation=OpRef(name='init.fields.2.annotation'), default=None, default"
         "_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_typ"
         "e=None)), self_param='self', std_params=('tag', 'body'), kw_only_params=('_metadata',), frozen=True, slots=Fal"
-        "se, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='_metadata', kw"
-        "_only=True, fn=OpRef(name='repr.fns.0.fn')), ReprPlan.Field(name='tag', kw_only=False, fn=None), ReprPlan.Fiel"
-        "d(name='body', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "se, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='tag', kw_only="
+        "False, fn=None), ReprPlan.Field(name='body', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)"
+        "))"
     ),
-    plan_repr_sha1='3cebe4c45faf434543bef35bc54753b0efb48327',
+    plan_repr_sha1='2e727a39486d5da75b5f2b035bb0d91c07e28821',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__0__default',
         '__dataclass__init__fields__1__annotation',
         '__dataclass__init__fields__2__annotation',
-        '__dataclass__repr__fns__0__fn',
     ),
     cls_names=(
         ('ommlds.minichain.backends.impls.mistral', 'TagContent'),
     ),
 )
-def _process_dataclass__3cebe4c45faf434543bef35bc54753b0efb48327():
+def _process_dataclass__2e727a39486d5da75b5f2b035bb0d91c07e28821():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -7092,7 +7413,6 @@ def _process_dataclass__3cebe4c45faf434543bef35bc54753b0efb48327():
         __dataclass__init__fields__0__default,
         __dataclass__init__fields__1__annotation,
         __dataclass__init__fields__2__annotation,
-        __dataclass__repr__fns__0__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -7205,8 +7525,6 @@ def _process_dataclass__3cebe4c45faf434543bef35bc54753b0efb48327():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
             parts.append(f"tag={self.tag!r}")
             parts.append(f"body={self.body!r}")
             return (
@@ -7233,178 +7551,21 @@ def _process_dataclass__3cebe4c45faf434543bef35bc54753b0efb48327():
         "otation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False,"
         " field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=("
         "'t',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_f"
-        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='_metadata', kw_only=True, fn=OpRef(name='repr.fns.0.fn')), ReprP"
-        "lan.Field(name='t', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='t', kw_only=False, fn=None),), id=False, terse=False, default_fn"
+        "=None)))"
     ),
-    plan_repr_sha1='484b69d9acddc84ab225a2e06f4ed574a339e353',
+    plan_repr_sha1='57c830149c3ca2c61665f91debc71be37c7ad297',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__0__default',
         '__dataclass__init__fields__1__annotation',
-        '__dataclass__repr__fns__0__fn',
     ),
     cls_names=(
         ('ommlds.minichain.backends.impls.mistral', 'TemplateContent'),
     ),
 )
-def _process_dataclass__484b69d9acddc84ab225a2e06f4ed574a339e353():
-    def _process_dataclass(
-        *,
-        __dataclass__cls,
-        __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
-        __dataclass__init__fields__0__default,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__repr__fns__0__fn,
-        __dataclass__FieldFnValidationError,  # noqa
-        __dataclass__FieldTypeValidationError,  # noqa
-        __dataclass__FnValidationError,  # noqa
-        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
-        __dataclass__FunctionType=types.FunctionType,  # noqa
-        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
-        __dataclass__MISSING=dataclasses.MISSING,  # noqa
-        __dataclass__None=None,  # noqa
-        __dataclass__TypeError=TypeError,  # noqa
-        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
-        __dataclass__isinstance=isinstance,  # noqa
-        __dataclass__object_setattr=object.__setattr__,  # noqa
-        __dataclass__property=property,  # noqa
-    ):
-        def __copy__(self):
-            if self.__class__ is not __dataclass__cls:
-                raise TypeError(self)
-            return __dataclass__cls(  # noqa
-                _metadata=self._metadata,
-                t=self.t,
-            )
-
-        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
-        if '__copy__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__copy__', __copy__)
-
-        def __eq__(self, other):
-            if self is other:
-                return True
-            if self.__class__ is not other.__class__:
-                return NotImplemented
-            return (
-                self._metadata == other._metadata and
-                self.t == other.t
-            )
-
-        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
-        if '__eq__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__eq__', __eq__)
-
-        __dataclass___setattr_frozen_fields = {
-            '_metadata',
-            't',
-        }
-
-        def __setattr__(self, name, value):
-            if (
-                type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
-            super(__dataclass__cls, self).__setattr__(name, value)
-
-        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
-        if '__setattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__setattr__', __setattr__)
-
-        __dataclass___delattr_frozen_fields = {
-            '_metadata',
-            't',
-        }
-
-        def __delattr__(self, name):
-            if (
-                type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
-            super(__dataclass__cls, self).__delattr__(name)
-
-        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
-        if '__delattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__delattr__', __delattr__)
-
-        def __hash__(self):
-            return hash((
-                self._metadata,
-                self.t,
-            ))
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
-        def __init__(
-            self,
-            t: __dataclass__init__fields__1__annotation,
-            *,
-            _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
-        ) -> __dataclass__None:
-            _metadata = __dataclass__init__fields__0__coerce(_metadata)
-            __dataclass__object_setattr(self, '_metadata', _metadata)
-            __dataclass__object_setattr(self, 't', t)
-
-        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
-        if '__init__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__init__', __init__)
-
-        @__dataclass___recursive_repr()
-        def __repr__(self):
-            parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
-            parts.append(f"t={self.t!r}")
-            return (
-                f"{self.__class__.__qualname__}("
-                f"{', '.join(parts)}"
-                f")"
-            )
-
-        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
-        if '__repr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__repr__', __repr__)
-
-    return _process_dataclass
-
-
-@_register(
-    plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('_metadata', 's')), EqPlan(fields=('_metadata', 's')), FrozenPlan(fields=('_metada"
-        "ta', 's'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('_metadata', 's'), cache=False), "
-        "InitPlan(fields=(InitPlan.Field(name='_metadata', annotation=OpRef(name='init.fields.0.annotation'), default=O"
-        "pRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
-        "ANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='s', ann"
-        "otation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False,"
-        " field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=("
-        "'s',), kw_only_params=('_metadata',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_f"
-        "ns=()), ReprPlan(fields=(ReprPlan.Field(name='_metadata', kw_only=True, fn=OpRef(name='repr.fns.0.fn')), ReprP"
-        "lan.Field(name='s', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
-    ),
-    plan_repr_sha1='f723863afd85d55cffe70bb94e882a00fd581c11',
-    op_ref_idents=(
-        '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
-        '__dataclass__init__fields__0__default',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__repr__fns__0__fn',
-    ),
-    cls_names=(
-        ('ommlds.minichain.backends.impls.mistral', 'TextContent'),
-    ),
-)
-def _process_dataclass__f723863afd85d55cffe70bb94e882a00fd581c11():
+def _process_dataclass__57c830149c3ca2c61665f91debc71be37c7ad297():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -7412,7 +7573,6 @@ def _process_dataclass__f723863afd85d55cffe70bb94e882a00fd581c11():
         __dataclass__init__fields__0__coerce,
         __dataclass__init__fields__0__default,
         __dataclass__init__fields__1__annotation,
-        __dataclass__repr__fns__0__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -7432,7 +7592,7 @@ def _process_dataclass__f723863afd85d55cffe70bb94e882a00fd581c11():
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
                 _metadata=self._metadata,
-                s=self.s,
+                t=self.t,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -7447,7 +7607,7 @@ def _process_dataclass__f723863afd85d55cffe70bb94e882a00fd581c11():
                 return NotImplemented
             return (
                 self._metadata == other._metadata and
-                self.s == other.s
+                self.t == other.t
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -7457,7 +7617,7 @@ def _process_dataclass__f723863afd85d55cffe70bb94e882a00fd581c11():
 
         __dataclass___setattr_frozen_fields = {
             '_metadata',
-            's',
+            't',
         }
 
         def __setattr__(self, name, value):
@@ -7475,7 +7635,7 @@ def _process_dataclass__f723863afd85d55cffe70bb94e882a00fd581c11():
 
         __dataclass___delattr_frozen_fields = {
             '_metadata',
-            's',
+            't',
         }
 
         def __delattr__(self, name):
@@ -7494,7 +7654,7 @@ def _process_dataclass__f723863afd85d55cffe70bb94e882a00fd581c11():
         def __hash__(self):
             return hash((
                 self._metadata,
-                self.s,
+                self.t,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -7502,13 +7662,13 @@ def _process_dataclass__f723863afd85d55cffe70bb94e882a00fd581c11():
 
         def __init__(
             self,
-            s: __dataclass__init__fields__1__annotation,
+            t: __dataclass__init__fields__1__annotation,
             *,
             _metadata: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
         ) -> __dataclass__None:
             _metadata = __dataclass__init__fields__0__coerce(_metadata)
             __dataclass__object_setattr(self, '_metadata', _metadata)
-            __dataclass__object_setattr(self, 's', s)
+            __dataclass__object_setattr(self, 't', t)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -7518,9 +7678,7 @@ def _process_dataclass__f723863afd85d55cffe70bb94e882a00fd581c11():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            if (s := __dataclass__repr__fns__0__fn(self._metadata)) is not None:
-                parts.append(f"_metadata={s}")
-            parts.append(f"s={self.s!r}")
+            parts.append(f"t={self.t!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -10222,29 +10380,29 @@ def _process_dataclass__e8c5e181501fac7b5abbf4cd74b1e97ce7051392():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('schema',)), EqPlan(fields=('schema',)), FrozenPlan(fields=('schema',), allow_dyna"
-        "mic_dunder_attrs=False), HashPlan(action='add', fields=('schema',), cache=False), InitPlan(fields=(InitPlan.Fi"
-        "eld(name='schema', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init.fields.0.defaul"
-        "t'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=Non"
-        "e, check_type=None),), self_param='self', std_params=('schema',), kw_only_params=(), frozen=True, slots=False,"
-        " post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='schema', kw_only="
-        "False, fn=None),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('fn',)), EqPlan(fields=('fn',)), FrozenPlan(fields=('fn',), allow_dynamic_dunder_a"
+        "ttrs=False), HashPlan(action='add', fields=('fn',), cache=False), InitPlan(fields=(InitPlan.Field(name='fn', a"
+        "nnotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=Fals"
+        "e, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_param"
+        "s=('fn',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), "
+        "ReprPlan(fields=(ReprPlan.Field(name='fn', kw_only=False, fn=None),), id=False, terse=False, default_fn=None))"
+        ")"
     ),
-    plan_repr_sha1='b2744f4fae3f6b409187f78feac9442e7e1db7ac',
+    plan_repr_sha1='9c26f5e7e2496284b4ba1e1072fb3e29dc4e0ec4',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__default',
     ),
     cls_names=(
-        ('ommlds.minichain.chat.formats', 'JsonResponseFormat'),
+        ('ommlds.minichain.chat.content', 'StringFnContentTransform'),
+        ('ommlds.minichain.chat.tools.ids', 'FnChatTransform'),
+        ('ommlds.minichain.chat.tools.ids', 'FnMessageTransform'),
     ),
 )
-def _process_dataclass__b2744f4fae3f6b409187f78feac9442e7e1db7ac():
+def _process_dataclass__9c26f5e7e2496284b4ba1e1072fb3e29dc4e0ec4():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -10263,7 +10421,7 @@ def _process_dataclass__b2744f4fae3f6b409187f78feac9442e7e1db7ac():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                schema=self.schema,
+                fn=self.fn,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -10277,7 +10435,7 @@ def _process_dataclass__b2744f4fae3f6b409187f78feac9442e7e1db7ac():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.schema == other.schema
+                self.fn == other.fn
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -10286,7 +10444,7 @@ def _process_dataclass__b2744f4fae3f6b409187f78feac9442e7e1db7ac():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'schema',
+            'fn',
         }
 
         def __setattr__(self, name, value):
@@ -10303,7 +10461,7 @@ def _process_dataclass__b2744f4fae3f6b409187f78feac9442e7e1db7ac():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'schema',
+            'fn',
         }
 
         def __delattr__(self, name):
@@ -10321,7 +10479,7 @@ def _process_dataclass__b2744f4fae3f6b409187f78feac9442e7e1db7ac():
 
         def __hash__(self):
             return hash((
-                self.schema,
+                self.fn,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -10329,9 +10487,9 @@ def _process_dataclass__b2744f4fae3f6b409187f78feac9442e7e1db7ac():
 
         def __init__(
             self,
-            schema: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            fn: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'schema', schema)
+            __dataclass__object_setattr(self, 'fn', fn)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -10341,7 +10499,7 @@ def _process_dataclass__b2744f4fae3f6b409187f78feac9442e7e1db7ac():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"schema={self.schema!r}")
+            parts.append(f"fn={self.fn!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -10358,27 +10516,29 @@ def _process_dataclass__b2744f4fae3f6b409187f78feac9442e7e1db7ac():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('m',)), EqPlan(fields=('m',)), FrozenPlan(fields=('m',), allow_dynamic_dunder_attr"
-        "s=False), HashPlan(action='add', fields=('m',), cache=False), InitPlan(fields=(InitPlan.Field(name='m', annota"
-        "tion=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, fi"
-        "eld_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_params=('m"
-        "',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPl"
-        "an(fields=(ReprPlan.Field(name='m', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('schema',)), EqPlan(fields=('schema',)), FrozenPlan(fields=('schema',), allow_dyna"
+        "mic_dunder_attrs=False), HashPlan(action='add', fields=('schema',), cache=False), InitPlan(fields=(InitPlan.Fi"
+        "eld(name='schema', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init.fields.0.defaul"
+        "t'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=Non"
+        "e, check_type=None),), self_param='self', std_params=('schema',), kw_only_params=(), frozen=True, slots=False,"
+        " post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='schema', kw_only="
+        "False, fn=None),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='00a32d02ca8d7c055f05a95a2073d8d5198c6d97',
+    plan_repr_sha1='b2744f4fae3f6b409187f78feac9442e7e1db7ac',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__default',
     ),
     cls_names=(
-        ('ommlds.minichain.chat.templating', 'ChatTemplater._MessageStep'),
-        ('ommlds.minichain.chat.tools.execution', 'ToolFn.MaysyncImpl'),
+        ('ommlds.minichain.chat.formats', 'JsonResponseFormat'),
     ),
 )
-def _process_dataclass__00a32d02ca8d7c055f05a95a2073d8d5198c6d97():
+def _process_dataclass__b2744f4fae3f6b409187f78feac9442e7e1db7ac():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -10397,7 +10557,7 @@ def _process_dataclass__00a32d02ca8d7c055f05a95a2073d8d5198c6d97():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                m=self.m,
+                schema=self.schema,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -10411,7 +10571,7 @@ def _process_dataclass__00a32d02ca8d7c055f05a95a2073d8d5198c6d97():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.m == other.m
+                self.schema == other.schema
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -10420,7 +10580,7 @@ def _process_dataclass__00a32d02ca8d7c055f05a95a2073d8d5198c6d97():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'm',
+            'schema',
         }
 
         def __setattr__(self, name, value):
@@ -10437,7 +10597,7 @@ def _process_dataclass__00a32d02ca8d7c055f05a95a2073d8d5198c6d97():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'm',
+            'schema',
         }
 
         def __delattr__(self, name):
@@ -10455,7 +10615,7 @@ def _process_dataclass__00a32d02ca8d7c055f05a95a2073d8d5198c6d97():
 
         def __hash__(self):
             return hash((
-                self.m,
+                self.schema,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -10463,9 +10623,9 @@ def _process_dataclass__00a32d02ca8d7c055f05a95a2073d8d5198c6d97():
 
         def __init__(
             self,
-            m: __dataclass__init__fields__0__annotation,
+            schema: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'm', m)
+            __dataclass__object_setattr(self, 'schema', schema)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -10475,7 +10635,7 @@ def _process_dataclass__00a32d02ca8d7c055f05a95a2073d8d5198c6d97():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"m={self.m!r}")
+            parts.append(f"schema={self.schema!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -10492,22 +10652,23 @@ def _process_dataclass__00a32d02ca8d7c055f05a95a2073d8d5198c6d97():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('p',)), EqPlan(fields=('p',)), FrozenPlan(fields=('p',), allow_dynamic_dunder_attr"
-        "s=False), HashPlan(action='add', fields=('p',), cache=False), InitPlan(fields=(InitPlan.Field(name='p', annota"
+        "Plans(tup=(CopyPlan(fields=('m',)), EqPlan(fields=('m',)), FrozenPlan(fields=('m',), allow_dynamic_dunder_attr"
+        "s=False), HashPlan(action='add', fields=('m',), cache=False), InitPlan(fields=(InitPlan.Field(name='m', annota"
         "tion=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, fi"
-        "eld_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_params=('p"
+        "eld_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_params=('m"
         "',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPl"
-        "an(fields=(ReprPlan.Field(name='p', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
+        "an(fields=(ReprPlan.Field(name='m', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='25598005d4986efc83d12d341829703b738d3f54',
+    plan_repr_sha1='00a32d02ca8d7c055f05a95a2073d8d5198c6d97',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.chat.templating', 'ChatTemplater._PlaceholderStep'),
+        ('ommlds.minichain.chat.templating', 'ChatTemplater._MessageStep'),
+        ('ommlds.minichain.chat.tools.execution', 'ToolFn.MaysyncImpl'),
     ),
 )
-def _process_dataclass__25598005d4986efc83d12d341829703b738d3f54():
+def _process_dataclass__00a32d02ca8d7c055f05a95a2073d8d5198c6d97():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -10530,7 +10691,7 @@ def _process_dataclass__25598005d4986efc83d12d341829703b738d3f54():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                p=self.p,
+                m=self.m,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -10544,7 +10705,7 @@ def _process_dataclass__25598005d4986efc83d12d341829703b738d3f54():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.p == other.p
+                self.m == other.m
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -10553,7 +10714,7 @@ def _process_dataclass__25598005d4986efc83d12d341829703b738d3f54():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'p',
+            'm',
         }
 
         def __setattr__(self, name, value):
@@ -10570,7 +10731,7 @@ def _process_dataclass__25598005d4986efc83d12d341829703b738d3f54():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'p',
+            'm',
         }
 
         def __delattr__(self, name):
@@ -10588,7 +10749,7 @@ def _process_dataclass__25598005d4986efc83d12d341829703b738d3f54():
 
         def __hash__(self):
             return hash((
-                self.p,
+                self.m,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -10596,9 +10757,9 @@ def _process_dataclass__25598005d4986efc83d12d341829703b738d3f54():
 
         def __init__(
             self,
-            p: __dataclass__init__fields__0__annotation,
+            m: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'p', p)
+            __dataclass__object_setattr(self, 'm', m)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -10608,7 +10769,7 @@ def _process_dataclass__25598005d4986efc83d12d341829703b738d3f54():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"p={self.p!r}")
+            parts.append(f"m={self.m!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -10625,31 +10786,26 @@ def _process_dataclass__25598005d4986efc83d12d341829703b738d3f54():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('m', 'd')), EqPlan(fields=('m', 'd')), FrozenPlan(fields=('m', 'd'), allow_dynamic"
-        "_dunder_attrs=False), HashPlan(action='add', fields=('m', 'd'), cache=False), InitPlan(fields=(InitPlan.Field("
-        "name='m', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ov"
-        "erride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name"
-        "='d', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, overri"
-        "de=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std"
-        "_params=('m', 'd'), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_"
-        "fns=()), ReprPlan(fields=(ReprPlan.Field(name='m', kw_only=False, fn=None), ReprPlan.Field(name='d', kw_only=F"
-        "alse, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('p',)), EqPlan(fields=('p',)), FrozenPlan(fields=('p',), allow_dynamic_dunder_attr"
+        "s=False), HashPlan(action='add', fields=('p',), cache=False), InitPlan(fields=(InitPlan.Field(name='p', annota"
+        "tion=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, fi"
+        "eld_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_params=('p"
+        "',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPl"
+        "an(fields=(ReprPlan.Field(name='p', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='a6847b703ccb991096e8362e4bfbc91af7df37bf',
+    plan_repr_sha1='25598005d4986efc83d12d341829703b738d3f54',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.chat.templating', 'ChatTemplater._TemplateStep'),
+        ('ommlds.minichain.chat.templating', 'ChatTemplater._PlaceholderStep'),
     ),
 )
-def _process_dataclass__a6847b703ccb991096e8362e4bfbc91af7df37bf():
+def _process_dataclass__25598005d4986efc83d12d341829703b738d3f54():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -10668,8 +10824,7 @@ def _process_dataclass__a6847b703ccb991096e8362e4bfbc91af7df37bf():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                m=self.m,
-                d=self.d,
+                p=self.p,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -10683,8 +10838,7 @@ def _process_dataclass__a6847b703ccb991096e8362e4bfbc91af7df37bf():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.m == other.m and
-                self.d == other.d
+                self.p == other.p
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -10693,8 +10847,7 @@ def _process_dataclass__a6847b703ccb991096e8362e4bfbc91af7df37bf():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'm',
-            'd',
+            'p',
         }
 
         def __setattr__(self, name, value):
@@ -10711,8 +10864,7 @@ def _process_dataclass__a6847b703ccb991096e8362e4bfbc91af7df37bf():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'm',
-            'd',
+            'p',
         }
 
         def __delattr__(self, name):
@@ -10730,8 +10882,7 @@ def _process_dataclass__a6847b703ccb991096e8362e4bfbc91af7df37bf():
 
         def __hash__(self):
             return hash((
-                self.m,
-                self.d,
+                self.p,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -10739,11 +10890,9 @@ def _process_dataclass__a6847b703ccb991096e8362e4bfbc91af7df37bf():
 
         def __init__(
             self,
-            m: __dataclass__init__fields__0__annotation,
-            d: __dataclass__init__fields__1__annotation,
+            p: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'm', m)
-            __dataclass__object_setattr(self, 'd', d)
+            __dataclass__object_setattr(self, 'p', p)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -10753,8 +10902,7 @@ def _process_dataclass__a6847b703ccb991096e8362e4bfbc91af7df37bf():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"m={self.m!r}")
-            parts.append(f"d={self.d!r}")
+            parts.append(f"p={self.p!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -10771,27 +10919,31 @@ def _process_dataclass__a6847b703ccb991096e8362e4bfbc91af7df37bf():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('key',)), EqPlan(fields=('key',)), FrozenPlan(fields=('key',), allow_dynamic_dunde"
-        "r_attrs=False), HashPlan(action='add', fields=('key',), cache=False), InitPlan(fields=(InitPlan.Field(name='ke"
-        "y', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override"
-        "=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_"
-        "params=('key',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns"
-        "=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=False, fn=None),), id=False, terse=False, default_fn"
-        "=None)))"
+        "Plans(tup=(CopyPlan(fields=('m', 'd')), EqPlan(fields=('m', 'd')), FrozenPlan(fields=('m', 'd'), allow_dynamic"
+        "_dunder_attrs=False), HashPlan(action='add', fields=('m', 'd'), cache=False), InitPlan(fields=(InitPlan.Field("
+        "name='m', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ov"
+        "erride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name"
+        "='d', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, overri"
+        "de=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std"
+        "_params=('m', 'd'), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_"
+        "fns=()), ReprPlan(fields=(ReprPlan.Field(name='m', kw_only=False, fn=None), ReprPlan.Field(name='d', kw_only=F"
+        "alse, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='4492a70e9341afc741b487e59ae5ea6624e3c95d',
+    plan_repr_sha1='a6847b703ccb991096e8362e4bfbc91af7df37bf',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.chat.templating', 'MessagePlaceholder'),
+        ('ommlds.minichain.chat.templating', 'ChatTemplater._TemplateStep'),
     ),
 )
-def _process_dataclass__4492a70e9341afc741b487e59ae5ea6624e3c95d():
+def _process_dataclass__a6847b703ccb991096e8362e4bfbc91af7df37bf():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -10810,7 +10962,8 @@ def _process_dataclass__4492a70e9341afc741b487e59ae5ea6624e3c95d():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                key=self.key,
+                m=self.m,
+                d=self.d,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -10824,7 +10977,8 @@ def _process_dataclass__4492a70e9341afc741b487e59ae5ea6624e3c95d():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.key == other.key
+                self.m == other.m and
+                self.d == other.d
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -10833,7 +10987,8 @@ def _process_dataclass__4492a70e9341afc741b487e59ae5ea6624e3c95d():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'key',
+            'm',
+            'd',
         }
 
         def __setattr__(self, name, value):
@@ -10850,7 +11005,8 @@ def _process_dataclass__4492a70e9341afc741b487e59ae5ea6624e3c95d():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'key',
+            'm',
+            'd',
         }
 
         def __delattr__(self, name):
@@ -10868,7 +11024,8 @@ def _process_dataclass__4492a70e9341afc741b487e59ae5ea6624e3c95d():
 
         def __hash__(self):
             return hash((
-                self.key,
+                self.m,
+                self.d,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -10876,9 +11033,11 @@ def _process_dataclass__4492a70e9341afc741b487e59ae5ea6624e3c95d():
 
         def __init__(
             self,
-            key: __dataclass__init__fields__0__annotation,
+            m: __dataclass__init__fields__0__annotation,
+            d: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'key', key)
+            __dataclass__object_setattr(self, 'm', m)
+            __dataclass__object_setattr(self, 'd', d)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -10888,7 +11047,8 @@ def _process_dataclass__4492a70e9341afc741b487e59ae5ea6624e3c95d():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"key={self.key!r}")
+            parts.append(f"m={self.m!r}")
+            parts.append(f"d={self.d!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -10905,25 +11065,23 @@ def _process_dataclass__4492a70e9341afc741b487e59ae5ea6624e3c95d():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('fn',)), EqPlan(fields=('fn',)), FrozenPlan(fields=('fn',), allow_dynamic_dunder_a"
-        "ttrs=False), HashPlan(action='add', fields=('fn',), cache=False), InitPlan(fields=(InitPlan.Field(name='fn', a"
-        "nnotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=Fals"
-        "e, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_param"
-        "s=('fn',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), "
-        "ReprPlan(fields=(ReprPlan.Field(name='fn', kw_only=False, fn=None),), id=False, terse=False, default_fn=None))"
-        ")"
+        "Plans(tup=(CopyPlan(fields=('key',)), EqPlan(fields=('key',)), FrozenPlan(fields=('key',), allow_dynamic_dunde"
+        "r_attrs=False), HashPlan(action='add', fields=('key',), cache=False), InitPlan(fields=(InitPlan.Field(name='ke"
+        "y', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override"
+        "=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_"
+        "params=('key',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns"
+        "=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=False, fn=None),), id=False, terse=False, default_fn"
+        "=None)))"
     ),
-    plan_repr_sha1='9c26f5e7e2496284b4ba1e1072fb3e29dc4e0ec4',
+    plan_repr_sha1='4492a70e9341afc741b487e59ae5ea6624e3c95d',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('ommlds.minichain.chat.templating', 'StringFnContentTransform'),
-        ('ommlds.minichain.chat.tools.ids', 'FnChatTransform'),
-        ('ommlds.minichain.chat.tools.ids', 'FnMessageTransform'),
+        ('ommlds.minichain.chat.templating', 'MessagePlaceholder'),
     ),
 )
-def _process_dataclass__9c26f5e7e2496284b4ba1e1072fb3e29dc4e0ec4():
+def _process_dataclass__4492a70e9341afc741b487e59ae5ea6624e3c95d():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -10946,7 +11104,7 @@ def _process_dataclass__9c26f5e7e2496284b4ba1e1072fb3e29dc4e0ec4():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                fn=self.fn,
+                key=self.key,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -10960,7 +11118,7 @@ def _process_dataclass__9c26f5e7e2496284b4ba1e1072fb3e29dc4e0ec4():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.fn == other.fn
+                self.key == other.key
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -10969,7 +11127,7 @@ def _process_dataclass__9c26f5e7e2496284b4ba1e1072fb3e29dc4e0ec4():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'fn',
+            'key',
         }
 
         def __setattr__(self, name, value):
@@ -10986,7 +11144,7 @@ def _process_dataclass__9c26f5e7e2496284b4ba1e1072fb3e29dc4e0ec4():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'fn',
+            'key',
         }
 
         def __delattr__(self, name):
@@ -11004,7 +11162,7 @@ def _process_dataclass__9c26f5e7e2496284b4ba1e1072fb3e29dc4e0ec4():
 
         def __hash__(self):
             return hash((
-                self.fn,
+                self.key,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -11012,9 +11170,9 @@ def _process_dataclass__9c26f5e7e2496284b4ba1e1072fb3e29dc4e0ec4():
 
         def __init__(
             self,
-            fn: __dataclass__init__fields__0__annotation,
+            key: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'fn', fn)
+            __dataclass__object_setattr(self, 'key', key)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -11024,7 +11182,7 @@ def _process_dataclass__9c26f5e7e2496284b4ba1e1072fb3e29dc4e0ec4():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"fn={self.fn!r}")
+            parts.append(f"key={self.key!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"