ommlds 0.0.0.dev492__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

ommlds/cli/_dataclasses.py

@@ -23,6 +23,121 @@ def _register(**kwargs):
 ##
 
 
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=()), EqPlan(fields=()), FrozenPlan(fields=(), allow_dynamic_dunder_attrs=False), Ha"
+        "shPlan(action='add', fields=(), cache=False), InitPlan(fields=(), self_param='self', std_params=(), kw_only_pa"
+        "rams=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(), i"
+        "d=False, terse=False, default_fn=None)))"
+    ),
+    plan_repr_sha1='e1f7edfe11f2b721d6a656c46e698fedc95461bb',
+    op_ref_idents=(),
+    cls_names=(
+        ('ommlds.cli.inject', 'SessionConfig'),
+        ('ommlds.cli.main', 'FacadeConfig'),
+        ('ommlds.cli.main', 'ToolSetConfig'),
+        ('ommlds.cli.sessions.chat.drivers.tools.fs.configs', 'FsToolSetConfig'),
+        ('ommlds.cli.sessions.chat.drivers.tools.todo.configs', 'TodoToolSetConfig'),
+        ('ommlds.cli.sessions.chat.drivers.tools.weather.configs', 'WeatherToolSetConfig'),
+    ),
+)
+def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
+    def _process_dataclass(
+        *,
+        __dataclass__cls,
+        __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
+
+        __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 True
+
+        __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__)
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+            ):
+                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__)
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+            ):
+                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(())
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
+        def __init__(
+            self,
+        ) -> __dataclass__None:
+            pass
+
+        __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=('stream', 'verbose', 'enable_tools')), EqPlan(fields=('stream', 'verbose', 'enable"
@@ -330,22 +445,27 @@ def _process_dataclass__fa5665ecddac4bdf52a6a47db3b5b5362a8b3c7a():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('driver', 'interface', 'rendering')), EqPlan(fields=('driver', 'interface', 'rende"
-        "ring')), FrozenPlan(fields=('driver', 'interface', 'rendering'), allow_dynamic_dunder_attrs=False), HashPlan(a"
-        "ction='add', fields=('driver', 'interface', 'rendering'), cache=False), InitPlan(fields=(InitPlan.Field(name='"
-        "driver', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init.fields.0.default'), defau"
-        "lt_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_t"
-        "ype=None), InitPlan.Field(name='interface', annotation=OpRef(name='init.fields.1.annotation'), default=OpRef(n"
-        "ame='init.fields.1.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, "
-        "coerce=None, validate=None, check_type=None), InitPlan.Field(name='rendering', annotation=OpRef(name='init.fie"
-        "lds.2.annotation'), default=OpRef(name='init.fields.2.default'), default_factory=None, init=True, override=Fal"
-        "se, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_param"
-        "s=(), kw_only_params=('driver', 'interface', 'rendering'), frozen=True, slots=False, post_init_params=None, in"
-        "it_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='driver', kw_only=True, fn=None), ReprPlan.F"
-        "ield(name='interface', kw_only=True, fn=None), ReprPlan.Field(name='rendering', kw_only=True, fn=None)), id=Fa"
-        "lse, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('enable_tools', 'dangerous_no_tool_confirmation', 'interactive', 'use_readline')),"
+        " EqPlan(fields=('enable_tools', 'dangerous_no_tool_confirmation', 'interactive', 'use_readline')), FrozenPlan("
+        "fields=('enable_tools', 'dangerous_no_tool_confirmation', 'interactive', 'use_readline'), allow_dynamic_dunder"
+        "_attrs=False), HashPlan(action='add', fields=('enable_tools', 'dangerous_no_tool_confirmation', 'interactive',"
+        " 'use_readline'), cache=False), InitPlan(fields=(InitPlan.Field(name='enable_tools', annotation=OpRef(name='in"
+        "it.fields.0.annotation'), default=OpRef(name='init.fields.0.default'), default_factory=None, init=True, overri"
+        "de=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='da"
+        "ngerous_no_tool_confirmation', annotation=OpRef(name='init.fields.1.annotation'), default=OpRef(name='init.fie"
+        "lds.1.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, "
+        "validate=None, check_type=None), InitPlan.Field(name='interactive', annotation=OpRef(name='init.fields.2.annot"
+        "ation'), default=OpRef(name='init.fields.2.default'), default_factory=None, init=True, override=False, field_t"
+        "ype=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='use_readline', anno"
+        "tation=OpRef(name='init.fields.3.annotation'), default=OpRef(name='init.fields.3.default'), default_factory=No"
+        "ne, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), s"
+        "elf_param='self', std_params=(), kw_only_params=('enable_tools', 'dangerous_no_tool_confirmation', 'interactiv"
+        "e', 'use_readline'), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan("
+        "fields=(ReprPlan.Field(name='enable_tools', kw_only=True, fn=None), ReprPlan.Field(name='dangerous_no_tool_con"
+        "firmation', kw_only=True, fn=None), ReprPlan.Field(name='interactive', kw_only=True, fn=None), ReprPlan.Field("
+        "name='use_readline', kw_only=True, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='103bad1f2af413714bd23ee2d6a5dffda2e6163d',
+    plan_repr_sha1='9e8c99e7d2eb01a6861d3003bd95e38b3c3fe9ae',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__default',
@@ -353,12 +473,14 @@ def _process_dataclass__fa5665ecddac4bdf52a6a47db3b5b5362a8b3c7a():
         '__dataclass__init__fields__1__default',
         '__dataclass__init__fields__2__annotation',
         '__dataclass__init__fields__2__default',
+        '__dataclass__init__fields__3__annotation',
+        '__dataclass__init__fields__3__default',
     ),
     cls_names=(
-        ('ommlds.cli.main', 'ChatConfig'),
+        ('ommlds.cli.main', 'BareInterfaceConfig'),
     ),
 )
-def _process_dataclass__103bad1f2af413714bd23ee2d6a5dffda2e6163d():
+def _process_dataclass__9e8c99e7d2eb01a6861d3003bd95e38b3c3fe9ae():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -368,6 +490,8 @@ def _process_dataclass__103bad1f2af413714bd23ee2d6a5dffda2e6163d():
         __dataclass__init__fields__1__default,
         __dataclass__init__fields__2__annotation,
         __dataclass__init__fields__2__default,
+        __dataclass__init__fields__3__annotation,
+        __dataclass__init__fields__3__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -386,9 +510,10 @@ def _process_dataclass__103bad1f2af413714bd23ee2d6a5dffda2e6163d():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                driver=self.driver,
-                interface=self.interface,
-                rendering=self.rendering,
+                enable_tools=self.enable_tools,
+                dangerous_no_tool_confirmation=self.dangerous_no_tool_confirmation,
+                interactive=self.interactive,
+                use_readline=self.use_readline,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -402,9 +527,10 @@ def _process_dataclass__103bad1f2af413714bd23ee2d6a5dffda2e6163d():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.driver == other.driver and
-                self.interface == other.interface and
-                self.rendering == other.rendering
+                self.enable_tools == other.enable_tools and
+                self.dangerous_no_tool_confirmation == other.dangerous_no_tool_confirmation and
+                self.interactive == other.interactive and
+                self.use_readline == other.use_readline
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -413,9 +539,10 @@ def _process_dataclass__103bad1f2af413714bd23ee2d6a5dffda2e6163d():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'driver',
-            'interface',
-            'rendering',
+            'enable_tools',
+            'dangerous_no_tool_confirmation',
+            'interactive',
+            'use_readline',
         }
 
         def __setattr__(self, name, value):
@@ -432,9 +559,10 @@ def _process_dataclass__103bad1f2af413714bd23ee2d6a5dffda2e6163d():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'driver',
-            'interface',
-            'rendering',
+            'enable_tools',
+            'dangerous_no_tool_confirmation',
+            'interactive',
+            'use_readline',
         }
 
         def __delattr__(self, name):
