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

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

@@ -2,6 +2,7 @@ from omlish import inject as inj
 from omlish import lang
 
 from ...... import minichain as mc
+from .configs import AiConfig
 from .injection import chat_options_providers
 
 
@@ -15,12 +16,7 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-def bind_ai(
-        *,
-        stream: bool = False,
-        silent: bool = False,
-        enable_tools: bool = False,
-) -> inj.Elements:
+def bind_ai(cfg: AiConfig = AiConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
@@ -38,12 +34,12 @@ def bind_ai(
 
     ai_stack = inj.wrapper_binder_helper(_types.AiChatGenerator)
 
-    if stream:
+    if cfg.stream:
         stream_ai_stack = inj.wrapper_binder_helper(_types.StreamAiChatGenerator)
 
         els.append(stream_ai_stack.push_bind(to_ctor=_services.ChatChoicesStreamServiceStreamAiChatGenerator, singleton=True))  # noqa
 
-        if not silent:
+        if not cfg.silent:
             els.append(stream_ai_stack.push_bind(to_ctor=_rendering.RenderingStreamAiChatGenerator, singleton=True))
 
         els.extend([
@@ -54,17 +50,17 @@ def bind_ai(
     else:
         els.append(ai_stack.push_bind(to_ctor=_services.ChatChoicesServiceAiChatGenerator, singleton=True))
 
-        if not silent:
+        if not cfg.silent:
             els.append(ai_stack.push_bind(to_ctor=_rendering.RenderingAiChatGenerator, singleton=True))
 
-    if enable_tools:
+    if cfg.enable_tools:
         els.append(ai_stack.push_bind(to_ctor=_tools.ToolExecutingAiChatGenerator, singleton=True))
 
     els.append(inj.bind(_types.AiChatGenerator, to_key=ai_stack.top))
 
     #
 
-    if enable_tools:
+    if cfg.enable_tools:
         def _provide_tools_chat_choices_options_provider(tc: mc.ToolCatalog) -> _services.ChatChoicesServiceOptionsProvider:  # noqa
             return _services.ChatChoicesServiceOptionsProvider(lambda: [
                 mc.Tool(tce.spec)

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

@@ -1,10 +1,10 @@
 import typing as ta
 
 from ...... import minichain as mc
-from ...content.messages import MessageContentExtractor
-from ...content.messages import MessageContentExtractorImpl
-from ...rendering.types import ContentRendering
-from ...rendering.types import StreamContentRendering
+from .....content.messages import MessageContentExtractor
+from .....content.messages import MessageContentExtractorImpl
+from .....rendering.types import ContentRendering
+from .....rendering.types import StreamContentRendering
 from .types import AiChatGenerator
 from .types import StreamAiChatGenerator
 

ommlds/cli/sessions/chat/chat/ai/services.py

@@ -4,8 +4,8 @@ from omlish import check
 from omlish import lang
 
 from ...... import minichain as mc
-from ...backends.types import ChatChoicesServiceBackendProvider
-from ...backends.types import ChatChoicesStreamServiceBackendProvider
+from .....backends.types import ChatChoicesServiceBackendProvider
+from .....backends.types import ChatChoicesStreamServiceBackendProvider
 from .types import AiChatGenerator
 from .types import StreamAiChatGenerator
 

ommlds/cli/sessions/chat/chat/state/configs.py

@@ -0,0 +1,11 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class StateConfig:
+    state: ta.Literal['new', 'continue', 'ephemeral'] = 'continue'

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

@@ -1,11 +1,10 @@
-import typing as ta
-
 from omlish import inject as inj
 from omlish import lang
 
 from ...phases.injection import phase_callbacks
 from ...phases.types import ChatPhase
 from ...phases.types import ChatPhaseCallback
+from .configs import StateConfig
 
 
 with lang.auto_proxy_import(globals()):
@@ -17,24 +16,21 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-def bind_state(
-        *,
-        state: ta.Literal['new', 'continue', 'ephemeral'] = 'continue',
-) -> inj.Elements:
+def bind_state(cfg: StateConfig = StateConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
-    if state in ('continue', 'new'):
+    if cfg.state in ('continue', 'new'):
         els.append(inj.bind(_types.ChatStateManager, to_ctor=_storage.StateStorageChatStateManager, singleton=True))
 
-        if state == 'new':
+        if cfg.state == 'new':
             els.append(phase_callbacks().bind_item(to_fn=lang.typed_lambda(cm=_types.ChatStateManager)(
                 lambda cm: ChatPhaseCallback(ChatPhase.STARTING, cm.clear_state),
             )))
 
-    elif state == 'ephemeral':
+    elif cfg.state == 'ephemeral':
         els.append(inj.bind(_types.ChatStateManager, to_ctor=_inmemory.InMemoryChatStateManager, singleton=True))
 
     else:
-        raise TypeError(state)
+        raise TypeError(cfg.state)
 
     return inj.as_elements(*els)

ommlds/cli/sessions/chat/chat/state/inmemory.py

@@ -1,5 +1,4 @@
-import dataclasses as dc
-
+from omlish import dataclasses as dc
 from omlish import lang
 
 from ...... import minichain as mc

ommlds/cli/sessions/chat/chat/state/storage.py

@@ -1,6 +1,5 @@
-import dataclasses as dc
-
 from omlish import check
+from omlish import dataclasses as dc
 from omlish import lang
 
 from ...... import minichain as mc

ommlds/cli/sessions/chat/chat/state/types.py

@@ -1,8 +1,8 @@
 import abc
-import dataclasses as dc
 import datetime
 import typing as ta
 
+from omlish import dataclasses as dc
 from omlish import lang
 
 from ...... import minichain as mc

ommlds/cli/sessions/chat/chat/user/configs.py

@@ -0,0 +1,17 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+from ...... import minichain as mc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class UserConfig:
+    initial_system_content: ta.Optional['mc.Content'] = None
+    initial_user_content: ta.Optional['mc.Content'] = None
+
+    interactive: bool = False
+    use_readline: bool | ta.Literal['auto'] = 'auto'

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

@@ -1,5 +1,3 @@
-import typing as ta
-
 from omlish import inject as inj
 from omlish import lang
 
@@ -7,11 +5,13 @@ from ...... import minichain as mc
 from ...phases.injection import phase_callbacks
 from ...phases.types import ChatPhase
 from ...phases.types import ChatPhaseCallback
+from .configs import UserConfig
 
 
 with lang.auto_proxy_import(globals()):
+    from .....inputs import asyncs as _inputs_asyncs
+    from .....inputs import sync as _inputs_sync
     from ..state import types as _state
-    from . import inputs as _inputs
     from . import interactive as _interactive
     from . import oneshot as _oneshot
     from . import types as _types
@@ -20,28 +20,22 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-def bind_user(
-        *,
-        initial_system_content: ta.Optional['mc.Content'] = None,
-        initial_user_content: ta.Optional['mc.Content'] = None,
-        interactive: bool = False,
-        use_readline: bool | ta.Literal['auto'] = False,
-) -> inj.Elements:
+def bind_user(cfg: UserConfig = UserConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     # FIXME: barf
-    if initial_system_content is not None:
+    if cfg.initial_system_content is not None:
         async def add_initial_system_content(cm: '_state.ChatStateManager') -> None:
-            await cm.extend_chat([mc.SystemMessage(initial_system_content)])
+            await cm.extend_chat([mc.SystemMessage(cfg.initial_system_content)])
 
         els.append(phase_callbacks().bind_item(to_fn=lang.typed_lambda(cm=_state.ChatStateManager)(
             lambda cm: ChatPhaseCallback(ChatPhase.STARTED, lambda: add_initial_system_content(cm)),
         )))
 
-    if interactive:
-        if initial_user_content is not None:
+    if cfg.interactive:
+        if cfg.initial_user_content is not None:
             async def add_initial_user_content(cm: '_state.ChatStateManager') -> None:
-                await cm.extend_chat([mc.UserMessage(initial_user_content)])
+                await cm.extend_chat([mc.UserMessage(cfg.initial_user_content)])
 
             els.append(phase_callbacks().bind_item(to_fn=lang.typed_lambda(cm=_state.ChatStateManager)(
                 lambda cm: ChatPhaseCallback(ChatPhase.STARTED, lambda: add_initial_user_content(cm)),
@@ -52,16 +46,16 @@ def bind_user(
         els.append(inj.bind(_types.UserChatInput, to_ctor=_interactive.InteractiveUserChatInput, singleton=True))
 
         els.extend([
-            inj.bind(_inputs.SyncStringInput, to_const=_inputs.InputSyncStringInput(use_readline=use_readline)),  # noqa
-            inj.bind(_inputs.AsyncStringInput, to_ctor=_inputs.ThreadAsyncStringInput, singleton=True),
+            inj.bind(_inputs_sync.SyncStringInput, to_const=_inputs_sync.InputSyncStringInput(use_readline=cfg.use_readline)),  # noqa
+            inj.bind(_inputs_asyncs.AsyncStringInput, to_ctor=_inputs_asyncs.ThreadAsyncStringInput, singleton=True),
         ])
 
     else:
-        if initial_user_content is None:
+        if cfg.initial_user_content is None:
             raise ValueError('Initial user content is required for non-interactive chat')
 
         els.extend([
-            inj.bind(_oneshot.OneshotUserChatInputInitialChat, to_const=[mc.UserMessage(initial_user_content)]),
+            inj.bind(_oneshot.OneshotUserChatInputInitialChat, to_const=[mc.UserMessage(cfg.initial_user_content)]),
             inj.bind(_types.UserChatInput, to_ctor=_oneshot.OneshotUserChatInput, singleton=True),
         ])
 

ommlds/cli/sessions/chat/chat/user/interactive.py

@@ -1,9 +1,9 @@
 import typing as ta
 
 from ...... import minichain as mc
-from .inputs import AsyncStringInput
-from .inputs import InputSyncStringInput
-from .inputs import SyncAsyncStringInput
+from .....inputs.asyncs import AsyncStringInput
+from .....inputs.asyncs import SyncAsyncStringInput
+from .....inputs.sync import InputSyncStringInput
 from .types import UserChatInput
 
 

ommlds/cli/sessions/chat/configs.py

@@ -1,38 +1,27 @@
-import dataclasses as dc
-import typing as ta
+from omlish import dataclasses as dc
 
-from .... import minichain as mc
+from ...backends.configs import BackendConfig
+from ...rendering.configs import RenderingConfig
+from .chat.ai.configs import AiConfig
+from .chat.state.configs import StateConfig
+from .chat.user.configs import UserConfig
+from .tools.configs import ToolsConfig
 
 
 ##
 
 
-DEFAULT_CHAT_MODEL_BACKEND = 'openai'
+DEFAULT_BACKEND = 'openai'
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass(frozen=True, kw_only=True)
 class ChatConfig:
-    _: dc.KW_ONLY
-
-    backend: str | None = None
-    model_name: str | None = None
-
-    state: ta.Literal['new', 'continue', 'ephemeral'] = 'continue'
-
-    initial_system_content: ta.Optional['mc.Content'] = None
-    initial_user_content: ta.Optional['mc.Content'] = None
-
-    interactive: bool = False
-    use_readline: bool | ta.Literal['auto'] = 'auto'
-
-    silent: bool = False
-    markdown: bool = False
-
-    stream: bool = False
-
-    enable_tools: bool = False
-    enabled_tools: ta.AbstractSet[str] | None = None
-    dangerous_no_tool_confirmation: bool = False
+    backend: BackendConfig = BackendConfig()
+    ai: AiConfig = AiConfig()
+    state: StateConfig = StateConfig()
+    user: UserConfig = UserConfig()
+    rendering: RenderingConfig = RenderingConfig()
+    tools: ToolsConfig = ToolsConfig()

ommlds/cli/sessions/chat/inject.py

@@ -2,20 +2,21 @@ from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
+from ...backends.types import DefaultBackendName
 from ..base import Session
-from .configs import DEFAULT_CHAT_MODEL_BACKEND
+from .configs import DEFAULT_BACKEND
 from .configs import ChatConfig
 
 
 with lang.auto_proxy_import(globals()):
+    from ...backends import inject as _backends
+    from ...rendering import inject as _rendering
     from . import driver as _driver
     from . import session as _session
-    from .backends import inject as _backends
     from .chat.ai import inject as _chat_ai
     from .chat.state import inject as _chat_state
     from .chat.user import inject as _chat_user
     from .phases import inject as _phases
-    from .rendering import inject as _rendering
     from .tools import inject as _tools
 
 
@@ -28,42 +29,20 @@ def bind_chat(cfg: ChatConfig) -> inj.Elements:
     #
 
     els.extend([
-        _backends.bind_backends(
-            backend=cfg.backend or DEFAULT_CHAT_MODEL_BACKEND,
-        ),
-
-        _chat_ai.bind_ai(
-            stream=cfg.stream,
-            silent=cfg.silent,
-            enable_tools=cfg.enable_tools,
-        ),
-
-        _chat_user.bind_user(
-            initial_system_content=cfg.initial_system_content,
-            initial_user_content=cfg.initial_user_content,
-            interactive=cfg.interactive,
-            use_readline=cfg.use_readline,
-        ),
-
-        _chat_state.bind_state(
-            state=cfg.state,
-        ),
+        _backends.bind_backends(cfg.backend),
 
-        _phases.bind_phases(),
+        _chat_ai.bind_ai(cfg.ai),
 
-        _rendering.bind_rendering(
-            markdown=cfg.markdown,
-        ),
-    ])
+        _chat_user.bind_user(cfg.user),
 
-    #
+        _chat_state.bind_state(cfg.state),
+
+        _phases.bind_phases(),
 
-    if cfg.enable_tools:
-        els.append(_tools.bind_tools(
-            silent=cfg.silent,
-            dangerous_no_confirmation=cfg.dangerous_no_tool_confirmation,
-            enabled_tools=cfg.enabled_tools,
-        ))
+        _rendering.bind_rendering(cfg.rendering),
+
+        _tools.bind_tools(cfg.tools),
+    ])
 
     #
 
@@ -80,4 +59,8 @@ def bind_chat(cfg: ChatConfig) -> inj.Elements:
 
     #
 
+    els.append(inj.bind(DefaultBackendName, to_const=DEFAULT_BACKEND))
+
+    #
+
     return inj.as_elements(*els)

ommlds/cli/sessions/chat/session.py

@@ -1,4 +1,4 @@
-import dataclasses as dc
+from omlish import dataclasses as dc
 
 from ..base import Session
 from .configs import ChatConfig

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

@@ -0,0 +1,22 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ToolsConfig:
+    silent: bool = False
+    dangerous_no_confirmation: bool = False
+    enabled_tools: ta.Iterable[str] | None = None
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ToolSetConfig(lang.Abstract):
+    pass

ommlds/cli/sessions/chat/tools/fs/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 FsToolSetConfig(ToolSetConfig, lang.Final):
+    pass

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

@@ -0,0 +1,35 @@
+import os
+
+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 FsToolSetConfig
+
+
+##
+
+
+def bind_fs_tools(cfg: FsToolSetConfig) -> 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),
+    )
+
+
+##
+
+
+FS_TOOL_SET_BINDER = ToolSetBinder(FsToolSetConfig, bind_fs_tools)

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

@@ -1,12 +1,10 @@
-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 .configs import ToolsConfig
+from .injection import ToolSetBinder
 from .injection import tool_catalog_entries
 from .injection import tool_context_providers
 
@@ -20,65 +18,6 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-_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()))
@@ -90,12 +29,7 @@ def _bind_fs_tools() -> inj.Elements:
 ##
 
 
-def bind_tools(
-        *,
-        silent: bool = False,
-        dangerous_no_confirmation: bool = False,
-        enabled_tools: ta.Iterable[str] | None = None,
-) -> inj.Elements:
+def bind_tools(cfg: ToolsConfig = ToolsConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
@@ -106,8 +40,17 @@ def bind_tools(
 
     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]())
+    for etn in check.not_isinstance(cfg.enabled_tools or [], str):
+        from .fs.inject import FS_TOOL_SET_BINDER
+        from .todo.inject import TODO_TOOL_SET_BINDER
+        from .weather.inject import WEATHER_TOOL_SET_BINDER
+        ts_binder: ToolSetBinder = {  # type: ignore[assignment]  # FIXME: placeholder obviously lol
+            'fs': FS_TOOL_SET_BINDER,
+            'todo': TODO_TOOL_SET_BINDER,
+            'weather': WEATHER_TOOL_SET_BINDER,
+        }[etn]
+
+        els.append(ts_binder.fn(ts_binder.cfg_cls()))
 
     #
 
@@ -115,10 +58,10 @@ def bind_tools(
 
     els.append(exec_stack.push_bind(to_ctor=_execution.ToolUseExecutorImpl, singleton=True))
 
-    if not silent:
+    if not cfg.silent:
         els.append(exec_stack.push_bind(to_ctor=_rendering.ResultRenderingToolUseExecutor, singleton=True))
 
-        if dangerous_no_confirmation:
+        if cfg.dangerous_no_confirmation:
             els.append(exec_stack.push_bind(to_ctor=_rendering.ArgsRenderingToolUseExecutor, singleton=True))
 
     els.extend([
@@ -127,7 +70,7 @@ def bind_tools(
 
     #
 
-    if not dangerous_no_confirmation:
+    if not cfg.dangerous_no_confirmation:
         els.append(inj.bind(_confirmation.ToolExecutionConfirmation, to_ctor=_confirmation.InteractiveToolExecutionConfirmation, singleton=True))  # noqa
 
     #

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

@@ -1,14 +1,20 @@
 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')
+
+
 ##
 
 
@@ -27,3 +33,12 @@ def bind_tool_context_provider_to_key(key: ta.Any) -> inj.Elements:
         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

@@ -1,7 +1,7 @@
 import typing as ta
 
 from ..... import minichain as mc
-from ..rendering.types import ContentRendering
+from ....rendering.types import ContentRendering
 from .execution import ToolUseExecutor