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

ommlds/cli/sessions/chat/code.py

@@ -0,0 +1,124 @@
+import dataclasses as dc
+import itertools
+import os.path
+
+from omlish import check
+from omlish import lang
+
+from .... import minichain as mc
+from ....minichain.lib.code.prompts import CODE_AGENT_SYSTEM_PROMPT
+from ...tools.config import ToolsConfig
+from .base import DEFAULT_CHAT_MODEL_BACKEND
+from .base import ChatOptions
+from .base import ChatSession
+from .printing import ChatSessionPrinter
+from .state import ChatStateManager
+from .tools import ToolExecRequestExecutor
+
+
+with lang.auto_proxy_import(globals()):
+    from omdev import ptk
+
+
+##
+
+
+class CodeChatSession(ChatSession['CodeChatSession.Config']):
+    @dc.dataclass(frozen=True)
+    class Config(ChatSession.Config):
+        _: dc.KW_ONLY
+
+        new: bool = False
+
+        backend: str | None = None
+        model_name: str | None = None
+
+        initial_message: mc.Content | None = None
+
+    def __init__(
+            self,
+            config: Config,
+            *,
+            state_manager: ChatStateManager,
+            chat_options: ChatOptions | None = None,
+            printer: ChatSessionPrinter,
+            backend_catalog: mc.BackendCatalog,
+            tool_exec_request_executor: ToolExecRequestExecutor,
+            tools_config: ToolsConfig | None = None,
+    ) -> None:
+        super().__init__(config)
+
+        self._state_manager = state_manager
+        self._chat_options = chat_options
+        self._printer = printer
+        self._backend_catalog = backend_catalog
+        self._tool_exec_request_executor = tool_exec_request_executor
+        self._tools_config = tools_config
+
+    async def run(self) -> None:
+        if self._config.new:
+            self._state_manager.clear_state()
+            state = self._state_manager.extend_chat([
+                mc.SystemMessage(CODE_AGENT_SYSTEM_PROMPT),
+            ])
+
+        else:
+            state = self._state_manager.get_state()
+
+        backend = self._config.backend
+        if backend is None:
+            backend = DEFAULT_CHAT_MODEL_BACKEND
+
+        # FIXME: lol
+        from ....minichain.lib.fs.context import FsContext
+        fs_tool_context = FsContext(
+            root_dir=os.getcwd(),
+            writes_permitted=self._tools_config is not None and self._tools_config.enable_unsafe_tools_do_not_use_lol,
+        )
+
+        from ....minichain.lib.todo.context import TodoContext
+        todo_tool_context = TodoContext()
+
+        mdl: mc.ChatChoicesService
+        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
+                mc.ChatChoicesService,
+                backend,
+                *([mc.ModelName(mn)] if (mn := self._config.model_name) is not None else []),
+        )) as mdl:
+            for i in itertools.count():
+                if not i and self._config.initial_message is not None:
+                    req_msg = mc.UserMessage(self._config.initial_message)
+                else:
+                    try:
+                        prompt = await ptk.prompt('> ')
+                    except EOFError:
+                        break
+                    req_msg = mc.UserMessage(prompt)
+
+                state = self._state_manager.extend_chat([req_msg])
+
+                while True:
+                    response = await mdl.invoke(mc.ChatChoicesRequest(
+                        state.chat,
+                        (self._chat_options or []),
+                    ))
+                    resp_msg = check.single(response.v).m
+
+                    self._printer.print(resp_msg)
+                    state = self._state_manager.extend_chat([resp_msg])
+
+                    if not (trs := resp_msg.tool_exec_requests):
+                        break
+
+                    tool_resp_lst = []
+                    for tr in trs:
+                        trm = await self._tool_exec_request_executor.execute_tool_request(
+                            tr,
+                            fs_tool_context,
+                            todo_tool_context,
+                        )
+
+                        self._printer.print(trm.c)
+                        tool_resp_lst.append(trm)
+
+                    state = self._state_manager.extend_chat(tool_resp_lst)

