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

ommlds/cli/sessions/chat/prompt.py

@@ -10,7 +10,7 @@ from .base import ChatOptions
 from .base import ChatSession
 from .printing import ChatSessionPrinter
 from .state import ChatStateManager
-from .tools import ToolExecRequestExecutor
+from .tools import ToolUseExecutor
 
 
 ##
@@ -42,7 +42,7 @@ class PromptChatSession(ChatSession['PromptChatSession.Config']):
             chat_options: ChatOptions | None = None,
             printer: ChatSessionPrinter,
             backend_catalog: mc.BackendCatalog,
-            tool_exec_request_executor: ToolExecRequestExecutor,
+            tool_exec_request_executor: ToolUseExecutor,
     ) -> None:
         super().__init__(config)
 
@@ -83,11 +83,10 @@ class PromptChatSession(ChatSession['PromptChatSession.Config']):
                 lst: list[str] = []
                 async for o in st_resp:
                     if o:
-                        m = check.single(o).m
-                        if m.c is not None:
-                            print(check.isinstance(m.c, str), end='', flush=True)
-                            lst.append(check.isinstance(m.c, str))
-                        check.none(m.tool_exec_requests)
+                        c = check.isinstance(check.single(check.single(o.choices).deltas), mc.ContentAiChoiceDelta).c
+                        if c is not None:
+                            print(check.isinstance(c, str), end='', flush=True)
+                            lst.append(check.isinstance(c, str))
                 print()
 
             resp_m = mc.AiMessage(''.join(lst))
@@ -118,33 +117,35 @@ class PromptChatSession(ChatSession['PromptChatSession.Config']):
                 (self._chat_options or []),
             ))
 
-            resp_m = response.v[0].m
-            new_chat.append(resp_m)
+            for resp_m in response.v[0].ms:
+                new_chat.append(resp_m)
 
-            if (trs := resp_m.tool_exec_requests):
-                check.state(resp_m.c is None)
+                if isinstance(resp_m, mc.AiMessage):
+                    self._printer.print(resp_m)
 
-                tr: mc.ToolExecRequest = check.single(check.not_none(trs))
+                elif isinstance(resp_m, mc.ToolUseMessage):
+                    tr: mc.ToolUse = resp_m.tu
 
-                # FIXME: lol
-                from ....minichain.lib.fs.context import FsContext
+                    # FIXME: lol
+                    from ....minichain.lib.fs.context import FsContext
 
-                trm = await self._tool_exec_request_executor.execute_tool_request(
-                    tr,
-                    FsContext(root_dir=os.getcwd()),
-                )
+                    trm = await self._tool_exec_request_executor.execute_tool_use(
+                        tr,
+                        FsContext(root_dir=os.getcwd()),
+                    )
 
-                print(trm.c)
-                new_chat.append(trm)
+                    print(trm.tur.c)
+                    new_chat.append(trm)
 
-                response = await mdl.invoke(mc.ChatChoicesRequest(
-                    [*state.chat, *new_chat],
-                    (self._chat_options or []),
-                ))
+                    response = await mdl.invoke(mc.ChatChoicesRequest(
+                        [*state.chat, *new_chat],
+                        (self._chat_options or []),
+                    ))
 
-                resp_m = response.v[0].m
-                new_chat.append(resp_m)
+                    resp_m = check.isinstance(check.single(response.v[0].ms), mc.AiMessage)
+                    new_chat.append(resp_m)
 
-            self._printer.print(resp_m)
+                else:
+                    raise TypeError(resp_m)
 
         self._state_manager.extend_chat(new_chat)

ommlds/cli/sessions/chat/tools.py

@@ -23,7 +23,7 @@ class ToolExecutionConfirmation(lang.Abstract):
     @abc.abstractmethod
     def confirm_tool_execution_or_raise(
             self,
-            tr: mc.ToolExecRequest,
+            tr: mc.ToolUse,
             tce: mc.ToolCatalogEntry,
     ) -> ta.Awaitable[None]:
         raise NotImplementedError
@@ -32,7 +32,7 @@ class ToolExecutionConfirmation(lang.Abstract):
 class NopToolExecutionConfirmation(ToolExecutionConfirmation):
     async def confirm_tool_execution_or_raise(
             self,
-            tr: mc.ToolExecRequest,
+            tr: mc.ToolUse,
             tce: mc.ToolCatalogEntry,
     ) -> None:
         pass
