ommlds 0.0.0.dev426__py3-none-any.whl → 0.0.0.dev485__py3-none-any.whl

ommlds/minichain/_marshal.py

@@ -1,27 +1,67 @@
+import typing as ta
+
 from omlish import dataclasses as dc
+from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
-from omlish.funcs import match as mfs
 from omlish.typedvalues.marshal import build_typed_values_marshaler
 from omlish.typedvalues.marshal import build_typed_values_unmarshaler
 
+from .json import JsonValue
+
 
 ##
 
 
 @dc.dataclass()
-class _TypedValuesFieldMarshalerFactory(msh.MarshalerFactoryMatchClass):
+class _TypedValuesFieldMarshalerFactory(msh.MarshalerFactory):
     tvs_rty: rfl.Type
 
-    @mfs.simple(lambda _, ctx, rty: True)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return build_typed_values_marshaler(ctx, self.tvs_rty)
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        return lambda: build_typed_values_marshaler(ctx, self.tvs_rty)
 
 
 @dc.dataclass()
-class _TypedValuesFieldUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
+class _TypedValuesFieldUnmarshalerFactory(msh.UnmarshalerFactory):
     tvs_rty: rfl.Type
 
-    @mfs.simple(lambda _, ctx, rty: True)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return build_typed_values_unmarshaler(ctx, self.tvs_rty)
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        return lambda: build_typed_values_unmarshaler(ctx, self.tvs_rty)
+
+
+##
+
+
+class MarshalJsonValue(lang.NotInstantiable, lang.Final):
+    pass
+
+
+class _JsonValueMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if rty is not MarshalJsonValue:
+            return None
+        return lambda: msh.NopMarshalerUnmarshaler()
+
+
+class _JsonValueUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if rty is not MarshalJsonValue:
+            return None
+        return lambda: msh.NopMarshalerUnmarshaler()
+
+
+##
+
+
+@lang.static_init
+def _install_standard_marshaling() -> None:
+    msh.register_global_config(
+        JsonValue,
+        msh.ReflectOverride(MarshalJsonValue),
+        identity=True,
+    )
+
+    msh.install_standard_factories(
+        _JsonValueMarshalerFactory(),
+        _JsonValueUnmarshalerFactory(),
+    )

ommlds/minichain/_typedvalues.py

@@ -74,12 +74,10 @@ def _tv_field_metadata(
                 omit_if=operator.not_,
             ),
             marshaler_factory=msh.FuncMarshalerFactory(
-                lambda ctx, rty: True,
-                lambda ctx, rty: _marshal._TypedValuesFieldMarshalerFactory(tvs_rty)(ctx, rty),  # noqa
+                lambda ctx, rty: _marshal._TypedValuesFieldMarshalerFactory(tvs_rty).make_marshaler(ctx, rty),  # noqa
             ),
             unmarshaler_factory=msh.FuncUnmarshalerFactory(
-                lambda ctx, rty: True,
-                lambda ctx, rty: _marshal._TypedValuesFieldUnmarshalerFactory(tvs_rty)(ctx, rty),  # noqa
+                lambda ctx, rty: _marshal._TypedValuesFieldUnmarshalerFactory(tvs_rty).make_unmarshaler(ctx, rty),  # noqa
             ),
         ),
     }

ommlds/minichain/backends/catalogs/base.py

@@ -3,15 +3,34 @@ import typing as ta
 
 from omlish import lang
 
+from ...configs import Config
+
+
+T = ta.TypeVar('T')
+
 
 ##
 
 
 class BackendCatalog(lang.Abstract):
+    class Backend(ta.NamedTuple):
+        factory: ta.Callable[..., ta.Any]
+        configs: ta.Sequence[Config] | None
+
     @abc.abstractmethod
-    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    def get_backend(self, service_cls: type[T], name: str) -> Backend:
         raise NotImplementedError
 
