ommlds 0.0.0.dev441__py3-none-any.whl → 0.0.0.dev442__py3-none-any.whl

ommlds/backends/openai/protocol/chatcompletion/request.py

@@ -1,6 +1,9 @@
-# ruff: noqa: UP007 UP045
+# ruff: noqa: UP007
 import typing as ta
 
+from omlish import dataclasses as dc
+from omlish import lang
+
 from .contentpart import TextChatCompletionContentPart
 from .message import ChatCompletionMessage
 from .responseformat import ChatCompletionResponseFormat
@@ -9,73 +12,72 @@ from .responseformat import ChatCompletionResponseFormat
 ##
 
 
-class ChatCompletionRequestWebSearchOptionsUserLocationApproximate(ta.TypedDict, total=False):
-    city: str
-    country: str
-    region: str
-    timezone: str
-
-
-class ChatCompletionRequestWebSearchOptionsUserLocation(ta.TypedDict):
-    approximate: ChatCompletionRequestWebSearchOptionsUserLocationApproximate
-    type: ta.Literal['approximate']
-
-
-class ChatCompletionRequestWebSearchOptions(ta.TypedDict, total=False):
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatCompletionRequestWebSearchOptions(lang.Final):
     search_context_size: ta.Literal[
         'low',
         'medium',
         'high',
-    ]
-    user_location: ChatCompletionRequestWebSearchOptionsUserLocation
+    ] | None = None
 
+    @dc.dataclass(frozen=True, kw_only=True)
+    class UserLocation(lang.Final):
+        @dc.dataclass(frozen=True, kw_only=True)
+        class Approximate(lang.Final):
+            city: str | None = None
+            country: str | None = None
+            region: str | None = None
+            timezone: str | None = None
 
-#
-
+        approximate: Approximate
+        type: ta.Literal['approximate'] | None = None
 
-class ChatCompletionRequestPrediction(ta.TypedDict):
-    content: str | ta.Iterable[TextChatCompletionContentPart]
-    type: ta.Literal['content']
+    user_location: UserLocation | None = None
 
 
 #
 
 
-class ChatCompletionRequestToolFunction(ta.TypedDict, total=False):
-    name: ta.Required[str]
-    description: str
-    parameters: ta.Mapping[str, ta.Any]
-    strict: bool
-
-
-class ChatCompletionRequestTool(ta.TypedDict):
-    function: ChatCompletionRequestToolFunction
-    type: ta.Literal['function']
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatCompletionRequestPrediction(lang.Final):
+    content: str | ta.Iterable[TextChatCompletionContentPart]
+    type: ta.Literal['content'] | None = None
 
 
 #
 
 
-class ChatCompletionRequestStreamOptions(ta.TypedDict, total=False):
-    include_usage: bool
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatCompletionRequestTool(lang.Final):
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Function(lang.Final):
+        name: str
+        description: str | None = None
+        parameters: ta.Mapping[str, ta.Any] | None = None
+        strict: bool | None = None
 
+    function: Function
+    type: ta.Literal['function'] | None = None
 
-#
 
+#
 
-class ChatCompletionRequestNamedToolChoiceFunction(ta.TypedDict):
-    name: str
 
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatCompletionRequestNamedToolChoice(lang.Final):
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Function(lang.Final):
+        name: str
 
-class ChatCompletionRequestNamedToolChoice(ta.TypedDict):
-    function: ChatCompletionRequestNamedToolChoiceFunction
-    type: ta.Literal['function']
+    function: Function
+    type: ta.Literal['function'] | None = None
 
 
 #
 
 
