ommlds 0.0.0.dev480__py3-none-any.whl → 0.0.0.dev503__py3-none-any.whl

ommlds/minichain/content/visitors.py

@@ -0,0 +1,231 @@
+import collections.abc
+import inspect
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+from .code import BlockCodeContent
+from .code import CodeContent
+from .code import InlineCodeContent
+from .composite import CompositeContent
+from .content import BaseContent
+from .content import Content
+from .dynamic import DynamicContent
+from .emphasis import BoldContent
+from .emphasis import BoldItalicContent
+from .emphasis import EmphasisContent
+from .emphasis import ItalicContent
+from .images import ImageContent
+from .json import JsonContent
+from .link import LinkContent
+from .markdown import MarkdownContent
+from .namespaces import NamespaceContent
+from .placeholders import PlaceholderContent
+from .quote import QuoteContent
+from .recursive import RecursiveContent
+from .section import SectionContent
+from .sequence import BlockContent
+from .sequence import InlineContent
+from .sequence import ItemListContent
+from .sequence import SequenceContent
+from .standard import StandardContent
+from .tag import TagContent
+from .templates import TemplateContent
+from .text import TextContent
+
+
+C = ta.TypeVar('C')
+R = ta.TypeVar('R')
+
+
+##
+
+
+class ContentVisitor(lang.Abstract, ta.Generic[C, R]):
+    _visit_method_map: ta.ClassVar[ta.Mapping[ta.Any, str]]
+
+    def visit(self, c: Content, ctx: C) -> R:
+        if isinstance(c, str):
+            return self.visit_str(c, ctx)
+
+        if isinstance(c, collections.abc.Sequence):
+            return self.visit_sequence(c, ctx)
+
+        try:
+            a = self._visit_method_map[type(c)]
+        except KeyError:
+            raise TypeError(c) from None
+
+        return getattr(self, a)(c, ctx)
+
+    ##
+    # per-type visit methods
+
+    def visit_content(self, c: Content, ctx: C) -> R:
+        raise TypeError(c)
+
+    ##
+    # non-BaseContent
+
+    def visit_str(self, c: str, ctx: C) -> R:
+        return self.visit_content(c, ctx)
+
+    def visit_sequence(self, c: ta.Sequence[Content], ctx: C) -> R:
+        return self.visit_content(c, ctx)
+
+    ##
+    # BaseContent
+
+    def visit_base_content(self, c: BaseContent, ctx: C) -> R:
+        return self.visit_content(c, ctx)
+
+    ##
+    # StandardContent
+
+    def visit_standard_content(self, c: StandardContent, ctx: C) -> R:
+        return self.visit_base_content(c, ctx)
+
+    ##
+    # leaf StandardContent
+
+    def visit_image_content(self, c: ImageContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_json_content(self, c: JsonContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_link_content(self, c: LinkContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_markdown_content(self, c: MarkdownContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_quote_content(self, c: QuoteContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_text_content(self, c: TextContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    ##
+    # CompositeContent
+
+    def visit_composite_content(self, c: CompositeContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_section_content(self, c: SectionContent, ctx: C) -> R:
+        return self.visit_composite_content(c, ctx)
+
+    def visit_tag_content(self, c: TagContent, ctx: C) -> R:
+        return self.visit_composite_content(c, ctx)
+
+    ##
+    # CodeContent
+
+    def visit_code_content(self, c: CodeContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_inline_code_content(self, c: InlineCodeContent, ctx: C) -> R:
+        return self.visit_code_content(c, ctx)
+
+    def visit_block_code_content(self, c: BlockCodeContent, ctx: C) -> R:
+        return self.visit_code_content(c, ctx)
+
+    ##
+    # DynamicContent
+
+    def visit_dynamic_content(self, c: DynamicContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_recursive_content(self, c: RecursiveContent, ctx: C) -> R:
+        return self.visit_dynamic_content(c, ctx)
+
+    def visit_namespace_content(self, c: NamespaceContent, ctx: C) -> R:
+        return self.visit_recursive_content(c, ctx)
+
+    def visit_placeholder_content(self, c: PlaceholderContent, ctx: C) -> R:
+        return self.visit_recursive_content(c, ctx)
+
+    def visit_template_content(self, c: TemplateContent, ctx: C) -> R:
+        return self.visit_dynamic_content(c, ctx)
+
+    ##
+    # EmphasisContent
+
+    def visit_emphasis_content(self, c: EmphasisContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_bold_content(self, c: BoldContent, ctx: C) -> R:
+        return self.visit_emphasis_content(c, ctx)
+
+    def visit_italic_content(self, c: ItalicContent, ctx: C) -> R:
+        return self.visit_emphasis_content(c, ctx)
+
+    def visit_bold_italic_content(self, c: BoldItalicContent, ctx: C) -> R:
+        return self.visit_emphasis_content(c, ctx)
+
+    ##
+    # SequenceContent
+
+    def visit_sequence_content(self, c: SequenceContent, ctx: C) -> R:
+        return self.visit_composite_content(c, ctx)
+
+    def visit_inline_content(self, c: InlineContent, ctx: C) -> R:
+        return self.visit_sequence_content(c, ctx)
+
+    def visit_block_content(self, c: BlockContent, ctx: C) -> R:
+        return self.visit_sequence_content(c, ctx)
+
+    def visit_item_list_content(self, c: ItemListContent, ctx: C) -> R:
+        return self.visit_sequence_content(c, ctx)
+
+
+ContentVisitor._visit_method_map = {  # noqa
+    list(inspect.signature(o).parameters.values())[1].annotation: a
+    for a, o in ContentVisitor.__dict__.items()
+    if a.startswith('visit_')
+}
+
+
+##
+
+
+class StandardContentVisitorTypeError(TypeError):
+    pass
+
+
+class StandardContentVisitor(ContentVisitor[C, R], lang.Abstract):
+    def visit_str(self, c: str, ctx: C) -> R:
+        raise StandardContentVisitorTypeError(c)
+
+    def visit_sequence(self, c: ta.Sequence[Content], ctx: C) -> R:
+        raise StandardContentVisitorTypeError(c)
+
+
+##
+
+
+class StaticContentVisitorTypeError(TypeError):
+    pass
+
+
+class StaticContentVisitor(ContentVisitor[C, R], lang.Abstract):
+    def visit_dynamic_content(self, c: DynamicContent, ctx: C) -> R:
+        raise StaticContentVisitorTypeError(c)
+
+
+##
+
+
+class ContentTransform(ContentVisitor[C, Content], lang.Abstract):
+    def visit_content(self, c: Content, ctx: C) -> Content:
+        return c
+
+    def visit_sequence(self, c: ta.Sequence[Content], ctx: C) -> Content:
+        return [self.visit(cc, ctx) for cc in c]
+
+    def visit_composite_content(self, c: CompositeContent, ctx: C) -> Content:
+        cc = c.child_content()
+        ncc = self.visit_sequence(cc, ctx)
+        nc = c.replace_child_content(check.isinstance(ncc, collections.abc.Sequence))
+        return super().visit_composite_content(nc, ctx)

ommlds/minichain/lib/fs/tools/read.py

@@ -27,7 +27,7 @@ MAX_LINE_LENGTH = 2_000
 
 @tool_spec_override(
     desc=f"""
-         Reads a file from the local filesystem. You can access any file directly by using this tool.
+        Reads a file from the local filesystem. You can access any file directly by using this tool.
 
         Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that
         path is valid. It is okay to read a file that does not exist; an error will be returned.

ommlds/minichain/lib/fs/tools/recursivels/rendering.py

@@ -5,10 +5,10 @@ TODO:
   - any directory with unlisted children will be suffixed inline with '...'
   - absence of '...' indicates an empty directory
 """
-import dataclasses as dc
 import typing as ta
 
 from omlish import check
+from omlish import dataclasses as dc
 from omlish import lang
 
 from .running import DirLsItem

ommlds/minichain/lib/fs/tools/recursivels/running.py

@@ -1,8 +1,8 @@
-import dataclasses as dc
 import os.path
 import typing as ta
 
 from omlish import check
+from omlish import dataclasses as dc
 from omlish import lang
 
 

ommlds/minichain/lib/todo/tools/write.py

@@ -8,6 +8,7 @@ from omlish import lang
 from omlish import marshal as msh
 
 from ....content.namespaces import ContentNamespace
+from ....content.namespaces import NamespaceContent
 from ....tools.execution.catalog import ToolCatalogEntry
 from ....tools.execution.reflect import reflect_tool_catalog_entry
 from ....tools.reflect import tool_spec_override
@@ -311,7 +312,7 @@ class TodoWriteDescriptionChunks(ContentNamespace):
 
 
 @tool_spec_override(
-    desc=TodoWriteDescriptionChunks,
+    desc=NamespaceContent(TodoWriteDescriptionChunks),
 )
 def execute_todo_write_tool(todo_items: ta.Sequence[TodoItem]) -> ta.Sequence[TodoItem]:
     if todo_items:

ommlds/minichain/lib/todo/types.py

@@ -3,9 +3,9 @@ TODO:
  - enums lol
   - * with ToolParam-like desc metadata somehow *
 """
-import dataclasses as dc
 import typing as ta
 
+from omlish import dataclasses as dc
 from omlish import lang
 
 from ...tools.reflect import tool_param_metadata

ommlds/minichain/metadata.py

@@ -3,9 +3,13 @@ import datetime
 import typing as ta
 import uuid
 
+from omlish import check
+from omlish import dataclasses as dc
 from omlish import lang
 from omlish import typedvalues as tv
 
+from ._typedvalues import _tv_field_metadata
+
 
 ##
 
@@ -21,9 +25,9 @@ MetadataT = ta.TypeVar('MetadataT', bound=Metadata)
 
 
 class MetadataContainer(
-    tv.TypedValueGeneric[MetadataT],
     lang.Abstract,
     lang.PackageSealed,
+    ta.Generic[MetadataT],
 ):
     @property
     @abc.abstractmethod
@@ -31,13 +35,63 @@ class MetadataContainer(
         raise NotImplementedError
 
     @abc.abstractmethod
-    def with_metadata(self, *mds: MetadataT, override: bool = False) -> ta.Self:
+    def with_metadata(
+            self,
+            *add: MetadataT,
+            discard: ta.Iterable[type] | None = None,
+            override: bool = False,
+    ) -> ta.Self:
         raise NotImplementedError
 
 
 ##
 
 
+@dc.dataclass(frozen=True)
+class MetadataContainerDataclass(  # noqa
+    MetadataContainer[MetadataT],
+    lang.Abstract,
+):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        check.state(hasattr(cls, '_metadata'))
+
+    @staticmethod
+    def _configure_metadata_field(md_fld, md_cls):
+        dc.set_field_metadata(
+            check.isinstance(md_fld, dc.Field),
+            _tv_field_metadata(
+                check.not_none(md_cls),
+                marshal_name='metadata',
+            ),
+        )
+
+    @property
+    def metadata(self) -> tv.TypedValues[MetadataT]:
+        return check.isinstance(getattr(self, '_metadata'), tv.TypedValues)
+
+    def with_metadata(
+            self,
+            *add: MetadataT,
+            discard: ta.Iterable[type] | None = None,
+            override: bool = False,
+    ) -> ta.Self:
+        new = (old := self.metadata).update(
+            *add,
+            discard=discard,
+            override=override,
+        )
+
+        if new is old:
+            return self
+
+        return dc.replace(self, _metadata=new)  # type: ignore[call-arg]  # noqa
+
+
+##
+
+
 class CommonMetadata(Metadata, lang.Abstract):
     pass
 

ommlds/minichain/resources.py

@@ -33,6 +33,10 @@ class ResourcesRefNotRegisteredError(Exception):
 
 @ta.final
 class Resources(lang.Final, lang.NotPicklable):
+    """
+    Essentially a reference-tracked AsyncContextManager.
+    """
+
     def __init__(
             self,
             *,
@@ -80,10 +84,14 @@ class Resources(lang.Final, lang.NotPicklable):
         @contextlib.asynccontextmanager
         async def inner():
             init_ref = Resources._InitRef()
+
             res = Resources(init_ref=init_ref, **kwargs)
+
             await res.init()
+
             try:
                 yield res
+
             finally:
                 await res.remove_ref(init_ref)
 
@@ -94,6 +102,7 @@ class Resources(lang.Final, lang.NotPicklable):
     def add_ref(self, ref: ResourcesRef) -> None:
         check.isinstance(ref, ResourcesRef)
         check.state(not self._closed)
+
         self._refs.add(ref)
 
     def has_ref(self, ref: ResourcesRef) -> bool:
@@ -101,10 +110,13 @@ class Resources(lang.Final, lang.NotPicklable):
 
     async def remove_ref(self, ref: ResourcesRef) -> None:
         check.isinstance(ref, ResourcesRef)
+
         try:
             self._refs.remove(ref)
+
         except KeyError:
             raise ResourcesRefNotRegisteredError(ref) from None
+
         if not self._no_autoclose and not self._refs:
             await self.aclose()
 
@@ -112,10 +124,12 @@ class Resources(lang.Final, lang.NotPicklable):
 
     def enter_context(self, cm: ta.ContextManager[T]) -> T:
         check.state(not self._closed)
+
         return self._aes.enter_context(cm)
 
     async def enter_async_context(self, cm: ta.AsyncContextManager[T]) -> T:
         check.state(not self._closed)
+
         return await self._aes.enter_async_context(cm)
 
     #
@@ -150,7 +164,11 @@ class Resources(lang.Final, lang.NotPicklable):
 class ResourceManaged(ResourcesRef, lang.Final, lang.NotPicklable, ta.Generic[T]):
     """
     A class to 'handoff' a ref to a `Resources`, allowing the `Resources` to temporarily survive being passed from
-    instantiation within a callee to being `__aenter__`'d in the caller.
+    instantiation within a callee.
+
+    This class wraps an arbitrary value, likely an object referencing resources managed by the `Resources`, which is
+    accessed by `__aenter__`'ing. However, as the point of this class is handoff of a `Resources`, not necessarily some
+    arbitrary value, the value needn't necessarily be related to the `Resources`, or may even be `None`.
 
     The ref to the `Resources` is allocated in the ctor, so the contract is that an instance of this must be immediately
     `__aenter__`'d before doing anything else with the return value of the call. Failure to do so leaks the `Resources`.
@@ -172,11 +190,13 @@ class ResourceManaged(ResourcesRef, lang.Final, lang.NotPicklable, ta.Generic[T]
     async def __aenter__(self) -> T:
         check.state(self.__state == 'new')
         self.__state = 'entered'
+
         return self.__v
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         check.state(self.__state == 'entered')
         self.__state = 'exited'
+
         await self.__resources.remove_ref(self)
 
     def __del__(self) -> None:
@@ -203,6 +223,7 @@ class UseResources(tv.UniqueScalarTypedValue[Resources], ResourcesOption, lang.F
         if (ur := tv.as_collection(options).get(UseResources)) is not None:
             async with ResourceManaged(ur.v, ur.v) as rs:
                 yield rs
+
         else:
             async with Resources.new() as rs:
                 yield rs

ommlds/minichain/services/README.md

@@ -0,0 +1,154 @@
+The core service abstraction. In general, Services are intended to encapsulate non-trivial, resourceful, effectful
+operations, which are likely to have various implementations, each having their own specific capabilities in addition
+to their common interface, and where wrapping, adapting, and transforming them in a uniform manner is desirable.
+
+For example:
+ - A ChatService is passed a Request with a Chat value and returns a Response with an AiChat value.
+ - A ChatChoicesService is passed a Request with a Chat and returns a Response with a list of AiChoices.
+ - A ChatChoicesServiceChatService is a simple adapter taking a ChatChoicesService which it will invoke with its given
+   Request, expect a single AiChoice value in that Response, and return that single AiChat as its Response - thus acting
+   as a ChatService.
+   - Thus, all chat backends that return choices can be adapted to code expecting a single chat as output.
+ - A ChatStreamService is passed a Request with a Chat value and returns a Response with a value from which AiDeltas
+   may be streamed.
+ - A ChatChoicesStreamService is passed a Request with a Chat value and returns a Response with a value from which
+   AiChoicesDeltas may be streamed.
+ - A ChatChoicesStreamServiceChatChoicesService is an adapter taking a ChatChoicesStreamService and aggregating the
+   AiChoicesDeltas into joined, non-delta AiChoices.
+   - This may then be wrapped in a ChatChoicesServiceChatService to act as a ChatService.
+   - In practice however there are usually dedicated streaming and non-streaming implementations if possible as
+     non-streaming will usually have less overhead.
+ - An OpenaiChatChoicesService can act as a ChatChoicesService, and will accept all generic ChatOptions, in addition to
+   any OpenaiChatOptions inapplicable to any other backend. It may also produce all generic ChatOutputs, in addition to
+   OpenaiChatOutputs that will not be produced by other backends.
+ - Beyond chat, a VectorSearchService is passed a Request with a VectorSearch value and returns a Response with a
+   VectorHits value.
+ - A RetryService wraps any other Service and will attempt to re-invoke it on failure.
+ - A FirstInWinsService wraps any number of other Services and will return the first non-error Response it receives.
+
+The service abstraction consists of 3 interrelated generic types:
+ - Request, an immutable final generic class containing a single value and any number of options.
+ - Response, an immutable final generic class containing a single value and any number of outputs.
+ - Service, a generic protocol consisting of a single async method `invoke`, taking a request and returning a response.
+
+There are 2 related abstract base classes in the parent package:
+ - Option, a non-generic abstract class representing a service option.
+ - Output, a non-generic abstract class representing a service output.
+
+The purpose of this arrangement is to provide the following:
+ - There is only one method - `Service.invoke` - to deal with.
+ - There is no base `Service` class - service types are distinguished only by the requests they accept and responses
+   they return.
+ - It facilitates a clear, introspectable, generally type-safe means for handling 'less-specific' and 'more-specific'
+   service types.
+ - It facilitates generic wrapper and transformation machinery.
+
+The variance of the type parameters of the 3 classes is central:
+ - `Request[V_co, OptionT_co]`
+ - `Response[V_co, OutputT_contra]`
+ - `Service[RequestT_contra, ResponseT_co]`
+
+And to understand this, it's important to understand how Option and Output subtypes are intended to be arranged:
+ - These types are *not* intended to form a deep type hierarchy:
+   - A RemoteChatOption is *not* intended to inherit from a ChatOption: a ChatOption (be it a base class or union alias)
+     represents an option that *any* ChatService can accept, whereas a RemoteChatOption represents an option that *only*
+     applies to a RemoteChatService.
+   - If RemoteChatOption inherited from a base ChatOption, then it would have to apply to *all* ChatService
+     implementations.
+   - For example: were ApiKey to inherit from ChatOption, then it would have to apply to all ChatServices, including
+     LocalChatService, which has no concept of an api key.
+ - Similarly, a RemoteChatOutput is *not* intended to inherit from a ChatOutput: a ChatOutput represents an output that
+   *any* ChatService can produce, whereas a RemoteChatOutput represents an output that *only* applies to a
+   RemoteChatService.
+ - These 2 types are intended to form flat, disjoint, unrelated families of subtypes, and Request and Response are
+   intended to be parameterized by the unions of all such families they may contain.
+ - Because of this, one's visual intuition regarding types and subtypes may be reversed: `int` is effectively a subtype
+   of `int | str` despite `int` being a visually shorter, less complex type.
+   - `int` is a *MORE SPECIFIC* / *STRICT SUBSET* subtype of `int | str`, the *LESS SPECIFIC* / *STRICT SUPERSET*
+     supertype.
+
+Regarding type variance:
+ - Service has the classic setup of contravariant input and covariant output:
+   - A RemoteChatService *is a* ChatService.
+   - A RemoteChatService may accept less specific requests than a ChatService.
+   - A RemoteChatService may return more specific responses than a ChatService.
+ - Request is covariant on its options:
+   - Recall, a RemoteChatOption *is not a* ChatOption.
+   - A ChatRequest *is a* RemoteChatRequest as it will not contain options RemoteChatService cannot accept.
+ - Response is contravariant on its outputs:
+   - Recall, a RemoteChatOutput *is not a* ChatOutput.
+   - A RemoteChatResponse *is a* ChatResponse even though it may contain additional output variants not produced by
+     every ChatService.
+   - Code that calls a ChatService and is given a ChatResponse must be prepared to handle (usually by simply ignoring)
+     outputs not necessarily produced by a base ChatService.
+
+Finally, in addition to a value and either options or outputs, a Request and Response each also contain a collection of
+metadata. Very much unlike the Options and Outputs, the elements of these collections are simply of the types
+`RequestMetadata | CommonMetadata` and `ResponseMetadata | CommonMetadata`, and are not otherwise parameterized. These
+are intended for looser inputs and outputs: a generic unique id, timestamps, metrics, etc., and in general should
+neither affect the behavior of services nor be depended upon by callers.
+
+Below is a representative illustration of these types and their relationships. Note how:
+ - There is no subclassing of Request, Response, or Service - just type aliasing.
+ - There is no deep, shared subclassing of Option or Output.
+ - The type args passed to Request and Response are unions of all the Option and Output subtypes they may contain.
+   - These unions are kept in pluralized type aliases for convenience.
+ - There is no base ChatOption or ChatOutput class - were there, it would not be included in the base classes of any
+   local or remote only option or output.
+ - The local and remote sections take different but equivalent approaches:
+   - There are no base LocalChatOption or LocalChatOutput classes, but there *are* base RemoteChatOption and
+     RemoteChatOutput classes.
+   - Without any common base classes (besides the lowest level Output and Option classes), the local section treats them
+     as each distinct and bespoke, and the pluralized LocalChatOptions and LocalChatOutputs type aliases aggregate them
+     by explicitly listing them.
+   - With the common RemoteChatOption and RemoteChatOutput base classes, the remote section treats them as a related
+     family that any 'RemoteChat'-like service should accept and produce.
+
+```python
+# Common chat
+
+class MaxTokens(Option, tv.UniqueScalarTypedValue[int]): pass
+class Temperature(Option, tv.UniqueScalarTypedValue[float]): pass
+
+ChatOptions: ta.TypeAlias = MaxTokens | Temperature
+ChatRequest: ta.TypeAlias = Request[Chat, ChatOptions]
+
+class TokenUsage(Output, tv.UniqueScalarTypedValue[int]): pass
+class ElapsedTime(Output, tv.UniqueScalarTypedValue[float]): pass
+
+ChatOutputs: ta.TypeAlias = TokenUsage | ElapsedTime
+ChatResponse: ta.TypeAlias = Response[Message, ChatOutputs]
+
+ChatService: ta.TypeAlias = Service[ChatRequest, ChatResponse]
+
+# Local chat
+
+class ModelPath(Option, tv.ScalarTypedValue[str]): pass
+
+LocalChatOptions: ta.TypeAlias = ChatOptions | ModelPath
+LocalChatRequest: ta.TypeAlias = Request[Chat, LocalChatOptions]
+
+class LogPath(Output, tv.ScalarTypedValue[str]): pass
+
+LocalChatOutputs: ta.TypeAlias = ChatOutputs | LogPath
+LocalChatResponse: ta.TypeAlias = Response[Message, LocalChatOutputs]
+
+LocalChatService: ta.TypeAlias = Service[LocalChatRequest, LocalChatResponse]
+
+# Remote chat
+
+class RemoteChatOption(Option, lang.Abstract): pass
+class ApiKey(RemoteChatOption, tv.ScalarTypedValue[str]): pass
+
+RemoteChatOptions: ta.TypeAlias = ChatOptions | RemoteChatOption
+RemoteChatRequest: ta.TypeAlias = Request[Chat, RemoteChatOptions]
+
+class RemoteChatOutput(Output, lang.Abstract): pass
+class BilledCostInUsd(RemoteChatOutput, tv.UniqueScalarTypedValue[float]): pass
+
+RemoteChatOutputs: ta.TypeAlias = ChatOutputs | RemoteChatOutput
+RemoteChatResponse: ta.TypeAlias = Response[Message, RemoteChatOutputs]
+
+RemoteChatService: ta.TypeAlias = Service[RemoteChatRequest, RemoteChatResponse]
+```
+

ommlds/minichain/services/__init__.py

@@ -1,6 +1,4 @@
 # ruff: noqa: I001
-
-
 from .facades import (  # noqa
     ServiceFacade,
 
@@ -8,10 +6,16 @@ from .facades import (  # noqa
 )
 
 from .requests import (  # noqa
+    RequestMetadata,
+    RequestMetadatas,
+
     Request,
 )
 
 from .responses import (  # noqa
+    ResponseMetadata,
+    ResponseMetadatas,
+
     Response,
 )