ommlds 0.0.0.dev475__py3-none-any.whl → 0.0.0.dev477__py3-none-any.whl

ommlds/.omlish-manifests.json

@@ -194,6 +194,60 @@
       }
     }
   },
+  {
+    "module": ".minichain.backends.impls.groq.chat",
+    "attr": null,
+    "file": "ommlds/minichain/backends/impls/groq/chat.py",
+    "line": 26,
+    "value": {
+      "!.minichain.registries.manifests.RegistryManifest": {
+        "module": "ommlds.minichain.backends.impls.groq.chat",
+        "attr": "GroqChatChoicesService",
+        "name": "groq",
+        "aliases": null,
+        "type": "ChatChoicesService"
+      }
+    }
+  },
+  {
+    "module": ".minichain.backends.impls.groq.names",
+    "attr": "_BACKEND_STRINGS_MANIFEST",
+    "file": "ommlds/minichain/backends/impls/groq/names.py",
+    "line": 40,
+    "value": {
+      "!.minichain.backends.strings.manifests.BackendStringsManifest": {
+        "service_cls_names": [
+          "ChatChoicesService",
+          "ChatChoicesStreamService"
+        ],
+        "backend_name": "groq",
+        "model_names": {
+          "default": "gpt-oss-120b",
+          "aliases": {
+            "gpt-oss-120b": "openai/gpt-oss-120b",
+            "openai/gpt-oss-120b": null,
+            "gpt-oss-20b": "openai/gpt-oss-20b",
+            "openai/gpt-oss-20b": null
+          }
+        }
+      }
+    }
+  },
+  {
+    "module": ".minichain.backends.impls.groq.stream",
+    "attr": null,
+    "file": "ommlds/minichain/backends/impls/groq/stream.py",
+    "line": 33,
+    "value": {
+      "!.minichain.registries.manifests.RegistryManifest": {
+        "module": "ommlds.minichain.backends.impls.groq.stream",
+        "attr": "GroqChatChoicesStreamService",
+        "name": "groq",
+        "aliases": null,
+        "type": "ChatChoicesStreamService"
+      }
+    }
+  },
   {
     "module": ".minichain.backends.impls.huggingface.repos",
     "attr": null,
@@ -440,7 +494,7 @@
   },
   {
     "module": ".minichain.backends.impls.openai.names",
-    "attr": "_BACKEND_STRINGS_MANIFEST",
+    "attr": "_CHAT_BACKEND_STRINGS_MANIFEST",
     "file": "ommlds/minichain/backends/impls/openai/names.py",
     "line": 63,
     "value": {
@@ -490,6 +544,36 @@
       }
     }
   },
