ommlds 0.0.0.dev466__py3-none-any.whl → 0.0.0.dev512__py3-none-any.whl

ommlds/minichain/backends/impls/ollama/protocol.py

@@ -0,0 +1,144 @@
+import itertools
+
+from omlish import check
+
+from .....backends.ollama import protocol as pt
+from ....chat.choices.services import ChatChoicesResponse
+from ....chat.choices.stream.types import AiChoiceDeltas
+from ....chat.choices.types import AiChoice
+from ....chat.messages import AiMessage
+from ....chat.messages import AnyAiMessage
+from ....chat.messages import Chat
+from ....chat.messages import SystemMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
+from ....chat.messages import UserMessage
+from ....chat.stream.types import AiDelta
+from ....chat.stream.types import ContentAiDelta
+from ....chat.stream.types import ToolUseAiDelta
+from ....chat.tools.types import Tool
+from ....content.transform.prepare import prepare_content_str
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+from ....tools.types import ToolUse
+
+
+##
+
+
+def build_ol_request_messages(chat: Chat) -> list[pt.Message]:
+    ol_msgs: list[pt.Message] = []
+
+    for _, g in itertools.groupby(chat, lambda mc_m: isinstance(mc_m, AnyAiMessage)):
+        mc_msgs = list(g)
+
+        if isinstance(mc_msgs[0], AnyAiMessage):
+            tups: list[tuple[AiMessage | None, list[ToolUseMessage]]] = []
+            for mc_msg in mc_msgs:
+                if isinstance(mc_msg, AiMessage):
+                    tups.append((mc_msg, []))
+
+                elif isinstance(mc_msg, ToolUseMessage):
+                    if not tups:
+                        tups.append((None, []))
+                    tups[-1][1].append(mc_msg)
+
+                else:
+                    raise TypeError(mc_msg)
+
+            for mc_ai_msg, mc_tu_msgs in tups:
+                ol_msgs.append(pt.Message(
+                    role='assistant',
+                    content=check.isinstance(mc_ai_msg.c, str) if mc_ai_msg is not None else None,
+                    tool_calls=[
+                        pt.Message.ToolCall(
+                            function=pt.Message.ToolCall.Function(
+                                name=mc_tu_msg.tu.name,
+                                arguments=mc_tu_msg.tu.args,
+                            ),
+                            id=check.not_none(mc_tu_msg.tu.id),
+                        )
+                        for mc_tu_msg in mc_tu_msgs
+                    ] if mc_tu_msgs else None,
+                ))
+
+        else:
+            for mc_msg in mc_msgs:
+                if isinstance(mc_msg, SystemMessage):
+                    ol_msgs.append(pt.Message(
+                        role='system',
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, UserMessage):
+                    ol_msgs.append(pt.Message(
+                        role='user',
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, ToolUseResultMessage):
+                    ol_msgs.append(pt.Message(
+                        role='tool',
+                        tool_name=mc_msg.tur.name,
+                        content=check.isinstance(mc_msg.tur.c, str),
+                    ))
+
+                else:
+                    raise TypeError(mc_msg)
+
+    return ol_msgs
+
+
+def build_ol_request_tool(t: Tool) -> pt.Tool:
+    return pt.Tool(
+        function=pt.Tool.Function(
+            name=check.not_none(t.spec.name),
+            description=prepare_content_str(t.spec.desc) if t.spec.desc is not None else None,
+            parameters=build_tool_spec_params_json_schema(t.spec),
+        ),
+    )
+
+
+def build_mc_choices_response(ol_resp: pt.ChatResponse) -> ChatChoicesResponse:
+    ol_msg = ol_resp.message
+
+    lst: list[AnyAiMessage] = []
+
+    if ol_msg.role in (None, 'assistant'):
+        if ol_msg.content is not None:
+            lst.append(AiMessage(
+                check.isinstance(ol_msg.content, str),
+            ))
+
+        for ol_tc in ol_msg.tool_calls or []:
+            lst.append(ToolUseMessage(ToolUse(
+                id=ol_tc.id,
+                name=ol_tc.function.name,
+                args=ol_tc.function.arguments,
+            )))
+
+    else:
+        raise ValueError(ol_msg)
+
+    return ChatChoicesResponse([AiChoice(lst)])
+
+
+def build_mc_ai_choice_deltas(ol_resp: pt.ChatResponse) -> AiChoiceDeltas:
+    ol_msg = ol_resp.message
+
+    if ol_msg.role in (None, 'assistant'):
+        lst: list[AiDelta] = []
+
+        if ol_msg.content is not None:
+            lst.append(ContentAiDelta(ol_msg.content))
+
+        for tc in ol_msg.tool_calls or []:
+            lst.append(ToolUseAiDelta(
+                id=tc.id,
+                name=check.not_none(tc.function.name),
+                args=tc.function.arguments,
+            ))
+
+        return AiChoiceDeltas(lst)
+
+    else:
+        raise ValueError(ol_msg)

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

@@ -26,9 +26,9 @@ 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 .format2 import OpenaiChatRequestHandler
-from .format2 import build_mc_choices_response
-from .names import MODEL_NAMES
+from .format import OpenaiChatRequestHandler
+from .format import build_mc_choices_response
+from .names import CHAT_MODEL_NAMES
 
 
 ##
@@ -40,11 +40,17 @@ from .names import MODEL_NAMES
 # )
 @static_check_is_chat_choices_service
 class OpenaiChatChoicesService:
-    DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
+    DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(CHAT_MODEL_NAMES.default))
 
-    def __init__(self, *configs: ApiKey | ModelName | DefaultOptions) -> None:
+    def __init__(
+            self,
+            *configs: ApiKey | ModelName | DefaultOptions,
+            http_client: http.AsyncHttpClient | None = None,
+    ) -> None:
         super().__init__()
 
+        self._http_client = http_client
+
         with tv.consume(*configs) as cc:
             self._model_name = cc.pop(self.DEFAULT_MODEL_NAME)
             self._api_key = ApiKey.pop_secret(cc, env='OPENAI_API_KEY')
@@ -60,7 +66,7 @@ class OpenaiChatChoicesService:
                 *request.options,
                 override=True,
             ),