@@ -41,7 +41,7 @@ class NopToolExecutionConfirmation(ToolExecutionConfirmation):
 class AskingToolExecutionConfirmation(ToolExecutionConfirmation):
     async def confirm_tool_execution_or_raise(
             self,
-            tr: mc.ToolExecRequest,
+            tr: mc.ToolUse,
             tce: mc.ToolCatalogEntry,
     ) -> None:
         tr_dct = dict(
@@ -59,17 +59,17 @@ class AskingToolExecutionConfirmation(ToolExecutionConfirmation):
 ##
 
 
-class ToolExecRequestExecutor(lang.Abstract):
+class ToolUseExecutor(lang.Abstract):
     @abc.abstractmethod
-    def execute_tool_request(
+    def execute_tool_use(
             self,
-            tr: mc.ToolExecRequest,
+            tr: mc.ToolUse,
             *ctx_items: ta.Any,
-    ) -> ta.Awaitable[mc.ToolExecResultMessage]:
+    ) -> ta.Awaitable[mc.ToolUseResultMessage]:
         raise NotImplementedError
 
 
-class ToolExecRequestExecutorImpl(ToolExecRequestExecutor):
+class ToolUseExecutorImpl(ToolUseExecutor):
     def __init__(
             self,
             *,
@@ -81,16 +81,16 @@ class ToolExecRequestExecutorImpl(ToolExecRequestExecutor):
         self._catalog = catalog
         self._confirmation = confirmation
 
-    async def execute_tool_request(
+    async def execute_tool_use(
             self,
-            tr: mc.ToolExecRequest,
+            tr: mc.ToolUse,
             *ctx_items: ta.Any,
-    ) -> mc.ToolExecResultMessage:
+    ) -> mc.ToolUseResultMessage:
         tce = self._catalog.by_name[check.non_empty_str(tr.name)]
 
         await self._confirmation.confirm_tool_execution_or_raise(tr, tce)
 
-        return await mc.execute_tool_request(
+        return await mc.execute_tool_use(
             mc.ToolContext(
                 tr,
                 *ctx_items,

ommlds/minichain/__init__.py

@@ -107,14 +107,16 @@ with _lang.auto_proxy_init(
         ChatChoicesStreamOutput,
         ChatChoicesStreamOutputs,
 
-        ToolExecRequestDelta,
-        AiMessageDelta,
         AiChoiceDelta,
+        ContentAiChoiceDelta,
+        ToolUseAiChoiceDelta,
+
         AiChoiceDeltas,
+        AiChoicesDeltas,
     )
 
     from .chat.tools.execution import (  # noqa
-        execute_tool_request,
+        execute_tool_use,
     )
 
     from .chat.transforms.base import (  # noqa
@@ -122,7 +124,6 @@ with _lang.auto_proxy_init(
         CompositeMessageTransform,
         FnMessageTransform,
         TypeFilteredMessageTransform,
-        fn_message_transform,
 
         ChatTransform,
         CompositeChatTransform,
@@ -153,12 +154,22 @@ with _lang.auto_proxy_init(
     )
 
     from .chat.messages import (  # noqa
-        AiMessage,
-        Chat,
         Message,
+        Chat,
+
+        AnyUserMessage,
+        UserChat,
+        check_user_chat,
+
+        AnyAiMessage,
+        AiChat,
+        check_ai_chat,
+
         SystemMessage,
-        ToolExecResultMessage,
         UserMessage,
+        AiMessage,
+        ToolUseMessage,
+        ToolUseResultMessage,
     )
 
     from .chat.services import (  # noqa
@@ -407,7 +418,8 @@ with _lang.auto_proxy_init(
 
         ToolSpec,
 
-        ToolExecRequest,
+        ToolUse,
+        ToolUseResult,
     )
 
     ##

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

@@ -18,16 +18,18 @@ 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 ....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 ToolExecRequest
+from ....tools.types import ToolUse
 from .names import MODEL_NAMES
 
 
@@ -46,6 +48,7 @@ class AnthropicChatChoicesService:
         SystemMessage: 'system',
         UserMessage: 'user',
         AiMessage: 'assistant',
+        ToolUseMessage: 'assistant',
     }
 
     def __init__(
@@ -83,12 +86,12 @@ class AnthropicChatChoicesService:
                     raise Exception('Only supports one system message and must be first')
                 system = [pt.Text(check.not_none(self._get_msg_content(m)))]
 
-            elif isinstance(m, ToolExecResultMessage):
+            elif isinstance(m, ToolUseResultMessage):
                 messages.append(pt.Message(
                     role='user',
                     content=[pt.ToolResult(
-                        tool_use_id=check.not_none(m.id),
-                        content=json.dumps_compact(msh.marshal(m.c)) if not isinstance(m.c, str) else m.c,
+                        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,
                     )],
                 ))
 
@@ -97,18 +100,22 @@ class AnthropicChatChoicesService:
                 #     role=self.ROLES_MAP[type(m)],  # noqa
                 #     content=[pt.Text(check.isinstance(self._get_msg_content(m), str))],
                 # ))
-                a_tus: list[pt.ToolUse] = []
-                for tr in m.tool_exec_requests or []:
-                    a_tus.append(pt.ToolUse(
-                        id=check.not_none(tr.id),
-                        name=check.not_none(tr.name),
-                        input=tr.args,
-                    ))
                 messages.append(pt.Message(
                     role='assistant',
                     content=[
                         *([pt.Text(check.isinstance(m.c, str))] if m.c is not None else []),
-                        *a_tus,
+                    ],
+                ))
+
+            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,
+                        ),
                     ],
                 ))
 
@@ -150,24 +157,21 @@ class AnthropicChatChoicesService:
 
         response = json.loads(check.not_none(raw_response.data).decode('utf-8'))
 
-        resp_c: ta.Any = None
-        ters: list[ToolExecRequest] = []
+        out: list[AnyAiMessage] = []
         for c in response['content']:
             if c['type'] == 'text':
-                check.none(resp_c)
-                resp_c = check.not_none(c['text'])
+                out.append(AiMessage(
+                    check.not_none(c['text']),
+                ))
             elif c['type'] == 'tool_use':
-                ters.append(ToolExecRequest(
+                out.append(ToolUseMessage(ToolUse(
                     id=c['id'],
                     name=c['name'],
                     args=c['input'],
-                ))
+                )))
             else:
                 raise TypeError(c['type'])
 
         return ChatChoicesResponse([
-            AiChoice(AiMessage(
-                resp_c,
-                tool_exec_requests=ters if ters else None,
-            )),
+            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,15 +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 ....content.types import Content
 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
 
@@ -61,6 +62,7 @@ class GoogleChatChoicesService:
     ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], str]] = {
         UserMessage: 'user',
         AiMessage: 'model',
+        ToolUseMessage: 'model',
     }
 
     async def invoke(
@@ -81,19 +83,19 @@ class GoogleChatChoicesService:
                     )],
                 )
 
-            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,
                             },
