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

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

@@ -0,0 +1,219 @@
+"""
+https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models
+"""
+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 omlish.io.buffers import DelimitingBuffer
+
+from .....backends.google.protocol import types as pt
+from ....chat.choices.stream.services import ChatChoicesStreamRequest
+from ....chat.choices.stream.services import ChatChoicesStreamResponse
+from ....chat.choices.stream.services import static_check_is_chat_choices_stream_service
+from ....chat.choices.stream.types import AiChoiceDeltas
+from ....chat.choices.stream.types import AiChoicesDeltas
+from ....chat.choices.types import ChatChoicesOutputs
+from ....chat.messages import AiMessage
+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 ContentAiDelta
+from ....chat.stream.types import ToolUseAiDelta
+from ....chat.tools.types import Tool
+from ....models.configs import ModelName
+from ....resources import UseResources
+from ....standard import ApiKey
+from ....stream.services import StreamResponseSink
+from ....stream.services import new_stream_response
+from .names import MODEL_NAMES
+from .tools import build_tool_spec_schema
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='google',
+#     type='ChatChoicesStreamService',
+# )
+@static_check_is_chat_choices_stream_service
+class GoogleChatChoicesStreamService:
+    DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
+
+    def __init__(
+            self,
+            *configs: ApiKey | ModelName,
+            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='GEMINI_API_KEY')
+
+    def _make_str_content(
+            self,
+            s: str | None,
+            *,
+            role: pt.ContentRole | None = None,
+    ) -> pt.Content | None:
+        if s is None:
+            return None
+
+        return pt.Content(
+            parts=[pt.Part(
+                text=check.not_none(s),
+            )],
+            role=role,
+        )
+
+    def _make_msg_content(self, m: Message) -> pt.Content:
+        if isinstance(m, (AiMessage, SystemMessage, UserMessage)):
+            return check.not_none(self._make_str_content(
+                check.isinstance(m.c, str),
+                role=self.ROLES_MAP[type(m)],
+            ))
+
+        elif isinstance(m, ToolUseResultMessage):
+            tr_resp_val: pt.Value
+            if m.tur.c is None:
+                tr_resp_val = pt.NullValue()  # type: ignore[unreachable]
+            elif isinstance(m.tur.c, str):
+                tr_resp_val = pt.StringValue(m.tur.c)
+            else:
+                raise TypeError(m.tur.c)
+            return pt.Content(
+                parts=[pt.Part(
+                    function_response=pt.FunctionResponse(
+                        id=m.tur.id,
+                        name=m.tur.name,
+                        response={
+                            'value': tr_resp_val,
+                        },
+                    ),
+                )],
+            )
+
+        elif isinstance(m, ToolUseMessage):
+            return pt.Content(
+                parts=[pt.Part(
+                    function_call=pt.FunctionCall(
+                        id=m.tu.id,
+                        name=m.tu.name,
+                        args=m.tu.args,
+                    ),
+                )],
+                role='model',
+            )
+
+        else:
+            raise TypeError(m)
+
+    BASE_URL: ta.ClassVar[str] = 'https://generativelanguage.googleapis.com/v1beta/models'
+
+    ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], pt.ContentRole | None]] = {  # noqa
+        SystemMessage: None,
+        UserMessage: 'user',
+        AiMessage: 'model',
+    }
+
+    READ_CHUNK_SIZE: ta.ClassVar[int] = -1
+
+    async def invoke(
+            self,
+            request: ChatChoicesStreamRequest,
+    ) -> ChatChoicesStreamResponse:
+        key = check.not_none(self._api_key).reveal()
+
+        msgs = list(request.v)
+
+        system_inst: pt.Content | None = None
+        if msgs and isinstance(m0 := msgs[0], SystemMessage):
+            system_inst = self._make_msg_content(m0)
+            msgs.pop(0)
+
+        g_tools: list[pt.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                g_tools.append(pt.Tool(
+                    function_declarations=[build_tool_spec_schema(t.spec)],
+                ))
+
+        g_req = pt.GenerateContentRequest(
+            contents=[
+                self._make_msg_content(m)
+                for m in msgs
+            ],
+            tools=g_tools or None,
+            system_instruction=system_inst,
+        )
+
+        req_dct = msh.marshal(g_req)
+
+        model_name = MODEL_NAMES.resolve(self._model_name.v)
+
+        http_request = http.HttpRequest(
+            f'{self.BASE_URL.rstrip("/")}/{model_name}:streamGenerateContent?alt=sse&key={key}',
+            headers={'Content-Type': 'application/json'},
+            data=json.dumps_compact(req_dct).encode('utf-8'),
+            method='POST',
+        )
+
+        async with UseResources.or_new(request.options) as rs:
+            http_client = await rs.enter_async_context(http.manage_async_client(self._http_client))
+            http_response = await rs.enter_async_context(await http_client.stream_request(http_request))
+
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
+                db = DelimitingBuffer([b'\r', b'\n', b'\r\n'])
+                while True:
+                    b = await http_response.stream.read1(self.READ_CHUNK_SIZE)
+                    for bl in db.feed(b):
+                        if isinstance(bl, DelimitingBuffer.Incomplete):
+                            # FIXME: handle
+                            return []
+
+                        l = bl.decode('utf-8')
+                        if not l:
+                            continue
+
+                        if l.startswith('data: '):
+                            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 []:
+                                if (txt := p.text) is not None:
+                                    check.none(p.function_call)
+                                    await sink.emit(AiChoicesDeltas([
+                                        AiChoiceDeltas([
+                                            ContentAiDelta(check.not_none(txt)),
+                                        ]),
+                                    ]))
+
+                                elif (fc := p.function_call) is not None:
+                                    check.none(p.text)
+                                    await sink.emit(AiChoicesDeltas([
+                                        AiChoiceDeltas([
+                                            ToolUseAiDelta(
+                                                id=fc.id,
+                                                name=fc.name,
+                                                args=fc.args,
+                                            ),
+                                        ]),
+                                    ]))
+
+                                else:
+                                    raise ValueError(p)
+
+                    if not b:
+                        return []
+
+            return await new_stream_response(rs, inner)

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

@@ -0,0 +1,149 @@
+"""
+https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models
+"""
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+
+from .....backends.google.protocol import types as pt
+from ....content.prepare import ContentStrPreparer
+from ....content.prepare import default_content_str_preparer
+from ....tools.types import EnumToolDtype
+from ....tools.types import MappingToolDtype
+from ....tools.types import NullableToolDtype
+from ....tools.types import ObjectToolDtype
+from ....tools.types import PrimitiveToolDtype
+from ....tools.types import SequenceToolDtype
+from ....tools.types import ToolDtype
+from ....tools.types import ToolSpec
+from ....tools.types import TupleToolDtype
+from ....tools.types import UnionToolDtype
+
+
+##
+
+
+def _shallow_dc_asdict_not_none(o: ta.Any) -> dict[str, ta.Any]:
+    return {k: v for k, v in dc.shallow_asdict(o).items() if v is not None}
+
+
+PT_TYPE_BY_PRIMITIVE_TYPE: ta.Mapping[str, pt.Type] = {
+    'string': 'STRING',
+    'number': 'NUMBER',
+    'integer': 'INTEGER',
+    'boolean': 'BOOLEAN',
+    'array': 'ARRAY',
+    'null': 'NULL',
+}
+
+
+class ToolSchemaRenderer:
+    def __init__(
+            self,
+            *,
+            content_str_preparer: ContentStrPreparer | None = None,
+    ) -> None:
+        super().__init__()
+
+        if content_str_preparer is None:
+            content_str_preparer = default_content_str_preparer()
+        self._content_str_preparer = content_str_preparer
+
+    def render_type(self, t: ToolDtype) -> pt.Schema:
+        if isinstance(t, PrimitiveToolDtype):
+            return pt.Schema(type=PT_TYPE_BY_PRIMITIVE_TYPE[t.type])
+
+        if isinstance(t, UnionToolDtype):
+            return pt.Schema(
+                any_of=[self.render_type(a) for a in t.args],
+            )
+
+        if isinstance(t, NullableToolDtype):
+            return pt.Schema(**{
+                **_shallow_dc_asdict_not_none(self.render_type(t.type)),
+                **dict(nullable=True),
+            })
+
+        if isinstance(t, SequenceToolDtype):
+            return pt.Schema(
+                type='ARRAY',
+                items=self.render_type(t.element),
+            )
+
+        if isinstance(t, MappingToolDtype):
+            # FIXME: t.key
+            # return {
+            #     'type': 'object',
+            #     'additionalProperties': self.render_type(t.value),
+            # }
+            raise NotImplementedError
+
+        if isinstance(t, TupleToolDtype):
+            # return {
+            #     'type': 'array',
+            #     'prefixItems': [self.render_type(e) for e in t.elements],
+            # }
+            raise NotImplementedError
+
+        if isinstance(t, EnumToolDtype):
+            return pt.Schema(**{
+                **_shallow_dc_asdict_not_none(self.render_type(t.type)),
+                **dict(enum=list(t.values)),
+            })
+
+        if isinstance(t, ObjectToolDtype):
+            return pt.Schema(
+                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) -> pt.Schema:
+        pr_dct: dict[str, pt.Schema] | None = None
+        req_lst: list[str] | None = None
+        if ts.params is not None:
+            pr_dct = {}
+            req_lst = []
+            for p in ts.params or []:
+                pr_dct[check.non_empty_str(p.name)] = pt.Schema(**{
+                    **(dict(description=self._content_str_preparer.prepare_str(p.desc)) if p.desc is not None else {}),
+                    **(_shallow_dc_asdict_not_none(self.render_type(p.type)) if p.type is not None else {}),
+                })
+                if p.required:
+                    req_lst.append(check.non_empty_str(p.name))
+
+        return pt.Schema(
+            type='OBJECT',
+            **(dict(properties=pr_dct) if pr_dct is not None else {}),  # type: ignore[arg-type]
+            **(dict(required=req_lst) if req_lst is not None else {}),  # type: ignore[arg-type]
+        )
+
+    def render_tool(self, ts: ToolSpec) -> pt.FunctionDeclaration:
+        ret_dct = {
+            **(dict(description=self._content_str_preparer.prepare_str(ts.returns_desc)) if ts.returns_desc is not None else {}),  # noqa
+            **(_shallow_dc_asdict_not_none(self.render_type(ts.returns_type)) if ts.returns_type is not None else {}),
+        }
+
+        return pt.FunctionDeclaration(
+            name=check.non_empty_str(ts.name),
+            description=self._content_str_preparer.prepare_str(ts.desc) if ts.desc is not None else None,  # type: ignore[arg-type]  # noqa
+            behavior='BLOCKING',
+            parameters=self.render_tool_params(ts) if ts.params else None,
+            response=(pt.Schema(**ret_dct) if ret_dct else None),
+        )
+
+
+##
+
+
+def build_tool_spec_schema(ts: ToolSpec) -> pt.FunctionDeclaration:
+    return ToolSchemaRenderer().render_tool(ts)
+
+
+def build_tool_spec_params_schema(ts: ToolSpec) -> pt.Schema:
+    return ToolSchemaRenderer().render_tool_params(ts)

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

@@ -0,0 +1,75 @@
+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.groq 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 ....chat.tools.types import Tool
+from ....models.configs import ModelName
+from ....standard import ApiKey
+from ....standard import DefaultOptions
+from .names import MODEL_NAMES
+from .protocol import build_gq_request_messages
+from .protocol import build_gq_request_tool
+from .protocol import build_mc_choices_response
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='groq',
+#     type='ChatChoicesService',
+# )
+@static_check_is_chat_choices_service
+class GroqChatChoicesService:
+    DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
+
+    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='GROQ_API_KEY')
+            self._default_options: tv.TypedValues = DefaultOptions.pop(cc)
+
+    async def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+        tools: list[pt.ChatCompletionRequest.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_gq_request_tool(t))
+
+        gq_request = pt.ChatCompletionRequest(
+            messages=build_gq_request_messages(request.v),
+            model=MODEL_NAMES.resolve(self._model_name.v),
+            tools=tools or None,
+        )
+
+        raw_request = msh.marshal(gq_request)
+
+        http_response = await http.async_request(
+            'https://api.groq.com/openai/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'))
+
+        return build_mc_choices_response(msh.unmarshal(raw_response, pt.ChatCompletionResponse))

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