@@ -452,9 +580,10 @@ def _process_dataclass__103bad1f2af413714bd23ee2d6a5dffda2e6163d():
 
         def __hash__(self):
             return hash((
-                self.driver,
-                self.interface,
-                self.rendering,
+                self.enable_tools,
+                self.dangerous_no_tool_confirmation,
+                self.interactive,
+                self.use_readline,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -463,13 +592,15 @@ def _process_dataclass__103bad1f2af413714bd23ee2d6a5dffda2e6163d():
         def __init__(
             self,
             *,
-            driver: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
-            interface: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
-            rendering: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
+            enable_tools: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            dangerous_no_tool_confirmation: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
+            interactive: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
+            use_readline: __dataclass__init__fields__3__annotation = __dataclass__init__fields__3__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'driver', driver)
-            __dataclass__object_setattr(self, 'interface', interface)
-            __dataclass__object_setattr(self, 'rendering', rendering)
+            __dataclass__object_setattr(self, 'enable_tools', enable_tools)
+            __dataclass__object_setattr(self, 'dangerous_no_tool_confirmation', dangerous_no_tool_confirmation)
+            __dataclass__object_setattr(self, 'interactive', interactive)
+            __dataclass__object_setattr(self, 'use_readline', use_readline)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -479,9 +610,10 @@ def _process_dataclass__103bad1f2af413714bd23ee2d6a5dffda2e6163d():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"driver={self.driver!r}")
-            parts.append(f"interface={self.interface!r}")
-            parts.append(f"rendering={self.rendering!r}")
+            parts.append(f"enable_tools={self.enable_tools!r}")
+            parts.append(f"dangerous_no_tool_confirmation={self.dangerous_no_tool_confirmation!r}")
+            parts.append(f"interactive={self.interactive!r}")
+            parts.append(f"use_readline={self.use_readline!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -498,35 +630,51 @@ def _process_dataclass__103bad1f2af413714bd23ee2d6a5dffda2e6163d():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('content', 'backend')), EqPlan(fields=('content', 'backend')), FrozenPlan(fields=("
-        "'content', 'backend'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('content', 'backend')"
-        ", cache=False), InitPlan(fields=(InitPlan.Field(name='content', annotation=OpRef(name='init.fields.0.annotatio"
-        "n'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None"
-        ", validate=None, check_type=None), InitPlan.Field(name='backend', annotation=OpRef(name='init.fields.1.annotat"
-        "ion'), default=OpRef(name='init.fields.1.default'), default_factory=None, init=True, override=False, field_typ"
-        "e=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('content',"
-        "), kw_only_params=('backend',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=())"
-        ", ReprPlan(fields=(ReprPlan.Field(name='content', kw_only=False, fn=None), ReprPlan.Field(name='backend', kw_o"
+        "Plans(tup=(CopyPlan(fields=('driver', 'facade', 'interface', 'rendering')), EqPlan(fields=('driver', 'facade',"
+        " 'interface', 'rendering')), FrozenPlan(fields=('driver', 'facade', 'interface', 'rendering'), allow_dynamic_d"
+        "under_attrs=False), HashPlan(action='add', fields=('driver', 'facade', 'interface', 'rendering'), cache=False)"
+        ", InitPlan(fields=(InitPlan.Field(name='driver', annotation=OpRef(name='init.fields.0.annotation'), default=Op"
+        "Ref(name='init.fields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTA"
+        "NCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='facade', annotation=OpRef(name='init.f"
+        "ields.1.annotation'), default=OpRef(name='init.fields.1.default'), default_factory=None, init=True, override=F"
+        "alse, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='interf"
+        "ace', 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, validate=None, check_type"
+        "=None), InitPlan.Field(name='rendering', annotation=OpRef(name='init.fields.3.annotation'), default=OpRef(name"
+        "='init.fields.3.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coe"
+        "rce=None, validate=None, check_type=None)), self_param='self', std_params=(), kw_only_params=('driver', 'facad"
+        "e', 'interface', 'rendering'), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()),"
+        " ReprPlan(fields=(ReprPlan.Field(name='driver', kw_only=True, fn=None), ReprPlan.Field(name='facade', kw_only="
+        "True, fn=None), ReprPlan.Field(name='interface', kw_only=True, fn=None), ReprPlan.Field(name='rendering', kw_o"
         "nly=True, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='010cef854496c65de48af9ea74be543fecd8bec1',
+    plan_repr_sha1='e6b40ac244fb47a1c6436b8775079bada9725246',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__default',
         '__dataclass__init__fields__1__annotation',
         '__dataclass__init__fields__1__default',
+        '__dataclass__init__fields__2__annotation',
+        '__dataclass__init__fields__2__default',
+        '__dataclass__init__fields__3__annotation',
+        '__dataclass__init__fields__3__default',
     ),
     cls_names=(
-        ('ommlds.cli.main', 'CompletionConfig'),
-        ('ommlds.cli.main', 'EmbeddingConfig'),
+        ('ommlds.cli.main', 'ChatConfig'),
     ),
 )
-def _process_dataclass__010cef854496c65de48af9ea74be543fecd8bec1():
+def _process_dataclass__e6b40ac244fb47a1c6436b8775079bada9725246():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__default,
         __dataclass__init__fields__1__annotation,
         __dataclass__init__fields__1__default,
+        __dataclass__init__fields__2__annotation,
+        __dataclass__init__fields__2__default,
+        __dataclass__init__fields__3__annotation,
+        __dataclass__init__fields__3__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -545,8 +693,10 @@ def _process_dataclass__010cef854496c65de48af9ea74be543fecd8bec1():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                content=self.content,
-                backend=self.backend,
+                driver=self.driver,
+                facade=self.facade,
+                interface=self.interface,
+                rendering=self.rendering,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -560,8 +710,10 @@ def _process_dataclass__010cef854496c65de48af9ea74be543fecd8bec1():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.content == other.content and
-                self.backend == other.backend
+                self.driver == other.driver and
+                self.facade == other.facade and
+                self.interface == other.interface and
+                self.rendering == other.rendering
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -570,8 +722,10 @@ def _process_dataclass__010cef854496c65de48af9ea74be543fecd8bec1():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'content',
-            'backend',
+            'driver',
+            'facade',
+            'interface',
+            'rendering',
         }
 
         def __setattr__(self, name, value):
@@ -588,8 +742,10 @@ def _process_dataclass__010cef854496c65de48af9ea74be543fecd8bec1():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'content',
-            'backend',
+            'driver',
+            'facade',
+            'interface',
+            'rendering',
         }
 
         def __delattr__(self, name):
@@ -607,8 +763,10 @@ def _process_dataclass__010cef854496c65de48af9ea74be543fecd8bec1():
 
         def __hash__(self):
             return hash((
-                self.content,
-                self.backend,
+                self.driver,
+                self.facade,
+                self.interface,
+                self.rendering,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -616,12 +774,16 @@ def _process_dataclass__010cef854496c65de48af9ea74be543fecd8bec1():
 
         def __init__(
             self,
-            content: __dataclass__init__fields__0__annotation,
             *,
-            backend: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
+            driver: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            facade: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
+            interface: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
+            rendering: __dataclass__init__fields__3__annotation = __dataclass__init__fields__3__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'content', content)
-            __dataclass__object_setattr(self, 'backend', backend)
+            __dataclass__object_setattr(self, 'driver', driver)
+            __dataclass__object_setattr(self, 'facade', facade)
+            __dataclass__object_setattr(self, 'interface', interface)
+            __dataclass__object_setattr(self, 'rendering', rendering)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -631,8 +793,10 @@ def _process_dataclass__010cef854496c65de48af9ea74be543fecd8bec1():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"content={self.content!r}")
-            parts.append(f"backend={self.backend!r}")
+            parts.append(f"driver={self.driver!r}")
+            parts.append(f"facade={self.facade!r}")
+            parts.append(f"interface={self.interface!r}")
+            parts.append(f"rendering={self.rendering!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -649,57 +813,35 @@ def _process_dataclass__010cef854496c65de48af9ea74be543fecd8bec1():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('ai', 'backend', 'state', 'tools', 'user')), EqPlan(fields=('ai', 'backend', 'stat"
-        "e', 'tools', 'user')), FrozenPlan(fields=('ai', 'backend', 'state', 'tools', 'user'), allow_dynamic_dunder_att"
-        "rs=False), HashPlan(action='add', fields=('ai', 'backend', 'state', 'tools', 'user'), cache=False), InitPlan(f"
-        "ields=(InitPlan.Field(name='ai', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init.f"
-        "ields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None"
+        "Plans(tup=(CopyPlan(fields=('content', 'backend')), EqPlan(fields=('content', 'backend')), FrozenPlan(fields=("
+        "'content', 'backend'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('content', 'backend')"
+        ", cache=False), InitPlan(fields=(InitPlan.Field(name='content', annotation=OpRef(name='init.fields.0.annotatio"
+        "n'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None"
         ", validate=None, check_type=None), InitPlan.Field(name='backend', annotation=OpRef(name='init.fields.1.annotat"
         "ion'), default=OpRef(name='init.fields.1.default'), default_factory=None, init=True, override=False, field_typ"
-        "e=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='state', annotation=Op"
-        "Ref(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, validate=None, check_type=None), InitPlan.Fi"
-        "eld(name='tools', annotation=OpRef(name='init.fields.3.annotation'), default=OpRef(name='init.fields.3.default"
-        "'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None"
-        ", check_type=None), InitPlan.Field(name='user', annotation=OpRef(name='init.fields.4.annotation'), default=OpR"
-        "ef(name='init.fields.4.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTAN"
-        "CE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=(), kw_only_params=('ai', 'ba"
-        "ckend', 'state', 'tools', 'user'), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns="
-        "()), ReprPlan(fields=(ReprPlan.Field(name='ai', kw_only=True, fn=None), ReprPlan.Field(name='backend', kw_only"
-        "=True, fn=None), ReprPlan.Field(name='state', kw_only=True, fn=None), ReprPlan.Field(name='tools', kw_only=Tru"
-        "e, fn=None), ReprPlan.Field(name='user', kw_only=True, fn=None)), id=False, terse=False, default_fn=None)))"
+        "e=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=(), kw_only"
+        "_params=('content', 'backend'), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=())"
+        ", ReprPlan(fields=(ReprPlan.Field(name='content', kw_only=True, fn=None), ReprPlan.Field(name='backend', kw_on"
+        "ly=True, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7',
+    plan_repr_sha1='3fffc5e71015066ea8ecac48620fe5be7ba69f26',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__default',
         '__dataclass__init__fields__1__annotation',
         '__dataclass__init__fields__1__default',
-        '__dataclass__init__fields__2__annotation',
-        '__dataclass__init__fields__2__default',
-        '__dataclass__init__fields__3__annotation',
-        '__dataclass__init__fields__3__default',
-        '__dataclass__init__fields__4__annotation',
-        '__dataclass__init__fields__4__default',
     ),
     cls_names=(
-        ('ommlds.cli.main', 'DriverConfig'),
+        ('ommlds.cli.main', 'CompletionConfig'),
+        ('ommlds.cli.main', 'EmbeddingConfig'),
     ),
 )