+    def new_backend(
+            self,
+            service_cls: ta.Any,
+            name: str,
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> ta.Any:
+        be = self.get_backend(service_cls, name)
+        return be.factory(*be.configs or [], *args, **kwargs)
+
     # #
     #
     # class Bound(lang.Final, ta.Generic[T]):

ommlds/minichain/backends/catalogs/simple.py

@@ -40,9 +40,9 @@ class SimpleBackendCatalog(BackendCatalog):
             sc_dct[e.name] = e
         self._dct = dct
 
-    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> BackendCatalog.Backend:
         e = self._dct[service_cls][name]
-        return e.factory_fn(*args, **kwargs)
+        return BackendCatalog.Backend(e.factory_fn, None)
 
 
 ##

ommlds/minichain/backends/catalogs/strings.py

@@ -5,7 +5,7 @@ from omlish import check
 from ...models.configs import ModelPath
 from ...models.configs import ModelRepo
 from ...models.repos.resolving import ModelRepoResolver
-from ...registries.globals import registry_new
+from ...registries.globals import get_registry_cls
 from ..strings.parsing import parse_backend_string
 from ..strings.resolving import BackendStringResolver
 from ..strings.resolving import ResolveBackendStringArgs
@@ -30,26 +30,28 @@ class BackendStringBackendCatalog(BackendCatalog):
         self._string_resolver = string_resolver
         self._model_repo_resolver = model_repo_resolver
 
-    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> BackendCatalog.Backend:
         ps = parse_backend_string(name)
         rs = check.not_none(self._string_resolver.resolve_backend_string(ResolveBackendStringArgs(
             service_cls,
             ps,
         )))
 
-        al = list(rs.args or [])
+        al: list = list(rs.args or [])
 
-        # FIXME: lol
+        # FIXME: lol - move *into* local model classes as an injected dep?
         if al and isinstance(al[0], ModelRepo):
             [mr] = al
             mrr = check.not_none(self._model_repo_resolver)
             mrp = check.not_none(mrr.resolve(mr))
             al = [ModelPath(mrp.path), *al[1:]]
 
-        return registry_new(
+        cls = get_registry_cls(
             service_cls,
             rs.name,
-            *al,
-            *args,
-            **kwargs,
+        )
+
+        return BackendCatalog.Backend(
+            cls,
+            al,
         )

ommlds/minichain/backends/impls/anthropic/chat.py

@@ -1,4 +1,5 @@
 """
+https://docs.claude.com/en/api/messages
 https://github.com/anthropics/anthropic-sdk-python/tree/cd80d46f7a223a5493565d155da31b898a4c6ee5/src/anthropic/types
 https://github.com/anthropics/anthropic-sdk-python/blob/cd80d46f7a223a5493565d155da31b898a4c6ee5/src/anthropic/resources/completions.py#L53
 https://github.com/anthropics/anthropic-sdk-python/blob/cd80d46f7a223a5493565d155da31b898a4c6ee5/src/anthropic/resources/messages.py#L70
@@ -6,22 +7,33 @@ https://github.com/anthropics/anthropic-sdk-python/blob/cd80d46f7a223a5493565d15
 import typing as ta
 
 from omlish import check
-from omlish import lang
+from omlish import marshal as msh
 from omlish import typedvalues as tv
 from omlish.formats import json
 from omlish.http import all as http
 
+from .....backends.anthropic.protocol import types as pt
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
 from ....chat.choices.types import AiChoice
+from ....chat.choices.types import ChatChoicesOptions
 from ....chat.messages import AiMessage
+from ....chat.messages import AnyAiMessage
 from ....chat.messages import Message
 from ....chat.messages import SystemMessage
+from ....chat.messages import ToolUseMessage
 from ....chat.messages import UserMessage
+from ....chat.tools.types import Tool
+from ....llms.types import MaxTokens
+from ....llms.types import Temperature
 from ....models.configs import ModelName
 from ....standard import ApiKey
+from ....tools.types import ToolUse
+from ....types import Option
 from .names import MODEL_NAMES
+from .protocol import build_protocol_chat_messages
+from .protocol import build_protocol_tool
 
 
 ##
@@ -35,18 +47,15 @@ from .names import MODEL_NAMES
 class AnthropicChatChoicesService:
     DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
 
-    ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], str]] = {
-        SystemMessage: 'system',
-        UserMessage: 'user',
-        AiMessage: 'assistant',
-    }
-
     def __init__(
             self,
             *configs: ApiKey | ModelName,
+            http_client: http.AsyncHttpClient | None = None,
     ) -> None:
         super().__init__()
 
+        self._http_client = http_client
+
         with tv.consume(*configs) as cc:
             self._api_key = check.not_none(ApiKey.pop_secret(cc, env='ANTHROPIC_API_KEY'))
             self._model_name = cc.pop(self.DEFAULT_MODEL_NAME)
@@ -62,33 +71,46 @@ class AnthropicChatChoicesService:
         else:
             raise TypeError(m)
 
-    def invoke(
+    DEFAULT_OPTIONS: ta.ClassVar[tv.TypedValues[Option]] = tv.TypedValues[Option](
+        MaxTokens(4096),
+    )
+
+    _OPTION_KWARG_NAMES_MAP: ta.ClassVar[ta.Mapping[str, type[ChatChoicesOptions]]] = dict(
+        temperature=Temperature,
+        max_tokens=MaxTokens,
+    )
+
+    async def invoke(
             self,
             request: ChatChoicesRequest,
-            *,
-            max_tokens: int = 4096,  # FIXME: ChatOption
     ) -> ChatChoicesResponse:
-        messages = []
-        system: str | None = None
-        for i, m in enumerate(request.v):
-            if isinstance(m, SystemMessage):
-                if i != 0 or system is not None:
-                    raise Exception('Only supports one system message and must be first')
-                system = self._get_msg_content(m)
-            else:
-                messages.append(dict(
-                    role=self.ROLES_MAP[type(m)],  # noqa
-                    content=check.isinstance(self._get_msg_content(m), str),
-                ))
+        messages, system = build_protocol_chat_messages(request.v)
+
+        kwargs: dict = dict()
 
-        raw_request = dict(
+        tools: list[pt.ToolSpec] = []
+        with tv.TypedValues(
+            *self.DEFAULT_OPTIONS,
+                *request.options,
+                override=True,
+        ).consume() as oc:
+            kwargs.update(oc.pop_scalar_kwargs(**self._OPTION_KWARG_NAMES_MAP))
+
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_protocol_tool(t))
+
+        a_req = pt.MessagesRequest(
             model=MODEL_NAMES.resolve(self._model_name.v),
-            **lang.opt_kw(system=system),
+            system=system,
             messages=messages,
-            max_tokens=max_tokens,
+            tools=tools or None,
+            **kwargs,
         )
 
-        raw_response = http.request(
+        raw_request = msh.marshal(a_req)
+
+        raw_response = await http.async_request(
             'https://api.anthropic.com/v1/messages',
             headers={
                 http.consts.HEADER_CONTENT_TYPE: http.consts.CONTENT_TYPE_JSON,
@@ -96,10 +118,26 @@ class AnthropicChatChoicesService:
                 b'anthropic-version': b'2023-06-01',
             },
             data=json.dumps(raw_request).encode('utf-8'),
+            client=self._http_client,
         )
 
         response = json.loads(check.not_none(raw_response.data).decode('utf-8'))
 
+        out: list[AnyAiMessage] = []
+        for c in response['content']:
+            if c['type'] == 'text':
+                out.append(AiMessage(
+                    check.not_none(c['text']),
+                ))
+            elif c['type'] == 'tool_use':
+                out.append(ToolUseMessage(ToolUse(
+                    id=c['id'],
+                    name=c['name'],
+                    args=c['input'],
+                )))
+            else:
+                raise TypeError(c['type'])
+
         return ChatChoicesResponse([
-            AiChoice(AiMessage(response['content'][0]['text'])),  # noqa
+            AiChoice(out),
         ])

ommlds/minichain/backends/impls/anthropic/names.py

@@ -18,14 +18,13 @@ MODEL_NAMES = ModelNameCollection(
         'claude-opus-4-1': 'claude-opus-4-1-20250805',
         'claude-opus': 'claude-opus-4-1',
 
-        'claude-sonnet-4-20250514': None,
-        'claude-sonnet-4': 'claude-sonnet-4-20250514',
-        'claude-sonnet': 'claude-sonnet-4',
+        'claude-sonnet-4-5-20250929': None,
+        'claude-sonnet-4-5': 'claude-sonnet-4-5-20250929',
+        'claude-sonnet': 'claude-sonnet-4-5',
 
-        'claude-3-5-haiku-latest': None,
-        'claude-haiku-3-5-latest': 'claude-3-5-haiku-latest',
-        'claude-haiku-3-5': 'claude-haiku-3-5-latest',
-        'claude-haiku': 'claude-haiku-3-5',
+        'claude-haiku-4-5-20251001': None,
+        'claude-haiku-4-5': 'claude-haiku-4-5-20251001',
+        'claude-haiku': 'claude-haiku-4-5',
 
         'claude': 'claude-haiku',
     },
@@ -34,7 +33,10 @@ MODEL_NAMES = ModelNameCollection(
 
 # @omlish-manifest
 _BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
-    ['ChatChoicesService'],
+    [
+        'ChatChoicesService',
+        'ChatChoicesStreamService',
+    ],
     'anthropic',
     model_names=MODEL_NAMES,
 )

ommlds/minichain/backends/impls/anthropic/protocol.py

@@ -0,0 +1,109 @@
+import typing as ta
+
+from omlish import check
+from omlish import marshal as msh
+from omlish.formats import json
+
+from .....backends.anthropic.protocol import types as pt
+from ....chat.messages import AiMessage
+from ....chat.messages import Message
+from ....chat.messages import SystemMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
+from ....chat.messages import UserMessage
+from ....chat.tools.types import Tool
+from ....content.prepare import prepare_content_str
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+
+
+##
+
+
+def get_message_content(m: Message) -> str | None:
+    if isinstance(m, AiMessage):
+        return check.isinstance(m.c, str)
+
+    elif isinstance(m, (UserMessage, SystemMessage)):
+        return check.isinstance(m.c, str)
+
+    else:
+        raise TypeError(m)
+
+
+#
+
+
+class BuiltChatMessages(ta.NamedTuple):
+    messages: list[pt.Message]
+    system: list[pt.Content] | None
+
+
+ROLES_MAP: ta.Mapping[type[Message], str] = {
+    SystemMessage: 'system',
+    UserMessage: 'user',
+    AiMessage: 'assistant',
+    ToolUseMessage: 'assistant',
+}
+
+
+def build_protocol_chat_messages(msgs: ta.Iterable[Message]) -> BuiltChatMessages:
+    messages: list[pt.Message] = []
+    system: list[pt.Content] | None = None
+
+    for i, m in enumerate(msgs):
+        if isinstance(m, SystemMessage):
+            if i or system is not None:
+                raise Exception('Only supports one system message and must be first')
+            system = [pt.Text(check.not_none(get_message_content(m)))]
+
+        elif isinstance(m, ToolUseResultMessage):
+            messages.append(pt.Message(
+                role='user',
+                content=[pt.ToolResult(
+                    tool_use_id=check.not_none(m.tur.id),
+                    content=json.dumps_compact(msh.marshal(m.tur.c)) if not isinstance(m.tur.c, str) else m.tur.c,
+                )],
+            ))
+
+        elif isinstance(m, AiMessage):
+            # messages.append(pt.Message(
+            #     role=ROLES_MAP[type(m)],  # noqa
+            #     content=[pt.Text(check.isinstance(get_message_content(m), str))],
+            # ))
+            messages.append(pt.Message(
+                role='assistant',
+                content=[
+                    *([pt.Text(check.isinstance(m.c, str))] if m.c is not None else []),
+                ],
+            ))
+
+        elif isinstance(m, ToolUseMessage):
+            messages.append(pt.Message(
+                role='assistant',
+                content=[
+                    pt.ToolUse(
+                        id=check.not_none(m.tu.id),
+                        name=check.not_none(m.tu.name),
+                        input=m.tu.args,
+                    ),
+                ],
+            ))
+
+        else:
+            messages.append(pt.Message(
+                role=ROLES_MAP[type(m)],  # type: ignore[arg-type]
+                content=[pt.Text(check.isinstance(get_message_content(m), str))],
+            ))
+
+    return BuiltChatMessages(messages, system)
+
+
+##
+
+
+def build_protocol_tool(t: Tool) -> pt.ToolSpec:
+    return pt.ToolSpec(
+        name=check.not_none(t.spec.name),
+        description=prepare_content_str(t.spec.desc),
+        input_schema=build_tool_spec_params_json_schema(t.spec),
+    )