@@ -0,0 +1,48 @@
+"""
+https://console.groq.com/docs/models
+
+curl -X GET "https://api.groq.com/openai/v1/models" \
+     -H "Authorization: Bearer $GROQ_API_KEY" \
+     -H "Content-Type: application/json"
+
+"compound-beta",
+"compound-beta-mini",
+"gemma2-9b-it",
+"llama-3.1-8b-instant",
+"llama-3.3-70b-versatile",
+"meta-llama/llama-4-maverick-17b-128e-instruct",
+"meta-llama/llama-4-scout-17b-16e-instruct",
+"meta-llama/llama-guard-4-12b",
+"moonshotai/kimi-k2-instruct",
+"openai/gpt-oss-120b",
+"openai/gpt-oss-20b",
+"qwen/qwen3-32b",
+"""
+from ....models.names import ModelNameCollection
+from ...strings.manifests import BackendStringsManifest
+
+
+##
+
+
+MODEL_NAMES = ModelNameCollection(
+    default='gpt-oss-120b',
+    aliases={
+        'gpt-oss-120b': 'openai/gpt-oss-120b',
+        'openai/gpt-oss-120b': None,
+
+        'gpt-oss-20b': 'openai/gpt-oss-20b',
+        'openai/gpt-oss-20b': None,
+    },
+)
+
+
+# @omlish-manifest
+_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'ChatChoicesService',
+        'ChatChoicesStreamService',
+    ],
+    'groq',
+    model_names=MODEL_NAMES,
+)

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

