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

ommlds/minichain/lib/todo/tools/write.py

@@ -1,15 +1,17 @@
 """
 TODO:
- - ContentNamespace
+ - ContentNamespace Example materializable class
 """
 import typing as ta
 
 from omlish import lang
+from omlish import marshal as msh
 
+from ....content.namespaces import ContentNamespace
 from ....tools.execution.catalog import ToolCatalogEntry
 from ....tools.execution.reflect import reflect_tool_catalog_entry
 from ....tools.reflect import tool_spec_override
-from ..context import todo_tool_context
+from ..context import tool_todo_context
 from ..types import TODO_ITEM_FIELD_DESCS
 from ..types import TodoItem
 
@@ -17,36 +19,54 @@ from ..types import TodoItem
 ##
 
 
-@tool_spec_override(
-    desc=f"""
+class TodoWriteDescriptionChunks(ContentNamespace):
+    INTRO: ta.ClassVar[str] = """
         Use this tool to create and manage a structured list of todo items corresponding to subtasks for your current
         session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user. It
         also helps the user understand the progress of the overall task and progress of their requests.
+    """
 
+    FIELD_DESCRIPTIONS: ta.ClassVar[str] = f"""
         A todo item is comprised of the following fields:
         - id: {TODO_ITEM_FIELD_DESCS['id']}
         - content: {TODO_ITEM_FIELD_DESCS['content']}
         - priority: {TODO_ITEM_FIELD_DESCS['priority']}
         - status: {TODO_ITEM_FIELD_DESCS['status']}
-
-        Todo item priorities are as follows:
+    """
+
+    WHEN_USING_THIS_TOOL: ta.ClassVar[str] = """
+        When using the todo write tool:
+        - All items must be present on each use of the tool.
+        - All fields except the id field must be present on all items. If not given, the id field will be automatically
+          set to a valid integer.
+        - The new todo list, including any generated ids, will be returned from the tool.
+    """
+
+    STATUS_DESCRIPTIONS: ta.ClassVar[str] = """
+        Todo item statuses are as follows:
         - pending: Task not yet started.
         - in_progress: Currently working on (limit to ONE task at a time).
         - completed: Task finished successfully.
         - cancelled: Task no longer needed.
+    """
 
+    MANAGING_ITEMS: ta.ClassVar[str] = """
         Manage todo items in the following manner:
         - Update todo item status in real-time as you work.
         - Mark todo items complete IMMEDIATELY after finishing (don't batch completions).
         - Only have ONE todo item task in_progress at any time.
         - Complete current todo item tasks before starting new ones.
         - Cancel todo items that become irrelevant.
+    """
 
+    BREAKING_DOWN: ta.ClassVar[str] = """
         Breakdown tasks in the following manner:
         - Create specific, actionable items.
         - Break complex tasks into smaller, manageable steps.
         - Use clear, descriptive task names.
+    """
 
+    USE_PROACTIVELY: ta.ClassVar[str] = """
         Use this tool proactively in these scenarios:
         - Complex multi-step tasks - When a task requires 3 or more distinct steps or actions.
         - Non-trivial and complex tasks - Tasks that require careful planning or multiple operations.
@@ -57,18 +77,26 @@ from ..types import TodoItem
         - After completing a task - Mark it complete and add any new follow-up tasks
         - When you start working on a new task, mark the todo item as in_progress. Ideally you should only have one todo
           item as in_progress at a time. Complete existing tasks before starting new ones.
+    """
 
+    SKIP_USE_WHEN: ta.ClassVar[str] = """
         Skip using this tool when:
         - There is only a single, straightforward task.
         - The task is trivial and tracking it provides no organizational benefit.
         - The task can be completed in less than 3 trivial steps.
         - The task is purely conversational or informational.
+    """
 
+    SKIP_WHEN_TRIVIAL: ta.ClassVar[str] = """
         You should not use this tool if there is only one trivial task to do. In this case you are better off just doing
         the task directly.
+    """
 
+    EXAMPLES_WHEN_HEADER: ta.ClassVar[str] = """
         ## Examples of WHEN to use the todo list
+    """
 
+    EXAMPLE_WHEN_1: ta.ClassVar[str] = """
         <example>
             <user>
                 I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when
@@ -96,7 +124,9 @@ from ..types import TodoItem
                   the final task.
             </reasoning>
         </example>
+    """
 
+    EXAMPLE_WHEN_2: ta.ClassVar[str] = """
         <example>
             <user>
                 Help me rename the function getCwd to getCurrentWorkingDirectory across my project
@@ -123,7 +153,9 @@ from ..types import TodoItem
                 - This approach prevents missing any occurrences and maintains code consistency.
             </reasoning>
         </example>
+    """
 
+    EXAMPLE_WHEN_3: ta.ClassVar[str] = """
         <example>
             <user>
                 I need to implement these features for my e-commerce site: user registration, product catalog, shopping
@@ -146,7 +178,9 @@ from ..types import TodoItem
                 - This approach allows for tracking progress across the entire implementation.
             </reasoning>
         </example>
+    """
 
+    EXAMPLE_WHEN_4: ta.ClassVar[str] = """
         <example>
             <user>
                 Can you help optimize my React application? It's rendering slowly and has performance issues.
@@ -182,9 +216,13 @@ from ..types import TodoItem
                 - This systematic approach ensures all performance bottlenecks are addressed.
             </reasoning>
         </example>
+    """
 
+    EXAMPLES_WHEN_NOT_HEADER: ta.ClassVar[str] = """
         ## Examples of when NOT to use the todo list
+    """
 
+    EXAMPLE_WHEN_NOT_1: ta.ClassVar[str] = """
         <example>
             <user>
                 How do I print 'Hello World' in Python?
@@ -200,8 +238,10 @@ from ..types import TodoItem
                 The assistant did not use the todo list because this is a single, trivial task that can be completed in
                 one step. There's no need to track multiple tasks or steps for such a straightforward request.
             </reasoning>
-        </counter>
+        </example>
+    """
 
+    EXAMPLE_WHEN_NOT_2: ta.ClassVar[str] = """
         <example>
             <user>
                 What does the git status command do?
@@ -217,7 +257,9 @@ from ..types import TodoItem
                 multiple steps or tasks.
             </reasoning>
         </example>
+    """
 
+    EXAMPLE_WHEN_NOT_3: ta.ClassVar[str] = """
         <example>
             <user>
                 Can you add a comment to the calculateTotal function to explain what it does?
@@ -234,7 +276,9 @@ from ..types import TodoItem
                 organization.
             </reasoning>
         </example>
+    """
 
+    EXAMPLE_WHEN_NOT_4: ta.ClassVar[str] = """
         <example>
             <user>
                 Run npm install for me and tell me what happens.
@@ -258,18 +302,34 @@ from ..types import TodoItem
                 straightforward task.
             </reasoning>
         </example>
+    """
 
+    OUTRO: ta.ClassVar[str] = """
         When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you
         complete all requirements successfully.
-    """,
+    """
+
+
+@tool_spec_override(
+    desc=TodoWriteDescriptionChunks,
 )
-def execute_todo_write_tool(todo_items: ta.Sequence[TodoItem]) -> str:
-    ctx = todo_tool_context()
-    ctx.set_items(todo_items)
+def execute_todo_write_tool(todo_items: ta.Sequence[TodoItem]) -> ta.Sequence[TodoItem]:
+    if todo_items:
+        todo_items = [
+            msh.unmarshal(o, TodoItem) if not isinstance(o, TodoItem) else o  # noqa
+            for o in todo_items
+        ]
+
+    ctx = tool_todo_context()
+    out_items = ctx.set_items(todo_items)
 
-    return 'Todo list updated.'
+    return out_items or []
 
 
 @lang.cached_function
 def todo_write_tool() -> ToolCatalogEntry:
-    return reflect_tool_catalog_entry(execute_todo_write_tool)
+    return reflect_tool_catalog_entry(
+        execute_todo_write_tool,
+        marshal_input=True,
+        marshal_output=True,
+    )

ommlds/minichain/lib/todo/types.py

@@ -38,7 +38,12 @@ TOOL_PRIORITIES: ta.Sequence[str] = str_literal_values(ToolPriority)
 
 @dc.dataclass(frozen=True, kw_only=True)
 class TodoItem(lang.Final):
-    id: str = dc.field(metadata=tool_param_metadata(desc='A unique identifier for this todo item.'))
+    id: str | None = dc.field(default=None, metadata=tool_param_metadata(
+        desc=(
+            'A unique identifier for this todo item within the current session. '
+            'If this is not provided it will be automatically set to an integer.'
+        ),
+    ))
     content: str = dc.field(metadata=tool_param_metadata(desc='A brief description of the task.'))
     priority: ToolPriority = dc.field(metadata=tool_param_metadata(
         desc=f'Priority of the task: {join_human_readable_str_list(map(repr, TOOL_PRIORITIES))}.',

ommlds/minichain/llms/_marshal.py

@@ -42,7 +42,7 @@ class TokensUnmarshalerFactory(msh.SimpleUnmarshalerFactory):
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     msh.install_standard_factories(
         TokensMarshalerFactory(),
         TokensUnmarshalerFactory(),

ommlds/minichain/services/_marshal.py

@@ -134,7 +134,7 @@ class _RequestResponseUnmarshalerFactory(msh.SimpleUnmarshalerFactory):
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     msh.install_standard_factories(
         _RequestResponseMarshalerFactory(),
         _RequestResponseUnmarshalerFactory(),

ommlds/minichain/tools/_marshal.py

@@ -8,7 +8,7 @@ from .types import ToolDtype
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     tool_dtype_poly = msh.polymorphism_from_subclasses(ToolDtype, naming=msh.Naming.SNAKE)
     msh.install_standard_factories(
         msh.PolymorphismMarshalerFactory(tool_dtype_poly),

ommlds/minichain/tools/execution/catalog.py

@@ -4,6 +4,7 @@ from omlish import check
 from omlish import dataclasses as dc
 from omlish import lang
 
+from ...content.types import Content
 from ..fns import ToolFn
 from ..types import ToolSpec
 from .context import ToolContext
@@ -68,7 +69,7 @@ class ToolCatalog(ToolExecutor):
             ctx: ToolContext,
             name: str,
             args: ta.Mapping[str, ta.Any],
-    ) -> str:
+    ) -> Content:
         e = self._by_name[name]
 
         return await e.executor().execute_tool(

ommlds/minichain/tools/execution/executors.py

@@ -1,9 +1,14 @@
+"""
+TODO:
+ - args is Mapping[str, Content] too
+"""
 import abc
 import typing as ta
 
 from omlish import dataclasses as dc
 from omlish import lang
 
+from ...content.types import Content
 from ..fns import ToolFn
 from ..fns import execute_tool_fn
 from .context import ToolContext
@@ -20,7 +25,7 @@ class ToolExecutor(lang.Abstract):
             ctx: ToolContext,
             name: str,
             args: ta.Mapping[str, ta.Any],
-    ) -> ta.Awaitable[str]:
+    ) -> ta.Awaitable[Content]:
         raise NotImplementedError
 
 
@@ -36,7 +41,7 @@ class ToolFnToolExecutor(ToolExecutor):
             ctx: ToolContext,
             name: str,
             args: ta.Mapping[str, ta.Any],
-    ) -> str:
+    ) -> Content:
         with bind_tool_context(ctx):
             return await execute_tool_fn(
                 self.tool_fn,
@@ -56,5 +61,5 @@ class NameSwitchedToolExecutor(ToolExecutor):
             ctx: ToolContext,
             name: str,
             args: ta.Mapping[str, ta.Any],
-    ) -> str:
+    ) -> Content:
         return await self.tool_executors_by_name[name].execute_tool(ctx, name, args)

ommlds/minichain/tools/execution/reflect.py

@@ -1,7 +1,13 @@
+"""
+TODO:
+ - ta.type_hints
+"""
 import inspect
 import typing as ta
 
 from omlish import lang
+from omlish import marshal as msh
+from omlish import reflect as rfl
 
 from ..fns import ToolFn
 from ..reflect import reflect_tool_spec
@@ -11,7 +17,13 @@ from .catalog import ToolCatalogEntry
 ##
 
 
-def reflect_tool_catalog_entry(fn: ta.Callable) -> ToolCatalogEntry:
+def reflect_tool_catalog_entry(
+        fn: ta.Callable,
+        *,
+        marshal_input: bool = False,
+        marshal_output: bool = False,
+        no_marshal_check: bool = False,
+) -> ToolCatalogEntry:
     impl: ToolFn.Impl
     if lang.is_maysync(fn):
         impl = ToolFn.MaysyncImpl(fn)
@@ -20,15 +32,41 @@ def reflect_tool_catalog_entry(fn: ta.Callable) -> ToolCatalogEntry:
     else:
         impl = ToolFn.FnImpl(s=fn, a=lang.as_async(fn, wrap=True))
 
+    #
+
+    tf_input: ToolFn.Input
     sig = inspect.signature(fn)
-    if sig.return_annotation is not str:
-        raise NotImplementedError(fn)
+    if marshal_input:
+        in_rtys: dict[str, rfl.Type] = {}
+        for p in sig.parameters.values():
+            p_rty = rfl.type_(p.annotation)
+            if not no_marshal_check:
+                msh.global_marshaling().new_unmarshal_context().make(p_rty)
+            in_rtys[p.name] = p_rty
+        tf_input = ToolFn.MarshalInput(in_rtys)
+    else:
+        tf_input = ToolFn.RawKwargsInput()
+
+    #
+
+    tf_output: ToolFn.Output
+    if marshal_output:
+        out_rty = rfl.type_(sig.return_annotation)
+        if not no_marshal_check:
+            msh.global_marshaling().new_marshal_context().make(out_rty)
+        tf_output = ToolFn.MarshalOutput(out_rty)
+    else:
+        if sig.return_annotation is not str:
+            raise NotImplementedError(fn)
+        tf_output = ToolFn.RawStringOutput()
+
+    #
 
     return ToolCatalogEntry(
         reflect_tool_spec(fn),
         ToolFn(
             impl,
-            ToolFn.KwargsInput(),
-            ToolFn.RawStringOutput(),
+            tf_input,
+            tf_output,
         ),
     )

ommlds/minichain/tools/fns.py

@@ -7,6 +7,11 @@ import typing as ta
 from omlish import check
 from omlish import dataclasses as dc
 from omlish import lang
+from omlish import marshal as msh
+from omlish import reflect as rfl
+
+from ..content.json import JsonContent
+from ..content.types import Content
 
 
 D = ta.TypeVar('D')
@@ -51,7 +56,11 @@ class ToolFn(lang.Final):
             check.arg(dc.is_dataclass(self.cls))
 
     @dc.dataclass(frozen=True)
-    class KwargsInput(Input, lang.Final):
+    class MarshalInput(Input, lang.Final):
+        rtys: ta.Mapping[str, rfl.Type]
+
+    @dc.dataclass(frozen=True)
+    class RawKwargsInput(Input, lang.Final):
         pass
 
     input: Input
@@ -70,6 +79,10 @@ class ToolFn(lang.Final):
             check.isinstance(self.cls, type)
             check.arg(dc.is_dataclass(self.cls))
 
+    @dc.dataclass(frozen=True)
+    class MarshalOutput(Output, lang.Final):
+        rty: rfl.Type
+
     @dc.dataclass(frozen=True)
     class RawStringOutput(Output, lang.Final):
         pass
@@ -100,7 +113,7 @@ async def execute_tool_fn(
         args: ta.Mapping[str, ta.Any],
         *,
         forbid_sync_as_async: bool = False,
-) -> str:
+) -> Content:
     m_fn: ta.Callable[..., ta.Awaitable[ta.Any]]
     if isinstance(tfn.impl, ToolFn.FnImpl):
         s_fn = tfn.impl.s