-class ChatCompletionRequestAudio(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatCompletionRequestAudio(lang.Final):
     format: ta.Literal[
         'wav',
         'aac',
@@ -91,40 +93,64 @@ class ChatCompletionRequestAudio(ta.TypedDict):
 #
 
 
-class ChatCompletionRequest(ta.TypedDict, total=False):
-    messages: ta.Required[ta.Iterable[ChatCompletionMessage]]
-    model: ta.Required[str]
-    audio: ChatCompletionRequestAudio
-    frequency_penalty: float
-    logit_bias: ta.Mapping[str, int]
-    logprobs: bool
-    max_completion_tokens: int
-    max_tokens: int
-    metadata: ta.Mapping[str, str]
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatCompletionRequest(lang.Final):
+    messages: ta.Iterable[ChatCompletionMessage]
+
+    model: str
+
+    audio: ChatCompletionRequestAudio | None = None
+
+    frequency_penalty: float | None = None
+    logit_bias: ta.Mapping[str, int] | None = None
+    logprobs: bool | None = None
+
+    max_completion_tokens: int | None = None
+    max_tokens: int | None = None
+
+    metadata: ta.Mapping[str, str] | None = None
+
     modalities: ta.Sequence[ta.Literal[
         'text',
         'audio',
-    ]]
-    n: int
-    parallel_tool_calls: bool
-    prediction: ChatCompletionRequestPrediction
-    presence_penalty: float
+    ]] | None = None
+
+    n: int | None = None
+
+    parallel_tool_calls: bool | None = None
+
+    prediction: ChatCompletionRequestPrediction | None = None
+
+    presence_penalty: float | None = None
+
     reasoning_effort: ta.Literal[
         'low',
         'medium',
         'high',
-    ]
-    response_format: ChatCompletionResponseFormat
-    seed: int
+    ] | None = None
+
+    response_format: ChatCompletionResponseFormat | None = None
+
+    seed: int | None = None
+
     service_tier: ta.Literal[
         'auto',
         'default',
         'flex',
-    ]
-    stop: ta.Union[str, ta.Sequence[str], None]
-    store: bool
-    stream_options: ChatCompletionRequestStreamOptions
-    temperature: float
+    ] | None = None
+
+    stop: ta.Union[str, ta.Sequence[str], None] = None
+
+    store: bool | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    class StreamOptions(lang.Final):
+        include_usage: bool | None = None
+
+    stream_options: StreamOptions | None = None
+
+    temperature: float | None = None
+
     tool_choice: ta.Union[
         ta.Literal[
             'none',
@@ -132,9 +158,13 @@ class ChatCompletionRequest(ta.TypedDict, total=False):
             'required',
         ],
         ChatCompletionRequestNamedToolChoice,
-    ]
-    tools: ta.Iterable[ChatCompletionRequestTool]
-    top_logprobs: int
-    top_p: float
-    user: str
-    web_search_options: ChatCompletionRequestWebSearchOptions
+    ] | None = None
+
+    tools: ta.Iterable[ChatCompletionRequestTool] | None = None
+
+    top_logprobs: int | None = None
+    top_p: float | None = None
+
+    user: str | None = None
+
+    web_search_options: ChatCompletionRequestWebSearchOptions | None = None

ommlds/backends/openai/protocol/chatcompletion/response.py

@@ -1,5 +1,8 @@
 import typing as ta
 
+from omlish import dataclasses as dc
+from omlish import lang
+
 from ..completionusage import CompletionUsage
 from .tokenlogprob import ChatCompletionTokenLogprob
 
@@ -7,84 +10,97 @@ from .tokenlogprob import ChatCompletionTokenLogprob
 ##
 
 
-class ChatCompletionResponseAnnotationUrlCitation(ta.TypedDict):
-    end_index: int
-    start_index: int
-    title: str
-    url: str
-
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatCompletionResponseMessage(lang.Final):
+    content: str | None = None
+    refusal: str | None = None
+    role: ta.Literal['assistant'] = dc.xfield('assistant', repr=False)
 
-class ChatCompletionResponseAnnotation(ta.TypedDict):
-    type: ta.Literal['url_citation']
-    url_citation: ChatCompletionResponseAnnotationUrlCitation
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Annotation(lang.Final):
+        type: ta.Literal['url_citation'] = dc.xfield('url_citation', repr=False)
 
+        @dc.dataclass(frozen=True, kw_only=True)
+        class UrlCitation(lang.Final):
+            end_index: int
+            start_index: int
+            title: str
+            url: str
 
-#
+        url_citation: UrlCitation
 
+    annotations: ta.Sequence[Annotation] | None = None
 
-class ChatCompletionResponseAudio(ta.TypedDict):
-    id: str
-    data: str
-    expires_at: int
-    transcript: str
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Audio(lang.Final):
+        id: str
+        data: str
+        expires_at: int
+        transcript: str
 
+    audio: Audio | None = None
 
-#
+    @dc.dataclass(frozen=True, kw_only=True)
+    class ToolCall(lang.Final):
+        id: str
 
+        @dc.dataclass(frozen=True, kw_only=True)
+        class Function(lang.Final):
+            arguments: str
+            name: str
 
-class ChatCompletionResponseMessageToolCallFunction(ta.TypedDict):
-    arguments: str
-    name: str
+        function: Function
 
+        type: ta.Literal['function'] = dc.xfield('function', repr=False)
 
