ommlds 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev449__py3-none-any.whl

ommlds/.omlish-manifests.json

@@ -138,7 +138,7 @@
     "module": ".minichain.backends.impls.google.stream",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/google/stream.py",
-    "line": 34,
+    "line": 36,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.google.stream",

ommlds/cli/sessions/chat/prompt.py

@@ -1,4 +1,5 @@
 import dataclasses as dc
+import os
 
 from omlish import check
 from omlish import lang
@@ -125,7 +126,13 @@ class PromptChatSession(ChatSession['PromptChatSession.Config']):
 
                 tr: mc.ToolExecRequest = check.single(check.not_none(trs))
 
-                trm = await self._tool_exec_request_executor.execute_tool_request(tr)
+                # FIXME: lol
+                from ....minichain.lib.fs.context import FsToolContext
+
+                trm = await self._tool_exec_request_executor.execute_tool_request(
+                    tr,
+                    FsToolContext(root_dir=os.getcwd()),
+                )
 
                 print(trm.c)
                 new_chat.append(trm)

ommlds/cli/sessions/chat/tools.py

@@ -63,7 +63,11 @@ class AskingToolExecutionConfirmation(ToolExecutionConfirmation):
 
 class ToolExecRequestExecutor(lang.Abstract):
     @abc.abstractmethod
-    def execute_tool_request(self, tr: mc.ToolExecRequest) -> ta.Awaitable[mc.ToolExecResultMessage]:
+    def execute_tool_request(
+            self,
+            tr: mc.ToolExecRequest,
+            *ctx_items: ta.Any,
+    ) -> ta.Awaitable[mc.ToolExecResultMessage]:
         raise NotImplementedError
 
 
@@ -79,13 +83,20 @@ class ToolExecRequestExecutorImpl(ToolExecRequestExecutor):
         self._catalog = catalog
         self._confirmation = confirmation
 
-    async def execute_tool_request(self, tr: mc.ToolExecRequest) -> mc.ToolExecResultMessage:
+    async def execute_tool_request(
+            self,
+            tr: mc.ToolExecRequest,
+            *ctx_items: ta.Any,
+    ) -> mc.ToolExecResultMessage:
         tce = self._catalog.by_name[check.non_empty_str(tr.name)]
 
         await self._confirmation.confirm_tool_execution_or_raise(tr, tce)
 
         return await mc.execute_tool_request(
-            mc.ToolContext(),
+            mc.ToolContext(
+                tr,
+                *ctx_items,
+            ),
             tce.executor(),
             tr,
         )

ommlds/cli/tools/inject.py

@@ -47,13 +47,14 @@ def bind_tools(tools_config: ToolsConfig) -> inj.Elements:
     #
 
     if tools_config.enable_fs_tools:
-        from ...minichain.lib.fs.ls.execution import ls_tool
-
+        from ...minichain.lib.fs.catalog.ls import ls_tool
         els.append(bind_tool(ls_tool()))
 
+        from ...minichain.lib.fs.catalog.read import read_tool
+        els.append(bind_tool(read_tool()))
+
     if tools_config.enable_unsafe_bash_tool:
         from ...minichain.lib.bash import bash_tool
-
         els.append(bind_tool(bash_tool()))
 
     if tools_config.enable_test_weather_tool:

ommlds/minichain/__init__.py

@@ -361,6 +361,10 @@ with _lang.auto_proxy_init(
         reflect_tool_catalog_entry,
     )
 
+    from .tools.execution.errors import (  # noqa
+        ToolExecutionError,
+    )
+
     from .tools.fns import (  # noqa
         ToolFn,
 

ommlds/minichain/backends/impls/google/stream.py

@@ -19,7 +19,9 @@ from ....chat.messages import UserMessage
 from ....chat.stream.services import ChatChoicesStreamRequest
 from ....chat.stream.services import ChatChoicesStreamResponse
 from ....chat.stream.services import static_check_is_chat_choices_stream_service
+from ....chat.stream.types import AiChoiceDelta
 from ....chat.stream.types import AiChoiceDeltas
+from ....chat.stream.types import AiMessageDelta
 from ....models.configs import ModelName
 from ....resources import UseResources
 from ....standard import ApiKey
@@ -64,6 +66,8 @@ class GoogleChatChoicesStreamService:
         AiMessage: 'assistant',
     }
 
+    READ_CHUNK_SIZE = 64 * 1024
+
     async def invoke(
             self,
             request: ChatChoicesStreamRequest,
@@ -87,7 +91,7 @@ class GoogleChatChoicesStreamService:
         model_name = MODEL_NAMES.resolve(self._model_name.v)
 
         http_request = http.HttpRequest(
-            f'{self.BASE_URL.rstrip("/")}/{model_name}:generateContent?key={key}',
+            f'{self.BASE_URL.rstrip("/")}/{model_name}:streamGenerateContent?alt=sse&key={key}',
             headers={'Content-Type': 'application/json'},
             data=json.dumps_compact(req_dct).encode('utf-8'),
             method='POST',
@@ -111,6 +115,11 @@ class GoogleChatChoicesStreamService:
                             continue
                         if l.startswith('data: '):
                             gcr = msh.unmarshal(json.loads(l[6:]), pt.GenerateContentResponse)  # noqa
-                            await sink.emit([])
+                            cnd = check.single(check.not_none(gcr.candidates))
+                            for p in check.not_none(cnd.content).parts or []:
+                                await sink.emit([AiChoiceDelta(AiMessageDelta(check.not_none(p.text)))])
+
+                    if not b:
+                        return []
 
             return await new_stream_response(rs, inner)

ommlds/minichain/lib/fs/binfiles.py

@@ -0,0 +1,108 @@
+import os.path
+import typing as ta
+
+
+##
+
+
+IMAGE_FILE_EXTENSIONS: ta.AbstractSet[str] = frozenset([
+    'jpg',
+    'jpeg',
+    'png',
+    'gif',
+    'bmp',
+    'webp',
+])
+
+
+ARCHIVE_FILE_EXTENSIONS: ta.AbstractSet[str] = frozenset([
+    'zip',
+    'tar',
+    'gz',
+    'xz',
+    '7z',
+])
+
+
+DOC_FILE_EXTENSIONS: ta.AbstractSet[str] = frozenset([
+    'doc',
+    'docx',
+    'xls',
+    'xlsx',
+    'ppt',
+    'pptx',
+    'odt',
+    'ods',
+    'odp',
+])
+
+
+EXECUTABLE_FILE_EXTENSIONS: ta.AbstractSet[str] = frozenset([
+    'exe',
+    'dll',
+    'so',
+
+    'obj',
+    'o',
+    'a',
+    'lib',
+
+    'class',
+    'jar',
+    'war',
+
+    'wasm',
+
+    'pyc',
+    'pyo',
+])
+
+
+BLOB_FILE_EXTENSIONS: ta.AbstractSet[str] = frozenset([
+    'bin',
+    'dat',
+])
+
+
+BINARY_FILE_EXTENSIONS: ta.AbstractSet[str] = frozenset([
+    *IMAGE_FILE_EXTENSIONS,
+    *ARCHIVE_FILE_EXTENSIONS,
+    *DOC_FILE_EXTENSIONS,
+    *EXECUTABLE_FILE_EXTENSIONS,
+    *BLOB_FILE_EXTENSIONS,
+])
+
+
+def has_binary_file_extension(file_path: str) -> bool:
+    return os.path.basename(file_path).partition('.')[-1] in BINARY_FILE_EXTENSIONS
+
+
+##
+
+
+def is_binary_file(
+        file_path: str,
+        *,
+        chunk_size: int = 0x1000,
+        non_printable_cutoff: float = .3,
+
+        st: os.stat_result | None = None,
+) -> bool:
+    if st is None:
+        try:
+            st = os.stat(file_path)
+        except OSError:
+            return False
+
+    if not st.st_size:
+        return False
+
+    with open(file_path, 'rb') as f:
+        chunk = f.read(chunk_size)
+
+    if 0 in chunk:
+        return True
+
+    # Count "non-printable" ASCII-ish control chars (excluding TAB/LF/CR)
+    np = sum(1 for b in chunk if b < 9 or (13 < b < 32))
+    return (np / len(chunk)) > non_printable_cutoff

ommlds/minichain/lib/fs/catalog/ls.py

@@ -0,0 +1,38 @@
+import io
+import os
+
+from omlish import lang
+
+from ....tools.execution.catalog import ToolCatalogEntry
+from ....tools.execution.reflect import reflect_tool_catalog_entry
+from ..context import fs_tool_context
+
+
+##
+
+
+def execute_ls_tool(
+        dir_path: str,
+) -> str:
+    """
+    Lists the contents of the specified dir.
+
+    Args:
+        dir_path: The dir to list the contents of. Must be an absolute path.
+    """
+
+    ft_ctx = fs_tool_context()
+    ft_ctx.check_stat_dir(dir_path)
+
+    out = io.StringIO()
+    out.write('<dir>\n')
+    for e in sorted(os.scandir(dir_path), key=lambda e: e.name):  # noqa
+        out.write(f'{e.name}{"/" if e.is_dir() else ""}\n')
+    out.write('</dir>\n')
+
+    return out.getvalue()
+
+
+@lang.cached_function
+def ls_tool() -> ToolCatalogEntry:
+    return reflect_tool_catalog_entry(execute_ls_tool)

ommlds/minichain/lib/fs/catalog/read.py

@@ -0,0 +1,115 @@
+"""
+TODO:
+ - better bad unicode handling
+ - read whole file if < some size, report filesize / num lines / mtime inline
+ - fs cache
+ - track changes
+"""
+import io
+import itertools
+
+from omlish import lang
+
+from ....tools.execution.catalog import ToolCatalogEntry
+from ....tools.execution.reflect import reflect_tool_catalog_entry
+from ....tools.reflect import tool_spec_override
+from ....tools.types import ToolParam
+from ..context import fs_tool_context
+
+
+##
+
+
+DEFAULT_MAX_NUM_LINES = 2_000
+
+MAX_LINE_LENGTH = 2_000
+
+
+@tool_spec_override(
+    desc=rf"""
+        Reads a file from the local filesystem. You can access any file directly by using this tool.
+
+        Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that
+        path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+        Usage:
+        - The file_path parameter must be an absolute path, not a relative path.
+        - By default, it reads up to {DEFAULT_MAX_NUM_LINES} lines starting from the beginning of the file.
+        - You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to
+          read the whole file by not providing these parameters.
+        - Any lines longer than {MAX_LINE_LENGTH} characters will be truncated with "...".
+        - Invalid unicode characters will be replaced with the unicode replacement character "\\ufffd".
+        - Results are returned using cat -n format, with line numbers starting at 1 and suffixed with a pipe character
+          "|".
+        - This tool cannot read binary files, including images.
+""",
+    params=[
+        ToolParam(
+            'file_path',
+            desc='The absolute path to the file to read.',
+        ),
+        ToolParam(
+            'line_offset',
+            desc='The line number to start reading from (0-based).',
+        ),
+        ToolParam(
+            'num_lines',
+            desc=f'The number of lines to read (defaults to {DEFAULT_MAX_NUM_LINES}).',
+        ),
+    ],
+)
+def execute_read_tool(
+        file_path: str,
+        *,
+        line_offset: int = 0,
+        num_lines: int = DEFAULT_MAX_NUM_LINES,
+) -> str:
+    ft_ctx = fs_tool_context()
+    ft_ctx.check_stat_file(file_path, text=True)
+
+    out = io.StringIO()
+    out.write('<file>\n')
+
+    zp = len(str(line_offset + num_lines))
+    n = line_offset
+    has_trunc = False  # noqa
+    with open(file_path, errors='replace') as f:
+        fi = iter(f)
+
+        for line in itertools.islice(fi, line_offset, line_offset + num_lines):
+            out.write(f'{str(n + 1).zfill(zp):}|')
+            line = line.removesuffix('\n')
+            if len(line) > MAX_LINE_LENGTH:
+                has_trunc = True  # noqa
+                out.write(line[:MAX_LINE_LENGTH])
+                out.write('...')
+            else:
+                out.write(line)
+            out.write('\n')
+            n += 1
+
+        # tl = n
+        # if (ml := lang.ilen(fi)):
+        #     check.state(n == num_lines)
+        #     tl += ml
+
+        try:
+            next(fi)
+        except StopIteration:
+            has_more = False
+        else:
+            has_more = True
+
+    out.write(f'</file>\n')
+
+    if has_more:
+        out.write(
+            f'\n(File has more lines. Use "line_offset" parameter to read beyond line {line_offset + num_lines}.)\n',
+        )
+
+    return out.getvalue()
+
+
+@lang.cached_function
+def read_tool() -> ToolCatalogEntry:
+    return reflect_tool_catalog_entry(execute_read_tool)

ommlds/minichain/lib/fs/catalog/recursivels/execution.py

@@ -0,0 +1,40 @@
+from omlish import lang
+
+from .....tools.execution.catalog import ToolCatalogEntry
+from .....tools.execution.reflect import reflect_tool_catalog_entry
+from ...context import fs_tool_context
+from .rendering import LsLinesRenderer
+from .running import LsRunner
+
+
+##
+
+
+def execute_recursive_ls_tool(
+        base_path: str,
+) -> str:
+    """
+    Recursively lists the directory contents of the given base path.
+
+    Args:
+        base_path: The path of the directory to list the contents of. Must be absolute.
+
+    Returns:
+        A formatted string of the recursive directory contents.
+    """
+
+    ft_ctx = fs_tool_context()
+    ft_ctx.check_requested_path(base_path)
+
+    root = LsRunner().run(base_path)
+    lines = LsLinesRenderer().render(root)
+    return '\n'.join([
+        '<dir>',
+        *lines.lines,
+        '</dir>',
+    ])
+
+
+@lang.cached_function
+def recursive_ls_tool() -> ToolCatalogEntry:
+    return reflect_tool_catalog_entry(execute_recursive_ls_tool)

ommlds/minichain/lib/fs/context.py

@@ -0,0 +1,112 @@
+import os.path
+import stat
+
+from omlish import check
+
+from ...tools.execution.context import tool_context
+from .binfiles import has_binary_file_extension
+from .binfiles import is_binary_file
+from .errors import RequestedPathDoesNotExistError
+from .errors import RequestedPathOutsideRootDirError
+from .errors import RequestedPathWrongTypeError
+from .suggestions import get_path_suggestions
+
+
+##
+
+
+class FsToolContext:
+    def __init__(
+            self,
+            *,
+            root_dir: str | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._root_dir = root_dir
+        self._abs_root_dir = os.path.abspath(root_dir) if root_dir is not None else None
+
+    #
+
+    def check_requested_path(self, req_path: str) -> None:
+        abs_req_path = os.path.abspath(req_path)
+
+        if (
+            self._abs_root_dir is None or
+            not (
+                abs_req_path == self._abs_root_dir or
+                abs_req_path.startswith(self._abs_root_dir + os.path.sep)
+            )
+        ):
+            raise RequestedPathOutsideRootDirError(
+                req_path,
+                root_dir=check.not_none(self._root_dir),
+            )
+
+    #
+
+    def check_stat_dir(
+            self,
+            req_path: str,
+    ) -> os.stat_result:
+        self.check_requested_path(req_path)
+
+        try:
+            st = os.stat(req_path)
+        except FileNotFoundError:
+            raise RequestedPathDoesNotExistError(
+                req_path,
+                suggested_paths=get_path_suggestions(
+                    req_path,
+                    filter=lambda e: e.is_dir(),
+                ),
+            ) from None
+
+        if not stat.S_ISDIR(st.st_mode):
+            raise RequestedPathWrongTypeError(
+                req_path,
+                expected_type='dir',
+                **(dict(actual_type='file') if stat.S_ISREG(st.st_mode) else {}),
+            )
+
+        return st
+
+    def check_stat_file(
+            self,
+            req_path: str,
+            *,
+            text: bool = False,
+    ) -> os.stat_result:
+        self.check_requested_path(req_path)
+
+        try:
+            st = os.stat(req_path)
+        except FileNotFoundError:
+            raise RequestedPathDoesNotExistError(
+                req_path,
+                suggested_paths=get_path_suggestions(
+                    req_path,
+                    filter=lambda e: (e.is_file() and not has_binary_file_extension(e.name)),
+                ),
+            ) from None
+
+        if not stat.S_ISREG(st.st_mode):
+            is_dir = stat.S_ISDIR(st.st_mode)
+            raise RequestedPathWrongTypeError(
+                req_path,
+                expected_type='file',
+                **(dict(actual_type='dir') if is_dir else {}),
+            )
+
+        if text and is_binary_file(req_path, st=st):
+            raise RequestedPathWrongTypeError(
+                req_path,
+                expected_type='text file',
+                actual_type='binary file',
+            )
+
+        return st
+
+
+def fs_tool_context() -> FsToolContext:
+    return tool_context()[FsToolContext]

ommlds/minichain/lib/fs/errors.py

@@ -0,0 +1,95 @@
+import typing as ta
+
+from omlish import lang
+
+from ...tools.execution.errors import ToolExecutionError
+
+
+##
+
+
+class FsToolExecutionError(ToolExecutionError, lang.Abstract):
+    pass
+
+
+##
+
+
+class RequestedPathError(FsToolExecutionError, lang.Abstract):
+    def __init__(self, requested_path: str, *args: ta.Any) -> None:
+        super().__init__(requested_path, *args)
+
+        self.requested_path = requested_path
+
+
+class RequestedPathMustBeAbsoluteError(RequestedPathError):
+    @property
+    def content(self) -> str:
+        return f'Requested path {self.requested_path!r} must be absolute.'
+
+
+class RequestedPathOutsideRootDirError(RequestedPathError):
+    def __init__(
+            self,
+            requested_path: str,
+            *,
+            root_dir: str,
+    ) -> None:
+        super().__init__(
+            requested_path,
+            root_dir,
+        )
+
+        self.root_dir = root_dir
+
+    @property
+    def content(self) -> str:
+        return f'Requested path {self.requested_path!r} was outside of permitted root directory {self.root_dir!r}.'
+
+
+class RequestedPathWrongTypeError(RequestedPathError):
+    def __init__(
+            self,
+            requested_path: str,
+            *,
+            expected_type: str,
+            actual_type: str | None = None,
+    ) -> None:
+        super().__init__(
+            requested_path,
+            expected_type,
+            actual_type,
+        )
+
+        self.expected_type = expected_type
+        self.actual_type = actual_type
+
+    @property
+    def content(self) -> str:
+        return ''.join([
+            f'Requested path {self.requested_path!r} must be of type {self.expected_type!r}',
+            *([f', but it is actually of type {self.actual_type!r}'] if self.actual_type is not None else []),
+            '.',
+        ])
+
+
+class RequestedPathDoesNotExistError(RequestedPathError):
+    def __init__(
+            self,
+            requested_path: str,
+            *,
+            suggested_paths: ta.Sequence[str] | None = None,
+    ) -> None:
+        super().__init__(
+            requested_path,
+            suggested_paths,
+        )
+
+        self.suggested_paths = suggested_paths
+
+    @property
+    def content(self) -> str:
+        return ''.join([
+            f'Requested path {self.requested_path!r} does not exist.',
+            *([f' Did you mean one of these valid paths: {self.suggested_paths!r}?'] if self.suggested_paths else []),
+        ])

ommlds/minichain/lib/fs/suggestions.py

@@ -0,0 +1,36 @@
+import difflib
+import os.path
+import typing as ta
+
+
+##
+
+
+def get_path_suggestions(
+        bad_path: str,
+        n: int = 3,
+        *,
+        filter: ta.Callable[[os.DirEntry], bool] | None = None,  # noqa
+        cutoff: float = .6,
+) -> ta.Sequence[str] | None:
+    dn = os.path.dirname(bad_path)
+    try:
+        sdi = os.scandir(dn)
+    except FileNotFoundError:
+        return None
+
+    fl = [
+        e.name
+        for e in sdi
+        if (filter is None or filter(e))
+    ]
+
+    return [
+        os.path.join(dn, sn)
+        for sn in difflib.get_close_matches(
+            os.path.basename(bad_path),
+            fl,
+            n,
+            cutoff=cutoff,
+        )
+    ]

ommlds/minichain/stream/services.py

@@ -1,5 +1,6 @@
 import abc
 import itertools
+import types
 import typing as ta
 
 from omlish import check
@@ -40,15 +41,11 @@ class StreamResponseSink(lang.Abstract, ta.Generic[V]):
         raise NotImplementedError
 
 
-class StreamResponseIterator(lang.Abstract, ta.Generic[V, OutputT]):
-    @abc.abstractmethod
-    def __aenter__(self) -> ta.Awaitable[ta.Self]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def __aexit__(self, exc_type, exc_val, exc_tb) -> ta.Awaitable[None]:
-        raise NotImplementedError
-
+class StreamResponseIterator(
+    ta.AsyncContextManager['StreamResponseIterator[V, OutputT]'],
+    lang.Abstract,
+    ta.Generic[V, OutputT],
+):
     @property
     @abc.abstractmethod
     def outputs(self) -> tv.TypedValues[OutputT]:
@@ -120,7 +117,8 @@ class _StreamServiceResponse(StreamResponseIterator[V, OutputT]):
         self._g = iter(self._a)
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+    @types.coroutine
+    def _aexit(self, exc_type, exc_val, exc_tb):
         old_state = self._state
         self._state = 'closed'
         if old_state != 'running':
@@ -137,7 +135,7 @@ class _StreamServiceResponse(StreamResponseIterator[V, OutputT]):
                     if cex2 is cex:
                         break
                     raise
-                await x
+                yield x
         if self._cr.cr_running:
             raise RuntimeError(f'Coroutine {self._cr!r} not terminated')
         if self._g is not self._a:
@@ -145,13 +143,17 @@ class _StreamServiceResponse(StreamResponseIterator[V, OutputT]):
         self._a.close()
         self._cr.close()
 
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        return await self._aexit(exc_type, exc_val, exc_tb)
+
     _outputs: tv.TypedValues[OutputT]
 
     @property
     def outputs(self) -> tv.TypedValues[OutputT]:
         return self._outputs
 
-    async def __anext__(self) -> V:
+    @types.coroutine
+    def _anext(self):
         check.state(self._state == 'running')
         while True:
             try:
@@ -168,7 +170,10 @@ class _StreamServiceResponse(StreamResponseIterator[V, OutputT]):
                 x.done = True
                 return x.value
 
-            await x
+            yield x
+
+    async def __anext__(self) -> V:
+        return await self._anext()
 
 
 ##

ommlds/minichain/tools/execution/context.py

@@ -2,8 +2,8 @@ import contextlib
 import contextvars
 import typing as ta
 
+from omlish import check
 from omlish import collections as col
-from omlish import dataclasses as dc
 from omlish import lang
 
 
@@ -13,30 +13,34 @@ T = ta.TypeVar('T')
 ##
 
 
-@dc.dataclass(frozen=True)
 class ToolContext(lang.Final):
-    dct: col.TypeMap = col.TypeMap()
+    def __init__(self, *items: ta.Any) -> None:
+        super().__init__()
 
-    @classmethod
-    def new(cls, *objs: ta.Any) -> 'ToolContext':
-        return cls(col.TypeMap(objs))
+        self._dct: col.TypeMap = col.TypeMap(items)
+        if ToolContext in self._dct:
+            raise KeyError(ToolContext)
 
-    #
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}<{", ".join(ic.__name__ for ic in self._dct)}>'
 
     def __len__(self) -> int:
-        return len(self.dct)
+        return len(self._dct)
 
     def __iter__(self) -> ta.Iterator[ta.Any]:
-        return iter(self.dct)
+        return iter(self._dct)
+
+    def __contains__(self, ty: type[T]) -> bool:
+        return ty in self._dct
 
     def get(self, ty: type[T]) -> T | None:
-        return self.dct.get(ty)
+        return self._dct.get(ty)
 
     def __getitem__(self, cls: type[T]) -> T:
-        return self.dct[cls]
+        return self._dct[cls]
 
     def get_any(self, cls: type | tuple[type, ...]) -> ta.Sequence[T]:
-        return self.dct.get_any(cls)
+        return self._dct.get_any(cls)
 
 
 ##
@@ -45,8 +49,24 @@ class ToolContext(lang.Final):
 _TOOL_CONTEXT: contextvars.ContextVar[ToolContext] = contextvars.ContextVar(f'{__name__}._TOOL_CONTEXT')
 
 
-@contextlib.contextmanager
-def bind_tool_context(ctx: ToolContext) -> ta.Generator[ToolContext]:
+@ta.overload
+def bind_tool_context(ctx: ToolContext) -> ta.ContextManager[ToolContext]:
+    ...
+
+
+@ta.overload
+def bind_tool_context(*items: ta.Any) -> ta.ContextManager[ToolContext]:
+    ...
+
+
+@contextlib.contextmanager  # type: ignore[misc]
+def bind_tool_context(*args):
+    if args and isinstance(args[0], ToolContext):
+        check.arg(len(args) == 1)
+        ctx = args[0]
+    else:
+        ctx = ToolContext(*args)
+
     try:
         cur = _TOOL_CONTEXT.get()
     except LookupError:

ommlds/minichain/tools/execution/errors.py

@@ -0,0 +1,15 @@
+import abc
+
+from omlish import lang
+
+from ...content.materialize import CanContent
+
+
+##
+
+
+class ToolExecutionError(Exception, lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def content(self) -> CanContent:
+        raise NotImplementedError

ommlds/minichain/tools/execution/reflect.py

@@ -1,6 +1,3 @@
-"""
-TODO:
-"""
 import inspect
 import typing as ta
 

ommlds/minichain/tools/reflect.py

@@ -23,6 +23,7 @@ from omlish import metadata as md
 from omlish import reflect as rfl
 from omlish.lite.cached import cached_nullary
 
+from ..content.materialize import CanContent
 from .types import EnumToolDtype
 from .types import MappingToolDtype
 from .types import NullableToolDtype
@@ -160,14 +161,22 @@ class ToolReflector:
 
         #
 
+        p_ovr_dct: dict[str, dict[str, ta.Any]] = {}
         ts_ovr: dict[str, ta.Any] = {}
+        o: _ToolSpecOverride
         for o in md.get_object_metadata(fn, type=_ToolSpecOverride):
-            # TODO: better params handling / merging
             ts_ovr.update({
                 k: v
                 for k, v in dc.asdict(o).items()
-                if v is not None
+                if k != 'params'
+                and v is not None
             })
+            for op in (o.params or []):
+                p_ovr_dct.setdefault(check.non_empty_str(op.name), {}).update({
+                    k: v
+                    for k, v in dc.asdict(op).items()
+                    if v is not None
+                })
 
         #
 
@@ -207,23 +216,39 @@ class ToolReflector:
         if 'params' not in ts_kw:
             ds_p_dct = {
                 ds_p.arg_name: ds_p
-                for ds_p in (ds.params if ds is not None else [])
+                for ds_p in (ds.params if ds is not None else {})
             }
 
-            params: dict[str, ToolParam] = {}
-            for sig_p in sig().parameters.values():
-                check.not_in(sig_p.name, params)
-
-                ds_p = ds_p_dct.get(sig_p.name)
-
-                params[sig_p.name] = ToolParam(
-                    sig_p.name,
+            sig_p_dct = sig().parameters
 
-                    desc=self._prepare_desc(ds_p.description) if ds_p is not None else None,
+            pns: list[str] = list({**p_ovr_dct, **ds_p_dct, **sig_p_dct})
 
-                    type=self.reflect_type(rfl.type_(th()[sig_p.name])) if sig_p.name in th() else None,
-
-                    required=sig_p.default is inspect.Parameter.empty,
+            params: dict[str, ToolParam] = {}
+            for pn in pns:
+                ovr_p = p_ovr_dct.get(pn, {})
+                ds_p = ds_p_dct.get(pn)
+                sig_p = sig_p_dct.get(pn)
+
+                p_desc: CanContent
+                if (p_desc := ovr_p.get('desc')) is None:
+                    if ds_p is not None:
+                        p_desc = ds_p.description
+
+                p_type: ToolDtype | None
+                if (p_type := ovr_p.get('type')) is None:
+                    if sig_p is not None and sig_p.name in th():
+                        p_type = self.reflect_type(rfl.type_(th()[sig_p.name]))
+
+                p_required: bool | None
+                if (p_required := ovr_p.get('required')) is None:
+                    if sig_p is not None:
+                        p_required = sig_p.default is inspect.Parameter.empty
+
+                params[pn] = ToolParam(
+                    pn,
+                    desc=self._prepare_desc(p_desc) if p_desc is not None else None,
+                    type=p_type,
+                    required=p_required,
                 )
 
             ts_kw.update(params=tuple(params.values()) if params else None)

{ommlds-0.0.0.dev447.dist-info → ommlds-0.0.0.dev449.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev447
+Version: 0.0.0.dev449
 Summary: ommlds
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev447
-Requires-Dist: omlish==0.0.0.dev447
+Requires-Dist: omdev==0.0.0.dev449
+Requires-Dist: omlish==0.0.0.dev449
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.29; extra == "all"

{ommlds-0.0.0.dev447.dist-info → ommlds-0.0.0.dev449.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ommlds/.omlish-manifests.json,sha256=0nHO21Xk5kpNbvdLvitrGGWPsn0baEhGD9I835QE_Es,17984
+ommlds/.omlish-manifests.json,sha256=s92cmVTNvGiopN6a0kMNziKvMkcePcRspm8dsIL6_SM,17984
 ommlds/__about__.py,sha256=Z9VIVQnuNBbIYEtIm9XZU4T2QGRqMNjtmQX2OOTaUc0,1759
 ommlds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/huggingface.py,sha256=JfEyfKOxU3-SY_ojtXBJFNeD-NIuKjvMe3GL3e93wNA,1175
@@ -89,21 +89,21 @@ ommlds/cli/sessions/chat/base.py,sha256=GlDBXZ-KymSokNl1a7uwX1abswmRE67Q0zOIHjhZ
 ommlds/cli/sessions/chat/inject.py,sha256=zg26F-yDm9sH4COzS-3yZua2taeb3ogHCOZ34UEKI54,2661
 ommlds/cli/sessions/chat/interactive.py,sha256=0Pt3H7uZl9nGXAvMqGxU8Ih65N-DrWSkLahRFmnkFw8,1984
 ommlds/cli/sessions/chat/printing.py,sha256=urlxuSBOisRVn1f_uDb343pyBps9ht2BznMWB_H0ti8,2321
-ommlds/cli/sessions/chat/prompt.py,sha256=nEj2vwzwBJ4WTEwXwKkygrOktqqsoyGaJ46z-LYl1pQ,4547
+ommlds/cli/sessions/chat/prompt.py,sha256=y6R12CasYWx2o4zE74uIV77dBQomU85ie4v9xN5FOYM,4754
 ommlds/cli/sessions/chat/state.py,sha256=en29yekINGqVqqMoqZxxIRMuU_j3Z7Qxvtr8q5igcgg,2621
-ommlds/cli/sessions/chat/tools.py,sha256=wEcpawpEj2Zgti9gWGjk_B9yfCM3SL-tFVb56cQnDso,2259
+ommlds/cli/sessions/chat/tools.py,sha256=VBylmlKyoHcjFgK2rN391ZL9SvVNBqDj-3IrqKM-wNQ,2446
 ommlds/cli/sessions/completion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/cli/sessions/completion/completion.py,sha256=2ZrzmHBCF3mG13ABcoiHva6OUzPpdF7qzByteaLNsxk,1077
 ommlds/cli/sessions/embedding/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/cli/sessions/embedding/embedding.py,sha256=9U5Maj-XI5nsrk7m-O3P2rZggey0z2p7onZn2QfQe38,1051
 ommlds/cli/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/cli/tools/config.py,sha256=fjdZAxs9r7aNN-YjYLQNU15KWOUtL5azX_3typf-ltQ,225
-ommlds/cli/tools/inject.py,sha256=dnS9OdYAGRE2QpWGAge3bu3UCmc7h5EUXVhnwL2zJsk,1447
+ommlds/cli/tools/inject.py,sha256=gaoBXour9MJCWSnoX9iPB9KJGSXdON7OLqnqovpx9F4,1550
 ommlds/cli/tools/weather.py,sha256=FUPxPF5KBbbyK3voBtcRUOkuMO2zK5GFZoFTJMaM6LQ,300
 ommlds/datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/datasets/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/datasets/lib/movies.py,sha256=LmdfoXsZU9XMM_r-sxCLv_s06BFzwWO4xUj6sc9XVcI,1961
-ommlds/minichain/__init__.py,sha256=6R-TOiDSx4PuK8_57XUWVmpG1bfzDx8pZxHSQWpMUtc,10400
+ommlds/minichain/__init__.py,sha256=aYCJoi85KolsqQ-UdtHcwDLy0Y0qHpnBdQaiQZH1ZoI,10485
 ommlds/minichain/_marshal.py,sha256=Lcib21J6jWyd-fkdQhUzij-TH2tnwylBChLRGrinWbk,892
 ommlds/minichain/_typedvalues.py,sha256=vPwVYGWtIJT_dclarnZlA-2sjP2o3L2HSDK5VDurYfM,2229
 ommlds/minichain/completion.py,sha256=lQ0LfCIYZsvDqteHhhDIv16D2_gn_xMfEL0ouywE5Yo,1033
@@ -133,7 +133,7 @@ ommlds/minichain/backends/impls/google/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JC
 ommlds/minichain/backends/impls/google/chat.py,sha256=Dq_PrkRt07dN5A3UPj0qwB3IMIS9caAQff6076q6kUQ,3192
 ommlds/minichain/backends/impls/google/names.py,sha256=HxHJ31HeKZg6aW1C_Anqp-gamCXpq9pOdKj8_yVgE8Y,871
 ommlds/minichain/backends/impls/google/search.py,sha256=5-2nAZ1QmbqHSQcwWnqqcgCM-Duy2ryctJEIv2tcpZg,3260
-ommlds/minichain/backends/impls/google/stream.py,sha256=3XWZwYFQrA8U_QIexjJkjaWfLo2lfLbF_x7DsqcNRF4,4313
+ommlds/minichain/backends/impls/google/stream.py,sha256=8DbgK61HRovW1dq_VBXYDnjU7oVFsE2DmCfLLHoznNI,4736
 ommlds/minichain/backends/impls/huggingface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/minichain/backends/impls/huggingface/configs.py,sha256=6jsBtPNXOP57PcpxNTVLGWLc-18Iwn_lDbGouwCJTIQ,258
 ommlds/minichain/backends/impls/huggingface/repos.py,sha256=8BDxJmra9elSQL2vzp2nr2p4Hpq56A3zTk7hTTnfJU4,861
@@ -216,10 +216,17 @@ ommlds/minichain/docs/filters.py,sha256=rIW_x4QR7P2a2sqsEDw0xWJOKtK670i_bWfMZ52J
 ommlds/minichain/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/minichain/lib/bash.py,sha256=a7HUzb0KOCPRjJuWuJW6IGUxcF53Zx13q6huHO_82nw,872
 ommlds/minichain/lib/fs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ommlds/minichain/lib/fs/ls/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ommlds/minichain/lib/fs/ls/execution.py,sha256=hwUTAwqwjSjH99hyH9EqzrnlXtv3u5ySt-QLWSZjAtY,753
-ommlds/minichain/lib/fs/ls/rendering.py,sha256=ZeeQA7o59Kg9Ili8icpBzlFMMUHvCejERSBnqpqRYPo,4296
-ommlds/minichain/lib/fs/ls/running.py,sha256=s52tal84PRvF2X8spvyFkKC8jHjBJbJMKSkriAXzt98,1601
+ommlds/minichain/lib/fs/binfiles.py,sha256=_N5REnCrscISObrYieO9mKD82b_0NoWSHlfMS8C5ksA,1742
+ommlds/minichain/lib/fs/context.py,sha256=slZk7NmTdXj-nugRFO3gW1wb2vRzy193yUsROrK3NpA,3087
+ommlds/minichain/lib/fs/errors.py,sha256=Iz_UedMiBLlN3qWH1dIh-ztOP4iA_qc0nEcOQ27nTUQ,2430
+ommlds/minichain/lib/fs/suggestions.py,sha256=mpWTr1XgXyt0XEp1kEFnC7CEhxKB80Z3t6C7WdUYt24,687
+ommlds/minichain/lib/fs/catalog/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ommlds/minichain/lib/fs/catalog/ls.py,sha256=H9pc04P33mdNb77eRF74OtDFj5Q7ln5jelVVT6ZOkXo,836
+ommlds/minichain/lib/fs/catalog/read.py,sha256=vDrlVEgc-kxOl5r9fZ4l4EK-PoghijOOXcB47YnUR2s,3538
+ommlds/minichain/lib/fs/catalog/recursivels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ommlds/minichain/lib/fs/catalog/recursivels/execution.py,sha256=0-yak1nesT_yPL__TQ5fMI9t-o63-htfsGt8dZKulIE,970
+ommlds/minichain/lib/fs/catalog/recursivels/rendering.py,sha256=ZeeQA7o59Kg9Ili8icpBzlFMMUHvCejERSBnqpqRYPo,4296
+ommlds/minichain/lib/fs/catalog/recursivels/running.py,sha256=s52tal84PRvF2X8spvyFkKC8jHjBJbJMKSkriAXzt98,1601
 ommlds/minichain/llms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/minichain/llms/_marshal.py,sha256=oxx5mLPl0KtcqFWOhdz0H5Nk9C27lDPAdOVOk8mPStE,1463
 ommlds/minichain/llms/tokens.py,sha256=RPrAzf4Qx9xNPGj7_EkzcVOR9qIGkhQg8AM6qhr7gfw,292
@@ -242,7 +249,7 @@ ommlds/minichain/services/requests.py,sha256=VAfKbYu4T0CZTWVQmZ2LUmYU7DNm6IerYMN
 ommlds/minichain/services/responses.py,sha256=4W6Z4Fx4_GFqKgle27OeLr0zzjVTA0pkZrlsZiFQNdo,1534
 ommlds/minichain/services/services.py,sha256=WjkQNYIp87SflLSReOHMkG2qIVAOem6vsrs_2NxWN_M,325
 ommlds/minichain/stream/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ommlds/minichain/stream/services.py,sha256=OQ-CjCM8iKYReTg8aj0VK3XzZLdRude86kg6FNr-wew,5279
+ommlds/minichain/stream/services.py,sha256=fFR1klP_PZJ3Pqmqx_SGap8gRDuthJah1fyoke6G9Ww,5328
 ommlds/minichain/stream/wrap.py,sha256=nQC0aCi49I18nF0Yx8qiiLkhIAECV6s6o4pvOy5Kx98,2041
 ommlds/minichain/text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/minichain/text/applypatch.py,sha256=YIN5JChJ0FXyK1I6OiAHQmE7BT-exHfaAMM9ay7ylyc,17705
@@ -264,13 +271,14 @@ ommlds/minichain/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 ommlds/minichain/tools/_marshal.py,sha256=CATmXmiDHB6cWgJngd3jE1ZcHK7M4Hwqa2KsBDvhpjo,411
 ommlds/minichain/tools/fns.py,sha256=4GA4N0x1BMSaEMS3QnyfpFi6FHWCPOvEbya_JNPfUR8,3119
 ommlds/minichain/tools/jsonschema.py,sha256=qKpDgD8IS6R-QLXbgU8DNpiS4bgHQBp7k1QGblAObDo,4029
-ommlds/minichain/tools/reflect.py,sha256=0II-ZtDtxhaM5CX56de-J1dcs7CQ8TUxULXmEv2qhr4,7340
+ommlds/minichain/tools/reflect.py,sha256=81664ngwoWOppJ6UgNMfPW7_GPkKGf-kf1v4lIhZN-8,8353
 ommlds/minichain/tools/types.py,sha256=V5EMfsuKuXOthLZzm75uu61wq4o2P-D9wuhKvG-JtGk,4050
 ommlds/minichain/tools/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/minichain/tools/execution/catalog.py,sha256=xjAgbbkVdjEuA44geaDMNE-KYfATJ-tPaI-jcTB8O9g,1961
-ommlds/minichain/tools/execution/context.py,sha256=nkYV03ZYbxAFy8I48oMT3y9_5nGayUevVxeTDlWsydw,1322
+ommlds/minichain/tools/execution/context.py,sha256=Gdl1UNjzLQTeIc7m2BlNyLtNsdqCookQv12_WwDDkAI,1872
+ommlds/minichain/tools/execution/errors.py,sha256=-fE4yh-PsKQqYMyZW0CZMZIjXkJHLZAYyl3j2VYkJ-U,251
 ommlds/minichain/tools/execution/executors.py,sha256=UPQh-aljQyLYmv-qf2bpVSYMlvjHUOystDEry3Z2WT8,1265
-ommlds/minichain/tools/execution/reflect.py,sha256=IGMFotVBJwBl8i-hK_bkkJZ4C8vVnhud5J43eMHmk0k,814
+ommlds/minichain/tools/execution/reflect.py,sha256=VQ_6YTnnHDPZowVdEa8RgELUFKKVNCaL-kdv41v8z_s,800
 ommlds/minichain/vectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ommlds/minichain/vectors/_marshal.py,sha256=lMyPX2qC6Ri0E1BZZOP7R4E009eoIS6TZKbqSe_nTos,1490
 ommlds/minichain/vectors/embeddings.py,sha256=_r5DcCaTI-we_XLAHcPv-1PsKI-i-ndptn_qOJ9_fbc,1000
@@ -300,9 +308,9 @@ ommlds/wiki/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 ommlds/wiki/utils/io.py,sha256=UKgDJGtmpnWvIqVd2mJc2QNPOqlToEY1GEveNp6_pMo,7088
 ommlds/wiki/utils/progress.py,sha256=EhvKcMFYtsarCQhIahlO6f0SboyAKP3UwUyrnVnP-Vk,3222
 ommlds/wiki/utils/xml.py,sha256=vVV8Ctn13aaRM9eYfs9Wd6rHn5WOCEUzQ44fIhOvJdg,3754
-ommlds-0.0.0.dev447.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-ommlds-0.0.0.dev447.dist-info/METADATA,sha256=a2muFyUNAsNLhxd5yCTZTUo1ZwX7RpjX8HI03hB57Lc,3224
-ommlds-0.0.0.dev447.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ommlds-0.0.0.dev447.dist-info/entry_points.txt,sha256=Z5YWtX7ClfiCKdW-dd_CSVvM0h4yQpJPi-2G3q6gNFo,35
-ommlds-0.0.0.dev447.dist-info/top_level.txt,sha256=Rbnk5d5wi58vnAXx13WFZqdQ4VX8hBCS2hEL3WeXOhY,7
-ommlds-0.0.0.dev447.dist-info/RECORD,,
+ommlds-0.0.0.dev449.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+ommlds-0.0.0.dev449.dist-info/METADATA,sha256=E-__wcJOkcxnzvGP5f5PsJWc3NGQ0Fw_aL6d4D2kqhU,3224
+ommlds-0.0.0.dev449.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ommlds-0.0.0.dev449.dist-info/entry_points.txt,sha256=Z5YWtX7ClfiCKdW-dd_CSVvM0h4yQpJPi-2G3q6gNFo,35
+ommlds-0.0.0.dev449.dist-info/top_level.txt,sha256=Rbnk5d5wi58vnAXx13WFZqdQ4VX8hBCS2hEL3WeXOhY,7
+ommlds-0.0.0.dev449.dist-info/RECORD,,

ommlds/minichain/lib/fs/ls/execution.py

@@ -1,32 +0,0 @@
-from omlish import lang
-
-from ....tools.execution.catalog import ToolCatalogEntry
-from ....tools.execution.reflect import reflect_tool_catalog_entry
-from .rendering import LsLinesRenderer
-from .running import LsRunner
-
-
-##
-
-
-def execute_ls_tool(
-        base_path: str,
-) -> str:
-    """
-    Recursively lists the directory contents of the given base path.
-
-    Args:
-        base_path: The path of the directory to list the contents of.
-
-    Returns:
-        A formatted string of the recursive directory contents.
-    """
-
-    root = LsRunner().run(base_path)
-    lines = LsLinesRenderer().render(root)
-    return '\n'.join(lines.lines)
-
-
-@lang.cached_function
-def ls_tool() -> ToolCatalogEntry:
-    return reflect_tool_catalog_entry(execute_ls_tool)