-            model=MODEL_NAMES.resolve(self._model_name.v),
+            model=CHAT_MODEL_NAMES.resolve(self._model_name.v),
             mandatory_kwargs=dict(
                 stream=False,
             ),
@@ -68,13 +74,14 @@ class OpenaiChatChoicesService:
 
         raw_request = msh.marshal(rh.oai_request())
 
-        http_response = http.request(
+        http_response = await http.async_request(
             'https://api.openai.com/v1/chat/completions',
             headers={
                 http.consts.HEADER_CONTENT_TYPE: http.consts.CONTENT_TYPE_JSON,
                 http.consts.HEADER_AUTH: http.consts.format_bearer_auth_header(check.not_none(self._api_key).reveal()),
             },
             data=json.dumps(raw_request).encode('utf-8'),
+            client=self._http_client,
         )
 
         raw_response = json.loads(check.not_none(http_response.data).decode('utf-8'))

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

@@ -23,9 +23,15 @@ from ....standard import ApiKey
 class OpenaiCompletionService:
     DEFAULT_MODEL_NAME: ta.ClassVar[str] = 'gpt-3.5-turbo-instruct'
 
-    def __init__(self, *configs: Config) -> None:
+    def __init__(
+            self,
+            *configs: Config,
+            http_client: http.AsyncHttpClient | None = None,
+    ) -> None:
         super().__init__()
 
+        self._http_client = http_client
+
         with tv.consume(*configs) as cc:
             self._api_key = ApiKey.pop_secret(cc, env='OPENAI_API_KEY')
 
@@ -41,13 +47,14 @@ class OpenaiCompletionService:
             stream=False,
         )
 
-        raw_response = http.request(
+        raw_response = await http.async_request(
             'https://api.openai.com/v1/completions',
             headers={
                 http.consts.HEADER_CONTENT_TYPE: http.consts.CONTENT_TYPE_JSON,
                 http.consts.HEADER_AUTH: http.consts.format_bearer_auth_header(check.not_none(self._api_key).reveal()),
             },
             data=json.dumps(raw_request).encode('utf-8'),
+            client=self._http_client,
         )
 
         response = json.loads(check.not_none(raw_response.data).decode('utf-8'))

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

@@ -22,9 +22,15 @@ from ....vectors.types import Vector
 class OpenaiEmbeddingService:
     model = 'text-embedding-3-small'
 
-    def __init__(self, *configs: Config) -> None:
+    def __init__(
+            self,
+            *configs: Config,
+            http_client: http.AsyncHttpClient | None = None,
+    ) -> None:
         super().__init__()
 
+        self._http_client = http_client
+
         with tv.consume(*configs) as cc:
             self._api_key = ApiKey.pop_secret(cc, env='OPENAI_API_KEY')
 
@@ -34,13 +40,14 @@ class OpenaiEmbeddingService:
             input=check.isinstance(request.v, str),
         )
 
