ommlds 0.0.0.dev448__py3-none-any.whl → 0.0.0.dev450__py3-none-any.whl

ommlds/cli/main.py

@@ -24,6 +24,7 @@ from omlish.subprocesses.sync import subprocesses
 from .. import minichain as mc
 from .inject import bind_main
 from .sessions.base import Session
+from .sessions.chat.code import CodeChatSession
 from .sessions.chat.interactive import InteractiveChatSession
 from .sessions.chat.prompt import PromptChatSession
 from .sessions.completion.completion import CompletionSession
@@ -58,6 +59,7 @@ async def _a_main(args: ta.Any = None) -> None:
 
     parser.add_argument('-e', '--editor', action='store_true')
     parser.add_argument('-i', '--interactive', action='store_true')
+    parser.add_argument('-c', '--code', action='store_true')
     parser.add_argument('-s', '--stream', action='store_true')
     parser.add_argument('-M', '--markdown', action='store_true')
 
@@ -65,6 +67,7 @@ async def _a_main(args: ta.Any = None) -> None:
     parser.add_argument('-j', '--image', action='store_true')
 
     parser.add_argument('--enable-fs-tools', action='store_true')
+    parser.add_argument('--enable-todo-tools', action='store_true')
     parser.add_argument('--enable-unsafe-bash-tool', action='store_true')
     parser.add_argument('--enable-test-weather-tool', action='store_true')
     parser.add_argument('--dangerous-no-tool-confirmation', action='store_true')
@@ -73,7 +76,7 @@ async def _a_main(args: ta.Any = None) -> None:
 
     #
 
-    content: mc.Content
+    content: mc.Content | None
 
     if args.image:
         content = mc.ImageContent(pimg.open(check.non_empty_str(check.single(args.prompt))))
@@ -88,12 +91,19 @@ async def _a_main(args: ta.Any = None) -> None:
         if args.prompt:
             raise ValueError('Must not provide prompt')
 
+    elif args.code:
+        if args.prompt:
+            content = ' '.join(args.prompt)
+        else:
+            content = None
+
     elif not args.prompt:
         raise ValueError('Must provide prompt')
 
     else:
         prompt = ' '.join(args.prompt)
 
+        # FIXME: ptk / maysync
         if not sys.stdin.isatty() and not pycharm.is_pycharm_hosted():
             stdin_data = sys.stdin.read()
             prompt = '\n'.join([prompt, stdin_data])
@@ -126,21 +136,31 @@ async def _a_main(args: ta.Any = None) -> None:
             dangerous_no_tool_confirmation=bool(args.dangerous_no_tool_confirmation),
         )
 
+    elif args.code:
+        session_cfg = CodeChatSession.Config(
+            backend=args.backend,
+            model_name=args.model_name,
+            new=bool(args.new),
+            dangerous_no_tool_confirmation=bool(args.dangerous_no_tool_confirmation),
+            initial_message=content,  # noqa
+            markdown=bool(args.markdown),
+        )
+
     elif args.embed:
         session_cfg = EmbeddingSession.Config(
-            content,  # noqa
+            check.not_none(content),  # noqa
             backend=args.backend,
         )
 
     elif args.completion:
         session_cfg = CompletionSession.Config(
-            content,  # noqa
+            check.not_none(content),  # noqa
             backend=args.backend,
         )
 
     else:
         session_cfg = PromptChatSession.Config(
-            content,  # noqa
+            check.not_none(content),  # noqa
             backend=args.backend,
             model_name=args.model_name,
             new=bool(args.new),
@@ -152,7 +172,8 @@ async def _a_main(args: ta.Any = None) -> None:
     #
 
     tools_config = ToolsConfig(
-        enable_fs_tools=args.enable_fs_tools,
+        enable_fs_tools=args.enable_fs_tools or args.code,
+        enable_todo_tools=args.enable_todo_tools or args.code,
         enable_unsafe_bash_tool=args.enable_unsafe_bash_tool,
         enable_test_weather_tool=args.enable_test_weather_tool,
     )
@@ -162,7 +183,7 @@ async def _a_main(args: ta.Any = None) -> None:
     with inj.create_managed_injector(bind_main(
             session_cfg=session_cfg,
             tools_config=tools_config,
-            enable_backend_strings=isinstance(session_cfg, PromptChatSession.Config),
+            enable_backend_strings=isinstance(session_cfg, (PromptChatSession.Config, CodeChatSession.Config)),
     )) as injector:
         await injector[Session].run()
 

ommlds/cli/sessions/chat/code.py

@@ -0,0 +1,114 @@
+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 .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,
+    ) -> 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
+
+    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())
+        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:
+                    prompt = await ptk.prompt('> ')
+                    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

