ommlds 0.0.0.dev463__py3-none-any.whl → 0.0.0.dev465__py3-none-any.whl

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

@@ -0,0 +1,145 @@
+import os
+import typing as ta
+
+from omlish import check
+from omlish import inject as inj
+from omlish import lang
+
+from ..... import minichain as mc
+from .injection import bind_tool_context_provider_to_key
+from .injection import tool_catalog_entries
+from .injection import tool_context_providers
+
+
+with lang.auto_proxy_import(globals()):
+    from . import confirmation as _confirmation
+    from . import execution as _execution
+    from . import rendering as _rendering
+
+
+##
+
+
+_TOOL_BINDERS: dict[str, ta.Callable[[], inj.Elements]] = {}
+
+
+def _tool_binder(name: str) -> ta.Callable[[ta.Callable[[], inj.Elements]], ta.Callable[[], inj.Elements]]:
+    def inner(fn):
+        check.not_in(name, _TOOL_BINDERS)
+        _TOOL_BINDERS[name] = fn
+        return fn
+    return inner
+
+
+#
+
+
+@_tool_binder('weather')
+def _bind_weather_tool() -> inj.Elements:
+    from .weather import WEATHER_TOOL
+
+    return inj.as_elements(
+        tool_catalog_entries().bind_item_consts(WEATHER_TOOL),
+    )
+
+
+@_tool_binder('todo')
+def _bind_todo_tools() -> 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),
+    )
+
+
+@_tool_binder('fs')
+def _bind_fs_tools() -> inj.Elements:
+    from .....minichain.lib.fs.context import FsContext
+    from .....minichain.lib.fs.tools.ls import ls_tool
+    from .....minichain.lib.fs.tools.read import read_tool
+
+    return inj.as_elements(
+        tool_catalog_entries().bind_item_consts(
+            ls_tool(),
+            read_tool(),
+        ),
+
+        inj.bind(FsContext(
+            root_dir=os.getcwd(),
+        )),
+        bind_tool_context_provider_to_key(FsContext),
+    )
+
+
+# if tools_config.enable_unsafe_tools_do_not_use_lol:
+#     from ...minichain.lib.bash import bash_tool
+#     els.append(bind_tool(bash_tool()))
+#
+#     from ...minichain.lib.fs.tools.edit import edit_tool
+#     els.append(bind_tool(edit_tool()))
+
+
+##
+
+
+def bind_tools(
+        *,
+        silent: bool = False,
+        dangerous_no_confirmation: bool = False,
+        enabled_tools: ta.Iterable[str] | None = None,
+) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.append(inj.bind(mc.ToolCatalog, singleton=True))
+
+    #
+
+    els.append(tool_catalog_entries().bind_items_provider(singleton=True))
+
+    for etn in check.not_isinstance(enabled_tools or [], str):
+        els.append(_TOOL_BINDERS[etn]())
+
+    #
+
+    exec_stack = inj.wrapper_binder_helper(_execution.ToolUseExecutor)
+
+    els.append(exec_stack.push_bind(to_ctor=_execution.ToolUseExecutorImpl, singleton=True))
+
+    if not silent:
+        els.append(exec_stack.push_bind(to_ctor=_rendering.ResultRenderingToolUseExecutor, singleton=True))
+
+        if dangerous_no_confirmation:
+            els.append(exec_stack.push_bind(to_ctor=_rendering.ArgsRenderingToolUseExecutor, singleton=True))
+
+    els.extend([
+        inj.bind(_execution.ToolUseExecutor, to_key=exec_stack.top),
+    ])
+
+    #
+
+    if not dangerous_no_confirmation:
+        els.append(inj.bind(_confirmation.ToolExecutionConfirmation, to_ctor=_confirmation.InteractiveToolExecutionConfirmation, singleton=True))  # noqa
+
+    #
+
+    els.extend([
+        tool_context_providers().bind_items_provider(singleton=True),
+
+        inj.bind(_execution.ToolContextProvider, to_fn=lang.typed_lambda(tcps=_execution.ToolContextProviders)(
+            lambda tcps: _execution.ToolContextProvider(lambda: [tc for tcp in tcps for tc in tcp()]),
+        ), singleton=True),
+    ])
+
+    #
+
+    return inj.as_elements(*els)

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

