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

ommlds/cli/sessions/chat/tools/todo/configs.py

@@ -0,0 +1,12 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..configs import ToolSetConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class TodoToolSetConfig(ToolSetConfig, lang.Final):
+    pass

ommlds/cli/sessions/chat/tools/todo/inject.py

@@ -0,0 +1,31 @@
+from omlish import inject as inj
+
+from ..injection import ToolSetBinder
+from ..injection import bind_tool_context_provider_to_key
+from ..injection import tool_catalog_entries
+from .configs import TodoToolSetConfig
+
+
+##
+
+
+def bind_todo_tools(cfg: TodoToolSetConfig) -> inj.Elements:
+    from ......minichain.lib.todo.context import TodoContext
+    from ......minichain.lib.todo.tools.read import todo_read_tool
+    from ......minichain.lib.todo.tools.write import todo_write_tool
+
+    return inj.as_elements(
+        tool_catalog_entries().bind_item_consts(
+            todo_read_tool(),
+            todo_write_tool(),
+        ),
+
+        inj.bind(TodoContext()),
+        bind_tool_context_provider_to_key(TodoContext),
+    )
+
+
+##
+
+
+TODO_TOOL_SET_BINDER = ToolSetBinder(TodoToolSetConfig, bind_todo_tools)

ommlds/cli/sessions/chat/tools/weather/configs.py

@@ -0,0 +1,12 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..configs import ToolSetConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class WeatherToolSetConfig(ToolSetConfig, lang.Final):
+    pass

ommlds/cli/sessions/chat/tools/weather/inject.py

@@ -0,0 +1,22 @@
+from omlish import inject as inj
+
+from ..injection import ToolSetBinder
+from ..injection import tool_catalog_entries
+from .configs import WeatherToolSetConfig
+
+
+##
+
+
+def bind_weather_tools(cfg: WeatherToolSetConfig) -> inj.Elements:
+    from .tools import WEATHER_TOOL
+
+    return inj.as_elements(
+        tool_catalog_entries().bind_item_consts(WEATHER_TOOL),
+    )
+
+
+##
+
+
+WEATHER_TOOL_SET_BINDER = ToolSetBinder(WeatherToolSetConfig, bind_weather_tools)

ommlds/cli/{tools/weather.py → sessions/chat/tools/weather/tools.py}

@@ -1,4 +1,4 @@
-from ... import minichain as mc
+from ...... import minichain as mc
 
 
 ##

ommlds/cli/sessions/completion/configs.py

@@ -0,0 +1,21 @@
+from omlish import dataclasses as dc
+
+from .... import minichain as mc
+
+
+##
+
+
+DEFAULT_BACKEND = 'openai'
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class CompletionConfig:
+    content: 'mc.Content'
+
+    _: dc.KW_ONLY
+
+    backend: str | None = None

ommlds/cli/sessions/completion/inject.py

@@ -0,0 +1,42 @@
+from omlish import dataclasses as dc
+from omlish import inject as inj
+from omlish import lang
+
+from ...backends.configs import BackendConfig
+from ...backends.types import DefaultBackendName
+from ..base import Session
+from .configs import DEFAULT_BACKEND
+from .configs import CompletionConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from ...backends import inject as _backends
+    from . import session as _session
+
+
+##
+
+
+def bind_completion(cfg: CompletionConfig) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.extend([
+        inj.bind(_session.CompletionSession.Config(**dc.asdict(cfg))),
+        inj.bind(Session, to_ctor=_session.CompletionSession, singleton=True),
+    ])
+
+    #
+
+    els.extend([
+        _backends.bind_backends(BackendConfig(
+            backend=cfg.backend,
+        )),
+
+        inj.bind(DefaultBackendName, to_const=DEFAULT_BACKEND),
+    ])
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/completion/session.py

@@ -0,0 +1,35 @@
+from omlish import check
+from omlish import dataclasses as dc
+
+from .... import minichain as mc
+from ...backends.types import CompletionServiceBackendProvider
+from ..base import Session
+from .configs import CompletionConfig
+
+
+##
+
+
+class CompletionSession(Session['CompletionSession.Config']):
+    @dc.dataclass(frozen=True)
+    class Config(Session.Config, CompletionConfig):
+        pass
+
+    def __init__(
+            self,
+            config: Config,
+            *,
+            service_provider: CompletionServiceBackendProvider,
+    ) -> None:
+        super().__init__(config)
+
+        self._service_provider = service_provider
+
+    async def run(self) -> None:
+        prompt = check.isinstance(self._config.content, str)
+
+        mdl: mc.CompletionService
+        async with self._service_provider.provide_backend() as mdl:
+            response = await mdl.invoke(mc.CompletionRequest(prompt))
+
+        print(response.v.strip())