@@ -7,12 +7,9 @@ from omlish import lang
 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')
 
 
 ##

ommlds/cli/sessions/chat/prompt.py

@@ -1,4 +1,5 @@
 import dataclasses as dc
+import os
 
 from omlish import check
 from omlish import lang
@@ -125,7 +126,13 @@ class PromptChatSession(ChatSession['PromptChatSession.Config']):
 
                 tr: mc.ToolExecRequest = check.single(check.not_none(trs))
 
-                trm = await self._tool_exec_request_executor.execute_tool_request(tr)
+                # 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()),
+                )
 
                 print(trm.c)
                 new_chat.append(trm)

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

@@ -9,10 +9,8 @@ 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 +47,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')
 
@@ -63,7 +62,11 @@ class AskingToolExecutionConfirmation(ToolExecutionConfirmation):
 
 class ToolExecRequestExecutor(lang.Abstract):
     @abc.abstractmethod
-    def execute_tool_request(self, tr: mc.ToolExecRequest) -> ta.Awaitable[mc.ToolExecResultMessage]:
+    def execute_tool_request(
+            self,
+            tr: mc.ToolExecRequest,
+            *ctx_items: ta.Any,
+    ) -> ta.Awaitable[mc.ToolExecResultMessage]:
         raise NotImplementedError
 
 
@@ -79,13 +82,20 @@ class ToolExecRequestExecutorImpl(ToolExecRequestExecutor):
         self._catalog = catalog
         self._confirmation = confirmation
 
-    async def execute_tool_request(self, tr: mc.ToolExecRequest) -> mc.ToolExecResultMessage:
+    async def execute_tool_request(
+            self,
+            tr: mc.ToolExecRequest,
+            *ctx_items: ta.Any,
+    ) -> mc.ToolExecResultMessage:
         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(
-            mc.ToolContext(),
+            mc.ToolContext(
+                tr,
+                *ctx_items,
+            ),
             tce.executor(),
             tr,
         )

ommlds/cli/tools/config.py

@@ -7,6 +7,7 @@ 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
 

ommlds/cli/tools/inject.py

@@ -47,13 +47,21 @@ def bind_tools(tools_config: ToolsConfig) -> inj.Elements:
     #
 
     if tools_config.enable_fs_tools:
-        from ...minichain.lib.fs.ls.execution import ls_tool
-
+        from ...minichain.lib.fs.tools.ls import ls_tool
         els.append(bind_tool(ls_tool()))
 
+        from ...minichain.lib.fs.tools.read import read_tool
+        els.append(bind_tool(read_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_bash_tool:
         from ...minichain.lib.bash import bash_tool
-
         els.append(bind_tool(bash_tool()))
 
     if tools_config.enable_test_weather_tool:

ommlds/minichain/__init__.py

@@ -361,6 +361,10 @@ with _lang.auto_proxy_init(
         reflect_tool_catalog_entry,
     )
 
+    from .tools.execution.errors import (  # noqa
+        ToolExecutionError,
+    )
+
     from .tools.fns import (  # noqa
         ToolFn,
 

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

@@ -17,10 +17,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 ....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,7 +58,6 @@ 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',
     }
@@ -65,16 +68,56 @@ 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,
+                            },
+                        ),
+                    )],
+                ))
+            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 +135,19 @@ 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 []:
+            g_resp_part = check.single(check.not_none(check.not_none(c.content).parts))
+            ter: ToolExecRequest | None = None
+            if (g_fc := g_resp_part.function_call) is not None:
+                ter = ToolExecRequest(
+                    id=g_fc.id,
+                    name=g_fc.name,
+                    args=g_fc.args or {},
+                )
+            ai_choices.append(AiChoice(AiMessage(
+                c=g_resp_part.text,
+                tool_exec_requests=[ter] if ter is not None else None,
+            )))
+
+        return ChatChoicesResponse(ai_choices)

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/lib/code/prompts.py

@@ -0,0 +1,6 @@
+CODE_AGENT_SYSTEM_PROMPT = """
+You are an interactive assistant specializing in programming tasks.
+
+Your goal is to assist the user by accomplishing the tasks and answering the questions given to you by the user using
+your available tools.
+"""