-def _process_dataclass__ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7():
+def _process_dataclass__3fffc5e71015066ea8ecac48620fe5be7ba69f26():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__default,
         __dataclass__init__fields__1__annotation,
         __dataclass__init__fields__1__default,
-        __dataclass__init__fields__2__annotation,
-        __dataclass__init__fields__2__default,
-        __dataclass__init__fields__3__annotation,
-        __dataclass__init__fields__3__default,
-        __dataclass__init__fields__4__annotation,
-        __dataclass__init__fields__4__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -718,11 +860,8 @@ def _process_dataclass__ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                ai=self.ai,
+                content=self.content,
                 backend=self.backend,
-                state=self.state,
-                tools=self.tools,
-                user=self.user,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -736,11 +875,8 @@ def _process_dataclass__ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.ai == other.ai and
-                self.backend == other.backend and
-                self.state == other.state and
-                self.tools == other.tools and
-                self.user == other.user
+                self.content == other.content and
+                self.backend == other.backend
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -749,11 +885,8 @@ def _process_dataclass__ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'ai',
+            'content',
             'backend',
-            'state',
-            'tools',
-            'user',
         }
 
         def __setattr__(self, name, value):
@@ -770,11 +903,8 @@ def _process_dataclass__ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'ai',
+            'content',
             'backend',
-            'state',
-            'tools',
-            'user',
         }
 
         def __delattr__(self, name):
@@ -792,11 +922,8 @@ def _process_dataclass__ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7():
 
         def __hash__(self):
             return hash((
-                self.ai,
+                self.content,
                 self.backend,
-                self.state,
-                self.tools,
-                self.user,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -805,17 +932,11 @@ def _process_dataclass__ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7():
         def __init__(
             self,
             *,
-            ai: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            content: __dataclass__init__fields__0__annotation,
             backend: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
-            state: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
-            tools: __dataclass__init__fields__3__annotation = __dataclass__init__fields__3__default,
-            user: __dataclass__init__fields__4__annotation = __dataclass__init__fields__4__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'ai', ai)
+            __dataclass__object_setattr(self, 'content', content)
             __dataclass__object_setattr(self, 'backend', backend)
-            __dataclass__object_setattr(self, 'state', state)
-            __dataclass__object_setattr(self, 'tools', tools)
-            __dataclass__object_setattr(self, 'user', user)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -825,11 +946,8 @@ def _process_dataclass__ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"ai={self.ai!r}")
+            parts.append(f"content={self.content!r}")
             parts.append(f"backend={self.backend!r}")
-            parts.append(f"state={self.state!r}")
-            parts.append(f"tools={self.tools!r}")
-            parts.append(f"user={self.user!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -846,31 +964,27 @@ def _process_dataclass__ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('interactive', 'use_textual', 'use_readline', 'enable_tools', 'dangerous_no_tool_c"
-        "onfirmation')), EqPlan(fields=('interactive', 'use_textual', 'use_readline', 'enable_tools', 'dangerous_no_too"
-        "l_confirmation')), FrozenPlan(fields=('interactive', 'use_textual', 'use_readline', 'enable_tools', 'dangerous"
-        "_no_tool_confirmation'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('interactive', 'use"
-        "_textual', 'use_readline', 'enable_tools', 'dangerous_no_tool_confirmation'), cache=False), InitPlan(fields=(I"
-        "nitPlan.Field(name='interactive', 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=Non"
-        "e, validate=None, check_type=None), InitPlan.Field(name='use_textual', annotation=OpRef(name='init.fields.1.an"
-        "notation'), default=OpRef(name='init.fields.1.default'), default_factory=None, init=True, override=False, fiel"
-        "d_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='use_readline', a"
-        "nnotation=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, validate=None, check_type=None),"
-        " InitPlan.Field(name='enable_tools', annotation=OpRef(name='init.fields.3.annotation'), default=OpRef(name='in"
-        "it.fields.3.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce="
-        "None, validate=None, check_type=None), InitPlan.Field(name='dangerous_no_tool_confirmation', annotation=OpRef("
-        "name='init.fields.4.annotation'), default=OpRef(name='init.fields.4.default'), default_factory=None, init=True"
-        ", override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='se"
-        "lf', std_params=(), kw_only_params=('interactive', 'use_textual', 'use_readline', 'enable_tools', 'dangerous_n"
-        "o_tool_confirmation'), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPla"
-        "n(fields=(ReprPlan.Field(name='interactive', kw_only=True, fn=None), ReprPlan.Field(name='use_textual', kw_onl"
-        "y=True, fn=None), ReprPlan.Field(name='use_readline', kw_only=True, fn=None), ReprPlan.Field(name='enable_tool"
-        "s', kw_only=True, fn=None), ReprPlan.Field(name='dangerous_no_tool_confirmation', kw_only=True, fn=None)), id="
-        "False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('ai', 'backend', 'state', 'tools', 'user')), EqPlan(fields=('ai', 'backend', 'stat"
+        "e', 'tools', 'user')), FrozenPlan(fields=('ai', 'backend', 'state', 'tools', 'user'), allow_dynamic_dunder_att"
+        "rs=False), HashPlan(action='add', fields=('ai', 'backend', 'state', 'tools', 'user'), cache=False), InitPlan(f"
+        "ields=(InitPlan.Field(name='ai', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init.f"
+        "ields.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None"
+        ", validate=None, check_type=None), InitPlan.Field(name='backend', annotation=OpRef(name='init.fields.1.annotat"
+        "ion'), default=OpRef(name='init.fields.1.default'), default_factory=None, init=True, override=False, field_typ"
+        "e=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='state', annotation=Op"
+        "Ref(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, validate=None, check_type=None), InitPlan.Fi"
+        "eld(name='tools', annotation=OpRef(name='init.fields.3.annotation'), default=OpRef(name='init.fields.3.default"
+        "'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None"
+        ", check_type=None), InitPlan.Field(name='user', annotation=OpRef(name='init.fields.4.annotation'), default=OpR"
+        "ef(name='init.fields.4.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTAN"
+        "CE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=(), kw_only_params=('ai', 'ba"
+        "ckend', 'state', 'tools', 'user'), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns="
+        "()), ReprPlan(fields=(ReprPlan.Field(name='ai', kw_only=True, fn=None), ReprPlan.Field(name='backend', kw_only"
+        "=True, fn=None), ReprPlan.Field(name='state', kw_only=True, fn=None), ReprPlan.Field(name='tools', kw_only=Tru"
+        "e, fn=None), ReprPlan.Field(name='user', kw_only=True, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='2ac54f7b23a3729b83684d53c78e05f4c2d354f2',
+    plan_repr_sha1='ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__default',
@@ -884,10 +998,10 @@ def _process_dataclass__ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7():
         '__dataclass__init__fields__4__default',
     ),
     cls_names=(
-        ('ommlds.cli.main', 'InterfaceConfig'),
+        ('ommlds.cli.main', 'DriverConfig'),
     ),
 )
-def _process_dataclass__2ac54f7b23a3729b83684d53c78e05f4c2d354f2():
+def _process_dataclass__ccc522b0563e76033e8f2d3b6864b8a7c48c0fb7():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -919,11 +1033,11 @@ def _process_dataclass__2ac54f7b23a3729b83684d53c78e05f4c2d354f2():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                interactive=self.interactive,
-                use_textual=self.use_textual,
-                use_readline=self.use_readline,
-                enable_tools=self.enable_tools,
-                dangerous_no_tool_confirmation=self.dangerous_no_tool_confirmation,
+                ai=self.ai,
+                backend=self.backend,
+                state=self.state,
+                tools=self.tools,
+                user=self.user,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -937,11 +1051,11 @@ def _process_dataclass__2ac54f7b23a3729b83684d53c78e05f4c2d354f2():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.interactive == other.interactive and
-                self.use_textual == other.use_textual and
-                self.use_readline == other.use_readline and
-                self.enable_tools == other.enable_tools and
-                self.dangerous_no_tool_confirmation == other.dangerous_no_tool_confirmation
+                self.ai == other.ai and
+                self.backend == other.backend and
+                self.state == other.state and
+                self.tools == other.tools and
+                self.user == other.user
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -950,11 +1064,11 @@ def _process_dataclass__2ac54f7b23a3729b83684d53c78e05f4c2d354f2():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'interactive',
-            'use_textual',
-            'use_readline',
-            'enable_tools',
-            'dangerous_no_tool_confirmation',
+            'ai',
+            'backend',
+            'state',
+            'tools',
+            'user',
         }
 
         def __setattr__(self, name, value):
@@ -971,11 +1085,11 @@ def _process_dataclass__2ac54f7b23a3729b83684d53c78e05f4c2d354f2():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'interactive',
-            'use_textual',
-            'use_readline',
-            'enable_tools',
-            'dangerous_no_tool_confirmation',
+            'ai',
+            'backend',
+            'state',
+            'tools',
+            'user',
         }
 
         def __delattr__(self, name):