ommlds/cli/sessions/embedding/configs.py

@@ -0,0 +1,21 @@
+from omlish import dataclasses as dc
+
+from .... import minichain as mc
+
+
+##
+
+
+DEFAULT_BACKEND = 'openai'
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class EmbeddingConfig:
+    content: 'mc.Content'
+
+    _: dc.KW_ONLY
+
+    backend: str | None = None

ommlds/cli/sessions/embedding/inject.py

@@ -0,0 +1,42 @@
+from omlish import dataclasses as dc
+from omlish import inject as inj
+from omlish import lang
+
+from ...backends.configs import BackendConfig
+from ...backends.types import DefaultBackendName
+from ..base import Session
+from .configs import DEFAULT_BACKEND
+from .configs import EmbeddingConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from ...backends import inject as _backends
+    from . import session as _session
+
+
+##
+
+
+def bind_embedding(cfg: EmbeddingConfig) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.extend([
+        inj.bind(_session.EmbeddingSession.Config(**dc.asdict(cfg))),
+        inj.bind(Session, to_ctor=_session.EmbeddingSession, singleton=True),
+    ])
+
+    #
+
+    els.extend([
+        _backends.bind_backends(BackendConfig(
+            backend=cfg.backend,
+        )),
+
+        inj.bind(DefaultBackendName, to_const=DEFAULT_BACKEND),
+    ])
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/embedding/session.py

@@ -0,0 +1,33 @@
+from omlish import dataclasses as dc
+from omlish.formats import json
+
+from .... import minichain as mc
+from ...backends.types import EmbeddingServiceBackendProvider
+from ..base import Session
+from .configs import EmbeddingConfig
+
+
+##
+
+
+class EmbeddingSession(Session['EmbeddingSession.Config']):
+    @dc.dataclass(frozen=True)
+    class Config(Session.Config, EmbeddingConfig):
+        pass
+
+    def __init__(
+            self,
+            config: Config,
+            *,
+            service_provider: EmbeddingServiceBackendProvider,
+    ) -> None:
+        super().__init__(config)
+
+        self._service_provider = service_provider
+
+    async def run(self) -> None:
+        mdl: mc.EmbeddingService
+        async with self._service_provider.provide_backend() as mdl:
+            response = await mdl.invoke(mc.EmbeddingRequest(self._config.content))
+
+        print(json.dumps_compact(list(map(float, response.v))))

ommlds/cli/sessions/inject.py

@@ -1,21 +1,38 @@
+import typing as ta
+
 from omlish import inject as inj
+from omlish import lang
+
 
-from .base import Session
-from .chat.base import ChatSession
-from .chat.inject import bind_chat_session
+with lang.auto_proxy_import(globals()):
+    from .chat import configs as _chat_cfgs
+    from .chat import inject as _chat_inj
+    from .completion import configs as _completion_cfgs
+    from .completion import inject as _completion_inj
+    from .embedding import configs as _embedding_cfgs
+    from .embedding import inject as _embedding_inj
 
 
 ##
 
 
-def bind_sessions(session_cfg: Session.Config) -> inj.Elements:
-    els: list[inj.Elemental] = [
-        inj.bind(session_cfg),
-        inj.bind(session_cfg.configurable_cls, singleton=True),
-        inj.bind(Session, to_key=session_cfg.configurable_cls),
-    ]
+def bind_sessions(cfg: ta.Any) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    if isinstance(cfg, _chat_cfgs.ChatConfig):
+        els.append(_chat_inj.bind_chat(cfg))
+
+    elif isinstance(cfg, _completion_cfgs.CompletionConfig):
+        els.append(_completion_inj.bind_completion(cfg))
+
+    elif isinstance(cfg, _embedding_cfgs.EmbeddingConfig):
+        els.append(_embedding_inj.bind_embedding(cfg))
+
+    else:
+        raise TypeError(cfg)
 
-    if isinstance(session_cfg, ChatSession.Config):
-        els.append(bind_chat_session(session_cfg))
+    #
 
     return inj.as_elements(*els)

ommlds/cli/state/inject.py

@@ -0,0 +1,28 @@
+import os.path
+
+from omdev.home.paths import get_home_paths
+from omlish import inject as inj
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from . import storage as _storage
+
+
+##
+
+
+def _provide_state_storage() -> '_storage.StateStorage':
+    state_dir = os.path.join(get_home_paths().state_dir, 'minichain', 'cli')
+    if not os.path.exists(state_dir):
+        os.makedirs(state_dir, exist_ok=True)
+        os.chmod(state_dir, 0o770)  # noqa
+
+    state_file = os.path.join(state_dir, 'state.json')
+    return _storage.JsonFileStateStorage(state_file)
+
+
+def bind_state() -> inj.Elements:
+    return inj.as_elements(
+        inj.bind(_provide_state_storage, singleton=True),
+    )