@@ -0,0 +1,143 @@
+import itertools
+
+from omlish import check
+from omlish.formats import json
+
+from .....backends.groq 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.prepare import prepare_content_str
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+from ....tools.types import ToolUse
+
+
+##
+
+
+def build_gq_request_messages(chat: Chat) -> list[pt.ChatCompletionRequest.Message]:
+    gq_msgs: list[pt.ChatCompletionRequest.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:
+                gq_msgs.append(pt.ChatCompletionRequest.AssistantMessage(
+                    content=check.isinstance(mc_ai_msg.c, str) if mc_ai_msg is not None else None,
+                    tool_calls=[
+                        pt.ChatCompletionRequest.AssistantMessage.ToolCall(
+                            function=pt.ChatCompletionRequest.AssistantMessage.ToolCall.Function(
+                                name=mc_tu_msg.tu.name,
+                                arguments=check.not_none(mc_tu_msg.tu.raw_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):
+                    gq_msgs.append(pt.ChatCompletionRequest.SystemMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, UserMessage):
+                    gq_msgs.append(pt.ChatCompletionRequest.UserMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, ToolUseResultMessage):
+                    gq_msgs.append(pt.ChatCompletionRequest.ToolMessage(
+                        tool_call_id=check.not_none(mc_msg.tur.id),
+                        content=check.isinstance(mc_msg.tur.c, str),
+                    ))
+
+                else:
+                    raise TypeError(mc_msg)
+
+    return gq_msgs
+
+
+def build_gq_request_tool(t: Tool) -> pt.ChatCompletionRequest.Tool:
+    return pt.ChatCompletionRequest.Tool(
+        function=pt.ChatCompletionRequest.Tool.Function(
+            name=check.not_none(t.spec.name),
+            description=prepare_content_str(t.spec.desc),
+            parameters=build_tool_spec_params_json_schema(t.spec),
+        ),
+    )
+
+
+def build_mc_choices_response(gq_resp: pt.ChatCompletionResponse) -> ChatChoicesResponse:
+    def build_choice(gq_choice: pt.ChatCompletionResponse.Choice) -> AiChoice:
+        gq_msg = gq_choice.message
+
+        lst: list[AnyAiMessage] = []
+
+        if gq_msg.content is not None:
+            lst.append(AiMessage(
+                check.isinstance(gq_msg.content, str),
+            ))
+
+        for gq_tc in gq_msg.tool_calls or []:
+            lst.append(ToolUseMessage(ToolUse(
+                id=gq_tc.id,
+                name=gq_tc.function.name,
+                args=json.loads(gq_tc.function.arguments or '{}'),
+                raw_args=gq_tc.function.arguments,
+            )))
+
+        return AiChoice(lst)
+
+    return ChatChoicesResponse(list(map(build_choice, gq_resp.choices)))
+
+
+def build_mc_ai_choice_deltas(delta: pt.ChatCompletionChunk.Choice.Delta) -> AiChoiceDeltas:
+    if delta.role in (None, 'assistant'):
+        lst: list[AiDelta] = []
+
+        if delta.content is not None:
+            lst.append(ContentAiDelta(delta.content))
+
+        for tc in delta.tool_calls or []:
+            tc_fn = check.not_none(tc.function)
+            lst.append(ToolUseAiDelta(
+                id=tc.id,
+                name=check.not_none(tc_fn.name),
+                args=json.loads(tc_fn.arguments or '{}'),
+            ))
+
+        return AiChoiceDeltas(lst)
+
+    elif delta.channel in ('analysis', 'commentary'):
+        return AiChoiceDeltas([])
+
+    else:
+        raise ValueError(delta)