@@ -993,11 +1107,11 @@ def _process_dataclass__2ac54f7b23a3729b83684d53c78e05f4c2d354f2():
 
         def __hash__(self):
             return hash((
-                self.interactive,
-                self.use_textual,
-                self.use_readline,
-                self.enable_tools,
-                self.dangerous_no_tool_confirmation,
+                self.ai,
+                self.backend,
+                self.state,
+                self.tools,
+                self.user,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1006,17 +1120,17 @@ def _process_dataclass__2ac54f7b23a3729b83684d53c78e05f4c2d354f2():
         def __init__(
             self,
             *,
-            interactive: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
-            use_textual: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
-            use_readline: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
-            enable_tools: __dataclass__init__fields__3__annotation = __dataclass__init__fields__3__default,
-            dangerous_no_tool_confirmation: __dataclass__init__fields__4__annotation = __dataclass__init__fields__4__default,
+            ai: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            backend: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
+            state: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
+            tools: __dataclass__init__fields__3__annotation = __dataclass__init__fields__3__default,
+            user: __dataclass__init__fields__4__annotation = __dataclass__init__fields__4__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'interactive', interactive)
-            __dataclass__object_setattr(self, 'use_textual', use_textual)
-            __dataclass__object_setattr(self, 'use_readline', use_readline)
-            __dataclass__object_setattr(self, 'enable_tools', enable_tools)
-            __dataclass__object_setattr(self, 'dangerous_no_tool_confirmation', dangerous_no_tool_confirmation)
+            __dataclass__object_setattr(self, 'ai', ai)
+            __dataclass__object_setattr(self, 'backend', backend)
+            __dataclass__object_setattr(self, 'state', state)
+            __dataclass__object_setattr(self, 'tools', tools)
+            __dataclass__object_setattr(self, 'user', user)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1026,11 +1140,11 @@ def _process_dataclass__2ac54f7b23a3729b83684d53c78e05f4c2d354f2():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"interactive={self.interactive!r}")
-            parts.append(f"use_textual={self.use_textual!r}")
-            parts.append(f"use_readline={self.use_readline!r}")
-            parts.append(f"enable_tools={self.enable_tools!r}")
-            parts.append(f"dangerous_no_tool_confirmation={self.dangerous_no_tool_confirmation!r}")
+            parts.append(f"ai={self.ai!r}")
+            parts.append(f"backend={self.backend!r}")
+            parts.append(f"state={self.state!r}")
+            parts.append(f"tools={self.tools!r}")
+            parts.append(f"user={self.user!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1047,29 +1161,39 @@ def _process_dataclass__2ac54f7b23a3729b83684d53c78e05f4c2d354f2():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('markdown',)), EqPlan(fields=('markdown',)), FrozenPlan(fields=('markdown',), allo"
-        "w_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('markdown',), cache=False), InitPlan(fields=(Ini"
-        "tPlan.Field(name='markdown', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init.field"
-        "s.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, va"
-        "lidate=None, check_type=None),), self_param='self', std_params=(), kw_only_params=('markdown',), frozen=True, "
-        "slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='markd"
-        "own', kw_only=True, fn=None),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('enable_tools', 'dangerous_no_tool_confirmation')), EqPlan(fields=('enable_tools',"
+        " 'dangerous_no_tool_confirmation')), FrozenPlan(fields=('enable_tools', 'dangerous_no_tool_confirmation'), all"
+        "ow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('enable_tools', 'dangerous_no_tool_confirmation"
+        "'), cache=False), InitPlan(fields=(InitPlan.Field(name='enable_tools', annotation=OpRef(name='init.fields.0.an"
+        "notation'), default=OpRef(name='init.fields.0.default'), default_factory=None, init=True, override=False, fiel"
+        "d_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='dangerous_no_too"
+        "l_confirmation', annotation=OpRef(name='init.fields.1.annotation'), default=OpRef(name='init.fields.1.default'"
+        "), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None,"
+        " check_type=None)), self_param='self', std_params=(), kw_only_params=('enable_tools', 'dangerous_no_tool_confi"
+        "rmation'), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(Re"
+        "prPlan.Field(name='enable_tools', kw_only=True, fn=None), ReprPlan.Field(name='dangerous_no_tool_confirmation'"
+        ", kw_only=True, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='254623427d52b86f69ed60d24a0e95b0b1b391ca',
+    plan_repr_sha1='d65d18393f357ae0fb02bb80268c6f1473462613',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__default',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__1__default',
     ),
     cls_names=(
-        ('ommlds.cli.main', 'RenderingConfig'),
+        ('ommlds.cli.main', 'InterfaceConfig'),
+        ('ommlds.cli.main', 'TextualInterfaceConfig'),
     ),
 )
-def _process_dataclass__254623427d52b86f69ed60d24a0e95b0b1b391ca():
+def _process_dataclass__d65d18393f357ae0fb02bb80268c6f1473462613():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
         __dataclass__init__fields__0__default,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__1__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1088,7 +1212,8 @@ def _process_dataclass__254623427d52b86f69ed60d24a0e95b0b1b391ca():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                markdown=self.markdown,
+                enable_tools=self.enable_tools,
+                dangerous_no_tool_confirmation=self.dangerous_no_tool_confirmation,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1102,7 +1227,8 @@ def _process_dataclass__254623427d52b86f69ed60d24a0e95b0b1b391ca():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.markdown == other.markdown
+                self.enable_tools == other.enable_tools and
+                self.dangerous_no_tool_confirmation == other.dangerous_no_tool_confirmation
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1111,7 +1237,8 @@ def _process_dataclass__254623427d52b86f69ed60d24a0e95b0b1b391ca():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'markdown',
+            'enable_tools',
+            'dangerous_no_tool_confirmation',
         }
 
         def __setattr__(self, name, value):
@@ -1128,7 +1255,8 @@ def _process_dataclass__254623427d52b86f69ed60d24a0e95b0b1b391ca():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'markdown',
+            'enable_tools',
+            'dangerous_no_tool_confirmation',
         }
 
         def __delattr__(self, name):
@@ -1146,7 +1274,8 @@ def _process_dataclass__254623427d52b86f69ed60d24a0e95b0b1b391ca():
 
         def __hash__(self):
             return hash((
-                self.markdown,
+                self.enable_tools,
+                self.dangerous_no_tool_confirmation,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1155,9 +1284,11 @@ def _process_dataclass__254623427d52b86f69ed60d24a0e95b0b1b391ca():
         def __init__(
             self,
             *,
-            markdown: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            enable_tools: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            dangerous_no_tool_confirmation: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'markdown', markdown)
+            __dataclass__object_setattr(self, 'enable_tools', enable_tools)
+            __dataclass__object_setattr(self, 'dangerous_no_tool_confirmation', dangerous_no_tool_confirmation)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1167,7 +1298,8 @@ def _process_dataclass__254623427d52b86f69ed60d24a0e95b0b1b391ca():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"markdown={self.markdown!r}")
+            parts.append(f"enable_tools={self.enable_tools!r}")
+            parts.append(f"dangerous_no_tool_confirmation={self.dangerous_no_tool_confirmation!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1184,23 +1316,29 @@ def _process_dataclass__254623427d52b86f69ed60d24a0e95b0b1b391ca():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=()), EqPlan(fields=()), FrozenPlan(fields=('configurable_cls',), allow_dynamic_dund"
-        "er_attrs=False), HashPlan(action='add', fields=(), cache=False), InitPlan(fields=(InitPlan.Field(name='configu"
-        "rable_cls', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, "
-        "override=False, field_type=FieldType.CLASS_VAR, coerce=None, validate=None, check_type=None),), self_param='se"
-        "lf', std_params=(), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_"
-        "fns=()), ReprPlan(fields=(), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('markdown',)), EqPlan(fields=('markdown',)), FrozenPlan(fields=('markdown',), allo"
+        "w_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('markdown',), cache=False), InitPlan(fields=(Ini"
+        "tPlan.Field(name='markdown', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init.field"
+        "s.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, va"
+        "lidate=None, check_type=None),), self_param='self', std_params=(), kw_only_params=('markdown',), frozen=True, "
+        "slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='markd"
+        "own', kw_only=True, fn=None),), id=False, terse=False, default_fn=None)))"
+    ),
+    plan_repr_sha1='254623427d52b86f69ed60d24a0e95b0b1b391ca',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__default',
     ),
-    plan_repr_sha1='d76e197a98f6f128efdad4ad19e3e15bf64e6652',
-    op_ref_idents=(),
     cls_names=(
-        ('ommlds.cli.main', 'Session.Config'),
+        ('ommlds.cli.main', 'RenderingConfig'),
     ),
 )
-def _process_dataclass__d76e197a98f6f128efdad4ad19e3e15bf64e6652():
+def _process_dataclass__254623427d52b86f69ed60d24a0e95b0b1b391ca():
     def _process_dataclass(
         *,
         __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1218,7 +1356,9 @@ def _process_dataclass__d76e197a98f6f128efdad4ad19e3e15bf64e6652():
         def __copy__(self):
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
-            return __dataclass__cls()  # noqa
+            return __dataclass__cls(  # noqa
+                markdown=self.markdown,
+            )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
         if '__copy__' in __dataclass__cls.__dict__:
@@ -1230,7 +1370,9 @@ def _process_dataclass__d76e197a98f6f128efdad4ad19e3e15bf64e6652():
                 return True
             if self.__class__ is not other.__class__:
                 return NotImplemented
-            return True
+            return (
+                self.markdown == other.markdown
+            )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
         if '__eq__' in __dataclass__cls.__dict__:
@@ -1238,7 +1380,7 @@ def _process_dataclass__d76e197a98f6f128efdad4ad19e3e15bf64e6652():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'configurable_cls',
+            'markdown',
         }
 
         def __setattr__(self, name, value):