@@ -102,21 +104,22 @@ class GoogleChatChoicesService:
                 ))
 
             elif isinstance(m, AiMessage):
-                ai_parts: list[pt.Part] = []
-                if m.c is not None:
-                    ai_parts.append(pt.Part(
+                g_contents.append(pt.Content(
+                    parts=[pt.Part(
                         text=check.not_none(self._get_msg_content(m)),
-                    ))
-                for teq in m.tool_exec_requests or []:
-                    ai_parts.append(pt.Part(
+                    )],
+                    role='model',
+                ))
+
+            elif isinstance(m, ToolUseMessage):
+                g_contents.append(pt.Content(
+                    parts=[pt.Part(
                         function_call=pt.FunctionCall(
-                            id=teq.id,
-                            name=teq.name,
-                            args=teq.args,
+                            id=m.tu.id,
+                            name=m.tu.name,
+                            args=m.tu.args,
                         ),
-                    ))
-                g_contents.append(pt.Content(
-                    parts=ai_parts,
+                    )],
                     role='model',
                 ))
 
@@ -159,23 +162,18 @@ class GoogleChatChoicesService:
 
         ai_choices: list[AiChoice] = []
         for c in g_resp.candidates or []:
-            ai_c: Content | None = None
-            ters: list[ToolExecRequest] = []
+            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:
-                    check.none(ai_c)
-                    ai_c = g_txt
+                    out.append(AiMessage(g_txt))
                 elif (g_fc := g_resp_part.function_call) is not None:
-                    ters.append(ToolExecRequest(
+                    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(AiMessage(
-                c=ai_c,
-                tool_exec_requests=ters if ters else None,
-            )))
+            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)