ommlds/cli/sessions/chat/interactive.py

@@ -1,5 +1,4 @@
 import dataclasses as dc
-import typing as ta
 
 from omlish import lang
 
@@ -10,10 +9,8 @@ from .printing import ChatSessionPrinter
 from .state import ChatStateManager
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     from omdev import ptk
-else:
-    ptk = lang.proxy_import('omdev.ptk')
 
 
 ##
@@ -60,7 +57,7 @@ class InteractiveChatSession(ChatSession['InteractiveChatSession.Config']):
                 *([mc.ModelName(mn)] if (mn := self._config.model_name) is not None else []),
         )) as mdl:
             while True:
-                prompt = ptk.prompt('> ')
+                prompt = await ptk.prompt('> ')
 
                 req_msg = mc.UserMessage(prompt)
 

ommlds/cli/sessions/chat/printing.py

@@ -3,16 +3,14 @@ import typing as ta
 
 from omlish import check
 from omlish import lang
+from omlish.formats import json
 
 from .... import minichain as mc
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     from omdev import ptk
     from omdev.ptk import markdown as ptk_md
-else:
-    ptk = lang.proxy_import('omdev.ptk')
-    ptk_md = lang.proxy_import('omdev.ptk.markdown')
 
 
 ##
@@ -51,6 +49,9 @@ class StringChatSessionPrinter(ChatSessionPrinter, lang.Abstract):
             else:
                 raise TypeError(obj)
 
+        elif isinstance(obj, mc.JsonContent):
+            self._print_str(json.dumps_pretty(obj.v))
+
         elif isinstance(obj, str):
             self._print_str(obj)
 

ommlds/cli/sessions/chat/prompt.py

@@ -127,11 +127,11 @@ class PromptChatSession(ChatSession['PromptChatSession.Config']):
                 tr: mc.ToolExecRequest = check.single(check.not_none(trs))
 
                 # FIXME: lol
-                from ....minichain.lib.fs.context import FsToolContext
+                from ....minichain.lib.fs.context import FsContext
 
                 trm = await self._tool_exec_request_executor.execute_tool_request(
                     tr,
-                    FsToolContext(root_dir=os.getcwd()),
+                    FsContext(root_dir=os.getcwd()),
                 )
 
                 print(trm.c)

ommlds/cli/sessions/chat/state.py

@@ -106,4 +106,5 @@ class StateStorageChatStateManager(ChatStateManager):
             updated_at=lang.utcnow(),
         )
         self._storage.save_state(self._key, state, ChatState)
+        self._state = state
         return state

ommlds/cli/sessions/chat/tools.py

@@ -3,16 +3,13 @@ import typing as ta
 
 from omlish import check
 from omlish import lang
-from omlish import marshal as msh
 from omlish.formats import json
 
 from .... import minichain as mc
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     from omdev import ptk
-else:
-    ptk = lang.proxy_import('omdev.ptk')
 
 
 ##
@@ -49,8 +46,9 @@ class AskingToolExecutionConfirmation(ToolExecutionConfirmation):
     ) -> None:
         tr_dct = dict(
             id=tr.id,
-            spec=msh.marshal(tce.spec),
+            name=tce.spec.name,
             args=tr.args,
+            # spec=msh.marshal(tce.spec),
         )
         cr = await ptk.strict_confirm(f'Execute requested tool?\n\n{json.dumps_pretty(tr_dct)}\n\n')
 

ommlds/cli/tools/config.py

@@ -7,7 +7,8 @@ from omlish import dataclasses as dc
 @dc.dataclass(frozen=True, kw_only=True)
 class ToolsConfig:
     enable_fs_tools: bool = False
+    enable_todo_tools: bool = False
 
-    enable_unsafe_bash_tool: bool = False
+    enable_unsafe_tools_do_not_use_lol: bool = False
 
     enable_test_weather_tool: bool = False