-class ChatCompletionResponseMessageToolCall(ta.TypedDict):
-    id: str
-    function: ChatCompletionResponseMessageToolCallFunction
-    type: ta.Literal['function']
-
-
-class ChatCompletionResponseMessage(ta.TypedDict, total=False):
-    content: str
-    refusal: str
-    role: ta.Required[ta.Literal['assistant']]
-    annotations: ta.Sequence[ChatCompletionResponseAnnotation]
-    audio: ChatCompletionResponseAudio
-    tool_calls: ta.Sequence[ChatCompletionResponseMessageToolCall]
+    tool_calls: ta.Sequence[ToolCall] | None = None
 
 
 #
 
 
-class ChatCompletionResponseChoiceLogprobs(ta.TypedDict, total=False):
-    content: ta.Sequence[ChatCompletionTokenLogprob]
-    refusal: ta.Sequence[ChatCompletionTokenLogprob]
-
-
-class ChatCompletionResponseChoice(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatCompletionResponseChoice(lang.Final):
     finish_reason: ta.Literal[
         'stop',
         'length',
         'tool_calls',
         'content_filter',
     ]
+
     index: int
-    logprobs: ta.NotRequired[ChatCompletionResponseChoiceLogprobs]
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Logprobs(lang.Final):
+        content: ta.Sequence[ChatCompletionTokenLogprob] | None = None
+        refusal: ta.Sequence[ChatCompletionTokenLogprob] | None = None
+
+    logprobs: Logprobs | None = None
+
     message: ChatCompletionResponseMessage
 
 
 #
 
 
-class ChatCompletionResponse(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatCompletionResponse(lang.Final):
     id: str
+
     choices: ta.Sequence[ChatCompletionResponseChoice]
+
     created: int
+
     model: str
-    object: ta.Literal['chat.completion']
-    service_tier: ta.NotRequired[ta.Literal[
+
+    object: ta.Literal['chat.completion'] = dc.xfield('chat.completion', repr=False)
+
+    service_tier: ta.Literal[
         'auto',
         'default',
         'flex',
-    ]]
-    system_fingerprint: ta.NotRequired[str]
-    usage: ta.NotRequired[CompletionUsage]
+    ] | None = None
+
+    system_fingerprint: str | None = None
+
+    usage: CompletionUsage | None = None

ommlds/backends/openai/protocol/chatcompletion/responseformat.py

@@ -1,41 +1,42 @@
-# ruff: noqa: UP007 UP045
 import typing as ta
 
+from omlish import dataclasses as dc
+from omlish import lang
+
 
 ##
 
 
-class TextChatCompletionResponseFormat(ta.TypedDict):
-    type: ta.Literal['text']
+class ChatCompletionResponseFormat(lang.Abstract, lang.Sealed):
+    pass
 
 
 #
 
 
-class JsonSchemaChatCompletionResponseFormatJsonSchema(ta.TypedDict, total=False):
-    name: ta.Required[str]
-    description: str
-    schema: ta.Mapping[str, ta.Any]
-    strict: bool
-
-
-class JsonSchemaChatCompletionResponseFormat(ta.TypedDict):
-    json_schema: JsonSchemaChatCompletionResponseFormatJsonSchema
-    type: ta.Literal['json_schema']
+@dc.dataclass(frozen=True, kw_only=True)
+class TextChatCompletionResponseFormat(ChatCompletionResponseFormat, lang.Final):
+    pass
 
 
 #
 
 
-class JsonObjectChatCompletionResponseFormat(ta.TypedDict):
-    type: ta.Literal['json_object']
+@dc.dataclass(frozen=True, kw_only=True)
+class JsonSchemaChatCompletionResponseFormat(ChatCompletionResponseFormat, lang.Final):
+    @dc.dataclass(frozen=True, kw_only=True)
+    class JsonSchema(lang.Final):
+        name: str
+        description: str | None = None
+        schema: ta.Mapping[str, ta.Any] | None = None
+        strict: bool | None = None
+
+    json_schema: JsonSchema
 
 
 #
 
 
-ChatCompletionResponseFormat: ta.TypeAlias = ta.Union[
-    TextChatCompletionResponseFormat,
-    JsonSchemaChatCompletionResponseFormat,
-    JsonObjectChatCompletionResponseFormat,
-]
+@dc.dataclass(frozen=True, kw_only=True)
+class JsonObjectChatCompletionResponseFormat(ChatCompletionResponseFormat, lang.Final):
+    pass

ommlds/backends/openai/protocol/chatcompletion/tokenlogprob.py

@@ -1,17 +1,22 @@
 import typing as ta
 
+from omlish import dataclasses as dc
+from omlish import lang
+
 
 ##
 
 
-class ChatCompletionTokenLogprobTopLogprob(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatCompletionTokenLogprob(lang.Final):
     token: str
-    bytes: ta.NotRequired[ta.Sequence[int]]
+    bytes: ta.Sequence[int] | None = None
     logprob: float
 
+    @dc.dataclass(frozen=True, kw_only=True)
+    class TopLogprob(lang.Final):
+        token: str
+        bytes: ta.Sequence[int] | None = None
+        logprob: float
 
-class ChatCompletionTokenLogprob(ta.TypedDict):
-    token: str
-    bytes: ta.NotRequired[ta.Sequence[int]]
-    logprob: float
-    top_logprobs: ta.Sequence[ChatCompletionTokenLogprobTopLogprob]
+    top_logprobs: ta.Sequence[TopLogprob]

ommlds/backends/openai/protocol/completionusage.py

@@ -1,24 +1,28 @@
-import typing as ta
+from omlish import dataclasses as dc
+from omlish import lang
 
 
 ##
 
 
-class CompletionUsageCompletionTokensDetails(ta.TypedDict, total=False):
-    accepted_prediction_tokens: int
-    audio_tokens: int
-    reasoning_tokens: int
-    rejected_prediction_tokens: int
+@dc.dataclass(frozen=True, kw_only=True)
+class CompletionUsage(lang.Final):
+    completion_tokens: int
+    prompt_tokens: int
+    total_tokens: int
 
+    @dc.dataclass(frozen=True, kw_only=True)
+    class CompletionTokensDetails(lang.Final):
+        accepted_prediction_tokens: int | None = None
+        audio_tokens: int | None = None
+        reasoning_tokens: int | None = None
+        rejected_prediction_tokens: int | None = None
 
-class CompletionUsagePromptTokensDetails(ta.TypedDict, total=False):
-    audio_tokens: int
-    cached_tokens: int
+    completion_tokens_details: CompletionTokensDetails | None = None
 
+    @dc.dataclass(frozen=True, kw_only=True)
+    class PromptTokensDetails(lang.Final):
+        audio_tokens: int | None = None
+        cached_tokens: int | None = None
 
-class CompletionUsage(ta.TypedDict):
-    completion_tokens: int
-    prompt_tokens: int
-    total_tokens: int
-    completion_tokens_details: ta.NotRequired[CompletionUsageCompletionTokensDetails]
-    prompt_tokens_details: ta.NotRequired[CompletionUsagePromptTokensDetails]
+    prompt_tokens_details: PromptTokensDetails | None = None

ommlds/cli/sessions/chat/interactive.py

@@ -64,7 +64,7 @@ class InteractiveChatSession(ChatSession['InteractiveChatSession.Config']):
 
                 req_msg = mc.UserMessage(prompt)
 
-                response = mdl.invoke(mc.ChatChoicesRequest([*state.chat, req_msg]))
+                response = await mdl.invoke(mc.ChatChoicesRequest([*state.chat, req_msg]))
 
                 resp_msg = response.v[0].m
 

ommlds/cli/sessions/chat/prompt.py

@@ -75,10 +75,10 @@ class PromptChatSession(ChatSession['PromptChatSession.Config']):
             self._config.backend or DEFAULT_CHAT_MODEL_BACKEND,
             *([mc.ModelName(mn)] if (mn := self._config.model_name) is not None else []),
         )) as mdl:
-            with mdl.invoke(mc.ChatChoicesStreamRequest(
+            with (await mdl.invoke(mc.ChatChoicesStreamRequest(
                     [*state.chat, *new_chat],
                     (self._chat_options or []),
-            )).v as st_resp:
+            ))).v as st_resp:
                 lst: list[str] = []
                 for o in st_resp:
                     if o:
@@ -112,7 +112,7 @@ class PromptChatSession(ChatSession['PromptChatSession.Config']):
                 self._config.backend or DEFAULT_CHAT_MODEL_BACKEND,
                 *([mc.ModelName(mn)] if (mn := self._config.model_name) is not None else []),
         )) as mdl:
-            response: mc.ChatChoicesResponse = mdl.invoke(mc.ChatChoicesRequest(
+            response: mc.ChatChoicesResponse = await mdl.invoke(mc.ChatChoicesRequest(
                 [*state.chat, *new_chat],
                 (self._chat_options or []),
             ))
@@ -130,7 +130,7 @@ class PromptChatSession(ChatSession['PromptChatSession.Config']):
                 print(trm.c)
                 new_chat.append(trm)
 
-                response = mdl.invoke(mc.ChatChoicesRequest(
+                response = await mdl.invoke(mc.ChatChoicesRequest(
                     [*state.chat, *new_chat],
                     (self._chat_options or []),
                 ))

ommlds/cli/sessions/completion/completion.py

@@ -40,5 +40,5 @@ class CompletionSession(Session['CompletionSession.Config']):
                 mc.CompletionService,
                 self._config.backend or DEFAULT_COMPLETION_MODEL_BACKEND,
         )) as mdl:
-            response = mdl.invoke(mc.CompletionRequest(prompt))
+            response = await mdl.invoke(mc.CompletionRequest(prompt))
             print(response.v.strip())

ommlds/cli/sessions/embedding/embedding.py

@@ -38,5 +38,5 @@ class EmbeddingSession(Session['EmbeddingSession.Config']):
             mc.EmbeddingService,
             self._config.backend or DEFAULT_EMBEDDING_MODEL_BACKEND,
         )) as mdl:
-            response = mdl.invoke(mc.EmbeddingRequest(self._config.content))
+            response = await mdl.invoke(mc.EmbeddingRequest(self._config.content))
             print(json.dumps_compact(list(map(float, response.v))))

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

@@ -62,7 +62,7 @@ class AnthropicChatChoicesService:
         else:
             raise TypeError(m)
 
-    def invoke(
+    async def invoke(
             self,
             request: ChatChoicesRequest,
             *,

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

@@ -2,12 +2,16 @@ 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 omlish.http import sse
 from omlish.io.buffers import DelimitingBuffer
 
+from .....backends.anthropic.protocol import types as pt
+from .....backends.anthropic.protocol.sse.assemble import AnthropicSseMessageAssembler
+from .....backends.anthropic.protocol.sse.events import AnthropicSseDecoderEvents
 from ....chat.choices.services import ChatChoicesOutputs
 from ....chat.messages import SystemMessage
 from ....chat.stream.services import ChatChoicesStreamRequest
@@ -15,6 +19,7 @@ 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 ....configs import Config
 from ....resources import UseResources
 from ....standard import ApiKey
@@ -41,7 +46,7 @@ class AnthropicChatChoicesStreamService:
 
     READ_CHUNK_SIZE = 64 * 1024
 
-    def invoke(
+    async def invoke(
             self,
             request: ChatChoicesStreamRequest,
             *,
@@ -85,6 +90,7 @@ class AnthropicChatChoicesStreamService:
             def yield_choices() -> ta.Generator[AiChoiceDeltas, None, ta.Sequence[ChatChoicesOutputs] | None]:
                 db = DelimitingBuffer([b'\r', b'\n', b'\r\n'])
                 sd = sse.SseDecoder()
+                ass = AnthropicSseMessageAssembler()
                 while True:
                     # FIXME: read1 not on response stream protocol
                     b = http_response.stream.read1(self.READ_CHUNK_SIZE)  # type: ignore[attr-defined]
@@ -95,24 +101,20 @@ class AnthropicChatChoicesStreamService:
 
                         # FIXME: https://docs.anthropic.com/en/docs/build-with-claude/streaming
                         for so in sd.process_line(l):
-                            # FIXME: AnthropicSseMessageAssembler lol
-                            if isinstance(so, sse.SseEvent) and so.type == b'message':
+                            if isinstance(so, sse.SseEvent):
                                 ss = so.data.decode('utf-8')
                                 if ss == '[DONE]':
                                     return []
 
-                                sj = json.loads(ss)  # ChatCompletionChunk
-
-                                check.state(sj['object'] == 'chat.completion.chunk')
-
-                                # FIXME: stop reason
-                                if not sj['choices']:
-                                    continue
-
-                                yield [
-                                    AiChoiceDelta(choice['delta'])
-                                    for choice in sj['choices']
-                                ]
+                                dct = json.loads(ss)
+                                check.equal(dct['type'], so.type.decode('utf-8'))
+                                ae = msh.unmarshal(dct, AnthropicSseDecoderEvents.Event)
+                                for am in ass(ae):
+                                    if isinstance(am, pt.Message):
+                                        mt = check.isinstance(check.single(check.not_none(am.content)), pt.Text)
+                                        yield [
+                                            AiChoiceDelta(AiMessageDelta(mt.text)),
+                                        ]
 
                     if not b:
                         return []

ommlds/minichain/backends/impls/duckduckgo/search.py

@@ -17,7 +17,7 @@ from ....search import static_check_is_search_service
 # )
 @static_check_is_search_service
 class DuckduckgoSearchService:
-    def invoke(self, request: SearchRequest) -> SearchResponse:
+    async def invoke(self, request: SearchRequest) -> SearchResponse:
         dsch = ddgs.DDGS()
         res = dsch.text(request.v)
         return SearchResponse(SearchHits(