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

ommlds/cli/sessions/chat/tools/injection.py

@@ -0,0 +1,44 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import inject as inj
+from omlish import lang
+
+from ..... import minichain as mc
+from .configs import ToolSetConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from . import execution as _execution
+
+
+ToolSetConfigT = ta.TypeVar('ToolSetConfigT', bound='ToolSetConfig')
+
+
+##
+
+
+@lang.cached_function
+def tool_catalog_entries() -> 'inj.ItemsBinderHelper[mc.ToolCatalogEntry]':
+    return inj.items_binder_helper[mc.ToolCatalogEntry](mc.ToolCatalogEntries)
+
+
+@lang.cached_function
+def tool_context_providers() -> 'inj.ItemsBinderHelper[_execution.ToolContextProvider]':
+    return inj.items_binder_helper[_execution.ToolContextProvider](_execution.ToolContextProviders)
+
+
+def bind_tool_context_provider_to_key(key: ta.Any) -> inj.Elements:
+    return tool_context_providers().bind_item(to_fn=inj.KwargsTarget.of(
+        lambda v: _execution.ToolContextProvider(lambda: [v]),
+        v=key,
+    ), singleton=True)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ToolSetBinder(lang.Final, ta.Generic[ToolSetConfigT]):
+    cfg_cls: type[ToolSetConfig]
+    fn: ta.Callable[[ToolSetConfigT], inj.Elements]

ommlds/cli/sessions/chat/tools/rendering.py

@@ -0,0 +1,58 @@
+import typing as ta
+
+from ..... import minichain as mc
+from ....rendering.types import ContentRendering
+from .execution import ToolUseExecutor
+
+
+##
+
+
+class ArgsRenderingToolUseExecutor(ToolUseExecutor):
+    def __init__(
+            self,
+            *,
+            wrapped: ToolUseExecutor,
+            renderer: ContentRendering,
+    ) -> None:
+        super().__init__()
+
+        self._wrapped = wrapped
+        self._renderer = renderer
+
+    async def execute_tool_use(
+            self,
+            use: 'mc.ToolUse',
+            *ctx_items: ta.Any,
+    ) -> 'mc.ToolUseResultMessage':
+        await self._renderer.render_content(mc.JsonContent(dict(
+            id=use.id,
+            name=use.name,
+            args=use.args,
+        )))
+
+        return await self._wrapped.execute_tool_use(use, *ctx_items)
+
+
+class ResultRenderingToolUseExecutor(ToolUseExecutor):
+    def __init__(
+            self,
+            *,
+            wrapped: ToolUseExecutor,
+            renderer: ContentRendering,
+    ) -> None:
+        super().__init__()
+
+        self._wrapped = wrapped
+        self._renderer = renderer
+
+    async def execute_tool_use(
+            self,
+            use: 'mc.ToolUse',
+            *ctx_items: ta.Any,
+    ) -> 'mc.ToolUseResultMessage':
+        out = await self._wrapped.execute_tool_use(use, *ctx_items)
+
+        await self._renderer.render_content(out.tur.c)
+
+        return out

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)