@@ -0,0 +1,29 @@
+import typing as ta
+
+from omlish import inject as inj
+from omlish import lang
+
+from ..... import minichain as mc
+
+
+with lang.auto_proxy_import(globals()):
+    from . import execution as _execution
+
+##
+
+
+@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)

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/{tools → sessions/chat/tools}/weather.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 @@
+import dataclasses as dc
+
+from .... import minichain as mc
+
+
+##
+
+
+DEFAULT_COMPLETION_MODEL_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,28 @@
+from omlish import dataclasses as dc
+from omlish import inject as inj
+from omlish import lang
+
+from ..base import Session
+from .configs import CompletionConfig
+
+
+with lang.auto_proxy_import(globals()):
+    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),
+    ])
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/completion/{completion.py → session.py}

@@ -5,22 +5,17 @@ from omlish import lang
 
 from .... import minichain as mc
 from ..base import Session
+from .configs import DEFAULT_COMPLETION_MODEL_BACKEND
+from .configs import CompletionConfig
 
 
 ##
 
 
-DEFAULT_COMPLETION_MODEL_BACKEND = 'openai'
-
-
 class CompletionSession(Session['CompletionSession.Config']):
     @dc.dataclass(frozen=True)
-    class Config(Session.Config):
-        content: mc.Content
-
-        _: dc.KW_ONLY
-
-        backend: str | None = None
+    class Config(Session.Config, CompletionConfig):
+        pass
 
     def __init__(
             self,

ommlds/cli/sessions/embedding/configs.py

@@ -0,0 +1,21 @@
+import dataclasses as dc
+
+from .... import minichain as mc
+
+
+##
+
+
+DEFAULT_EMBEDDING_MODEL_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,28 @@
+from omlish import dataclasses as dc
+from omlish import inject as inj
+from omlish import lang
+
+from ..base import Session
+from .configs import EmbeddingConfig
+
+
+with lang.auto_proxy_import(globals()):
+    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),
+    ])
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/embedding/{embedding.py → session.py}

@@ -5,22 +5,17 @@ from omlish.formats import json
 
 from .... import minichain as mc
 from ..base import Session
+from .configs import DEFAULT_EMBEDDING_MODEL_BACKEND
+from .configs import EmbeddingConfig
 
 
 ##
 
 
-DEFAULT_EMBEDDING_MODEL_BACKEND = 'openai'
-
-
 class EmbeddingSession(Session['EmbeddingSession.Config']):
     @dc.dataclass(frozen=True)
-    class Config(Session.Config):
-        content: mc.Content
-
-        _: dc.KW_ONLY
-
-        backend: str | None = None
+    class Config(Session.Config, EmbeddingConfig):
+        pass
 
     def __init__(
             self,

ommlds/cli/sessions/inject.py

@@ -1,26 +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 .chat2.session import Chat2Session
+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))
 
-    if isinstance(session_cfg, ChatSession.Config):
-        from .chat.inject import bind_chat_session
-        els.append(bind_chat_session(session_cfg))
+    else:
+        raise TypeError(cfg)
 
-    elif isinstance(session_cfg, Chat2Session.Config):
-        from .chat2.inject import bind_chat
-        els.append(bind_chat(session_cfg))  # noqa
+    #
 
     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/minichain/backends/impls/anthropic/chat.py

@@ -22,15 +22,14 @@ from ....chat.messages import AnyAiMessage
 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 ....models.configs import ModelName
 from ....standard import ApiKey
-from ....tools.jsonschema import build_tool_spec_params_json_schema
 from ....tools.types import ToolUse
 from .names import MODEL_NAMES
+from .protocol import build_protocol_chat_messages
+from .protocol import build_protocol_tool
 
 
 ##
@@ -44,13 +43,6 @@ 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',
-        ToolUseMessage: 'assistant',
-    }
-
     def __init__(
             self,
             *configs: ApiKey | ModelName,
@@ -78,62 +70,13 @@ class AnthropicChatChoicesService:
             *,
             max_tokens: int = 4096,  # FIXME: ChatOption
     ) -> ChatChoicesResponse:
-        messages: list[pt.Message] = []
-        system: list[pt.Content] | 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 = [pt.Text(check.not_none(self._get_msg_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=self.ROLES_MAP[type(m)],  # noqa
-                #     content=[pt.Text(check.isinstance(self._get_msg_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=self.ROLES_MAP[type(m)],  # type: ignore[arg-type]
-                    content=[pt.Text(check.isinstance(self._get_msg_content(m), str))],
-                ))
+        messages, system = build_protocol_chat_messages(request.v)
 
         tools: list[pt.ToolSpec] = []
         with tv.TypedValues(*request.options).consume() as oc:
             t: Tool
             for t in oc.pop(Tool, []):
-                tools.append(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),
-                ))
+                tools.append(build_protocol_tool(t))
 
         a_req = pt.MessagesRequest(
             model=MODEL_NAMES.resolve(self._model_name.v),

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),
+    )