ommlds/cli/tools/inject.py

@@ -47,16 +47,26 @@ def bind_tools(tools_config: ToolsConfig) -> inj.Elements:
     #
 
     if tools_config.enable_fs_tools:
-        from ...minichain.lib.fs.catalog.ls import ls_tool
+        from ...minichain.lib.fs.tools.ls import ls_tool
         els.append(bind_tool(ls_tool()))
 
-        from ...minichain.lib.fs.catalog.read import read_tool
+        from ...minichain.lib.fs.tools.read import read_tool
         els.append(bind_tool(read_tool()))
 
-    if tools_config.enable_unsafe_bash_tool:
+    if tools_config.enable_todo_tools:
+        from ...minichain.lib.todo.tools.read import todo_read_tool
+        els.append(bind_tool(todo_read_tool()))
+
+        from ...minichain.lib.todo.tools.write import todo_write_tool
+        els.append(bind_tool(todo_write_tool()))
+
+    if tools_config.enable_unsafe_tools_do_not_use_lol:
         from ...minichain.lib.bash import bash_tool
         els.append(bind_tool(bash_tool()))
 
+        from ...minichain.lib.fs.tools.edit import edit_tool
+        els.append(bind_tool(edit_tool()))
+
     if tools_config.enable_test_weather_tool:
         els.append(bind_tool(WEATHER_TOOL))
 

ommlds/minichain/__init__.py

@@ -197,8 +197,14 @@ with _lang.auto_proxy_init(
         ImageContent,
     )
 
+    from .content.json import (  # noqa
+        JsonContent,
+    )
+
     from .content.materialize import (  # noqa
         CanContent,
+
+        materialize_content,
     )
 
     from .content.metadata import (  # noqa
@@ -493,6 +499,12 @@ with _lang.auto_proxy_init(
         EnvKey,
     )
 
+    from .json import (  # noqa
+        JsonSchema,
+
+        JsonValue,
+    )
+
     from .metadata import (  # noqa
         Metadata,
 

ommlds/minichain/_marshal.py

@@ -1,10 +1,13 @@
 from omlish import dataclasses as dc
+from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
 from omlish.funcs import match as mfs
 from omlish.typedvalues.marshal import build_typed_values_marshaler
 from omlish.typedvalues.marshal import build_typed_values_unmarshaler
 
+from .json import JsonValue
+
 
 ##
 
@@ -25,3 +28,39 @@ class _TypedValuesFieldUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
     @mfs.simple(lambda _, ctx, rty: True)
     def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
         return build_typed_values_unmarshaler(ctx, self.tvs_rty)
+
+
+##
+
+
+class MarshalJsonValue(lang.NotInstantiable, lang.Final):
+    pass
+
+
+class _JsonValueMarshalerFactory(msh.MarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: rty is MarshalJsonValue)
+    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
+        return msh.NopMarshalerUnmarshaler()
+
+
+class _JsonValueUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: rty is MarshalJsonValue)
+    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
+        return msh.NopMarshalerUnmarshaler()
+
+
+##
+
+
+@lang.static_init
+def _install_standard_marshaling() -> None:
+    msh.register_global_config(
+        JsonValue,
+        msh.ReflectOverride(MarshalJsonValue),
+        identity=True,
+    )
+
+    msh.install_standard_factories(
+        _JsonValueMarshalerFactory(),
+        _JsonValueUnmarshalerFactory(),
+    )

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

@@ -1,4 +1,5 @@
 """
+https://docs.claude.com/en/api/messages
 https://github.com/anthropics/anthropic-sdk-python/tree/cd80d46f7a223a5493565d155da31b898a4c6ee5/src/anthropic/types
 https://github.com/anthropics/anthropic-sdk-python/blob/cd80d46f7a223a5493565d155da31b898a4c6ee5/src/anthropic/resources/completions.py#L53
 https://github.com/anthropics/anthropic-sdk-python/blob/cd80d46f7a223a5493565d155da31b898a4c6ee5/src/anthropic/resources/messages.py#L70
@@ -6,11 +7,12 @@ https://github.com/anthropics/anthropic-sdk-python/blob/cd80d46f7a223a5493565d15
 import typing as ta
 
 from omlish import check
-from omlish import lang
+from omlish import marshal as msh
 from omlish import typedvalues as tv
 from omlish.formats import json
 from omlish.http import all as http
 
+from .....backends.anthropic.protocol import types as pt
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
@@ -18,9 +20,14 @@ from ....chat.choices.types import AiChoice
 from ....chat.messages import AiMessage
 from ....chat.messages import Message
 from ....chat.messages import SystemMessage
+from ....chat.messages import ToolExecResultMessage
 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 .names import MODEL_NAMES
 
 
@@ -68,26 +75,69 @@ class AnthropicChatChoicesService:
             *,
             max_tokens: int = 4096,  # FIXME: ChatOption
     ) -> ChatChoicesResponse:
-        messages = []
-        system: str | None = None
+        messages: list[pt.Message] = []
+        system: list[pt.Content] | None = None
         for i, m in enumerate(request.v):
             if isinstance(m, SystemMessage):
                 if i != 0 or system is not None:
                     raise Exception('Only supports one system message and must be first')
-                system = self._get_msg_content(m)
+                system = [pt.Text(check.not_none(self._get_msg_content(m)))]
+
+            elif isinstance(m, ToolExecResultMessage):
+                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,
+                    )],
+                ))
+
+            elif isinstance(m, AiMessage):
+                # messages.append(pt.Message(
+                #     role=self.ROLES_MAP[type(m)],  # noqa
+                #     content=[pt.Text(check.isinstance(self._get_msg_content(m), str))],
+                # ))
+                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,
+                    ],
+                ))
+
             else:
-                messages.append(dict(
-                    role=self.ROLES_MAP[type(m)],  # noqa
-                    content=check.isinstance(self._get_msg_content(m), str),
+                messages.append(pt.Message(
+                    role=self.ROLES_MAP[type(m)],  # type: ignore[arg-type]
+                    content=[pt.Text(check.isinstance(self._get_msg_content(m), str))],
+                ))
+
+        tools: list[pt.ToolSpec] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(pt.ToolSpec(
+                    name=check.not_none(t.spec.name),
+                    description=prepare_content_str(t.spec.desc),
+                    input_schema=build_tool_spec_params_json_schema(t.spec),
                 ))
 
-        raw_request = dict(
+        a_req = pt.MessagesRequest(
             model=MODEL_NAMES.resolve(self._model_name.v),
-            **lang.opt_kw(system=system),
+            system=system,
             messages=messages,
+            tools=tools or None,
             max_tokens=max_tokens,
         )
 
+        raw_request = msh.marshal(a_req)
+
         raw_response = http.request(
             'https://api.anthropic.com/v1/messages',
             headers={
@@ -100,6 +150,24 @@ class AnthropicChatChoicesService:
 
         response = json.loads(check.not_none(raw_response.data).decode('utf-8'))
 
+        resp_c: ta.Any = None
+        ters: list[ToolExecRequest] = []
+        for c in response['content']:
+            if c['type'] == 'text':
+                check.none(resp_c)
+                resp_c = check.not_none(c['text'])
+            elif c['type'] == 'tool_use':
+                ters.append(ToolExecRequest(
+                    id=c['id'],
+                    name=c['name'],
+                    args=c['input'],
+                ))
+            else:
+                raise TypeError(c['type'])
+
         return ChatChoicesResponse([
-            AiChoice(AiMessage(response['content'][0]['text'])),  # noqa
+            AiChoice(AiMessage(
+                resp_c,
+                tool_exec_requests=ters if ters else None,
+            )),
         ])

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

@@ -17,10 +17,15 @@ from ....chat.choices.types import AiChoice
 from ....chat.messages import AiMessage
 from ....chat.messages import Message
 from ....chat.messages import SystemMessage
+from ....chat.messages import ToolExecResultMessage
 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 .names import MODEL_NAMES
+from .tools import build_tool_spec_schema
 
 
 ##
@@ -54,9 +59,8 @@ class GoogleChatChoicesService:
     BASE_URL: ta.ClassVar[str] = 'https://generativelanguage.googleapis.com/v1beta/models'
 
     ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], str]] = {
-        SystemMessage: 'system',
         UserMessage: 'user',
-        AiMessage: 'assistant',
+        AiMessage: 'model',
     }
 
     async def invoke(
@@ -65,16 +69,77 @@ class GoogleChatChoicesService:
     ) -> ChatChoicesResponse:
         key = check.not_none(self._api_key).reveal()
 
-        g_req = pt.GenerateContentRequest(
-            contents=[
-                pt.Content(
+        g_sys_content: pt.Content | None = None
+        g_contents: list[pt.Content] = []
+        for i, m in enumerate(request.v):
+            if isinstance(m, SystemMessage):
+                check.arg(i == 0)
+                check.none(g_sys_content)
+                g_sys_content = pt.Content(
                     parts=[pt.Part(
                         text=check.not_none(self._get_msg_content(m)),
                     )],
-                    role=self.ROLES_MAP[type(m)],  # type: ignore[arg-type]
                 )
-                for m in request.v
-            ],
+
+            elif isinstance(m, ToolExecResultMessage):
+                tr_resp_val: pt.Value
+                if m.c is None:
+                    tr_resp_val = pt.NullValue()  # type: ignore[unreachable]
+                elif isinstance(m.c, str):
+                    tr_resp_val = pt.StringValue(m.c)
+                else:
+                    raise TypeError(m.c)
+                g_contents.append(pt.Content(
+                    parts=[pt.Part(
+                        function_response=pt.FunctionResponse(
+                            id=m.id,
+                            name=m.name,
+                            response={
+                                'value': tr_resp_val,
+                            },
+                        ),
+                    )],
+                ))
+
+            elif isinstance(m, AiMessage):
+                ai_parts: list[pt.Part] = []
+                if m.c is not None:
+                    ai_parts.append(pt.Part(
+                        text=check.not_none(self._get_msg_content(m)),
+                    ))
+                for teq in m.tool_exec_requests or []:
+                    ai_parts.append(pt.Part(
+                        function_call=pt.FunctionCall(
+                            id=teq.id,
+                            name=teq.name,
+                            args=teq.args,
+                        ),
+                    ))
+                g_contents.append(pt.Content(
+                    parts=ai_parts,
+                    role='model',
+                ))
+
+            else:
+                g_contents.append(pt.Content(
+                    parts=[pt.Part(
+                        text=check.not_none(self._get_msg_content(m)),
+                    )],
+                    role=self.ROLES_MAP[type(m)],  # type: ignore[arg-type]
+                ))
+
+        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=g_contents or None,
+            tools=g_tools or None,
+            system_instruction=g_sys_content,
         )
 
         req_dct = msh.marshal(g_req)
@@ -92,7 +157,25 @@ class GoogleChatChoicesService:
 
         g_resp = msh.unmarshal(resp_dct, pt.GenerateContentResponse)
 
-        return ChatChoicesResponse([
-            AiChoice(AiMessage(check.not_none(check.not_none(check.not_none(c.content).parts)[0].text)))
-            for c in g_resp.candidates or []
-        ])
+        ai_choices: list[AiChoice] = []
+        for c in g_resp.candidates or []:
+            ai_c: Content | None = None
+            ters: list[ToolExecRequest] = []
+            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
+                elif (g_fc := g_resp_part.function_call) is not None:
+                    ters.append(ToolExecRequest(
+                        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,
+            )))
+
+        return ChatChoicesResponse(ai_choices)