delos-cli 1.0.1__tar.gz → 1.0.2__tar.gz

{delos_cli-1.0.1 → delos_cli-1.0.2}/.gitignore

@@ -27,6 +27,7 @@ backend/.python-version
 backend/scripts/*
 !backend/scripts/__init__.py
 !backend/scripts/export_tools_catalog.py
+!backend/scripts/check_supabase_models.py
 
 .claude/worktrees
 

{delos_cli-1.0.1 → delos_cli-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: delos-cli
-Version: 1.0.1
+Version: 1.0.2
 Summary: Terminal REPL for the Delos agent — the Claude-Code-style CLI for Delos.
 Project-URL: Homepage, https://delos.so
 Project-URL: Repository, https://github.com/Delos-Intelligence/cosmos-saas
@@ -24,6 +24,8 @@ Requires-Dist: httpx>=0.27.0
 Requires-Dist: prompt-toolkit>=3.0.47
 Requires-Dist: questionary>=2.0.1
 Requires-Dist: rich>=13.8.0
+Requires-Dist: ripgrep>=15; sys_platform == 'darwin' and platform_machine == 'arm64'
+Requires-Dist: ripgrep>=15; sys_platform == 'linux' and platform_machine == 'x86_64'
 Requires-Dist: typer>=0.12.5
 Description-Content-Type: text/markdown
 

{delos_cli-1.0.1 → delos_cli-1.0.2}/delos_cli/__init__.py

@@ -3,7 +3,7 @@
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
 
-try:
+try:  # noqa: RUF067
     __version__ = version("delos-cli")
 except PackageNotFoundError:  # editable checkout without installed metadata
     __version__ = "0.0.0+dev"

{delos_cli-1.0.1 → delos_cli-1.0.2}/delos_cli/agent/session.py

@@ -11,6 +11,8 @@ how client-tool calls collect input from the user.
 
 from __future__ import annotations
 
+import asyncio
+from itertools import starmap
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -90,18 +92,37 @@ class AgentSession:
             if stopped or not pending:
                 return
 
-            for tcid, meta in pending.items():
+            # The backend only batches non-interactive client tools
+            # (read/grep/glob…) in the same turn, so the pending calls are
+            # safe to EXECUTE concurrently.  Results are then POSTed
+            # sequentially: the ``app_cli_messages`` seq trigger computes
+            # ``MAX(seq)+1``, so concurrent inserts on the same chat race
+            # into a unique-constraint 500.  Execution is the slow part;
+            # the posts are cheap.
+            async def _execute(
+                tcid: str, meta: dict[str, Any],
+            ) -> tuple[str, dict[str, Any], str]:
                 handler = self._registry.handler_for(meta["name"])
                 result = await handler(meta["input"], ctx)
+                return tcid, meta, result
+
+            outcomes = await asyncio.gather(
+                *starmap(_execute, pending.items()),
+                return_exceptions=True,
+            )
+            for outcome in outcomes:
+                if isinstance(outcome, BaseException):
+                    raise outcome
+                tcid, meta, result = outcome
+                await self._transport.submit_tool_result(
+                    self._chat_id, tcid, meta["name"], result,
+                )
                 if emit_tool_output:
                     yield {
                         "type": "tool-output-available",
                         "toolCallId": tcid,
                         "output": result,
                     }
-                await self._transport.submit_tool_result(
-                    self._chat_id, tcid, meta["name"], result,
-                )
 
             current_body = {**body, "messages": [], "tool_continuation": True}
 

{delos_cli-1.0.1 → delos_cli-1.0.2}/delos_cli/apps/chat/app.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 import contextlib
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from rich.text import Text
@@ -21,9 +22,11 @@ from rich.text import Text
 from delos_cli.agent import AgentSession, AgentTransport, ToolRegistry
 from delos_cli.apps.base import App
 from delos_cli.apps.replay import replay_messages
+from delos_cli.git_context import collect_git_context
 from delos_cli.state import TodoStore
 from delos_cli.tools import (
     handle_edit_content,
+    handle_explore,
     handle_glob,
     handle_grep,
     handle_read,
@@ -31,6 +34,7 @@ from delos_cli.tools import (
     handle_todo_write,
     handle_write_content,
     render_edit_content,
+    render_explore,
     render_glob,
     render_grep,
     render_read,
@@ -74,6 +78,10 @@ def default_tool_registry() -> ToolRegistry:
     # `task` is server-side (no handler needed); the renderer shows the
     # sub-agent's input/output lifecycle in the terminal.
     reg.renderers["task"] = render_task
+    # `explore` spawns a local read-only sub-agent conversation and returns
+    # only its report — see delos_cli.tools.explore.
+    reg.handlers["explore"] = handle_explore
+    reg.renderers["explore"] = render_explore
     return reg
 
 
@@ -136,6 +144,10 @@ class ChatApp(App):
         }
         if ctx.custom_instructions:
             body["custom_instructions"] = ctx.custom_instructions
+        # Fresh git snapshot per turn — rendered into the system prompt so
+        # the agent doesn't burn its first tool call on `git status`.
+        if (git_ctx := await collect_git_context(Path.cwd())) is not None:
+            body["git_context"] = git_ctx
 
         self._current_session = session
         try:

{delos_cli-1.0.1 → delos_cli-1.0.2}/delos_cli/apps/chat/commands.py

@@ -24,6 +24,7 @@ from prompt_toolkit.application import get_app
 from rich.text import Text
 
 from delos_cli.commands.base import CommandSpec, registry_from
+from delos_cli.commands.prompts import EXECUTE_PROMPT, INIT_PROMPT_NEW, INIT_PROMPT_UPDATE
 from delos_cli.transport.chats import patch_chat_model
 from delos_cli.transport.client import TransportError
 
@@ -86,4 +87,45 @@ MODEL = CommandSpec(
 )
 
 
-CHAT_COMMANDS: dict[str, CommandSpec] = registry_from([MODEL])
+# ---------------------------------------------------------------------------
+# /init — generate (or refresh) the project's DELOS.md
+# ---------------------------------------------------------------------------
+
+
+async def _handle_init(ctx: Ctx, args: str) -> None:  # noqa: RUF029 — CommandSpec handlers are async
+    """Stage the DELOS.md generation prompt as the next agent turn."""
+    _ = args
+    ctx.state.staged_message = (
+        INIT_PROMPT_UPDATE if ctx.custom_instructions else INIT_PROMPT_NEW
+    )
+
+
+INIT = CommandSpec(
+    name="/init",
+    summary="generate or refresh the project's DELOS.md by exploring the codebase",
+    handler=_handle_init,
+)
+
+
+# ---------------------------------------------------------------------------
+# /execute — hand a plan-mode plan over to execution
+# ---------------------------------------------------------------------------
+
+
+async def _handle_execute(ctx: Ctx, args: str) -> None:  # noqa: RUF029 — CommandSpec handlers are async
+    """Leave plan permission-mode and stage the execute prompt."""
+    _ = args
+    if ctx.state.permission_mode == "plan":
+        ctx.state.permission_mode = "default"
+        _sink(ctx).print(Text("permission mode → default", style="dim"))
+    ctx.state.staged_message = EXECUTE_PROMPT
+
+
+EXECUTE = CommandSpec(
+    name="/execute",
+    summary="execute the plan from the previous plan-mode turn (loads it into todos)",
+    handler=_handle_execute,
+)
+
+
+CHAT_COMMANDS: dict[str, CommandSpec] = registry_from([MODEL, INIT, EXECUTE])

{delos_cli-1.0.1 → delos_cli-1.0.2}/delos_cli/auth/oauth.py

@@ -54,16 +54,52 @@ HTTP_ERROR_THRESHOLD = 400
 CLIENT_ID = "delos-code"
 LOOPBACK_PORT = 52700
 
+# Self-contained sign-in result pages. No external assets (the loopback server
+# only serves these two responses), brand teal matching the apps, dark-mode
+# aware via prefers-color-scheme.
+_PAGE_STYLE = """
+:root { color-scheme: light dark; --brand: #3dd6b9; --bg: #f7f8f8; --card: #ffffff;
+  --fg: #1a1a1a; --muted: #6b7280; --border: rgba(0,0,0,.08); --shadow: rgba(0,0,0,.08); }
+@media (prefers-color-scheme: dark) { :root { --bg: #0e1110; --card: #171a19;
+  --fg: #e8eae9; --muted: #9aa3a0; --border: rgba(255,255,255,.08); --shadow: rgba(0,0,0,.4); } }
+* { box-sizing: border-box; }
+body { margin: 0; min-height: 100vh; display: flex; align-items: center; justify-content: center;
+  background: var(--bg); color: var(--fg); padding: 1.5rem;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif; }
+.card { background: var(--card); border: 1px solid var(--border); border-radius: 16px;
+  padding: 2.5rem 2.75rem; max-width: 380px; width: 100%; text-align: center;
+  box-shadow: 0 8px 30px var(--shadow); animation: rise .35s ease both; }
+@keyframes rise { from { opacity: 0; transform: translateY(8px); } }
+.badge { width: 56px; height: 56px; border-radius: 50%; display: flex; align-items: center;
+  justify-content: center; margin: 0 auto 1.25rem; }
+.badge svg { width: 28px; height: 28px; }
+.ok { background: rgba(61,214,185,.14); color: var(--brand); }
+.err { background: rgba(239,68,68,.14); color: #ef4444; }
+h1 { margin: 0 0 .4rem; font-size: 1.3rem; font-weight: 650; letter-spacing: -.01em; }
+p { margin: 0; color: var(--muted); font-size: .92rem; line-height: 1.5; }
+""".strip()
+
 _SUCCESS_HTML = (
-    b"<!doctype html><html><head><meta charset='utf-8'>"
-    b"<title>Delos CLI</title></head><body style='font-family:sans-serif;padding:3rem'>"
-    b"<h1>Signed in.</h1><p>You can close this tab.</p></body></html>"
-)
+    "<!doctype html><html lang='en'><head><meta charset='utf-8'>"
+    "<meta name='viewport' content='width=device-width, initial-scale=1'>"
+    "<title>Signed in · Delos</title><style>" + _PAGE_STYLE + "</style></head>"
+    "<body><main class='card'><div class='badge ok'>"
+    "<svg viewBox='0 0 24 24' fill='none' stroke='currentColor' stroke-width='2.5' "
+    "stroke-linecap='round' stroke-linejoin='round'><path d='M20 6 9 17l-5-5'/></svg>"
+    "</div><h1>You're signed in</h1>"
+    "<p>You can close this tab and return to your editor.</p></main></body></html>"
+).encode("utf-8")
+
 _ERROR_HTML = (
-    b"<!doctype html><html><head><meta charset='utf-8'>"
-    b"<title>Delos CLI</title></head><body style='font-family:sans-serif;padding:3rem'>"
-    b"<h1>Sign-in failed.</h1><p>Check the terminal for details.</p></body></html>"
-)
+    "<!doctype html><html lang='en'><head><meta charset='utf-8'>"
+    "<meta name='viewport' content='width=device-width, initial-scale=1'>"
+    "<title>Sign-in failed · Delos</title><style>" + _PAGE_STYLE + "</style></head>"
+    "<body><main class='card'><div class='badge err'>"
+    "<svg viewBox='0 0 24 24' fill='none' stroke='currentColor' stroke-width='2.5' "
+    "stroke-linecap='round' stroke-linejoin='round'><path d='M18 6 6 18M6 6l12 12'/></svg>"
+    "</div><h1>Sign-in failed</h1>"
+    "<p>Something went wrong. Check the terminal for details and try again.</p></main></body></html>"
+).encode("utf-8")
 
 
 class OAuthError(RuntimeError):

delos_cli-1.0.2/delos_cli/commands/prompts.py

@@ -0,0 +1,80 @@
+"""Slash commands that expand into agent prompts — shared REPL/serve.
+
+The REPL surfaces these as ``CommandSpec`` handlers (``/init``, ``/execute``
+in ``apps/chat/commands.py``); serve mode expands them inline when a
+``user_message`` starts with the command, so typing ``/init`` in the VSCode
+input works without any extension change.  ``list_commands`` (RPC) exposes
+the catalogue so the webview can offer autocomplete.
+"""
+
+from __future__ import annotations
+
+INIT_PROMPT_NEW = """\
+Generate this project's DELOS.md — the instructions file that will be loaded \
+into your system prompt for every future conversation in this repository.
+
+Method: use `explore` (several calls in the same turn, they run in parallel) \
+to map the project — build/run/test/lint commands, architecture and directory \
+layout, tech stack, code conventions, anything a coding agent must know to \
+work here safely. Read the key config files (package manifests, CI, existing \
+README) yourself where precision matters.
+
+Then write a DELOS.md at the repository root with `write_content` (create it \
+with `run_shell touch DELOS.md` first if needed). Keep it under ~150 lines: \
+dense, factual, imperative. Sections: project overview (2-3 lines), commands, \
+architecture, conventions, warnings/pitfalls. No filler prose."""
+
+INIT_PROMPT_UPDATE = """\
+This repository already has DELOS.md content (it is loaded in your system \
+prompt under "Project instructions"). Review it against the actual codebase \
+and update it: use `explore` (several calls in the same turn, they run in \
+parallel) to verify the documented commands, architecture and conventions \
+still match reality, then edit DELOS.md at the repository root to fix what \
+drifted, remove what's dead, and add what's missing. Keep it under ~150 \
+lines: dense, factual, imperative."""
+
+EXECUTE_PROMPT = """\
+Execute the plan you presented above. First mirror its steps into \
+`todo_write`, then work through them in order, marking each step completed \
+as you go. If no plan exists in this conversation, say so instead of \
+improvising one."""
+
+#: Catalogue served to frontends (``list_commands`` RPC) for autocomplete.
+PROMPT_COMMANDS: tuple[dict[str, str], ...] = (
+    {
+        "name": "/init",
+        "summary": "generate or refresh the project's DELOS.md by exploring the codebase",
+    },
+    {
+        "name": "/execute",
+        "summary": "execute the plan from the previous plan-mode turn (loads it into todos)",
+    },
+)
+
+
+def expand_slash_command(
+    content: str,
+    mode: str,
+    *,
+    has_project_instructions: bool,
+) -> tuple[str, str]:
+    """Expand a leading slash command into its agent prompt.
+
+    Returns ``(content, mode)`` — unchanged when the message isn't a known
+    command (unknown ``/xyz`` passes through as plain text; the agent can
+    answer helpfully).  ``/execute`` forces build mode: executing a plan is
+    pointless with read-only tools.
+    """
+    head, _, rest = content.strip().partition(" ")
+    rest = rest.strip()
+    if head == "/init":
+        prompt = INIT_PROMPT_UPDATE if has_project_instructions else INIT_PROMPT_NEW
+        if rest:
+            prompt += f"\n\nAdditional user instructions: {rest}"
+        return prompt, mode
+    if head == "/execute":
+        prompt = EXECUTE_PROMPT
+        if rest:
+            prompt += f"\n\nAdditional user instructions: {rest}"
+        return prompt, "build"
+    return content, mode

delos_cli-1.0.2/delos_cli/git_context.py

@@ -0,0 +1,74 @@
+"""Collect a compact git snapshot at the start of each agent turn.
+
+Sent to the backend as ``git_context`` on every ``/completions`` request and
+rendered into the system prompt, so the agent knows the branch, dirty state,
+and recent history without burning its first tool call on ``git status``.
+
+Collection is best-effort: any failure (not a repo, git missing, timeout)
+returns ``None`` and the turn proceeds without the section.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+_CMD_TIMEOUT_S = 2.0
+_MAX_STATUS_LINES = 20
+_LOG_COUNT = 5
+
+
+async def _git(workspace: Path, *args: str) -> str | None:
+    """Run one git command in ``workspace``; None on any failure."""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "git",
+            "-C",
+            str(workspace),
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=_CMD_TIMEOUT_S)
+    except (OSError, TimeoutError):
+        return None
+    if proc.returncode != 0:
+        return None
+    return stdout.decode("utf-8", errors="replace").rstrip()
+
+
+async def collect_git_context(workspace: Path) -> str | None:
+    """Return a compact ``branch / status / recent commits`` block, or None.
+
+    ``None`` when the workspace isn't a git repo or git isn't usable —
+    callers just omit the field.
+    """
+    inside = await _git(workspace, "rev-parse", "--is-inside-work-tree")
+    if inside != "true":
+        return None
+
+    branch, status, log = await asyncio.gather(
+        _git(workspace, "branch", "--show-current"),
+        _git(workspace, "status", "--porcelain"),
+        _git(workspace, "log", "--oneline", f"-{_LOG_COUNT}"),
+    )
+
+    lines: list[str] = [f"Branch: {branch or '(detached HEAD)'}"]
+
+    if status:
+        status_lines = status.splitlines()
+        shown = status_lines[:_MAX_STATUS_LINES]
+        lines.append(f"Status ({len(status_lines)} changed file(s)):")
+        lines.extend(shown)
+        if len(status_lines) > len(shown):
+            lines.append(f"... ({len(status_lines) - len(shown)} more)")
+    else:
+        lines.append("Status: clean")
+
+    if log:
+        lines.extend(("Recent commits:", log))
+
+    return "\n".join(lines)

delos_cli-1.0.2/delos_cli/serve/app.py

@@ -0,0 +1,125 @@
+"""Minimal :class:`App` for headless serve mode.
+
+The stdio server drives :class:`~delos_cli.agent.AgentSession` directly and
+forwards raw v6 events to the frontend — there is no renderer and no REPL
+command set.  This class only exists so ``Ctx.app`` is populated with the
+bits tool handlers actually reach for: the :class:`ToolRegistry` and the
+``todo_store`` the ``todo_write`` handler looks up via ``getattr``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from delos_cli.agent import ToolRegistry
+from delos_cli.apps.base import App
+from delos_cli.apps.chat.app import default_tool_registry
+from delos_cli.state import TodoStore
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Awaitable, Callable
+
+    from delos_cli.agent.tools import ToolHandler
+    from delos_cli.apps.base import Renderer
+    from delos_cli.commands.base import CommandSpec
+    from delos_cli.ctx import Ctx
+    from delos_cli.ui.output import OutputBuffer
+
+#: Tools resolved by the VSCode extension itself (they need the editor API);
+#: the serve loop relays them over the stdio protocol.  Single source of
+#: truth for the forwarding wiring — must match the backend's
+#: ``cosmos.agents.tools.client.vscode`` package.
+VSCODE_FORWARDED_TOOLS: tuple[str, ...] = (
+    "get_diagnostics",
+    "get_active_editor_context",
+    "get_document_symbols",
+)
+
+
+class HeadlessToolRegistry(ToolRegistry):
+    """Registry whose fallback fails fast instead of prompting.
+
+    The base registry's default handler opens an interactive
+    prompt_toolkit session.  In headless serve mode there is no TTY —
+    stdin is the extension's NDJSON pipe — so an unknown client tool
+    (typically a backend newer than this CLI build) would block the turn
+    forever waiting for keyboard input.  Return a self-describing error
+    so the model can route around the missing tool and the user sees a
+    reply instead of an infinite spinner.
+    """
+
+    def handler_for(self, name: str) -> ToolHandler:
+        """Return the registered handler, or an error-returning stub."""
+        handler = self.handlers.get(name)
+        if handler is not None:
+            return handler
+
+        async def _unknown_tool(tool_input: dict[str, Any], ctx: Ctx) -> str:  # noqa: RUF029 — ToolHandler protocol is async
+            _ = tool_input, ctx
+            return (
+                f"Error: client tool '{name}' is not supported by this "
+                "delos-cli build (backend/CLI version skew). Do not retry it. "
+                "Continue with the tools that work, and suggest the user "
+                "restart or update the Delos CLI."
+            )
+
+        return _unknown_tool
+
+
+def _make_forwarding_handler(name: str) -> ToolHandler:
+    """Relay one editor tool through ``ctx.app.forward_tool`` (set by the server)."""
+
+    async def _handler(tool_input: dict[str, Any], ctx: Ctx) -> str:
+        forward = getattr(ctx.app, "forward_tool", None)
+        if forward is None:
+            return (
+                f"Error: '{name}' needs the VSCode editor bridge, which is not "
+                "connected. Continue without it."
+            )
+        return await forward(name, tool_input)
+
+    return _handler
+
+
+def _headless_registry() -> HeadlessToolRegistry:
+    """The default tool set + editor forwarding, wrapped with the fail-fast fallback."""
+    reg = default_tool_registry()
+    for name in VSCODE_FORWARDED_TOOLS:
+        reg.handlers[name] = _make_forwarding_handler(name)
+    return HeadlessToolRegistry(renderers=reg.renderers, handlers=reg.handlers)
+
+
+@dataclass
+class VsCodeServeApp(App):
+    """Ctx.app placeholder for ``delos serve --app vscode``."""
+
+    name: str = "vscode"
+    commands: dict[str, CommandSpec] = field(default_factory=dict)
+    tools: ToolRegistry = field(default_factory=_headless_registry)
+    #: Mutated by the ``todo_write`` handler; no ``attach`` hook in
+    #: headless mode (the frontend renders its own plan UI, if any).
+    todo_store: TodoStore = field(default_factory=TodoStore)
+    #: Set by :class:`~delos_cli.serve.server.StdioServer` — async
+    #: ``(tool_name, input) -> result`` relay used by the editor-tool
+    #: forwarding handlers.  ``None`` outside serve mode.
+    forward_tool: Callable[[str, dict[str, Any]], Awaitable[str]] | None = None
+
+    async def on_enter(self, ctx: Ctx) -> None:
+        """Nothing to prefetch in headless mode."""
+
+    def send(
+        self,
+        ctx: Ctx,
+        messages: list[dict[str, str]],
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Unused — the serve loop drives :class:`AgentSession` itself."""
+        _ = self, ctx, messages
+        msg = "VsCodeServeApp.send is not used; the stdio server owns the turn loop"
+        raise NotImplementedError(msg)
+
+    def make_renderer(self, output: OutputBuffer) -> Renderer:
+        """Unused — headless mode forwards raw events, nothing renders."""
+        _ = self, output
+        msg = "VsCodeServeApp has no renderer; events are forwarded raw"
+        raise NotImplementedError(msg)

{delos_cli-1.0.1 → delos_cli-1.0.2}/delos_cli/serve/rpc.py

@@ -8,10 +8,14 @@ the dispatcher in ``server.py`` turns exceptions into error responses.
 from __future__ import annotations
 
 import asyncio
+import base64
+import binascii
 import os
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+from delos_cli.transport.chats import fork_chat as _fork_chat
+from delos_cli.transport.documents import list_drive_documents as _list_drive_documents
 from delos_cli.transport.integrations import (
     fetch_integrations,
     fetch_manage_url,
@@ -63,6 +67,23 @@ async def delete_chat(server: StdioServer, params: dict[str, Any]) -> dict[str,
     )
 
 
+async def fork_chat(server: StdioServer, params: dict[str, Any]) -> dict[str, Any]:
+    """Duplicate a chat's context into a new conversation.
+
+    ``userMessageCount`` bounds the copied prefix (see
+    :func:`delos_cli.transport.chats.fork_chat`); ``0`` copies everything.
+    """
+    http = server.require_http()
+    chat_id = _required_str(params, "chatId")
+    user_message_count = int(params.get("userMessageCount") or 0)
+    new_id, title = await _fork_chat(
+        http,
+        source_chat_id=chat_id,
+        user_message_count=user_message_count,
+    )
+    return {"id": new_id, "title": title}
+
+
 async def find_files(server: StdioServer, params: dict[str, Any]) -> list[str]:
     """Fuzzy-ish file lookup: ``rg --files`` + case-insensitive substring filter.
 
@@ -152,6 +173,49 @@ async def toggle_integration(
     return await set_integration_active(server.require_http(), service, active)
 
 
+async def upload_file(server: StdioServer, params: dict[str, Any]) -> dict[str, Any]:
+    """Upload one attachment to ``/files/upload`` (origin=chat); return its id.
+
+    The frontend sends ``filename``, ``mime`` and base64 ``content``. Returns
+    ``{"fileId": str, "name": str, "fileType": str | None, "kind": "doc"}`` —
+    the shape the frontend turns into a ``message_files`` ref for the next turn.
+    """
+    http = server.require_http()
+    filename = _required_str(params, "filename")
+    mime = str(params.get("mime") or "application/octet-stream")
+    b64 = str(params.get("content") or "")
+    try:
+        content = base64.b64decode(b64.rsplit(",", maxsplit=1)[-1], validate=False)
+    except (binascii.Error, ValueError) as exc:
+        msg = "invalid base64 file content"
+        raise ValueError(msg) from exc
+
+    result = await http.upload_file(
+        "/files/upload",
+        filename=filename,
+        content=content,
+        mime=mime,
+        data={"org_uuid": str(server.cfg.org_uuid), "origin": "chat", "language": "en"},
+    )
+    file_id = str(result.get("file_id") or "")
+    if not file_id:
+        msg = "upload did not return a file_id"
+        raise ValueError(msg)
+    ext = filename.rsplit(".", 1)[-1].lower() if "." in filename else None
+    return {"fileId": file_id, "name": filename, "fileType": ext, "kind": "doc"}
+
+
+async def list_drive_documents(server: StdioServer, params: dict[str, Any]) -> list[dict[str, Any]]:
+    """List Delos documents the user can attach (Import from Drive)."""
+    _ = params
+    http = server.require_http()
+    items = await _list_drive_documents(http, str(server.cfg.org_uuid))
+    return [
+        {"id": it.id, "name": it.name, "kind": it.kind, "fileType": it.file_type}
+        for it in items
+    ]
+
+
 def _required_str(params: dict[str, Any], key: str) -> str:
     value = str(params.get(key) or "").strip()
     if not value: