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

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

@@ -0,0 +1,149 @@
+"""
+https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models
+"""
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+
+from .....backends.google.protocol import types as pt
+from ....content.prepare import ContentStrPreparer
+from ....content.prepare import default_content_str_preparer
+from ....tools.types import EnumToolDtype
+from ....tools.types import MappingToolDtype
+from ....tools.types import NullableToolDtype
+from ....tools.types import ObjectToolDtype
+from ....tools.types import PrimitiveToolDtype
+from ....tools.types import SequenceToolDtype
+from ....tools.types import ToolDtype
+from ....tools.types import ToolSpec
+from ....tools.types import TupleToolDtype
+from ....tools.types import UnionToolDtype
+
+
+##
+
+
+def _shallow_dc_asdict_not_none(o: ta.Any) -> dict[str, ta.Any]:
+    return {k: v for k, v in dc.shallow_asdict(o).items() if v is not None}
+
+
+PT_TYPE_BY_PRIMITIVE_TYPE: ta.Mapping[str, pt.Type] = {
+    'string': 'STRING',
+    'number': 'NUMBER',
+    'integer': 'INTEGER',
+    'boolean': 'BOOLEAN',
+    'array': 'ARRAY',
+    'null': 'NULL',
+}
+
+
+class ToolSchemaRenderer:
+    def __init__(
+            self,
+            *,
+            content_str_preparer: ContentStrPreparer | None = None,
+    ) -> None:
+        super().__init__()
+
+        if content_str_preparer is None:
+            content_str_preparer = default_content_str_preparer()
+        self._content_str_preparer = content_str_preparer
+
+    def render_type(self, t: ToolDtype) -> pt.Schema:
+        if isinstance(t, PrimitiveToolDtype):
+            return pt.Schema(type=PT_TYPE_BY_PRIMITIVE_TYPE[t.type])
+
+        if isinstance(t, UnionToolDtype):
+            return pt.Schema(
+                any_of=[self.render_type(a) for a in t.args],
+            )
+
+        if isinstance(t, NullableToolDtype):
+            return pt.Schema(**{
+                **_shallow_dc_asdict_not_none(self.render_type(t.type)),
+                **dict(nullable=True),
+            })
+
+        if isinstance(t, SequenceToolDtype):
+            return pt.Schema(
+                type='ARRAY',
+                items=self.render_type(t.element),
+            )
+
+        if isinstance(t, MappingToolDtype):
+            # FIXME: t.key
+            # return {
+            #     'type': 'object',
+            #     'additionalProperties': self.render_type(t.value),
+            # }
+            raise NotImplementedError
+
+        if isinstance(t, TupleToolDtype):
+            # return {
+            #     'type': 'array',
+            #     'prefixItems': [self.render_type(e) for e in t.elements],
+            # }
+            raise NotImplementedError
+
+        if isinstance(t, EnumToolDtype):
+            return pt.Schema(**{
+                **_shallow_dc_asdict_not_none(self.render_type(t.type)),
+                **dict(enum=list(t.values)),
+            })
+
+        if isinstance(t, ObjectToolDtype):
+            return pt.Schema(
+                type='OBJECT',
+                properties={
+                    k: self.render_type(v)
+                    for k, v in t.fields.items()
+                },
+            )
+
+        raise TypeError(t)
+
+    def render_tool_params(self, ts: ToolSpec) -> pt.Schema:
+        pr_dct: dict[str, pt.Schema] | None = None
+        req_lst: list[str] | None = None
+        if ts.params is not None:
+            pr_dct = {}
+            req_lst = []
+            for p in ts.params or []:
+                pr_dct[check.non_empty_str(p.name)] = pt.Schema(**{
+                    **(dict(description=self._content_str_preparer.prepare_str(p.desc)) if p.desc is not None else {}),
+                    **(_shallow_dc_asdict_not_none(self.render_type(p.type)) if p.type is not None else {}),
+                })
+                if p.required:
+                    req_lst.append(check.non_empty_str(p.name))
+
+        return pt.Schema(
+            type='OBJECT',
+            **(dict(properties=pr_dct) if pr_dct is not None else {}),  # type: ignore[arg-type]
+            **(dict(required=req_lst) if req_lst is not None else {}),  # type: ignore[arg-type]
+        )
+
+    def render_tool(self, ts: ToolSpec) -> pt.FunctionDeclaration:
+        ret_dct = {
+            **(dict(description=self._content_str_preparer.prepare_str(ts.returns_desc)) if ts.returns_desc is not None else {}),  # noqa
+            **(_shallow_dc_asdict_not_none(self.render_type(ts.returns_type)) if ts.returns_type is not None else {}),
+        }
+
+        return pt.FunctionDeclaration(
+            name=check.non_empty_str(ts.name),
+            description=self._content_str_preparer.prepare_str(ts.desc) if ts.desc is not None else None,  # type: ignore[arg-type]  # noqa
+            behavior='BLOCKING',
+            parameters=self.render_tool_params(ts) if ts.params else None,
+            response=(pt.Schema(**ret_dct) if ret_dct else None),
+        )
+
+
+##
+
+
+def build_tool_spec_schema(ts: ToolSpec) -> pt.FunctionDeclaration:
+    return ToolSchemaRenderer().render_tool(ts)
+
+
+def build_tool_spec_params_schema(ts: ToolSpec) -> pt.Schema:
+    return ToolSchemaRenderer().render_tool_params(ts)