ommlds/cli/{state.py → state/storage.py}

@@ -1,8 +1,8 @@
 import abc
-import dataclasses as dc
 import os.path
 import typing as ta
 
+from omlish import dataclasses as dc
 from omlish import lang
 from omlish import marshal as msh
 from omlish.formats import json
@@ -14,6 +14,38 @@ T = ta.TypeVar('T')
 ##
 
 
+class StateStorage(lang.Abstract):
+    @abc.abstractmethod
+    def load_state(self, key: str, ty: type[T] | None) -> ta.Awaitable[T | None]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def save_state(self, key: str, obj: ta.Any | None, ty: type[T] | None) -> ta.Awaitable[None]:
+        raise NotImplementedError
+
+
+##
+
+
+class InMemoryStateStorage(StateStorage):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._dct: dict[str, ta.Any] = {}
+
+    async def load_state(self, key: str, ty: type[T] | None) -> T | None:
+        return self._dct.get(key)
+
+    async def save_state(self, key: str, obj: ta.Any | None, ty: type[T] | None) -> None:
+        if obj is None:
+            self._dct.pop(key, None)
+        else:
+            self._dct[key] = obj
+
+
+##
+
+
 STATE_VERSION = 0
 
 
@@ -23,10 +55,7 @@ class MarshaledState:
     payload: ta.Any
 
 