+  {
+    "module": ".minichain.backends.impls.openai.names",
+    "attr": "_COMPLETION_BACKEND_STRINGS_MANIFEST",
+    "file": "ommlds/minichain/backends/impls/openai/names.py",
+    "line": 77,
+    "value": {
+      "!.minichain.backends.strings.manifests.BackendStringsManifest": {
+        "service_cls_names": [
+          "CompletionService"
+        ],
+        "backend_name": "openai",
+        "model_names": null
+      }
+    }
+  },
+  {
+    "module": ".minichain.backends.impls.openai.names",
+    "attr": "_EMBEDDING_BACKEND_STRINGS_MANIFEST",
+    "file": "ommlds/minichain/backends/impls/openai/names.py",
+    "line": 89,
+    "value": {
+      "!.minichain.backends.strings.manifests.BackendStringsManifest": {
+        "service_cls_names": [
+          "EmbeddingService"
+        ],
+        "backend_name": "openai",
+        "model_names": null
+      }
+    }
+  },
   {
     "module": ".minichain.backends.impls.openai.stream",
     "attr": null,

ommlds/__about__.py

@@ -60,7 +60,7 @@ class Project(ProjectBase):
         ],
 
         'search': [
-            'ddgs ~= 9.8',
+            'ddgs ~= 9.9',
         ],
 
         'wiki': [

ommlds/backends/groq/_marshal.py

@@ -0,0 +1,23 @@
+from omlish import lang
+from omlish import marshal as msh
+
+from .protocol import ChatCompletionRequest
+
+
+##
+
+
+@lang.static_init
+def _install_standard_marshaling() -> None:
+    for root_cls, tag_field in [
+        (ChatCompletionRequest.Message, 'role'),
+    ]:
+        msh.install_standard_factories(*msh.standard_polymorphism_factories(
+            msh.polymorphism_from_subclasses(
+                root_cls,
+                naming=msh.Naming.SNAKE,
+                strip_suffix=msh.AutoStripSuffix,
+            ),
+            msh.FieldTypeTagging(tag_field),
+            unions='partial',
+        ))

ommlds/backends/groq/protocol.py

@@ -0,0 +1,249 @@
+"""
+https://console.groq.com/docs/api-reference#chat-create
+"""
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish import marshal as msh
+
+
+##
+
+
+def _set_class_marshal_options(cls):
+    msh.update_object_metadata(
+        cls,
+        field_defaults=msh.FieldMetadata(
+            options=msh.FieldOptions(
+                omit_if=lang.is_none,
+            ),
+        ),
+    )
+
+    return cls
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionRequest(lang.Final):
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Message(lang.Sealed, lang.Abstract):
+        pass
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class SystemMessage(Message, lang.Final):
+        content: str | ta.Sequence[str]
+        name: str | None = None
+        role: ta.Literal['system'] = 'system'
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class UserMessage(Message, lang.Final):
+        content: str | ta.Sequence[str]
+        name: str | None = None
+        role: ta.Literal['user'] = 'user'
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class AssistantMessage(Message, lang.Final):
+        content: str | ta.Sequence[str] | None = None
+        name: str | None = None
+        reasoning: str | None = None
+        role: ta.Literal['assistant'] = 'assistant'
+
+        @dc.dataclass(frozen=True, kw_only=True)
+        @_set_class_marshal_options
+        class ToolCall(lang.Final):
+            @dc.dataclass(frozen=True, kw_only=True)
+            @_set_class_marshal_options
+            class Function(lang.Final):
+                arguments: str
+                name: str
+
+            function: Function
+            id: str
+            type: ta.Literal['function'] = 'function'
+
+        tool_calls: ta.Sequence[ToolCall] | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class ToolMessage(Message, lang.Final):
+        content: str | ta.Sequence[str]
+        role: ta.Literal['tool'] = 'tool'
+        tool_call_id: str
+
+    messages: ta.Sequence[Message]
+    model: str
+    citation_options: ta.Literal['enabled', 'disabled'] | None = None
+    compound_custom: ta.Mapping[str, ta.Any] | None = None
+    disable_tool_validation: bool | None = None
+    documents: ta.Sequence[ta.Mapping[str, ta.Any]] | None = None
+    frequency_penalty: float | None = None
+    include_reasoning: bool | None = None
+    logit_bias: ta.Mapping[str, ta.Any] | None = None
+    logprobs: bool | None = None
+    max_completion_tokens: int | None = None
+    n: int | None = None
+    parallel_tool_calls: bool | None = None
+    presence_penalty: float | None = None
+    reasoning_effort: ta.Literal['none', 'default', 'low', 'medium', 'high'] | None = None
+    reasoning_format: ta.Literal['hidden', 'raw', 'parsed'] | None = None
+    response_format: ta.Any | None = None
+    search_settings: ta.Mapping[str, ta.Any] | None = None
+    seed: int | None = None
+    service_tier: ta.Literal['auto', 'on_demand', 'flex', 'performance', 'null'] | None = None
+    stop: str | ta.Sequence[str] | None = None
+    store: bool | None = None
+    stream: bool | None = None
+    stream_options: ta.Mapping[str, ta.Any] | None = None
+    temperature: float | None = None
+    ool_choice: str | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Tool(lang.Final):
+        @dc.dataclass(frozen=True, kw_only=True)
+        @_set_class_marshal_options
+        class Function(lang.Final):
+            description: str | None = None
+            name: str
+            parameters: ta.Mapping[str, ta.Any] | None = None  # json schema
+            strict: bool | None = None
+
+        function: Function
+        type: ta.Literal['function', 'browser_search', 'code_interpreter'] = 'function'
+
+    tools: ta.Sequence[Tool] | None = None
+
+    top_logprobs: int | None = None
+    top_p: float | None = None
+    user: str | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ExecutedTool(lang.Final):
+    arguments: str
+    index: int
+    type: str
+    browser_results: ta.Sequence[ta.Any] | None = None
+    code_results: ta.Sequence[ta.Any] | None = None
+    output: str | None = None
+    search_results: ta.Any | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionResponse(lang.Final):
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Choice(lang.Final):
+        finish_reason: ta.Literal['stop', 'length', 'tool_calls', 'function_call']
+        index: int
+        logprobs: ta.Mapping[str, ta.Any] | None = None
+
+        @dc.dataclass(frozen=True, kw_only=True)
+        @_set_class_marshal_options
+        class Message(lang.Final):
+            annotations: ta.Sequence[ta.Mapping[str, ta.Any]] | None = None
+            content: str | None = None
+
+            executed_tools: ta.Sequence[ExecutedTool] | None = None
+
+            reasoning: str | None = None
+            role: ta.Literal['assistant'] = 'assistant'
+
+            @dc.dataclass(frozen=True, kw_only=True)
+            @_set_class_marshal_options
+            class ToolCall(lang.Final):
+                id: str
+
+                @dc.dataclass(frozen=True, kw_only=True)
+                @_set_class_marshal_options
+                class Function(lang.Final):
+                    arguments: str
+                    name: str
+
+                function: Function
+                type: ta.Literal['function'] = 'function'
+
+            tool_calls: ta.Sequence[ToolCall] | None = None
+
+        message: Message
+
+    choices: ta.Sequence[Choice]
+    created: int
+    id: str
+    model: str
+    object: ta.Literal['chat.completion'] = 'chat.completion'
+    system_fingerprint: str
+    usage: ta.Mapping[str, ta.Any] | None = None
+    usage_breakdown: ta.Mapping[str, ta.Any] | None = None
+    x_groq: ta.Mapping[str, ta.Any] | None = None
+    service_tier: str | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionChunk(lang.Final):
+    id: str
+    object: ta.Literal['chat.completion.chunk'] = 'chat.completion.chunk'
+    created: int
+    model: str
+    system_fingerprint: str
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Choice(lang.Final):
+        index: int
+
+        @dc.dataclass(frozen=True, kw_only=True)
+        @_set_class_marshal_options
+        class Delta(lang.Final):
+            role: str | None = None
+            content: str | None = None
+
+            channel: str | None = None
+            reasoning: str | None = None
+
+            @dc.dataclass(frozen=True, kw_only=True)
+            @_set_class_marshal_options
+            class ToolCall(lang.Final):
+                index: int
+                id: str | None = None
+
+                @dc.dataclass(frozen=True, kw_only=True)
+                @_set_class_marshal_options
+                class Function(lang.Final):
+                    arguments: str | None = None
+                    name: str | None = None
+
+                function: Function | None = None
+
+                type: ta.Literal['function'] = 'function'
+
+            tool_calls: ta.Sequence[ToolCall] | None = None
+
+            executed_tools: ta.Sequence[ExecutedTool] | None = None
+
+        delta: Delta
+        logprobs: ta.Mapping[str, ta.Any] | None = None
+        finish_reason: ta.Literal['stop', 'length', 'tool_calls', 'function_call'] | None = None
+
+    choices: ta.Sequence[Choice]
+
+    x_groq: ta.Mapping[str, ta.Any] | None = None
+    service_tier: str | None = None
+    usage: ta.Mapping[str, ta.Any] | None = None
+
+
+##
+
+
+msh.register_global_module_import('._marshal', __package__)

ommlds/cli/{sessions/chat/backends → backends}/catalog.py

@@ -3,12 +3,15 @@ import typing as ta
 
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 from .types import BackendConfigs
 from .types import BackendName
 from .types import BackendProvider
 from .types import ChatChoicesServiceBackendProvider
 from .types import ChatChoicesStreamServiceBackendProvider
+from .types import CompletionServiceBackendProvider
+from .types import DefaultBackendName
+from .types import EmbeddingServiceBackendProvider
 from .types import ServiceT
 
 
@@ -22,7 +25,8 @@ class CatalogBackendProvider(BackendProvider[ServiceT], lang.Abstract):
     def __init__(
             self,
             *,
-            name: BackendName,
+            name: BackendName | None = None,
+            default_name: DefaultBackendName | None = None,
             catalog: 'mc.BackendCatalog',
             configs: BackendConfigs | None = None,
             instantiator: Instantiator | None = None,
@@ -30,6 +34,7 @@ class CatalogBackendProvider(BackendProvider[ServiceT], lang.Abstract):
         super().__init__()
 
         self._name = name
+        self._default_name = default_name
         self._catalog = catalog
         self._configs = configs
         if instantiator is None:
@@ -38,13 +43,24 @@ class CatalogBackendProvider(BackendProvider[ServiceT], lang.Abstract):
 
     @contextlib.asynccontextmanager
     async def _provide_backend(self, cls: type[ServiceT]) -> ta.AsyncIterator[ServiceT]:
-        be = self._catalog.get_backend(cls, self._name)
+        name: str
+        if self._name is not None:
+            name = self._name
+        elif self._default_name is not None:
+            name = self._default_name
+        else:
+            raise RuntimeError('No backend name specified')
+
+        be = self._catalog.get_backend(cls, name)
 
         service: ServiceT
         async with lang.async_or_sync_maybe_managing(await self._instantiator(be, self._configs)) as service:
             yield service
 
 
+##
+
+
 class CatalogChatChoicesServiceBackendProvider(
     CatalogBackendProvider['mc.ChatChoicesService'],
     ChatChoicesServiceBackendProvider,
@@ -59,3 +75,19 @@ class CatalogChatChoicesStreamServiceBackendProvider(
 ):
     def provide_backend(self) -> ta.AsyncContextManager['mc.ChatChoicesStreamService']:
         return self._provide_backend(mc.ChatChoicesStreamService)  # type: ignore[type-abstract]
+
+
+class CatalogCompletionServiceBackendProvider(
+    CatalogBackendProvider['mc.CompletionService'],
+    CompletionServiceBackendProvider,
+):
+    def provide_backend(self) -> ta.AsyncContextManager['mc.CompletionService']:
+        return self._provide_backend(mc.CompletionService)  # type: ignore[type-abstract]
+
+
+class CatalogEmbeddingServiceBackendProvider(
+    CatalogBackendProvider['mc.EmbeddingService'],
+    EmbeddingServiceBackendProvider,
+):
+    def provide_backend(self) -> ta.AsyncContextManager['mc.EmbeddingService']:
+        return self._provide_backend(mc.EmbeddingService)  # type: ignore[type-abstract]

ommlds/cli/backends/configs.py

@@ -0,0 +1,9 @@
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class BackendConfig:
+    backend: str | None = None

ommlds/cli/backends/inject.py

@@ -2,69 +2,64 @@ import typing as ta
 
 from omlish import inject as inj
 from omlish import lang
+from omlish import typedvalues as tv
 
 from ... import minichain as mc
+from .configs import BackendConfig
+from .injection import backend_configs
+
+
+with lang.auto_proxy_import(globals()):
+    from ...minichain.backends.impls.huggingface import repos as hf_repos
+    from . import catalog as _catalog
+    from . import types as _types
 
 
 ##
 
 
-def bind_strings_backends() -> inj.Elements:
+def bind_backends(cfg: BackendConfig = BackendConfig()) -> inj.Elements:
     lst: list[inj.Elemental] = []
 
+    #
+
     lst.extend([
         inj.bind(mc.BackendStringBackendCatalog, singleton=True),
         inj.bind(mc.BackendCatalog, to_key=mc.BackendStringBackendCatalog),
     ])
 
-    from ...minichain.backends.impls.huggingface.repos import HuggingfaceModelRepoResolver
-
     lst.extend([
-        inj.bind(HuggingfaceModelRepoResolver, singleton=True),
-        inj.bind(mc.ModelRepoResolver, to_key=HuggingfaceModelRepoResolver),
+        inj.bind(hf_repos.HuggingfaceModelRepoResolver, singleton=True),
+        inj.bind(mc.ModelRepoResolver, to_key=hf_repos.HuggingfaceModelRepoResolver),
 
     ])
 
-    return inj.as_elements(*lst)
-
-
-def bind_simple_backends() -> inj.Elements:
-    lst: list[inj.Elemental] = []
+    #
 
-    lst.extend([
-        inj.set_binder[mc.SimpleBackendCatalogEntry](),
-        inj.bind(
-            lang.typed_lambda(mc.SimpleBackendCatalogEntries, s=ta.AbstractSet[mc.SimpleBackendCatalogEntry])(
-                lambda s: list(s),
-            ),
-            singleton=True,
-        ),
-    ])
+    lst.append(backend_configs().bind_items_provider(singleton=True))
 
-    lst.extend([
-        inj.bind(mc.SimpleBackendCatalog, singleton=True),
-        inj.bind(mc.BackendCatalog, to_key=mc.SimpleBackendCatalog),
-    ])
+    #
 
-    from .standard import STANDARD_BACKEND_CATALOG_ENTRIES
+    if cfg.backend is not None:
+        lst.append(inj.bind(_types.BackendName, to_const=cfg.backend))
 
     lst.extend([
-        inj.bind_set_entry_const(ta.AbstractSet[mc.SimpleBackendCatalogEntry], e)
-        for e in STANDARD_BACKEND_CATALOG_ENTRIES
+        inj.bind(_types.ChatChoicesServiceBackendProvider, to_ctor=_catalog.CatalogChatChoicesServiceBackendProvider, singleton=True),  # noqa
+        inj.bind(_types.ChatChoicesStreamServiceBackendProvider, to_ctor=_catalog.CatalogChatChoicesStreamServiceBackendProvider, singleton=True),  # noqa
+        inj.bind(_types.CompletionServiceBackendProvider, to_ctor=_catalog.CatalogCompletionServiceBackendProvider, singleton=True),  # noqa
+        inj.bind(_types.EmbeddingServiceBackendProvider, to_ctor=_catalog.CatalogEmbeddingServiceBackendProvider, singleton=True),  # noqa
     ])
 
-    return inj.as_elements(*lst)
+    #
 
+    async def catalog_backend_instantiator_provider(injector: inj.AsyncInjector) -> _catalog.CatalogBackendProvider.Instantiator:  # noqa
+        async def inner(be: 'mc.BackendCatalog.Backend', cfgs: _types.BackendConfigs | None) -> ta.Any:
+            kwt = inj.build_kwargs_target(be.factory, non_strict=True)
+            kw = await injector.provide_kwargs(kwt)
+            return be.factory(*tv.collect(*(be.configs or []), *(cfgs or []), override=True), **kw)
 
-def bind_backends(
-        *,
-        enable_backend_strings: bool = False,
-) -> inj.Elements:
-    lst: list[inj.Elemental] = []
+        return _catalog.CatalogBackendProvider.Instantiator(inner)
 
-    if enable_backend_strings:
-        lst.append(bind_strings_backends())
-    else:
-        lst.append(bind_simple_backends())
+    lst.append(inj.bind(_catalog.CatalogBackendProvider.Instantiator, to_async_fn=catalog_backend_instantiator_provider))  # noqa
 
     return inj.as_elements(*lst)

ommlds/cli/{sessions/chat/backends → backends}/injection.py

@@ -1,7 +1,7 @@
 from omlish import inject as inj
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 
 
 with lang.auto_proxy_import(globals()):

ommlds/cli/{sessions/chat/backends → backends}/types.py

@@ -3,7 +3,7 @@ import typing as ta
 
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 
 
 ServiceT = ta.TypeVar('ServiceT', bound=mc.Service)
@@ -13,6 +13,8 @@ ServiceT = ta.TypeVar('ServiceT', bound=mc.Service)
 
 
 BackendName = ta.NewType('BackendName', str)
+DefaultBackendName = ta.NewType('DefaultBackendName', str)
+
 BackendConfigs = ta.NewType('BackendConfigs', ta.Sequence['mc.Config'])
 
 
@@ -34,3 +36,11 @@ class ChatChoicesServiceBackendProvider(BackendProvider['mc.ChatChoicesService']
 
 class ChatChoicesStreamServiceBackendProvider(BackendProvider['mc.ChatChoicesStreamService'], lang.Abstract):
     pass
+
+
+class CompletionServiceBackendProvider(BackendProvider['mc.CompletionService'], lang.Abstract):
+    pass
+
+
+class EmbeddingServiceBackendProvider(BackendProvider['mc.EmbeddingService'], lang.Abstract):
+    pass

ommlds/cli/{sessions/chat/content → content}/messages.py

@@ -4,7 +4,7 @@ import typing as ta
 from omlish import check
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 
 
 ##

ommlds/cli/{sessions/chat/content → content}/strings.py

@@ -4,7 +4,7 @@ import typing as ta
 from omlish import lang
 from omlish.formats import json
 
-from ..... import minichain as mc
+from ... import minichain as mc
 
 
 ##

ommlds/cli/inject.py

@@ -6,7 +6,6 @@ from omlish import lang
 
 with lang.auto_proxy_import(globals()):
     from . import asyncs
-    from .backends import inject as _backends
     from .sessions import inject as _sessions
     from .state import inject as _state
 
@@ -17,17 +16,12 @@ with lang.auto_proxy_import(globals()):
 def bind_main(
         *,
         session_cfg: ta.Any,
-        enable_backend_strings: bool = False,
 ) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
 
     els.extend([
-        _backends.bind_backends(
-            enable_backend_strings=enable_backend_strings,
-        ),
-
         _sessions.bind_sessions(session_cfg),
 
         _state.bind_state(),