@@ -1255,7 +1397,7 @@ def _process_dataclass__d76e197a98f6f128efdad4ad19e3e15bf64e6652():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'configurable_cls',
+            'markdown',
         }
 
         def __delattr__(self, name):
@@ -1272,15 +1414,19 @@ def _process_dataclass__d76e197a98f6f128efdad4ad19e3e15bf64e6652():
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
         def __hash__(self):
-            return hash(())
+            return hash((
+                self.markdown,
+            ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
         setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
+            *,
+            markdown: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
         ) -> __dataclass__None:
-            pass
+            __dataclass__object_setattr(self, 'markdown', markdown)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1290,6 +1436,7 @@ def _process_dataclass__d76e197a98f6f128efdad4ad19e3e15bf64e6652():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
+            parts.append(f"markdown={self.markdown!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1306,29 +1453,36 @@ def _process_dataclass__d76e197a98f6f128efdad4ad19e3e15bf64e6652():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('state',)), EqPlan(fields=('state',)), FrozenPlan(fields=('state',), allow_dynamic"
-        "_dunder_attrs=False), HashPlan(action='add', fields=('state',), cache=False), InitPlan(fields=(InitPlan.Field("
-        "name='state', 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=None, validate=None, ch"
-        "eck_type=None),), self_param='self', std_params=(), kw_only_params=('state',), frozen=True, slots=False, post_"
-        "init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='state', kw_only=True, f"
-        "n=None),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('state', 'chat_id')), EqPlan(fields=('state', 'chat_id')), FrozenPlan(fields=('sta"
+        "te', 'chat_id'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('state', 'chat_id'), cache="
+        "False), InitPlan(fields=(InitPlan.Field(name='state', 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=None, validate=None, check_type=None), InitPlan.Field(name='chat_id', annotation=OpRef(name='"
+        "init.fields.1.annotation'), default=OpRef(name='init.fields.1.default'), default_factory=None, init=True, over"
+        "ride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', s"
+        "td_params=(), kw_only_params=('state', 'chat_id'), frozen=True, slots=False, post_init_params=None, init_fns=("
+        "), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='state', kw_only=True, fn=None), ReprPlan.Field(name"
+        "='chat_id', kw_only=True, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='ecd4e8fdaa04b3fa64e0c01eea919a83fc862e6a',
+    plan_repr_sha1='76648be4a999973a966584081092052c01632d85',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__default',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__1__default',
     ),
     cls_names=(
         ('ommlds.cli.main', 'StateConfig'),
     ),
 )
-def _process_dataclass__ecd4e8fdaa04b3fa64e0c01eea919a83fc862e6a():
+def _process_dataclass__76648be4a999973a966584081092052c01632d85():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
         __dataclass__init__fields__0__default,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__1__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1348,6 +1502,7 @@ def _process_dataclass__ecd4e8fdaa04b3fa64e0c01eea919a83fc862e6a():
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
                 state=self.state,
+                chat_id=self.chat_id,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1361,7 +1516,8 @@ def _process_dataclass__ecd4e8fdaa04b3fa64e0c01eea919a83fc862e6a():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.state == other.state
+                self.state == other.state and
+                self.chat_id == other.chat_id
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1371,6 +1527,7 @@ def _process_dataclass__ecd4e8fdaa04b3fa64e0c01eea919a83fc862e6a():
 
         __dataclass___setattr_frozen_fields = {
             'state',
+            'chat_id',
         }
 
         def __setattr__(self, name, value):
@@ -1388,6 +1545,7 @@ def _process_dataclass__ecd4e8fdaa04b3fa64e0c01eea919a83fc862e6a():
 
         __dataclass___delattr_frozen_fields = {
             'state',
+            'chat_id',
         }
 
         def __delattr__(self, name):
@@ -1406,6 +1564,7 @@ def _process_dataclass__ecd4e8fdaa04b3fa64e0c01eea919a83fc862e6a():
         def __hash__(self):
             return hash((
                 self.state,
+                self.chat_id,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1415,8 +1574,10 @@ def _process_dataclass__ecd4e8fdaa04b3fa64e0c01eea919a83fc862e6a():
             self,
             *,
             state: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            chat_id: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
         ) -> __dataclass__None:
             __dataclass__object_setattr(self, 'state', state)
+            __dataclass__object_setattr(self, 'chat_id', chat_id)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1427,6 +1588,7 @@ def _process_dataclass__ecd4e8fdaa04b3fa64e0c01eea919a83fc862e6a():
         def __repr__(self):
             parts = []
             parts.append(f"state={self.state!r}")
+            parts.append(f"chat_id={self.chat_id!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1443,24 +1605,37 @@ def _process_dataclass__ecd4e8fdaa04b3fa64e0c01eea919a83fc862e6a():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=()), EqPlan(fields=()), FrozenPlan(fields=(), allow_dynamic_dunder_attrs=False), Ha"
-        "shPlan(action='add', fields=(), cache=False), InitPlan(fields=(), self_param='self', std_params=(), kw_only_pa"
-        "rams=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(), i"
-        "d=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('enabled_tools', 'verbose')), EqPlan(fields=('enabled_tools', 'verbose')), FrozenP"
+        "lan(fields=('enabled_tools', 'verbose'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('en"
+        "abled_tools', 'verbose'), cache=False), InitPlan(fields=(InitPlan.Field(name='enabled_tools', 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=None, validate=None, check_type=None), InitPlan.Field"
+        "(name='verbose', annotation=OpRef(name='init.fields.1.annotation'), default=OpRef(name='init.fields.1.default'"
+        "), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None,"
+        " check_type=None)), self_param='self', std_params=(), kw_only_params=('enabled_tools', 'verbose'), frozen=True"
+        ", slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='ena"
+        "bled_tools', kw_only=True, fn=None), ReprPlan.Field(name='verbose', kw_only=True, fn=None)), id=False, terse=F"
+        "alse, default_fn=None)))"
+    ),
+    plan_repr_sha1='aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__default',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__1__default',
     ),
-    plan_repr_sha1='e1f7edfe11f2b721d6a656c46e698fedc95461bb',
-    op_ref_idents=(),
     cls_names=(
-        ('ommlds.cli.main', 'ToolSetConfig'),
-        ('ommlds.cli.sessions.chat.drivers.tools.fs.configs', 'FsToolSetConfig'),
-        ('ommlds.cli.sessions.chat.drivers.tools.todo.configs', 'TodoToolSetConfig'),
-        ('ommlds.cli.sessions.chat.drivers.tools.weather.configs', 'WeatherToolSetConfig'),
+        ('ommlds.cli.main', 'ToolsConfig'),
     ),
 )
-def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
+def _process_dataclass__aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42():
     def _process_dataclass(
         *,
         __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__default,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__1__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1478,8 +1653,11 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
         def __copy__(self):
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
-            return __dataclass__cls()  # noqa
-
+            return __dataclass__cls(  # noqa
+                enabled_tools=self.enabled_tools,
+                verbose=self.verbose,
+            )
+
         __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__}")
@@ -1490,16 +1668,25 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
                 return True
             if self.__class__ is not other.__class__:
                 return NotImplemented
-            return True
+            return (
+                self.enabled_tools == other.enabled_tools and
+                self.verbose == other.verbose
+            )
 
         __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 = {
+            'enabled_tools',
+            'verbose',
+        }
+
         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)
@@ -1509,9 +1696,15 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
+        __dataclass___delattr_frozen_fields = {
+            'enabled_tools',
+            'verbose',
+        }
+
         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)
@@ -1522,15 +1715,22 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
         def __hash__(self):
-            return hash(())
+            return hash((
+                self.enabled_tools,
+                self.verbose,
+            ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
         setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
+            *,
+            enabled_tools: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            verbose: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
         ) -> __dataclass__None:
-            pass
+            __dataclass__object_setattr(self, 'enabled_tools', enabled_tools)
+            __dataclass__object_setattr(self, 'verbose', verbose)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1540,6 +1740,8 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
+            parts.append(f"enabled_tools={self.enabled_tools!r}")
+            parts.append(f"verbose={self.verbose!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1556,19 +1758,20 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('enabled_tools', 'verbose')), EqPlan(fields=('enabled_tools', 'verbose')), FrozenP"
-        "lan(fields=('enabled_tools', 'verbose'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('en"
-        "abled_tools', 'verbose'), cache=False), InitPlan(fields=(InitPlan.Field(name='enabled_tools', 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=None, validate=None, check_type=None), InitPlan.Field"
-        "(name='verbose', annotation=OpRef(name='init.fields.1.annotation'), default=OpRef(name='init.fields.1.default'"
+        "Plans(tup=(CopyPlan(fields=('initial_system_content', 'initial_user_content')), EqPlan(fields=('initial_system"
+        "_content', 'initial_user_content')), FrozenPlan(fields=('initial_system_content', 'initial_user_content'), all"
+        "ow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('initial_system_content', 'initial_user_content"
+        "'), cache=False), InitPlan(fields=(InitPlan.Field(name='initial_system_content', annotation=OpRef(name='init.f"
+        "ields.0.annotation'), default=OpRef(name='init.fields.0.default'), default_factory=None, init=True, override=F"
+        "alse, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='initia"
+        "l_user_content', annotation=OpRef(name='init.fields.1.annotation'), default=OpRef(name='init.fields.1.default'"
         "), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None,"
-        " check_type=None)), self_param='self', std_params=(), kw_only_params=('enabled_tools', 'verbose'), frozen=True"
-        ", slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='ena"
-        "bled_tools', kw_only=True, fn=None), ReprPlan.Field(name='verbose', kw_only=True, fn=None)), id=False, terse=F"
-        "alse, default_fn=None)))"
+        " check_type=None)), self_param='self', std_params=(), kw_only_params=('initial_system_content', 'initial_user_"
+        "content'), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(Re"
+        "prPlan.Field(name='initial_system_content', kw_only=True, fn=None), ReprPlan.Field(name='initial_user_content'"
+        ", kw_only=True, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42',
+    plan_repr_sha1='55eb2b38eb7d4e32f3a9306577040632e1c376fb',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__default',
@@ -1576,10 +1779,10 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
         '__dataclass__init__fields__1__default',
     ),
     cls_names=(
-        ('ommlds.cli.main', 'ToolsConfig'),
+        ('ommlds.cli.main', 'UserConfig'),
     ),
 )