-#
-
-
-class StateStorage(lang.Abstract):
+class MarshalStateStorage(StateStorage, lang.Abstract):
     def __init__(
             self,
             *,
@@ -36,36 +65,24 @@ class StateStorage(lang.Abstract):
 
         self._version = version
 
-    #
-
-    def unmarshal_state(self, obj: ta.Any, ty: type[T] | None = None) -> T | None:
+    def _unmarshal_state(self, obj: ta.Any, ty: type[T] | None = None) -> T | None:
         ms = msh.unmarshal(obj, MarshaledState)
         if ms.version < self._version:
             return None
         return msh.unmarshal(ms.payload, ty)
 
-    def marshal_state(self, obj: ta.Any, ty: type | None = None) -> ta.Any:
+    def _marshal_state(self, obj: ta.Any, ty: type | None = None) -> ta.Any:
         ms = MarshaledState(
             version=self._version,
             payload=msh.marshal(obj, ty),
         )
         return msh.marshal(ms)
 
-    #
-
-    @abc.abstractmethod
-    def load_state(self, key: str, ty: type[T] | None) -> T | None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def save_state(self, key: str, obj: ta.Any | None, ty: type[T] | None) -> None:
-        raise NotImplementedError
-
 
 #
 
 
-class JsonFileStateStorage(StateStorage):
+class JsonFileStateStorage(MarshalStateStorage):
     def __init__(
             self,
             file: str,
@@ -91,19 +108,19 @@ class JsonFileStateStorage(StateStorage):
 
     #
 
-    def load_state(self, key: str, ty: type[T] | None) -> T | None:
+    async def load_state(self, key: str, ty: type[T] | None) -> T | None:
         if not (data := self._load_file_data()):
             return None
         if (dct := data.get(key)) is None:
             return None
-        return self.unmarshal_state(dct, ty)
+        return self._unmarshal_state(dct, ty)
 
-    def save_state(self, key: str, obj: ta.Any | None, ty: type[T] | None) -> None:
+    async def save_state(self, key: str, obj: ta.Any | None, ty: type[T] | None) -> None:
         if (data := self._load_file_data()) is None:
             data = {}
         if obj is None:
             data.pop(key, None)
         else:
-            dct = self.marshal_state(obj, ty)
+            dct = self._marshal_state(obj, ty)
             data[key] = dct
         self._save_file_data(data)

ommlds/minichain/__init__.py

@@ -65,6 +65,33 @@ with _lang.auto_proxy_init(
 
     ##
 
+    from .chat.choices.stream.adapters import (  # noqa
+        ChatChoicesStreamServiceChatChoicesService,
+    )
+
+    from .chat.choices.stream.joining import (  # noqa
+        AiChoicesDeltaJoiner,
+    )
+
+    from .chat.choices.stream.services import (  # noqa
+        ChatChoicesStreamRequest,
+        ChatChoicesStreamResponse,
+        ChatChoicesStreamService,
+        AbstractChatChoicesStreamService,
+        static_check_is_chat_choices_stream_service,
+    )
+
+    from .chat.choices.stream.types import (  # noqa
+        ChatChoicesStreamOption,
+        ChatChoicesStreamOptions,
+
+        ChatChoicesStreamOutput,
+        ChatChoicesStreamOutputs,
+
+        AiChoiceDeltas,
+        AiChoicesDeltas,
+    )
+
     from .chat.choices.adapters import (  # noqa
         ChatChoicesServiceChatService,
     )
@@ -88,35 +115,31 @@ with _lang.auto_proxy_init(
         AiChoices,
     )
 
-    from .chat.stream.adapters import (  # noqa
-        ChatChoicesStreamServiceChatChoicesService,
+    from .chat.stream.joining import (  # noqa
+        AiDeltaJoiner,
     )
 
     from .chat.stream.services import (  # noqa
-        ChatChoicesStreamRequest,
-        ChatChoicesStreamResponse,
-        ChatChoicesStreamService,
-        AbstractChatChoicesStreamService,
-        static_check_is_chat_choices_stream_service,
-
-        ChatChoicesStreamGenerator,
+        ChatStreamRequest,
+        ChatStreamResponse,
+        ChatStreamService,
+        AbstractChatStreamService,
+        static_check_is_chat_stream_service,
     )
 
     from .chat.stream.types import (  # noqa
-        ChatChoicesStreamOption,
-        ChatChoicesStreamOptions,
+        AiDelta,
+        AiDeltas,
 
-        ChatChoicesStreamOutput,
-        ChatChoicesStreamOutputs,
+        ContentAiDelta,
 
-        ToolExecRequestDelta,
-        AiMessageDelta,
-        AiChoiceDelta,
-        AiChoiceDeltas,
+        AnyToolUseAiDelta,
+        ToolUseAiDelta,
+        PartialToolUseAiDelta,
     )
 
     from .chat.tools.execution import (  # noqa
-        execute_tool_request,
+        execute_tool_use,
     )
 
     from .chat.transforms.base import (  # noqa
@@ -124,7 +147,6 @@ with _lang.auto_proxy_init(
         CompositeMessageTransform,
         FnMessageTransform,
         TypeFilteredMessageTransform,
-        fn_message_transform,
 
         ChatTransform,
         CompositeChatTransform,
@@ -155,12 +177,22 @@ with _lang.auto_proxy_init(
     )
 
     from .chat.messages import (  # noqa
-        AiMessage,
-        Chat,
         Message,
+        Chat,
+
+        AnyUserMessage,
+        UserChat,
+        check_user_chat,
+
+        AnyAiMessage,
+        AiChat,
+        check_ai_chat,
+
         SystemMessage,
-        ToolExecResultMessage,
         UserMessage,
+        AiMessage,
+        ToolUseMessage,
+        ToolUseResultMessage,
     )
 
     from .chat.services import (  # noqa
@@ -199,8 +231,14 @@ with _lang.auto_proxy_init(
         ImageContent,
     )
 
+    from .content.json import (  # noqa
+        JsonContent,
+    )
+
     from .content.materialize import (  # noqa
         CanContent,
+
+        materialize_content,
     )
 
     from .content.metadata import (  # noqa
@@ -270,6 +308,7 @@ with _lang.auto_proxy_init(
         TopK,
         Temperature,
         MaxTokens,
+        MaxCompletionTokens,
 
         LlmOutput,
 
@@ -301,6 +340,7 @@ with _lang.auto_proxy_init(
     ##
 
     from .registries.globals import (  # noqa
+        get_registry_cls,
         register_type,
         registry_new,
         registry_of,
@@ -322,7 +362,12 @@ with _lang.auto_proxy_init(
         StreamOption,
         StreamOptions,
 
-        ResponseGenerator,
+        StreamResponseSink,
+        StreamResponseIterator,
+
+        StreamServiceCancelledError,
+        StreamServiceNotAwaitedError,
+
         StreamResponse,
         new_stream_response,
     )
@@ -358,6 +403,10 @@ with _lang.auto_proxy_init(
         reflect_tool_catalog_entry,
     )
 
+    from .tools.execution.errors import (  # noqa
+        ToolExecutionError,
+    )
+
     from .tools.fns import (  # noqa
         ToolFn,
 
@@ -394,7 +443,8 @@ with _lang.auto_proxy_init(
 
         ToolSpec,
 
-        ToolExecRequest,
+        ToolUse,
+        ToolUseResult,
     )
 
     ##
@@ -486,6 +536,12 @@ with _lang.auto_proxy_init(
         EnvKey,
     )
 
+    from .json import (  # noqa
+        JsonSchema,
+
+        JsonValue,
+    )
+
     from .metadata import (  # noqa
         Metadata,
 
@@ -521,6 +577,10 @@ with _lang.auto_proxy_init(
     )
 
     from .standard import (  # noqa
+        Device,
+
+        ApiUrl,
+
         ApiKey,
 
         DefaultOptions,