ommlds 0.0.0.dev449__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

@@ -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

@@ -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')
 

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,12 +47,19 @@ 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_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()))

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.
+"""

ommlds/minichain/lib/fs/context.py

@@ -15,7 +15,7 @@ from .suggestions import get_path_suggestions
 ##
 
 
-class FsToolContext:
+class FsContext:
     def __init__(
             self,
             *,
@@ -86,7 +86,7 @@ class FsToolContext:
                 req_path,
                 suggested_paths=get_path_suggestions(
                     req_path,
-                    filter=lambda e: (e.is_file() and not has_binary_file_extension(e.name)),
+                    filter=lambda e: (e.is_file() and not (text and has_binary_file_extension(e.name))),
                 ),
             ) from None
 
@@ -108,5 +108,5 @@ class FsToolContext:
         return st
 
 
-def fs_tool_context() -> FsToolContext:
-    return tool_context()[FsToolContext]
+def fs_tool_context() -> FsContext:
+    return tool_context()[FsContext]

ommlds/minichain/lib/fs/{catalog → tools}/ls.py

@@ -21,8 +21,8 @@ def execute_ls_tool(
         dir_path: The dir to list the contents of. Must be an absolute path.
     """
 
-    ft_ctx = fs_tool_context()
-    ft_ctx.check_stat_dir(dir_path)
+    ctx = fs_tool_context()
+    ctx.check_stat_dir(dir_path)
 
     out = io.StringIO()
     out.write('<dir>\n')

ommlds/minichain/lib/fs/{catalog → tools}/read.py

@@ -26,8 +26,8 @@ MAX_LINE_LENGTH = 2_000
 
 
 @tool_spec_override(
-    desc=rf"""
-        Reads a file from the local filesystem. You can access any file directly by using this tool.
+    desc=f"""
+         Reads a file from the local filesystem. You can access any file directly by using this tool.
 
         Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that
         path is valid. It is okay to read a file that does not exist; an error will be returned.
@@ -42,7 +42,7 @@ MAX_LINE_LENGTH = 2_000
         - Results are returned using cat -n format, with line numbers starting at 1 and suffixed with a pipe character
           "|".
         - This tool cannot read binary files, including images.
-""",
+    """,
     params=[
         ToolParam(
             'file_path',
@@ -64,8 +64,8 @@ def execute_read_tool(
         line_offset: int = 0,
         num_lines: int = DEFAULT_MAX_NUM_LINES,
 ) -> str:
-    ft_ctx = fs_tool_context()
-    ft_ctx.check_stat_file(file_path, text=True)
+    ctx = fs_tool_context()
+    ctx.check_stat_file(file_path, text=True)
 
     out = io.StringIO()
     out.write('<file>\n')