-        raw_response = http.request(
+        raw_response = await http.async_request(
             'https://api.openai.com/v1/embeddings',
             headers={
                 http.consts.HEADER_CONTENT_TYPE: http.consts.CONTENT_TYPE_JSON,
                 http.consts.HEADER_AUTH: http.consts.format_bearer_auth_header(check.not_none(self._api_key).reveal()),
             },
             data=json.dumps(raw_request).encode('utf-8'),
+            client=self._http_client,
         )
 
         response = json.loads(check.not_none(raw_response.data).decode('utf-8'))

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

@@ -2,33 +2,33 @@ import typing as ta
 
 from omlish import cached
 from omlish import check
-from omlish import lang
 from omlish import typedvalues as tv
 from omlish.formats import json
 
+from .....backends.openai import protocol as pt
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.types import AiChoice
+from ....chat.choices.types import AiChoices
 from ....chat.choices.types import ChatChoicesOptions
-from ....chat.messages import AiChat
 from ....chat.messages import AiMessage
 from ....chat.messages import AnyAiMessage
 from ....chat.messages import Chat
-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.stream.types import AiChoiceDelta
-from ....chat.stream.types import ContentAiChoiceDelta
-from ....chat.stream.types import PartialToolUseAiChoiceDelta
+from ....chat.stream.types import AiDelta
+from ....chat.stream.types import ContentAiDelta
+from ....chat.stream.types import PartialToolUseAiDelta
 from ....chat.tools.types import Tool
 from ....content.json import JsonContent
-from ....content.prepare import prepare_content_str
+from ....content.transform.prepare import prepare_content_str
+from ....llms.types import MaxCompletionTokens
 from ....llms.types import MaxTokens
 from ....llms.types import Temperature
 from ....llms.types import TokenUsage
 from ....llms.types import TokenUsageOutput
-from ....tools.jsonschema import build_tool_spec_json_schema
+from ....tools.jsonschema import build_tool_spec_params_json_schema
 from ....tools.types import ToolSpec
 from ....tools.types import ToolUse
 from ....types import Option
@@ -37,61 +37,116 @@ from ....types import Option
 ##
 
 
-def build_request_messages(chat: Chat) -> ta.Sequence[ta.Mapping[str, ta.Any]]:
-    out: list[dict[str, ta.Any]] = []
+def build_oai_request_msgs(mc_chat: Chat) -> ta.Sequence[pt.ChatCompletionMessage]:
+    oai_msgs: list[pt.ChatCompletionMessage] = []
 
-    for m in chat:
-        if isinstance(m, SystemMessage):
-            out.append(dict(
-                role='system',
-                content=m.c,
+    for mc_msg in mc_chat:
+        if isinstance(mc_msg, SystemMessage):
+            oai_msgs.append(pt.SystemChatCompletionMessage(
+                content=check.isinstance(mc_msg.c, str),
             ))
 
-        elif isinstance(m, AiMessage):
-            out.append(dict(
-                role='assistant',
-                content=check.isinstance(m.c, (str, None)),
+        elif isinstance(mc_msg, AiMessage):
+            oai_msgs.append(pt.AssistantChatCompletionMessage(
+                content=check.isinstance(mc_msg.c, (str, None)),
             ))
 
-        elif isinstance(m, ToolUseMessage):
-            out.append(dict(
-                role='assistant',
-                tool_calls=[
-                    dict(
-                        id=m.tu.id,
-                        function=dict(
-                            arguments=check.not_none(m.tu.raw_args),
-                            name=m.tu.name,
-                        ),
-                        type='function',
+        elif isinstance(mc_msg, ToolUseMessage):
+            oai_msgs.append(pt.AssistantChatCompletionMessage(
+                tool_calls=[pt.AssistantChatCompletionMessage.ToolCall(
+                    id=check.not_none(mc_msg.tu.id),
+                    function=pt.AssistantChatCompletionMessage.ToolCall.Function(
+                        arguments=check.not_none(mc_msg.tu.raw_args),
+                        name=mc_msg.tu.name,
                     ),
-                ],
+                )],
             ))
 
-        elif isinstance(m, UserMessage):
-            out.append(dict(
-                role='user',
-                content=prepare_content_str(m.c),
+        elif isinstance(mc_msg, UserMessage):
+            oai_msgs.append(pt.UserChatCompletionMessage(
+                content=prepare_content_str(mc_msg.c),
             ))
 
-        elif isinstance(m, ToolUseResultMessage):
+        elif isinstance(mc_msg, ToolUseResultMessage):
             tc: str
-            if isinstance(m.tur.c, str):
-                tc = m.tur.c
-            elif isinstance(m.tur.c, JsonContent):
-                tc = json.dumps_compact(m.tur.c)
+            if isinstance(mc_msg.tur.c, str):
+                tc = mc_msg.tur.c
+            elif isinstance(mc_msg.tur.c, JsonContent):
+                tc = json.dumps_compact(mc_msg.tur.c)
             else:
-                raise TypeError(m.tur.c)
-            out.append(dict(
-                role='tool',
-                tool_call_id=m.tur.id,
+                raise TypeError(mc_msg.tur.c)
+            oai_msgs.append(pt.ToolChatCompletionMessage(
+                tool_call_id=check.not_none(mc_msg.tur.id),
                 content=tc,
             ))
 
         else:
-            raise TypeError(m)
+            raise TypeError(mc_msg)
 
-    return out
+    return oai_msgs
+
+
+#
+
+
+def build_mc_ai_choice(oai_choice: pt.ChatCompletionResponseChoice) -> AiChoice:
+    cur: list[AnyAiMessage] = []
+
+    oai_msg = oai_choice.message
+
+    if (oai_c := oai_msg.content) is not None:
+        cur.append(AiMessage(check.isinstance(oai_c, str)))
+
+    for oai_tc in oai_msg.tool_calls or []:
+        cur.append(ToolUseMessage(ToolUse(
+            id=oai_tc.id,
+            name=oai_tc.function.name,
+            args=json.loads(oai_tc.function.arguments or '{}'),
+            raw_args=oai_tc.function.arguments,
+        )))
+
+    return AiChoice(cur)
+
+
+def build_mc_ai_choices(oai_resp: pt.ChatCompletionResponse) -> AiChoices:
+    return [
+        build_mc_ai_choice(oai_choice)
+        for oai_choice in oai_resp.choices
+    ]
+
+
+def build_mc_choices_response(oai_resp: pt.ChatCompletionResponse) -> ChatChoicesResponse:
+    return ChatChoicesResponse(
+        build_mc_ai_choices(oai_resp),
+
+        tv.TypedValues(
+            *([TokenUsageOutput(TokenUsage(
+                input=tu.prompt_tokens,
+                output=tu.completion_tokens,
+                total=tu.total_tokens,
+            ))] if (tu := oai_resp.usage) is not None else []),
+        ),
+    )
+
+
+def build_mc_ai_delta(delta: pt.ChatCompletionChunkChoiceDelta) -> AiDelta:
+    if delta.content is not None:
+        check.state(not delta.tool_calls)
+        return ContentAiDelta(delta.content)
+
+    elif delta.tool_calls is not None:
+        check.state(delta.content is None)
+        tc = check.single(delta.tool_calls)
+        tc_fn = check.not_none(tc.function)
+        return PartialToolUseAiDelta(
+            id=tc.id,
+            name=tc_fn.name,
+            raw_args=tc_fn.arguments,
+        )
+
+    else:
+        # FIXME: no
+        return ContentAiDelta('')
 
 
 ##
@@ -112,22 +167,15 @@ class OpenaiChatRequestHandler:
         self._model = model
         self._mandatory_kwargs = mandatory_kwargs
 
-    ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], str]] = {
-        SystemMessage: 'system',
-        UserMessage: 'user',
-        AiMessage: 'assistant',
-        ToolUseMessage: 'assistant',
-        ToolUseResultMessage: 'tool',
-    }
-
     DEFAULT_OPTIONS: ta.ClassVar[tv.TypedValues[Option]] = tv.TypedValues[Option](
-        Temperature(0.),
-        MaxTokens(1024),
+        # Temperature(0.),
+        # MaxTokens(1024),
     )
 
     _OPTION_KWARG_NAMES_MAP: ta.ClassVar[ta.Mapping[str, type[ChatChoicesOptions]]] = dict(
         temperature=Temperature,
         max_tokens=MaxTokens,
+        max_completion_tokens=MaxCompletionTokens,
     )
 
     class _ProcessedOptions(ta.NamedTuple):
@@ -137,8 +185,8 @@ class OpenaiChatRequestHandler:
     @cached.function
     def _process_options(self) -> _ProcessedOptions:
         kwargs: dict = dict(
-            temperature=0,
-            max_tokens=1024,
+            # temperature=0,
+            # max_tokens=1024,
         )
 
         tools_by_name: dict[str, ToolSpec] = {}
@@ -162,72 +210,26 @@ class OpenaiChatRequestHandler:
         )
 
     @cached.function
-    def raw_request(self) -> ta.Mapping[str, ta.Any]:
+    def oai_request(self) -> pt.ChatCompletionRequest:
         po = self._process_options()
 
-        tools = [
-            dict(
-                type='function',
-                function=build_tool_spec_json_schema(ts),
+        tools: list[pt.ChatCompletionRequestTool] = [
+            pt.ChatCompletionRequestTool(
+                function=pt.ChatCompletionRequestTool.Function(
+                    name=check.not_none(ts.name),
+                    description=prepare_content_str(ts.desc) if ts.desc is not None else None,
+                    parameters=build_tool_spec_params_json_schema(ts),
+                ),
             )
             for ts in po.tools_by_name.values()
         ]
 
-        return dict(
+        return pt.ChatCompletionRequest(
             model=self._model,
-            messages=build_request_messages(self._chat),
+            messages=build_oai_request_msgs(self._chat),
             top_p=1,
-            **lang.opt_kw(tools=tools),
+            tools=tools or None,
             frequency_penalty=0.0,
             presence_penalty=0.0,
             **po.kwargs,
         )
-
-    def build_ai_chat(self, message: ta.Mapping[str, ta.Any]) -> AiChat:
-        out: list[AnyAiMessage] = []
-        if (c := message.get('content')) is not None:
-            out.append(AiMessage(c))
-        for tc in message.get('tool_calls', []):
-            out.append(ToolUseMessage(
-                ToolUse(
-                    id=tc['id'],
-                    name=tc['function']['name'],
-                    args=json.loads(tc['function']['arguments'] or '{}'),
-                    raw_args=tc['function']['arguments'],
-                ),
-            ))
-        return out
-
-    def build_response(self, raw_response: ta.Mapping[str, ta.Any]) -> ChatChoicesResponse:
-        return ChatChoicesResponse(
-            [
-                AiChoice(self.build_ai_chat(choice['message']))
-                for choice in raw_response['choices']
-            ],
-
-            tv.TypedValues(
-                *([TokenUsageOutput(TokenUsage(
-                    input=tu['prompt_tokens'],
-                    output=tu['completion_tokens'],
-                    total=tu['total_tokens'],
-                ))] if (tu := raw_response.get('usage')) is not None else []),
-            ),
-        )
-
-    def build_ai_choice_delta(self, delta: ta.Mapping[str, ta.Any]) -> AiChoiceDelta:
-        if (c := delta.get('content')) is not None:
-            check.state(not delta.get('tool_calls'))
-            return ContentAiChoiceDelta(c)
-
-        elif (tcs := delta.get('tool_calls')) is not None:  # noqa
-            check.state(delta.get('content') is None)
-            tc = check.single(tcs)
-            tc_fn = tc['function']
-            return PartialToolUseAiChoiceDelta(
-                id=tc.get('id'),
-                name=tc_fn.get('name'),
-                raw_args=tc_fn.get('arguments'),
-            )
-
-        else:
-            raise ValueError(delta)

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

@@ -30,10 +30,14 @@ _GPT_MODEL_NAMES = [
     'gpt-5-chat-latest',
     'gpt-5-mini',
     'gpt-5-nano',
+
+    'gpt-5.1',
+
+    'gpt-5.2',
 ]
 
 
-MODEL_NAMES = ModelNameCollection(
+CHAT_MODEL_NAMES = ModelNameCollection(
     default='gpt',
     aliases={
         **{
@@ -46,8 +50,8 @@ MODEL_NAMES = ModelNameCollection(
             for n in _GPT_MODEL_NAMES
         },
 
-        'gpt': 'gpt-4o',
-        'gpt-mini': 'gpt-4o-mini',
+        'gpt': 'gpt-5.2',
+        'gpt-mini': 'gpt-5-mini',
 
         #
 
@@ -61,11 +65,35 @@ MODEL_NAMES = ModelNameCollection(
 
 
 # @omlish-manifest
-_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+_CHAT_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
     [
         'ChatChoicesService',
         'ChatChoicesStreamService',
     ],
     'openai',
-    model_names=MODEL_NAMES,
+    model_names=CHAT_MODEL_NAMES,
+)
+
+
+##
+
+
+# @omlish-manifest
+_COMPLETION_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'CompletionService',
+    ],
+    'openai',
+)
+
+
+##
+
+
+# @omlish-manifest
+_EMBEDDING_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'EmbeddingService',
+    ],
+    'openai',
 )