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

ommlds/minichain/backends/impls/anthropic/chat.py

@@ -1,4 +1,5 @@
 """
+https://docs.claude.com/en/api/messages
 https://github.com/anthropics/anthropic-sdk-python/tree/cd80d46f7a223a5493565d155da31b898a4c6ee5/src/anthropic/types
 https://github.com/anthropics/anthropic-sdk-python/blob/cd80d46f7a223a5493565d155da31b898a4c6ee5/src/anthropic/resources/completions.py#L53
 https://github.com/anthropics/anthropic-sdk-python/blob/cd80d46f7a223a5493565d155da31b898a4c6ee5/src/anthropic/resources/messages.py#L70
@@ -6,21 +7,29 @@ https://github.com/anthropics/anthropic-sdk-python/blob/cd80d46f7a223a5493565d15
 import typing as ta
 
 from omlish import check
-from omlish import lang
+from omlish import marshal as msh
 from omlish import typedvalues as tv
 from omlish.formats import json
 from omlish.http import all as http
 
+from .....backends.anthropic.protocol import types as pt
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
 from ....chat.choices.types import AiChoice
 from ....chat.messages import AiMessage
+from ....chat.messages import AnyAiMessage
 from ....chat.messages import Message
 from ....chat.messages import SystemMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
 from ....chat.messages import UserMessage
+from ....chat.tools.types import Tool
+from ....content.prepare import prepare_content_str
 from ....models.configs import ModelName
 from ....standard import ApiKey
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+from ....tools.types import ToolUse
 from .names import MODEL_NAMES
 
 
@@ -39,6 +48,7 @@ class AnthropicChatChoicesService:
         SystemMessage: 'system',
         UserMessage: 'user',
         AiMessage: 'assistant',
+        ToolUseMessage: 'assistant',
     }
 
     def __init__(
@@ -68,26 +78,73 @@ class AnthropicChatChoicesService:
             *,
             max_tokens: int = 4096,  # FIXME: ChatOption
     ) -> ChatChoicesResponse:
-        messages = []
-        system: str | None = None
+        messages: list[pt.Message] = []
+        system: list[pt.Content] | None = None
         for i, m in enumerate(request.v):
             if isinstance(m, SystemMessage):
                 if i != 0 or system is not None:
                     raise Exception('Only supports one system message and must be first')
-                system = self._get_msg_content(m)
+                system = [pt.Text(check.not_none(self._get_msg_content(m)))]
+
+            elif isinstance(m, ToolUseResultMessage):
+                messages.append(pt.Message(
+                    role='user',
+                    content=[pt.ToolResult(
+                        tool_use_id=check.not_none(m.tur.id),
+                        content=json.dumps_compact(msh.marshal(m.tur.c)) if not isinstance(m.tur.c, str) else m.tur.c,
+                    )],
+                ))
+
+            elif isinstance(m, AiMessage):
+                # messages.append(pt.Message(
+                #     role=self.ROLES_MAP[type(m)],  # noqa
+                #     content=[pt.Text(check.isinstance(self._get_msg_content(m), str))],
+                # ))
+                messages.append(pt.Message(
+                    role='assistant',
+                    content=[
+                        *([pt.Text(check.isinstance(m.c, str))] if m.c is not None else []),
+                    ],
+                ))
+
+            elif isinstance(m, ToolUseMessage):
+                messages.append(pt.Message(
+                    role='assistant',
+                    content=[
+                        pt.ToolUse(
+                            id=check.not_none(m.tu.id),
+                            name=check.not_none(m.tu.name),
+                            input=m.tu.args,
+                        ),
+                    ],
+                ))
+
             else:
-                messages.append(dict(
-                    role=self.ROLES_MAP[type(m)],  # noqa
-                    content=check.isinstance(self._get_msg_content(m), str),
+                messages.append(pt.Message(
+                    role=self.ROLES_MAP[type(m)],  # type: ignore[arg-type]
+                    content=[pt.Text(check.isinstance(self._get_msg_content(m), str))],
                 ))
 
-        raw_request = dict(
+        tools: list[pt.ToolSpec] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(pt.ToolSpec(
+                    name=check.not_none(t.spec.name),
+                    description=prepare_content_str(t.spec.desc),
+                    input_schema=build_tool_spec_params_json_schema(t.spec),
+                ))
+
+        a_req = pt.MessagesRequest(
             model=MODEL_NAMES.resolve(self._model_name.v),
-            **lang.opt_kw(system=system),
+            system=system,
             messages=messages,
+            tools=tools or None,
             max_tokens=max_tokens,
         )
 
+        raw_request = msh.marshal(a_req)
+
         raw_response = http.request(
             'https://api.anthropic.com/v1/messages',
             headers={
@@ -100,6 +157,21 @@ class AnthropicChatChoicesService:
 
         response = json.loads(check.not_none(raw_response.data).decode('utf-8'))
 
+        out: list[AnyAiMessage] = []
+        for c in response['content']:
+            if c['type'] == 'text':
+                out.append(AiMessage(
+                    check.not_none(c['text']),
+                ))
+            elif c['type'] == 'tool_use':
+                out.append(ToolUseMessage(ToolUse(
+                    id=c['id'],
+                    name=c['name'],
+                    args=c['input'],
+                )))
+            else:
+                raise TypeError(c['type'])
+
         return ChatChoicesResponse([
-            AiChoice(AiMessage(response['content'][0]['text'])),  # noqa
+            AiChoice(out),
         ])

ommlds/minichain/backends/impls/anthropic/names.py

@@ -18,9 +18,9 @@ MODEL_NAMES = ModelNameCollection(
         'claude-opus-4-1': 'claude-opus-4-1-20250805',
         'claude-opus': 'claude-opus-4-1',
 
-        'claude-sonnet-4-20250514': None,
-        'claude-sonnet-4': 'claude-sonnet-4-20250514',
-        'claude-sonnet': 'claude-sonnet-4',
+        'claude-sonnet-4-5-20250929': None,
+        'claude-sonnet-4-5': 'claude-sonnet-4-5-20250929',
+        'claude-sonnet': 'claude-sonnet-4-5',
 
         'claude-3-5-haiku-latest': None,
         'claude-haiku-3-5-latest': 'claude-3-5-haiku-latest',

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

@@ -15,9 +15,9 @@ from ....chat.messages import SystemMessage
 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 ....chat.stream.types import AiChoicesDeltas
+from ....chat.stream.types import ContentAiChoiceDelta
 from ....configs import Config
 from ....resources import UseResources
 from ....standard import ApiKey
@@ -86,7 +86,7 @@ class AnthropicChatChoicesStreamService:
             http_client = rs.enter_context(http.client())
             http_response = rs.enter_context(http_client.stream_request(http_request))
 
-            async def inner(sink: StreamResponseSink[AiChoiceDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
                 msg_start: AnthropicSseDecoderEvents.MessageStart | None = None
                 cbk_start: AnthropicSseDecoderEvents.ContentBlockStart | None = None
                 msg_stop: AnthropicSseDecoderEvents.MessageStop | None = None
@@ -124,18 +124,18 @@ class AnthropicChatChoicesStreamService:
                                         check.none(cbk_start)
                                         cbk_start = ae
                                         if isinstance(ae.content_block, AnthropicSseDecoderEvents.ContentBlockStart.Text):  # noqa
-                                            await sink.emit([AiChoiceDelta(AiMessageDelta(
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiChoiceDelta(
                                                 ae.content_block.text,
-                                            ))])
+                                            )])]))
                                         else:
                                             raise TypeError(ae.content_block)
 
                                     case AnthropicSseDecoderEvents.ContentBlockDelta():
                                         check.not_none(cbk_start)
                                         if isinstance(ae.delta, AnthropicSseDecoderEvents.ContentBlockDelta.TextDelta):
-                                            await sink.emit([AiChoiceDelta(AiMessageDelta(
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiChoiceDelta(
                                                 ae.delta.text,
-                                            ))])
+                                            )])]))
                                         else:
                                             raise TypeError(ae.delta)
 

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

@@ -15,14 +15,16 @@ from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
 from ....chat.choices.types import AiChoice
 from ....chat.messages import AiMessage
+from ....chat.messages import AnyAiMessage
 from ....chat.messages import Message
 from ....chat.messages import SystemMessage
-from ....chat.messages import ToolExecResultMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
 from ....chat.messages import UserMessage
 from ....chat.tools.types import Tool
 from ....models.configs import ModelName
 from ....standard import ApiKey
-from ....tools.types import ToolExecRequest
+from ....tools.types import ToolUse
 from .names import MODEL_NAMES
 from .tools import build_tool_spec_schema
 
@@ -59,7 +61,8 @@ class GoogleChatChoicesService:
 
     ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], str]] = {
         UserMessage: 'user',
-        AiMessage: 'assistant',
+        AiMessage: 'model',
+        ToolUseMessage: 'model',
     }
 
     async def invoke(
@@ -79,25 +82,47 @@ class GoogleChatChoicesService:
                         text=check.not_none(self._get_msg_content(m)),
                     )],
                 )
-            elif isinstance(m, ToolExecResultMessage):
+
+            elif isinstance(m, ToolUseResultMessage):
                 tr_resp_val: pt.Value
-                if m.c is None:
+                if m.tur.c is None:
                     tr_resp_val = pt.NullValue()  # type: ignore[unreachable]
-                elif isinstance(m.c, str):
-                    tr_resp_val = pt.StringValue(m.c)
+                elif isinstance(m.tur.c, str):
+                    tr_resp_val = pt.StringValue(m.tur.c)
                 else:
-                    raise TypeError(m.c)
+                    raise TypeError(m.tur.c)
                 g_contents.append(pt.Content(
                     parts=[pt.Part(
                         function_response=pt.FunctionResponse(
-                            id=m.id,
-                            name=m.name,
+                            id=m.tur.id,
+                            name=m.tur.name,
                             response={
                                 'value': tr_resp_val,
                             },
                         ),
                     )],
                 ))
+
+            elif isinstance(m, AiMessage):
+                g_contents.append(pt.Content(
+                    parts=[pt.Part(
+                        text=check.not_none(self._get_msg_content(m)),
+                    )],
+                    role='model',
+                ))
+
+            elif isinstance(m, ToolUseMessage):
+                g_contents.append(pt.Content(
+                    parts=[pt.Part(
+                        function_call=pt.FunctionCall(
+                            id=m.tu.id,
+                            name=m.tu.name,
+                            args=m.tu.args,
+                        ),
+                    )],
+                    role='model',
+                ))
+
             else:
                 g_contents.append(pt.Content(
                     parts=[pt.Part(
@@ -137,17 +162,18 @@ class GoogleChatChoicesService:
 
         ai_choices: list[AiChoice] = []
         for c in g_resp.candidates or []:
-            g_resp_part = check.single(check.not_none(check.not_none(c.content).parts))
-            ter: ToolExecRequest | None = None
-            if (g_fc := g_resp_part.function_call) is not None:
-                ter = ToolExecRequest(
-                    id=g_fc.id,
-                    name=g_fc.name,
-                    args=g_fc.args or {},
-                )
-            ai_choices.append(AiChoice(AiMessage(
-                c=g_resp_part.text,
-                tool_exec_requests=[ter] if ter is not None else None,
-            )))
+            out: list[AnyAiMessage] = []
+            for g_resp_part in check.not_none(check.not_none(c.content).parts):
+                if (g_txt := g_resp_part.text) is not None:
+                    out.append(AiMessage(g_txt))
+                elif (g_fc := g_resp_part.function_call) is not None:
+                    out.append(ToolUseMessage(ToolUse(
+                        id=g_fc.id,
+                        name=g_fc.name,
+                        args=g_fc.args or {},
+                    )))
+                else:
+                    raise TypeError(g_resp_part)
+            ai_choices.append(AiChoice(out))
 
         return ChatChoicesResponse(ai_choices)

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

@@ -19,9 +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 ....chat.stream.types import AiChoicesDeltas
+from ....chat.stream.types import ContentAiChoiceDelta
 from ....models.configs import ModelName
 from ....resources import UseResources
 from ....standard import ApiKey
@@ -101,7 +101,7 @@ class GoogleChatChoicesStreamService:
             http_client = rs.enter_context(http.client())
             http_response = rs.enter_context(http_client.stream_request(http_request))
 
-            async def inner(sink: StreamResponseSink[AiChoiceDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
                 db = DelimitingBuffer([b'\r', b'\n', b'\r\n'])
                 while True:
                     # FIXME: read1 not on response stream protocol
@@ -117,7 +117,11 @@ class GoogleChatChoicesStreamService:
                             gcr = msh.unmarshal(json.loads(l[6:]), pt.GenerateContentResponse)  # noqa
                             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)))])
+                                await sink.emit(AiChoicesDeltas([
+                                    AiChoiceDeltas([
+                                        ContentAiChoiceDelta(check.not_none(p.text)),
+                                    ]),
+                                ]))
 
                     if not b:
                         return []

ommlds/minichain/backends/impls/llamacpp/chat.py

@@ -15,7 +15,8 @@ from ....chat.choices.services import static_check_is_chat_choices_service
 from ....chat.choices.types import AiChoice
 from ....chat.choices.types import ChatChoicesOptions
 from ....chat.messages import AiMessage
-from ....chat.messages import ToolExecResultMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
 from ....chat.tools.types import Tool
 from ....configs import Config
 from ....llms.types import MaxTokens
@@ -100,29 +101,34 @@ class LlamacppChatChoicesService:
 
             ims: list = []
             for rm in request.v:
-                if isinstance(rm, ToolExecResultMessage):
+                if isinstance(rm, ToolUseResultMessage):
                     ims.append(dict(
                         role='tool',
-                        **(dict(id=rm.id) if rm.id is not None else {}),
-                        name=rm.name,
-                        content=check.isinstance(rm.c, str),
+                        **(dict(id=rm.tur.id) if rm.tur.id is not None else {}),
+                        name=rm.tur.name,
+                        content=check.isinstance(rm.tur.c, str),
                     ))
+
                 elif isinstance(rm, AiMessage):
-                    tcs: list[dict] = []
-                    for ter in rm.tool_exec_requests or []:
-                        tcs.append(dict(
-                            id=check.not_none(ter.id),
-                            type='function',
-                            function=dict(
-                                name=ter.name,
-                                arguments=check.isinstance(ter.raw_args, str),
-                            ),
-                        ))
                     ims.append(dict(
                         role=ROLES_MAP[type(rm)],
                         **(dict(content=mc) if (mc := get_msg_content(rm)) is not None else {}),
-                        **(dict(tool_calls=tcs) if tcs else {}),
                     ))
+
+                elif isinstance(rm, ToolUseMessage):
+                    ims.append(dict(
+                        role=ROLES_MAP[type(rm)],
+                        content='',
+                        tool_calls=[dict(
+                            id=check.not_none(rm.tu.id),
+                            type='function',
+                            function=dict(
+                                name=rm.tu.name,
+                                arguments=check.isinstance(rm.tu.raw_args, str),
+                            ),
+                        )],
+                    ))
+
                 else:
                     ims.append(dict(
                         role=ROLES_MAP[type(rm)],
@@ -137,6 +143,6 @@ class LlamacppChatChoicesService:
             out: list[AiChoice] = []
             for c in ta.cast(ta.Any, output)['choices']:
                 m = c['message']
-                out.append(AiChoice(AiMessage(m['content'])))
+                out.append(AiChoice([AiMessage(m['content'])]))
 
             return ChatChoicesResponse(out)

ommlds/minichain/backends/impls/llamacpp/format.py

@@ -5,7 +5,8 @@ from omlish import check
 from ....chat.messages import AiMessage
 from ....chat.messages import Message
 from ....chat.messages import SystemMessage
-from ....chat.messages import ToolExecResultMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
 from ....chat.messages import UserMessage
 
 
@@ -16,7 +17,8 @@ ROLES_MAP: ta.Mapping[type[Message], str] = {
     SystemMessage: 'system',
     UserMessage: 'user',
     AiMessage: 'assistant',
-    ToolExecResultMessage: 'tool',
+    ToolUseMessage: 'assistant',
+    ToolUseResultMessage: 'tool',
 }
 
 

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

@@ -13,9 +13,9 @@ from ....chat.choices.services import ChatChoicesOutputs
 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 ....chat.stream.types import AiChoicesDeltas
+from ....chat.stream.types import ContentAiChoiceDelta
 from ....configs import Config
 from ....models.configs import ModelPath
 from ....resources import UseResources
@@ -75,10 +75,10 @@ class LlamacppChatChoicesStreamService(lang.ExitStacked):
 
             rs.enter_context(lang.defer(close_output))
 
-            async def inner(sink: StreamResponseSink[AiChoiceDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
                 for chunk in output:
                     check.state(chunk['object'] == 'chat.completion.chunk')
-                    l: list[AiChoiceDelta] = []
+                    l: list[AiChoiceDeltas] = []
                     for choice in chunk['choices']:
                         # FIXME: check role is assistant
                         # FIXME: stop reason
@@ -86,8 +86,8 @@ class LlamacppChatChoicesStreamService(lang.ExitStacked):
                             continue
                         if not (content := delta.get('content', '')):
                             continue
-                        l.append(AiChoiceDelta(AiMessageDelta(content)))
-                    await sink.emit(l)
+                        l.append(AiChoiceDeltas([ContentAiChoiceDelta(content)]))
+                    await sink.emit(AiChoicesDeltas(l))
                 return None
 
             return await new_stream_response(rs, inner)

ommlds/minichain/backends/impls/mistral.py

@@ -90,6 +90,6 @@ class MistralChatChoicesService:
         resp_dct = json.loads(check.not_none(resp.data).decode('utf-8'))
 
         return ChatChoicesResponse([
-            AiChoice(AiMessage(c['message']['content']))
+            AiChoice([AiMessage(c['message']['content'])])
             for c in resp_dct['choices']
         ])

ommlds/minichain/backends/impls/mlx/chat.py

@@ -137,5 +137,5 @@ class MlxChatChoicesService(lang.ExitStacked):
         )
 
         return ChatChoicesResponse([
-            AiChoice(AiMessage(response))  # noqa
+            AiChoice([AiMessage(response)])  # noqa
         ])

ommlds/minichain/backends/impls/openai/chat.py

@@ -14,17 +14,20 @@ TODO:
 import typing as ta
 
 from omlish import check
+from omlish import marshal as msh
 from omlish import typedvalues as tv
 from omlish.formats import json
 from omlish.http import all as http
 
+from .....backends.openai import protocol as pt
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
 from ....models.configs import ModelName
 from ....standard import ApiKey
 from ....standard import DefaultOptions
-from .format import OpenaiChatRequestHandler
+from .format2 import OpenaiChatRequestHandler
+from .format2 import build_mc_choices_response
 from .names import MODEL_NAMES
 
 
@@ -63,7 +66,7 @@ class OpenaiChatChoicesService:
             ),
         )
 
-        raw_request = rh.raw_request()
+        raw_request = msh.marshal(rh.oai_request())
 
         http_response = http.request(
             'https://api.openai.com/v1/chat/completions',
@@ -76,4 +79,4 @@ class OpenaiChatChoicesService:
 
         raw_response = json.loads(check.not_none(http_response.data).decode('utf-8'))
 
-        return rh.build_response(raw_response)
+        return build_mc_choices_response(msh.unmarshal(raw_response, pt.ChatCompletionResponse))