-def _process_dataclass__aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42():
+def _process_dataclass__55eb2b38eb7d4e32f3a9306577040632e1c376fb():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -1605,8 +1808,8 @@ def _process_dataclass__aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                enabled_tools=self.enabled_tools,
-                verbose=self.verbose,
+                initial_system_content=self.initial_system_content,
+                initial_user_content=self.initial_user_content,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1620,8 +1823,8 @@ def _process_dataclass__aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.enabled_tools == other.enabled_tools and
-                self.verbose == other.verbose
+                self.initial_system_content == other.initial_system_content and
+                self.initial_user_content == other.initial_user_content
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1630,8 +1833,8 @@ def _process_dataclass__aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'enabled_tools',
-            'verbose',
+            'initial_system_content',
+            'initial_user_content',
         }
 
         def __setattr__(self, name, value):
@@ -1648,8 +1851,8 @@ def _process_dataclass__aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'enabled_tools',
-            'verbose',
+            'initial_system_content',
+            'initial_user_content',
         }
 
         def __delattr__(self, name):
@@ -1667,8 +1870,8 @@ def _process_dataclass__aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42():
 
         def __hash__(self):
             return hash((
-                self.enabled_tools,
-                self.verbose,
+                self.initial_system_content,
+                self.initial_user_content,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1677,11 +1880,11 @@ def _process_dataclass__aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42():
         def __init__(
             self,
             *,
-            enabled_tools: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
-            verbose: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
+            initial_system_content: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            initial_user_content: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'enabled_tools', enabled_tools)
-            __dataclass__object_setattr(self, 'verbose', verbose)
+            __dataclass__object_setattr(self, 'initial_system_content', initial_system_content)
+            __dataclass__object_setattr(self, 'initial_user_content', initial_user_content)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1691,8 +1894,8 @@ def _process_dataclass__aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"enabled_tools={self.enabled_tools!r}")
-            parts.append(f"verbose={self.verbose!r}")
+            parts.append(f"initial_system_content={self.initial_system_content!r}")
+            parts.append(f"initial_user_content={self.initial_user_content!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1709,38 +1912,27 @@ def _process_dataclass__aa22ff44ed3bf3e31aaa2841f61d3f7175c85c42():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('initial_system_content', 'initial_user_content')), EqPlan(fields=('initial_system"
-        "_content', 'initial_user_content')), FrozenPlan(fields=('initial_system_content', 'initial_user_content'), all"
-        "ow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('initial_system_content', 'initial_user_content"
-        "'), cache=False), InitPlan(fields=(InitPlan.Field(name='initial_system_content', annotation=OpRef(name='init.f"
-        "ields.0.annotation'), default=OpRef(name='init.fields.0.default'), default_factory=None, init=True, override=F"
-        "alse, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='initia"
-        "l_user_content', annotation=OpRef(name='init.fields.1.annotation'), default=OpRef(name='init.fields.1.default'"
-        "), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None,"
-        " check_type=None)), self_param='self', std_params=(), kw_only_params=('initial_system_content', 'initial_user_"
-        "content'), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(Re"
-        "prPlan.Field(name='initial_system_content', kw_only=True, fn=None), ReprPlan.Field(name='initial_user_content'"
-        ", kw_only=True, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('delta',)), EqPlan(fields=('delta',)), FrozenPlan(fields=('delta',), allow_dynamic"
+        "_dunder_attrs=False), HashPlan(action='add', fields=('delta',), cache=False), InitPlan(fields=(InitPlan.Field("
+        "name='delta', 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='s"
+        "elf', std_params=('delta',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), "
+        "validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='delta', kw_only=False, fn=None),), id=False, terse=Fal"
+        "se, default_fn=None)))"
     ),
-    plan_repr_sha1='55eb2b38eb7d4e32f3a9306577040632e1c376fb',
+    plan_repr_sha1='aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__default',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__1__default',
     ),
     cls_names=(
-        ('ommlds.cli.main', 'UserConfig'),
+        ('ommlds.cli.sessions.chat.drivers.driver', 'AiDeltaChatEvent'),
     ),
 )
-def _process_dataclass__55eb2b38eb7d4e32f3a9306577040632e1c376fb():
+def _process_dataclass__aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__default,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__1__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1759,8 +1951,7 @@ def _process_dataclass__55eb2b38eb7d4e32f3a9306577040632e1c376fb():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                initial_system_content=self.initial_system_content,
-                initial_user_content=self.initial_user_content,
+                delta=self.delta,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1774,8 +1965,7 @@ def _process_dataclass__55eb2b38eb7d4e32f3a9306577040632e1c376fb():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.initial_system_content == other.initial_system_content and
-                self.initial_user_content == other.initial_user_content
+                self.delta == other.delta
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1784,8 +1974,7 @@ def _process_dataclass__55eb2b38eb7d4e32f3a9306577040632e1c376fb():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'initial_system_content',
-            'initial_user_content',
+            'delta',
         }
 
         def __setattr__(self, name, value):
@@ -1802,8 +1991,7 @@ def _process_dataclass__55eb2b38eb7d4e32f3a9306577040632e1c376fb():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'initial_system_content',
-            'initial_user_content',
+            'delta',
         }
 
         def __delattr__(self, name):
@@ -1821,8 +2009,7 @@ def _process_dataclass__55eb2b38eb7d4e32f3a9306577040632e1c376fb():
 
         def __hash__(self):
             return hash((
-                self.initial_system_content,
-                self.initial_user_content,
+                self.delta,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1830,12 +2017,9 @@ def _process_dataclass__55eb2b38eb7d4e32f3a9306577040632e1c376fb():
 
         def __init__(
             self,
-            *,
-            initial_system_content: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
-            initial_user_content: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
+            delta: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'initial_system_content', initial_system_content)
-            __dataclass__object_setattr(self, 'initial_user_content', initial_user_content)
+            __dataclass__object_setattr(self, 'delta', delta)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1845,8 +2029,7 @@ def _process_dataclass__55eb2b38eb7d4e32f3a9306577040632e1c376fb():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"initial_system_content={self.initial_system_content!r}")
-            parts.append(f"initial_user_content={self.initial_user_content!r}")
+            parts.append(f"delta={self.delta!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1863,23 +2046,24 @@ def _process_dataclass__55eb2b38eb7d4e32f3a9306577040632e1c376fb():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('delta',)), EqPlan(fields=('delta',)), FrozenPlan(fields=('delta',), allow_dynamic"
-        "_dunder_attrs=False), HashPlan(action='add', fields=('delta',), cache=False), InitPlan(fields=(InitPlan.Field("
-        "name='delta', 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='s"
-        "elf', std_params=('delta',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), "
-        "validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='delta', kw_only=False, fn=None),), id=False, terse=Fal"
-        "se, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('chat',)), EqPlan(fields=('chat',)), FrozenPlan(fields=('chat',), allow_dynamic_du"
+        "nder_attrs=False), HashPlan(action='add', fields=('chat',), cache=False), InitPlan(fields=(InitPlan.Field(name"
+        "='chat', 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=('chat',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
+        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='chat', kw_only=False, fn=None),), id=False, terse=False, def"
+        "ault_fn=None)))"
     ),
-    plan_repr_sha1='aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f',
+    plan_repr_sha1='b211fde543b7c2c533cdcf9f21b47d2f7f76e5c9',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('ommlds.cli.sessions.chat.drivers.driver', 'AiDeltaChatEvent'),
+        ('ommlds.cli.sessions.chat.drivers.driver', 'AiMessagesChatEvent'),
+        ('ommlds.cli.sessions.chat.drivers.driver', 'UserMessagesChatEvent'),
     ),
 )
-def _process_dataclass__aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f():
+def _process_dataclass__b211fde543b7c2c533cdcf9f21b47d2f7f76e5c9():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -1902,7 +2086,7 @@ def _process_dataclass__aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                delta=self.delta,
+                chat=self.chat,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1916,7 +2100,7 @@ def _process_dataclass__aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.delta == other.delta
+                self.chat == other.chat
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1925,7 +2109,7 @@ def _process_dataclass__aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'delta',
+            'chat',
         }
 
         def __setattr__(self, name, value):
@@ -1942,7 +2126,7 @@ def _process_dataclass__aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'delta',
+            'chat',
         }
 
         def __delattr__(self, name):