@@ -115,20 +128,44 @@ async def execute_tool_fn(
     else:
         raise TypeError(tfn.impl)
 
-    out: ta.Any
+    #
+
+    fn_kw: ta.Mapping[str, ta.Any]
     if isinstance(tfn.input, ToolFn.DataclassInput):
         raise NotImplementedError
-    elif isinstance(tfn.input, ToolFn.KwargsInput):
-        out = await m_fn(**args)
+
+    elif isinstance(tfn.input, ToolFn.MarshalInput):
+        fn_kw_dct: dict[str, ta.Any] = {}
+        for k, v in args.items():
+            fn_kw_dct[k] = msh.unmarshal(v, tfn.input.rtys[k])
+        fn_kw = fn_kw_dct
+
+    elif isinstance(tfn.input, ToolFn.RawKwargsInput):
+        fn_kw = args
+
     else:
-        raise NotImplementedError
+        raise TypeError(tfn.input)
 
-    ret: str
+    #
+
+    fn_out = await m_fn(**fn_kw)
+
+    #
+
+    ret: Content
     if isinstance(tfn.output, ToolFn.DataclassOutput):
         raise NotImplementedError
+
+    elif isinstance(tfn.output, ToolFn.MarshalOutput):
+        out_v = msh.marshal(fn_out, tfn.output.rty)
+        ret = JsonContent(out_v)
+
     elif isinstance(tfn.output, ToolFn.RawStringOutput):
-        ret = check.isinstance(out, str)
+        ret = check.isinstance(fn_out, str)
+
     else:
-        raise NotImplementedError
+        raise TypeError(tfn.output)
+
+    #
 
     return ret

ommlds/minichain/tools/reflect.py

@@ -155,10 +155,10 @@ class ToolReflector:
 
     #
 
-    def _prepare_desc(self, s: str | None) -> str | None:
+    def _prepare_desc(self, s: CanContent) -> CanContent:
         if s is None:
             return None
-        if not self._raw_descs:
+        if not self._raw_descs and isinstance(s, str):
             s = s.strip()
         return s
 

ommlds/minichain/vectors/_marshal.py

@@ -49,7 +49,7 @@ class _VectorUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     msh.install_standard_factories(
         _VectorMarshalerFactory(),
         _VectorUnmarshalerFactory(),

ommlds/tools/ocr.py

@@ -34,7 +34,7 @@ else:
 Ocr: ta.TypeAlias = ta.Callable[['Image.Image'], str]
 
 OCR_BACKENDS: ta.Mapping[str, Ocr] = {
-    'rapidocr': lambda img: '\n'.join(text[1] for text in rapidocr.RapidOCR()(img)[0] or []),
+    'rapidocr': lambda img: '\n'.join(text[1] for text in rapidocr.RapidOCR()(_get_img_png_bytes(img))[0] or []),
     'tesseract': lambda img: pytesseract.image_to_string(img),
 }
 
@@ -62,6 +62,12 @@ def _get_img_data(file: str | None) -> ta.Any:
         return sys.stdin.buffer
 
 
+def _get_img_png_bytes(img: 'Image.Image') -> bytes:
+    out = io.BytesIO()
+    img.save(out, format='PNG')
+    return out.getvalue()
+
+
 def _main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument('file', nargs='?')

{ommlds-0.0.0.dev450.dist-info → ommlds-0.0.0.dev451.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev450
+Version: 0.0.0.dev451
 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.dev450
-Requires-Dist: omlish==0.0.0.dev450
+Requires-Dist: omdev==0.0.0.dev451
+Requires-Dist: omlish==0.0.0.dev451
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.29; extra == "all"