ommlds 0.0.0.dev426__py3-none-any.whl → 0.0.0.dev485__py3-none-any.whl

ommlds/minichain/stream/wrap.py

@@ -1,12 +1,12 @@
 # ruff: noqa: UP028
 import typing as ta
 
-from ..resources import Resources
+from ..resources import UseResources
 from ..services import Request
 from ..services import Service
 from ..types import Output
-from .services import ResponseGenerator
 from .services import StreamResponse
+from .services import StreamResponseSink
 from .services import new_stream_response
 
 
@@ -29,36 +29,34 @@ class WrappedStreamService(ta.Generic[StreamRequestT, V, OutputT, StreamOutputT]
 
     #
 
-    def _process_request(self, request: StreamRequestT) -> StreamRequestT:
+    async def _process_request(self, request: StreamRequestT) -> StreamRequestT:
         return request
 
-    def _process_stream_outputs(self, outputs: ta.Sequence[StreamOutputT]) -> ta.Sequence[StreamOutputT]:
+    async def _process_stream_outputs(self, outputs: ta.Sequence[StreamOutputT]) -> ta.Sequence[StreamOutputT]:
         return outputs
 
-    def _process_vs(self, vs: ta.Iterator[V]) -> ta.Iterator[V]:
-        return vs
+    async def _process_value(self, v: V) -> ta.Iterable[V]:
+        return [v]
 
-    def _process_outputs(self, outputs: ta.Sequence[OutputT]) -> ta.Sequence[OutputT]:
+    async def _process_outputs(self, outputs: ta.Sequence[OutputT]) -> ta.Sequence[OutputT]:
         return outputs
 
     #
 
-    def invoke(self, request: StreamRequestT) -> StreamResponse[V, OutputT, StreamOutputT]:
-        with Resources.new() as rs:
-            in_response = self._inner.invoke(self._process_request(request))
-            in_vs: ResponseGenerator[V, OutputT] = rs.enter_context(in_response.v)
-            out_vs = self._process_vs(in_vs)
-
-            def yield_vs() -> ta.Generator[V, None, ta.Sequence[OutputT] | None]:
-                while True:
-                    try:
-                        out_v = next(out_vs)
-                    except StopIteration as se:
-                        return self._process_outputs(se.value)
-                    yield out_v
-
-            return new_stream_response(
+    async def invoke(self, request: StreamRequestT) -> StreamResponse[V, OutputT, StreamOutputT]:
+        async with UseResources.or_new(request.options) as rs:  # noqa
+            in_resp = await self._inner.invoke(await self._process_request(request))
+            in_vs = await rs.enter_async_context(in_resp.v)
+
+            async def inner(sink: StreamResponseSink[V]) -> ta.Sequence[OutputT] | None:
+                async for in_v in in_vs:
+                    for out_v in (await self._process_value(in_v)):
+                        await sink.emit(out_v)
+
+                return await self._process_outputs(in_vs.outputs)
+
+            return await new_stream_response(
                 rs,
-                yield_vs(),
-                self._process_stream_outputs(in_response.outputs),
+                inner,
+                await self._process_stream_outputs(in_resp.outputs),
             )

ommlds/minichain/text/toolparsing/llamacpp/hermes2.py

@@ -1,14 +1,15 @@
 # @omlish-llm-author gemini-2.5-pro
-import logging
 import re
 
+from omlish.logs import all as logs
+
 from .types import ChatMsg
 from .utils import handle_think_tag_prelude
 from .utils import parse_json_from_string
 from .utils import process_tool_call
 
 
-log = logging.getLogger(__name__)
+log = logs.get_module_logger(globals())
 
 
 ##

ommlds/minichain/text/toolparsing/llamacpp/llama31.py

@@ -1,14 +1,15 @@
 # @omlish-llm-author gemini-2.5-pro
 import json
-import logging
 import re
 
+from omlish.logs import all as logs
+
 from .types import ChatMsg
 from .types import ChatToolCall
 from .utils import parse_json_tool_calls
 
 
-log = logging.getLogger(__name__)
+log = logs.get_module_logger(globals())
 
 
 ##

ommlds/minichain/text/toolparsing/llamacpp/utils.py

@@ -1,14 +1,15 @@
 # @omlish-llm-author gemini-2.5-pro
 import json
-import logging
 import re
 import typing as ta
 
+from omlish.logs import all as logs
+
 from .types import ChatMsg
 from .types import ChatToolCall
 
 
-log = logging.getLogger(__name__)
+log = logs.get_module_logger(globals())
 
 
 ##

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)