@@ -1960,7 +2144,7 @@ def _process_dataclass__aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f():
 
         def __hash__(self):
             return hash((
-                self.delta,
+                self.chat,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1968,9 +2152,9 @@ def _process_dataclass__aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f():
 
         def __init__(
             self,
-            delta: __dataclass__init__fields__0__annotation,
+            chat: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'delta', delta)
+            __dataclass__object_setattr(self, 'chat', chat)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1980,7 +2164,7 @@ def _process_dataclass__aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"delta={self.delta!r}")
+            parts.append(f"chat={self.chat!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1997,24 +2181,24 @@ def _process_dataclass__aff24d9a92d53ba94dacb7fb303b9eb4ebd0763f():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('chat',)), EqPlan(fields=('chat',)), FrozenPlan(fields=('chat',), allow_dynamic_du"
-        "nder_attrs=False), HashPlan(action='add', fields=('chat',), cache=False), InitPlan(fields=(InitPlan.Field(name"
-        "='chat', 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=('chat',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
-        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='chat', kw_only=False, fn=None),), id=False, terse=False, def"
-        "ault_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('v',)), EqPlan(fields=('v',)), FrozenPlan(fields=('v',), allow_dynamic_dunder_attr"
+        "s=False), HashPlan(action='add', fields=('v',), cache=False), InitPlan(fields=(InitPlan.Field(name='v', 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=('v"
+        "',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPl"
+        "an(fields=(ReprPlan.Field(name='v', kw_only=False, fn=None),), id=False, terse=True, default_fn=None)))"
     ),
-    plan_repr_sha1='b211fde543b7c2c533cdcf9f21b47d2f7f76e5c9',
+    plan_repr_sha1='3576262424b3ef8ff20966fa3744e5dba9a2ae7d',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('ommlds.cli.sessions.chat.drivers.driver', 'AiMessagesChatEvent'),
-        ('ommlds.cli.sessions.chat.drivers.driver', 'UserMessagesChatEvent'),
+        ('ommlds.cli.sessions.chat.drivers.driver', 'ChatId'),
+        ('ommlds.cli.sessions.chat.drivers.state.ids', 'ChatStateStorageKey'),
+        ('ommlds.cli.sessions.chat.drivers.types', 'ChatDriverId'),
     ),
 )
-def _process_dataclass__b211fde543b7c2c533cdcf9f21b47d2f7f76e5c9():
+def _process_dataclass__3576262424b3ef8ff20966fa3744e5dba9a2ae7d():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -2037,7 +2221,7 @@ def _process_dataclass__b211fde543b7c2c533cdcf9f21b47d2f7f76e5c9():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                chat=self.chat,
+                v=self.v,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2051,7 +2235,7 @@ def _process_dataclass__b211fde543b7c2c533cdcf9f21b47d2f7f76e5c9():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.chat == other.chat
+                self.v == other.v
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2060,7 +2244,7 @@ def _process_dataclass__b211fde543b7c2c533cdcf9f21b47d2f7f76e5c9():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'chat',
+            'v',
         }
 
         def __setattr__(self, name, value):
@@ -2077,7 +2261,7 @@ def _process_dataclass__b211fde543b7c2c533cdcf9f21b47d2f7f76e5c9():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'chat',
+            'v',
         }
 
         def __delattr__(self, name):
@@ -2095,7 +2279,7 @@ def _process_dataclass__b211fde543b7c2c533cdcf9f21b47d2f7f76e5c9():
 
         def __hash__(self):
             return hash((
-                self.chat,
+                self.v,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -2103,9 +2287,9 @@ def _process_dataclass__b211fde543b7c2c533cdcf9f21b47d2f7f76e5c9():
 
         def __init__(
             self,
-            chat: __dataclass__init__fields__0__annotation,
+            v: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'chat', chat)
+            __dataclass__object_setattr(self, 'v', v)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2115,7 +2299,7 @@ def _process_dataclass__b211fde543b7c2c533cdcf9f21b47d2f7f76e5c9():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"chat={self.chat!r}")
+            parts.append(f"{self.v!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2474,32 +2658,47 @@ def _process_dataclass__9f7e26a87dd163b610f38caa1ce9b3c6356e632a():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('version', 'payload')), EqPlan(fields=('version', 'payload')), FrozenPlan(fields=("
-        "'version', 'payload'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('version', 'payload')"
-        ", cache=False), InitPlan(fields=(InitPlan.Field(name='version', annotation=OpRef(name='init.fields.0.annotatio"
-        "n'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None"
-        ", validate=None, check_type=None), InitPlan.Field(name='payload', annotation=OpRef(name='init.fields.1.annotat"
+        "Plans(tup=(CopyPlan(fields=('version', 'payload', 'created_at', 'updated_at')), EqPlan(fields=('version', 'pay"
+        "load', 'created_at', 'updated_at')), FrozenPlan(fields=('version', 'payload', 'created_at', 'updated_at'), all"
+        "ow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('version', 'payload', 'created_at', 'updated_at"
+        "'), cache=False), InitPlan(fields=(InitPlan.Field(name='version', annotation=OpRef(name='init.fields.0.annotat"
         "ion'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=No"
-        "ne, validate=None, check_type=None)), self_param='self', std_params=('version', 'payload'), kw_only_params=(),"
-        " frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Fie"
-        "ld(name='version', kw_only=False, fn=None), ReprPlan.Field(name='payload', kw_only=False, fn=None)), id=False,"
-        " terse=False, default_fn=None)))"
+        "ne, validate=None, check_type=None), InitPlan.Field(name='payload', annotation=OpRef(name='init.fields.1.annot"
+        "ation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce="
+        "None, validate=None, check_type=None), InitPlan.Field(name='created_at', annotation=OpRef(name='init.fields.2."
+        "annotation'), default=None, default_factory=OpRef(name='init.fields.2.default_factory'), init=True, override=F"
+        "alse, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='update"
+        "d_at', annotation=OpRef(name='init.fields.3.annotation'), default=None, default_factory=OpRef(name='init.field"
+        "s.3.default_factory'), init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, c"
+        "heck_type=None)), self_param='self', std_params=('version', 'payload', 'created_at', 'updated_at'), kw_only_pa"
+        "rams=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(Repr"
+        "Plan.Field(name='version', kw_only=False, fn=None), ReprPlan.Field(name='payload', kw_only=False, fn=None), Re"
+        "prPlan.Field(name='created_at', kw_only=False, fn=None), ReprPlan.Field(name='updated_at', kw_only=False, fn=N"
+        "one)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='be0d400bb9a95f7b7d493de698bc2bcac269b46e',
+    plan_repr_sha1='61e69339fbc885327f4389d705747f188b874a91',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__2__annotation',
+        '__dataclass__init__fields__2__default_factory',
+        '__dataclass__init__fields__3__annotation',
+        '__dataclass__init__fields__3__default_factory',
     ),
     cls_names=(
-        ('ommlds.cli.sessions.chat.drivers.state.storage', 'MarshaledState'),
+        ('ommlds.cli.sessions.chat.drivers.state.ids', 'MarshaledState'),
     ),
 )
-def _process_dataclass__be0d400bb9a95f7b7d493de698bc2bcac269b46e():
+def _process_dataclass__61e69339fbc885327f4389d705747f188b874a91():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
         __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__2__annotation,