ommlds/minichain/chat/_marshal.py

@@ -12,7 +12,7 @@ from .messages import Message
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     msgs_poly = msh.polymorphism_from_subclasses(
         Message,
         naming=msh.Naming.SNAKE,

ommlds/minichain/content/_marshal.py

@@ -9,6 +9,7 @@ from omlish import reflect as rfl
 from omlish.funcs import match as mfs
 
 from .images import ImageContent  # noqa
+from .json import JsonContent  # noqa
 from .materialize import CanContent
 from .materialize import _InnerCanContent
 from .sequence import BlockContent  # noqa
@@ -139,28 +140,48 @@ class _ImageContentUnmarshaler(msh.Unmarshaler):
 ##
 
 
+class _JsonContentMarshaler(msh.Marshaler):
+    def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
+        return ta.cast(msh.Value, check.isinstance(o, JsonContent).v)
+
+
+class _JsonContentUnmarshaler(msh.Unmarshaler):
+    def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
+        return JsonContent(v)
+
+
+##
+
+
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     extended_content_poly = msh.Polymorphism(
         ExtendedContent,
         [
             msh.Impl(InlineContent, 'inline'),
             msh.Impl(BlockContent, 'block'),
             msh.Impl(ImageContent, 'image'),
+            msh.Impl(JsonContent, 'json'),
             msh.Impl(TextContent, 'text'),
         ],
     )
 
     msh.install_standard_factories(
         msh.PolymorphismMarshalerFactory(extended_content_poly),
-        msh.TypeMapMarshalerFactory({ImageContent: _ImageContentMarshaler()}),
+        msh.TypeMapMarshalerFactory({
+            ImageContent: _ImageContentMarshaler(),
+            JsonContent: _JsonContentMarshaler(),
+        }),
         _ContentMarshalerFactory(),
         _CanContentMarshalerFactory(),
     )
 
     msh.install_standard_factories(
         msh.PolymorphismUnmarshalerFactory(extended_content_poly),
-        msh.TypeMapUnmarshalerFactory({ImageContent: _ImageContentUnmarshaler()}),
+        msh.TypeMapUnmarshalerFactory({
+            ImageContent: _ImageContentUnmarshaler(),
+            JsonContent: _JsonContentUnmarshaler(),
+        }),
         _ContentUnmarshalerFactory(),
         _CanContentUnmarshalerFactory(),
     )

ommlds/minichain/content/json.py

@@ -0,0 +1,13 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..json import JsonValue
+from .simple import SimpleSingleExtendedContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class JsonContent(SimpleSingleExtendedContent, lang.Final):
+    v: JsonValue

ommlds/minichain/content/materialize.py

@@ -130,7 +130,13 @@ class ContentMaterializer:
 
     @_materialize.register
     def _materialize_iterable(self, o: ta.Iterable) -> Content:
-        return [self.materialize(e) for e in o]
+        # `collections.abc.Iterable` appears as a virtual base in the dispatch c3.mro for ContentNamespace before `type`
+        # does (due to NamespaceMeta having `__iter__`), so handle that here too.
+        if isinstance(o, type) and issubclass(o, ContentNamespace):
+            return self._materialize_namespace_type(o)
+
+        else:
+            return [self.materialize(e) for e in o]
 
     @_materialize.register
     def _materialize_none(self, o: None) -> Content:
@@ -151,25 +157,12 @@ class ContentMaterializer:
     def _materialize_namespace_type(self, o: type[ContentNamespace]) -> Content:
         check.issubclass(o, ContentNamespace)
 
-        def rec(v: ta.Any) -> ta.Generator[Content]:
-            if isinstance(v, (bytes, bytearray, ta.Mapping)):
-                return
-
-            elif isinstance(v, type):
-                if issubclass(v, ContentNamespace):
-                    for n, e in v:
-                        if n.startswith('_'):
-                            continue
-                        yield from rec(e)
-
-            elif isinstance(v, ta.Iterable):
-                for e in v:
-                    yield from rec(e)
-
-            else:
-                yield self.materialize(v)
-
-        return list(rec(o))
+        out: list[Content] = []
+        for n, e in o:
+            if n.startswith('_'):
+                continue
+            out.append(self.materialize(e))
+        return out
 
     #
 

ommlds/minichain/content/prepare.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - re-softwrap
+"""
 import abc
 import dataclasses as dc
 import typing as ta

ommlds/minichain/json.py

@@ -1,3 +1,4 @@
+# ruff: noqa: UP007
 import typing as ta
 
 from omlish import dataclasses as dc
@@ -11,3 +12,22 @@ from omlish import lang
 class JsonSchema(lang.Final):
     name: str
     root: ta.Any
+
+
+##
+
+
+JsonValue: ta.TypeAlias = ta.Union[
+    ta.Mapping[str, 'JsonValue'],
+
+    ta.Sequence['JsonValue'],
+
+    str,
+
+    int,
+    float,
+
+    bool,
+
+    None,
+]

ommlds/minichain/lib/code/prompts.py

@@ -0,0 +1,6 @@
+CODE_AGENT_SYSTEM_PROMPT = """
+You are an interactive assistant specializing in programming tasks.
+
+Your goal is to assist the user by accomplishing the tasks and answering the questions given to you by the user using
+your available tools.
+"""

ommlds/minichain/lib/fs/context.py

@@ -8,6 +8,7 @@ from .binfiles import has_binary_file_extension
 from .binfiles import is_binary_file
 from .errors import RequestedPathDoesNotExistError
 from .errors import RequestedPathOutsideRootDirError
+from .errors import RequestedPathWriteNotPermittedError
 from .errors import RequestedPathWrongTypeError
 from .suggestions import get_path_suggestions
 
@@ -15,19 +16,28 @@ from .suggestions import get_path_suggestions
 ##
 
 
-class FsToolContext:
+class FsContext:
     def __init__(
             self,
             *,
             root_dir: str | None = None,
+            writes_permitted: bool = False,
     ) -> None:
         super().__init__()
 
         self._root_dir = root_dir
+        self._writes_permitted = writes_permitted
+
         self._abs_root_dir = os.path.abspath(root_dir) if root_dir is not None else None
 
     #
 
+    @property
+    def writes_permitted(self) -> bool:
+        return self._writes_permitted
+
+    #
+
     def check_requested_path(self, req_path: str) -> None:
         abs_req_path = os.path.abspath(req_path)
 
@@ -76,6 +86,7 @@ class FsToolContext:
             req_path: str,
             *,
             text: bool = False,
+            write: bool = False,
     ) -> os.stat_result:
         self.check_requested_path(req_path)
 
@@ -86,7 +97,7 @@ class FsToolContext:
                 req_path,
                 suggested_paths=get_path_suggestions(
                     req_path,
-                    filter=lambda e: (e.is_file() and not has_binary_file_extension(e.name)),
+                    filter=lambda e: (e.is_file() and not (text and has_binary_file_extension(e.name))),
                 ),
             ) from None
 
@@ -105,8 +116,11 @@ class FsToolContext:
                 actual_type='binary file',
             )
 
+        if write and not self._writes_permitted:
+            raise RequestedPathWriteNotPermittedError(req_path)
+
         return st
 
 
-def fs_tool_context() -> FsToolContext:
-    return tool_context()[FsToolContext]
+def tool_fs_context() -> FsContext:
+    return tool_context()[FsContext]

ommlds/minichain/lib/fs/errors.py

@@ -93,3 +93,9 @@ class RequestedPathDoesNotExistError(RequestedPathError):
             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 []),
         ])
+
+
+class RequestedPathWriteNotPermittedError(RequestedPathError):
+    @property
+    def content(self) -> str:
+        return f'Writes are not permitted to requested path {self.requested_path!r}.'

ommlds/minichain/lib/fs/tools/edit.py

@@ -0,0 +1,104 @@
+"""
+TODO:
+ - must read file before editing
+ - must re-read file if file has been modified
+ - loosened replacer helpers
+ - accept diff format impl
+ - injectable confirmation, diff format
+"""
+from omlish import lang
+
+from ....tools.execution.catalog import ToolCatalogEntry
+from ....tools.execution.reflect import reflect_tool_catalog_entry
+from ..context import tool_fs_context
+from ..errors import RequestedPathError
+
+
+##
+
+
+class EditToolError(RequestedPathError, lang.Abstract):
+    pass
+
+
+class EmptyNewStringError(EditToolError):
+    @property
+    def content(self) -> str:
+        return f'The requested edit to {self.requested_path!r} was given an empty "old_string" parameter.'
+
+
+class OldStringNotPresentError(EditToolError):
+    @property
+    def content(self) -> str:
+        return f'The requested edit to {self.requested_path!r} did not contain the given "old_string" parameter.'
+
+
+class OldStringPresentMultipleTimesError(EditToolError):
+    @property
+    def content(self) -> str:
+        return f'The requested edit to {self.requested_path!r} contained the given "old_string" parameter multiple times.'  # noqa
+
+
+##
+
+
+def execute_edit_tool(
+        *,
+        file_path: str,
+        old_string: str,
+        new_string: str,
+        replace_all: bool = False,
+) -> str:
+    """
+    Edits the given file by replacing the string given by the 'old_string' parameter with the string given by the
+    'new_string' parameter.
+
+    The file must exist, must be a valid text file, and must be given as an absolute path.
+
+    If the 'replace_all' parameter is false (the default) then 'new_string' must be present exactly once in the file,
+    otherwise the operation will fail. If 'replace_all' is true then all instances of 'old_string' will be replaced by
+    'new_string', but the operation will fail if there are no instances of 'old_string'
+    present in the file.
+
+    For the operation to succeed, both 'old_string' and 'new_string' must be EXACT, including all exact indentation and
+    other whitespace. This *includes* trailing newlines - this operates on the file as a single string, not a list of
+    lines.
+
+    Args:
+        file_path: The path of the file to edit. Must be an absolute path.
+        old_string: The old string to be replaced. May not be empty, and must be exact, including all exact whitespace.
+        new_string: The new string to replace the old string with.
+        replace_all: If false (the default) then exactly one instance of 'old_string' must be present in the file to be
+            replaced. If true then all instances of 'old_string' will be replaced by 'new_string', but at least one
+            instance of 'old_string' must be present in the file.
+    """
+
+    if not old_string:
+        raise EmptyNewStringError(file_path)
+
+    ctx = tool_fs_context()
+    ctx.check_stat_file(file_path, text=True, write=True)
+
+    with open(file_path) as f:
+        old_file = f.read()
+
+    n = old_file.count(old_string)
+    if not n:
+        raise OldStringNotPresentError(file_path)
+
+    if not replace_all and n != 1:
+        raise OldStringPresentMultipleTimesError(file_path)
+
+    new_file = old_file.replace(old_string, new_string)
+
+    # FIXME: confirm lol
+
+    with open(file_path, 'w') as f:
+        f.write(new_file)
+
+    return 'The file has been edited successfully.'
+
+
+@lang.cached_function
+def edit_tool() -> ToolCatalogEntry:
+    return reflect_tool_catalog_entry(execute_edit_tool)

ommlds/minichain/lib/fs/{catalog → tools}/ls.py

@@ -5,7 +5,7 @@ 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 ..context import tool_fs_context
 
 
 ##
@@ -21,8 +21,8 @@ def execute_ls_tool(
         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)
+    ctx = tool_fs_context()
+    ctx.check_stat_dir(dir_path)
 
     out = io.StringIO()
     out.write('<dir>\n')

ommlds/minichain/lib/fs/{catalog → tools}/read.py

@@ -14,7 +14,7 @@ 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
+from ..context import tool_fs_context
 
 
 ##
@@ -26,8 +26,8 @@ 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.
+    desc=f"""
+         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.
@@ -42,7 +42,7 @@ MAX_LINE_LENGTH = 2_000
         - 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',
@@ -64,8 +64,8 @@ def execute_read_tool(
         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)
+    ctx = tool_fs_context()
+    ctx.check_stat_file(file_path, text=True)
 
     out = io.StringIO()
     out.write('<file>\n')

ommlds/minichain/lib/fs/{catalog → tools}/recursivels/execution.py

@@ -2,7 +2,7 @@ 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 ...context import tool_fs_context
 from .rendering import LsLinesRenderer
 from .running import LsRunner
 
@@ -23,7 +23,7 @@ def execute_recursive_ls_tool(
         A formatted string of the recursive directory contents.
     """
 
-    ft_ctx = fs_tool_context()
+    ft_ctx = tool_fs_context()
     ft_ctx.check_requested_path(base_path)
 
     root = LsRunner().run(base_path)

ommlds/minichain/lib/todo/context.py

@@ -0,0 +1,54 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+from ...tools.execution.context import tool_context
+from .types import TodoItem
+
+
+##
+
+
+def _try_int(s: str | None) -> int | None:
+    if s is None:
+        return None
+    try:
+        return int(s)
+    except ValueError:
+        return None
+
+
+class TodoContext:
+    def __init__(
+            self,
+            items: ta.Sequence[TodoItem] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._items = items
+        self._next_id: int = 1
+
+    def get_items(self) -> ta.Sequence[TodoItem] | None:
+        return self._items
+
+    def set_items(self, items: ta.Sequence[TodoItem] | None) -> ta.Sequence[TodoItem] | None:
+        if items and any(item.id is None for item in items):
+            max_id = max([
+                *[ii for item in items if (ii := _try_int(item.id)) is not None],
+                self._next_id - 1,
+            ])
+            new_items: list[TodoItem] = []
+            for item in items:
+                if item.id is None:
+                    item = dc.replace(item, id=str(max_id + 1))
+                    max_id += 1
+                new_items.append(item)
+            items = new_items
+            self._next_id = max_id + 1
+
+        self._items = list(items) if items is not None else None
+        return items
+
+
+def tool_todo_context() -> TodoContext:
+    return tool_context()[TodoContext]