ommlds 0.0.0.dev440__py3-none-any.whl → 0.0.0.dev480__py3-none-any.whl

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/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/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,10 +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
@@ -14,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)
@@ -23,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_factory_context().make_unmarshaler(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_factory_context().make_marshaler(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/jsonschema.py

@@ -9,6 +9,7 @@ from ..content.prepare import default_content_str_preparer
 from .types import EnumToolDtype
 from .types import MappingToolDtype
 from .types import NullableToolDtype
+from .types import ObjectToolDtype
 from .types import PrimitiveToolDtype
 from .types import SequenceToolDtype
 from .types import ToolDtype
@@ -72,15 +73,23 @@ class ToolJsonschemaRenderer:
                 'enum': list(t.values),
             }
 
+        if isinstance(t, ObjectToolDtype):
+            return {
+                '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) -> dict:
-        pr_dct: dict[str, dict] | None = None
+        pr_dct: dict[str, dict] = {}
         req_lst: list[str] | None = None
-        if ts.params is not None:
-            pr_dct = {}
+        if ts.params:
             req_lst = []
-            for p in ts.params or []:
+            for p in ts.params:
                 pr_dct[check.non_empty_str(p.name)] = {
                     **({'description': self._content_str_preparer.prepare_str(p.desc)} if p.desc is not None else {}),
                     **(self.render_type(p.type) if p.type is not None else {}),
@@ -90,7 +99,7 @@ class ToolJsonschemaRenderer:
 
         return {
             'type': 'object',
-            **({'properties': pr_dct} if pr_dct is not None else {}),
+            'properties': pr_dct,
             **({'required': req_lst} if req_lst is not None else {}),
             # By default any additional properties are allowed.
             # https://json-schema.org/understanding-json-schema/reference/object#additionalproperties

ommlds/minichain/tools/reflect.py

@@ -15,17 +15,19 @@ import textwrap
 import types
 import typing as ta
 
-from omdev.py import docstrings
 from omlish import check
 from omlish import collections as col
 from omlish import dataclasses as dc
+from omlish import lang
 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
+from .types import ObjectToolDtype
 from .types import PrimitiveToolDtype
 from .types import SequenceToolDtype
 from .types import ToolDtype
@@ -35,6 +37,10 @@ from .types import TupleToolDtype
 from .types import UnionToolDtype
 
 
+with lang.auto_proxy_import(globals()):
+    from omdev.py import docstrings
+
+
 ##
 
 
@@ -108,6 +114,12 @@ class ToolReflector:
     ])
 
     def reflect_type(self, rty: rfl.Type) -> ToolDtype:
+        if isinstance(rty, type) and dc.is_dataclass(rty):
+            return ObjectToolDtype({
+                f.name: self.reflect_type(rfl.type_(f.type))
+                for f in dc.fields(rty)
+            })
+
         if isinstance(rty, (type, rfl.Any)):
             return PrimitiveToolDtype.of(rty)
 
@@ -147,10 +159,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
 
@@ -160,14 +172,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 +227,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)
+            sig_p_dct = sig().parameters
 
-                params[sig_p.name] = ToolParam(
-                    sig_p.name,
+            pns: list[str] = list({**p_ovr_dct, **ds_p_dct, **sig_p_dct})
 
-                    desc=self._prepare_desc(ds_p.description) if ds_p is not None else None,
-
-                    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/minichain/tools/types.py

@@ -6,11 +6,14 @@ from omlish import cached
 from omlish import check
 from omlish import collections as col
 from omlish import dataclasses as dc
+from omlish import dispatch
 from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
 
 from ..content.materialize import CanContent
+from ..content.transforms.base import ContentTransform
+from ..content.types import Content
 
 
 msh.register_global_module_import('._marshal', __package__)
@@ -127,6 +130,15 @@ class EnumToolDtype(ToolDtype):
     values: ta.Sequence[ta.Any]
 
 
+#
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_class_params(terse_repr=True)
+class ObjectToolDtype(ToolDtype):
+    fields: ta.Mapping[str, ToolDtype]
+
+
 ##
 
 
@@ -177,9 +189,29 @@ class ToolSpec:
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class ToolExecRequest(lang.Final):
+class ToolUse(lang.Final):
     id: str | None = None
     name: str
     args: ta.Mapping[str, ta.Any]
 
     raw_args: str | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ToolUseResult(lang.Final):
+    id: str | None = None
+    name: str
+    c: Content
+
+
+##
+
+
+class _ToolUseContentTransform(ContentTransform, lang.Final, lang.NotInstantiable):
+    @dispatch.install_method(ContentTransform.apply)
+    def apply_tool_use(self, tu: ToolUse) -> ToolUse:
+        return tu  # TODO: args are Content
+
+    @dispatch.install_method(ContentTransform.apply)
+    def apply_tool_use_result(self, tur: ToolUseResult) -> ToolUseResult:
+        return dc.replace(tur, c=self.apply(tur.c))  # noqa

ommlds/minichain/utils.py

@@ -0,0 +1,27 @@
+import typing as ta
+
+from omlish import check
+from omlish import reflect as rfl
+
+
+##
+
+
+def join_human_readable_str_list(
+        strs: ta.Iterable[str],
+        *,
+        sep: str = ', ',
+        disj: str = 'or ',
+) -> str:
+    seq = list(strs)
+    return sep.join(
+        (disj if i == len(seq) - 1 else '') + s
+        for i, s in enumerate(seq)
+    )
+
+
+##
+
+
+def str_literal_values(lit: ta.Any) -> ta.Sequence[str]:
+    return tuple(check.isinstance(rfl.type_(lit), rfl.Literal).args)

ommlds/minichain/vectors/_marshal.py

@@ -9,7 +9,6 @@ from omlish import check
 from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
-from omlish.funcs import match as mfs
 
 from .types import Vector
 
@@ -25,10 +24,11 @@ class _VectorMarshaler(msh.Marshaler):
         return self.et.marshal(ctx, list(map(float, check.isinstance(o, Vector))))
 
 
-class _VectorMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is Vector)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return _VectorMarshaler(ctx.make(ta.Sequence[float]))
+class _VectorMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if rty is not Vector:
+            return None
+        return lambda: _VectorMarshaler(ctx.make_marshaler(ta.Sequence[float]))
 
 
 @dc.dataclass(frozen=True)
@@ -39,17 +39,18 @@ class _VectorUnmarshaler(msh.Unmarshaler):
         return Vector(self.et.unmarshal(ctx, v))
 
 
-class _VectorUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is Vector)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return _VectorUnmarshaler(ctx.make(ta.Sequence[float]))
+class _VectorUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if rty is not Vector:
+            return None
+        return lambda: _VectorUnmarshaler(ctx.make_unmarshaler(ta.Sequence[float]))
 
 
 ##
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     msh.install_standard_factories(
         _VectorMarshalerFactory(),
         _VectorUnmarshalerFactory(),

ommlds/nanochat/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andrej Karpathy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.