+        __dataclass__init__fields__2__default_factory,
+        __dataclass__init__fields__3__annotation,
+        __dataclass__init__fields__3__default_factory,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2520,6 +2719,8 @@ def _process_dataclass__be0d400bb9a95f7b7d493de698bc2bcac269b46e():
             return __dataclass__cls(  # noqa
                 version=self.version,
                 payload=self.payload,
+                created_at=self.created_at,
+                updated_at=self.updated_at,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2534,7 +2735,9 @@ def _process_dataclass__be0d400bb9a95f7b7d493de698bc2bcac269b46e():
                 return NotImplemented
             return (
                 self.version == other.version and
-                self.payload == other.payload
+                self.payload == other.payload and
+                self.created_at == other.created_at and
+                self.updated_at == other.updated_at
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2545,6 +2748,8 @@ def _process_dataclass__be0d400bb9a95f7b7d493de698bc2bcac269b46e():
         __dataclass___setattr_frozen_fields = {
             'version',
             'payload',
+            'created_at',
+            'updated_at',
         }
 
         def __setattr__(self, name, value):
@@ -2563,6 +2768,8 @@ def _process_dataclass__be0d400bb9a95f7b7d493de698bc2bcac269b46e():
         __dataclass___delattr_frozen_fields = {
             'version',
             'payload',
+            'created_at',
+            'updated_at',
         }
 
         def __delattr__(self, name):
@@ -2582,6 +2789,8 @@ def _process_dataclass__be0d400bb9a95f7b7d493de698bc2bcac269b46e():
             return hash((
                 self.version,
                 self.payload,
+                self.created_at,
+                self.updated_at,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -2591,9 +2800,17 @@ def _process_dataclass__be0d400bb9a95f7b7d493de698bc2bcac269b46e():
             self,
             version: __dataclass__init__fields__0__annotation,
             payload: __dataclass__init__fields__1__annotation,
+            created_at: __dataclass__init__fields__2__annotation = __dataclass__HAS_DEFAULT_FACTORY,
+            updated_at: __dataclass__init__fields__3__annotation = __dataclass__HAS_DEFAULT_FACTORY,
         ) -> __dataclass__None:
+            if created_at is __dataclass__HAS_DEFAULT_FACTORY:
+                created_at = __dataclass__init__fields__2__default_factory()
+            if updated_at is __dataclass__HAS_DEFAULT_FACTORY:
+                updated_at = __dataclass__init__fields__3__default_factory()
             __dataclass__object_setattr(self, 'version', version)
             __dataclass__object_setattr(self, 'payload', payload)
+            __dataclass__object_setattr(self, 'created_at', created_at)
+            __dataclass__object_setattr(self, 'updated_at', updated_at)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2605,6 +2822,8 @@ def _process_dataclass__be0d400bb9a95f7b7d493de698bc2bcac269b46e():
             parts = []
             parts.append(f"version={self.version!r}")
             parts.append(f"payload={self.payload!r}")
+            parts.append(f"created_at={self.created_at!r}")
+            parts.append(f"updated_at={self.updated_at!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2767,22 +2986,23 @@ def _process_dataclass__0f6d91dd6a878d827836d961e4683d55b1c9095a():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('v',)), EqPlan(fields=('v',)), FrozenPlan(fields=('v',), allow_dynamic_dunder_attr"
-        "s=False), HashPlan(action='add', fields=('v',), cache=False), InitPlan(fields=(InitPlan.Field(name='v', 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=('v"
-        "',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPl"
-        "an(fields=(ReprPlan.Field(name='v', kw_only=False, fn=None),), id=False, terse=True, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('text',)), EqPlan(fields=('text',)), FrozenPlan(fields=('text',), allow_dynamic_du"
+        "nder_attrs=False), HashPlan(action='add', fields=('text',), cache=False), InitPlan(fields=(InitPlan.Field(name"
+        "='text', 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=('text',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
+        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='text', kw_only=False, fn=None),), id=False, terse=False, def"
+        "ault_fn=None)))"
     ),
-    plan_repr_sha1='3576262424b3ef8ff20966fa3744e5dba9a2ae7d',
+    plan_repr_sha1='ce2a4c81e0f66e62a54ea3adfdc532902daece78',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('ommlds.cli.sessions.chat.drivers.types', 'ChatDriverId'),
+        ('ommlds.cli.sessions.chat.interfaces.textual.app', 'ChatApp.UserInput'),
     ),
 )
-def _process_dataclass__3576262424b3ef8ff20966fa3744e5dba9a2ae7d():
+def _process_dataclass__ce2a4c81e0f66e62a54ea3adfdc532902daece78():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -2805,7 +3025,7 @@ def _process_dataclass__3576262424b3ef8ff20966fa3744e5dba9a2ae7d():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                v=self.v,
+                text=self.text,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2819,7 +3039,7 @@ def _process_dataclass__3576262424b3ef8ff20966fa3744e5dba9a2ae7d():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.v == other.v
+                self.text == other.text
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2828,7 +3048,7 @@ def _process_dataclass__3576262424b3ef8ff20966fa3744e5dba9a2ae7d():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'v',
+            'text',
         }
 
         def __setattr__(self, name, value):
@@ -2845,7 +3065,7 @@ def _process_dataclass__3576262424b3ef8ff20966fa3744e5dba9a2ae7d():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'v',
+            'text',
         }
 
         def __delattr__(self, name):
@@ -2863,7 +3083,7 @@ def _process_dataclass__3576262424b3ef8ff20966fa3744e5dba9a2ae7d():
 
         def __hash__(self):
             return hash((
-                self.v,
+                self.text,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -2871,9 +3091,9 @@ def _process_dataclass__3576262424b3ef8ff20966fa3744e5dba9a2ae7d():
 
         def __init__(
             self,
-            v: __dataclass__init__fields__0__annotation,
+            text: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'v', v)
+            __dataclass__object_setattr(self, 'text', text)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2883,334 +3103,7 @@ def _process_dataclass__3576262424b3ef8ff20966fa3744e5dba9a2ae7d():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"{self.v!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=('driver', 'interface', 'rendering')), EqPlan(fields=('driver', 'interface', 'rende"
-        "ring')), FrozenPlan(fields=('driver', 'interface', 'rendering', 'configurable_cls'), allow_dynamic_dunder_attr"
-        "s=False), HashPlan(action='add', fields=('driver', 'interface', 'rendering'), cache=False), InitPlan(fields=(I"
-        "nitPlan.Field(name='driver', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init.field"
-        "s.0.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, va"
-        "lidate=None, check_type=None), InitPlan.Field(name='interface', annotation=OpRef(name='init.fields.1.annotatio"
-        "n'), default=OpRef(name='init.fields.1.default'), default_factory=None, init=True, override=False, field_type="
-        "FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='rendering', annotation="
-        "OpRef(name='init.fields.2.annotation'), default=OpRef(name='init.fields.2.default'), default_factory=None, ini"
-        "t=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan."
-        "Field(name='configurable_cls', annotation=OpRef(name='init.fields.3.annotation'), default=None, default_factor"
-        "y=None, init=True, override=False, field_type=FieldType.CLASS_VAR, coerce=None, validate=None, check_type=None"
-        ")), self_param='self', std_params=(), kw_only_params=('driver', 'interface', 'rendering'), frozen=True, slots="
-        "False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='driver', kw"
-        "_only=True, fn=None), ReprPlan.Field(name='interface', kw_only=True, fn=None), ReprPlan.Field(name='rendering'"
-        ", kw_only=True, fn=None)), id=False, terse=False, default_fn=None)))"
-    ),
-    plan_repr_sha1='9ae844d2d0421cd416bf6d9a25f3a9571a7e1251',
-    op_ref_idents=(
-        '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__default',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__1__default',
-        '__dataclass__init__fields__2__annotation',
-        '__dataclass__init__fields__2__default',
-    ),
-    cls_names=(
-        ('ommlds.cli.sessions.chat.session', 'ChatSession.Config'),
-    ),
-)
-def _process_dataclass__9ae844d2d0421cd416bf6d9a25f3a9571a7e1251():
-    def _process_dataclass(
-        *,
-        __dataclass__cls,
-        __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__default,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__1__default,
-        __dataclass__init__fields__2__annotation,
-        __dataclass__init__fields__2__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
-                driver=self.driver,
-                interface=self.interface,
-                rendering=self.rendering,
-            )
-
-        __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.driver == other.driver and
-                self.interface == other.interface and
-                self.rendering == other.rendering
-            )
-
-        __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 = {
-            'driver',
-            'interface',
-            'rendering',
-            'configurable_cls',
-        }
-
-        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 = {
-            'driver',
-            'interface',
-            'rendering',
-            'configurable_cls',
-        }
-
-        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.driver,
-                self.interface,
-                self.rendering,
-            ))
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
-        def __init__(
-            self,
-            *,
-            driver: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
-            interface: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
-            rendering: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
-        ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'driver', driver)
-            __dataclass__object_setattr(self, 'interface', interface)
-            __dataclass__object_setattr(self, 'rendering', rendering)
-
-        __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"driver={self.driver!r}")
-            parts.append(f"interface={self.interface!r}")
-            parts.append(f"rendering={self.rendering!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=('content', 'backend')), EqPlan(fields=('content', 'backend')), FrozenPlan(fields=("
-        "'content', 'backend', 'configurable_cls'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('"
-        "content', 'backend'), cache=False), InitPlan(fields=(InitPlan.Field(name='content', annotation=OpRef(name='ini"
-        "t.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.I"
-        "NSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='backend', annotation=OpRef(name='i"
-        "nit.fields.1.annotation'), default=OpRef(name='init.fields.1.default'), default_factory=None, init=True, overr"
-        "ide=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='c"
-        "onfigurable_cls', annotation=OpRef(name='init.fields.2.annotation'), default=None, default_factory=None, init="
-        "True, override=False, field_type=FieldType.CLASS_VAR, coerce=None, validate=None, check_type=None)), self_para"
-        "m='self', std_params=('content',), kw_only_params=('backend',), frozen=True, slots=False, post_init_params=Non"
-        "e, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='content', kw_only=False, fn=None), Rep"
-        "rPlan.Field(name='backend', kw_only=True, fn=None)), id=False, terse=False, default_fn=None)))"
-    ),
-    plan_repr_sha1='68fe24967af76c907a1aebfe8185412042d24fa8',
-    op_ref_idents=(
-        '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__1__default',
-    ),
-    cls_names=(
-        ('ommlds.cli.sessions.completion.session', 'CompletionSession.Config'),
-        ('ommlds.cli.sessions.embedding.session', 'EmbeddingSession.Config'),
-    ),
-)
-def _process_dataclass__68fe24967af76c907a1aebfe8185412042d24fa8():
-    def _process_dataclass(
-        *,
-        __dataclass__cls,
-        __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__1__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
-                content=self.content,
-                backend=self.backend,
-            )
-
-        __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.content == other.content and
-                self.backend == other.backend
-            )
-
-        __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 = {
-            'content',
-            'backend',
-            'configurable_cls',
-        }
-
-        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 = {
-            'content',
-            'backend',
-            'configurable_cls',
-        }
-
-        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.content,
-                self.backend,
-            ))
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
-        def __init__(
-            self,
-            content: __dataclass__init__fields__0__annotation,
-            *,
-            backend: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
-        ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'content', content)
-            __dataclass__object_setattr(self, 'backend', backend)
-
-        __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"content={self.content!r}")
-            parts.append(f"backend={self.backend!r}")
+            parts.append(f"text={self.text!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"