insightfactory-cli 1.0.3.dev20__py3-none-any.whl → 1.0.3.dev21__py3-none-any.whl

if_cli/commands/mcp.py

@@ -132,7 +132,8 @@ def mcp_command(argv: list[str]) -> None:
     # import bug inside if_cli.router propagates instead of reading as a missing extra.
     if importlib.util.find_spec("mcp") is None:
         die(MISSING_MCP_EXTRA)
-    from if_cli.router.server import build_router, log, run_server
+    from if_cli.router.log import log
+    from if_cli.router.server import build_router, run_server
 
     timeout = parse_timeout_seconds(values["timeout"], "--timeout")
     extra_read_only = frozenset(values["allow-tool"] or [])

if_cli/router/log.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import sys
+
+
+def log(message: str) -> None:
+    """Write one diagnostic line to stderr.
+
+    The router speaks MCP over stdout, so stderr is the only channel that can
+    carry anything to the operator. This lives in its own module because both
+    `server` and `upstream` write to it and `server` imports `upstream`.
+    """
+    sys.stderr.write(f"[if-cli mcp] {message}\n")

if_cli/router/server.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import os
-import sys
 from dataclasses import dataclass
 from importlib.metadata import version
 from typing import Any
@@ -15,6 +14,7 @@ from mcp.server.stdio import stdio_server
 from if_cli.config import Profile
 from if_cli.router import catalog, policy
 from if_cli.router.catalog import ENV_ARG, EnvironmentSpec
+from if_cli.router.log import log
 from if_cli.router.upstream import Upstream
 from if_cli.runtime import CliError
 
@@ -24,10 +24,6 @@ SERVER_VERSION = version("insightfactory-cli")
 DEFAULT_CATALOG_RETRY_WINDOW_S = 5.0
 
 
-def log(message: str) -> None:
-    sys.stderr.write(f"[if-cli mcp] {message}\n")
-
-
 def _catalog_retry_window_seconds() -> float:
     """Read the catalogue-rebuild retry window, in milliseconds, from the environment.
 

if_cli/router/upstream.py

@@ -12,6 +12,7 @@ from mcp.client.streamable_http import streamable_http_client
 from if_cli.config import Profile
 from if_cli.http import parse_url, url_origin
 from if_cli.oauth import get_valid_token
+from if_cli.router.log import log
 
 if sys.version_info >= (3, 11):
     _BaseExceptionGroup = BaseExceptionGroup  # noqa: F821 - builtin from 3.11 on, guarded above
@@ -65,6 +66,107 @@ class ProfileBearerAuth(httpx2.Auth):
             yield request
 
 
+def _result_texts(result: Any) -> list[str]:
+    """The text of a result's content blocks, dropping any block that is not text.
+
+    Only the older-revision path needs this, and there the result is the tool's
+    own refusal, which is text.
+    """
+    return [block.text for block in getattr(result, "content", []) if isinstance(block, types.TextContent)]
+
+
+def _connect_url(params: types.ElicitRequestURLParams, origin: str) -> str | None:
+    """The elicited URL, if it is on this environment's own origin.
+
+    What the check buys is narrow and worth stating plainly: the router will not
+    itself render a link to a host that is not this environment's. It cannot stop
+    a factory naming a host in the prose of a message, here or in ordinary tool
+    result text, which passes through verbatim either way. Same rule as the
+    bearer token in `ProfileBearerAuth`, applied in the other direction.
+
+    A rejected URL is reported on stderr. It means the factory named a page on a
+    host that is not its own, which the operator wants to hear about, and which
+    the tool result cannot distinguish from an elicitation in a mode the router
+    does not answer.
+    """
+    try:
+        # `urlparse` defers port validation to `.port`, which `url_origin` reads,
+        # so a malformed port raises here rather than in `parse_url`.
+        if url_origin(parse_url(params.url)) == origin:
+            return params.url
+    except ValueError:
+        pass
+    log(f"WARN dropped a connect URL that is not on {origin}: {params.url!r}")
+    return None
+
+
+class ConnectUrlRecorder:
+    """Declines every elicitation, keeping the first same-origin URL it saw.
+
+    Two jobs. Constructing this and handing it to `Client` is what advertises
+    `elicitation.url`: the SDK derives the capability from the callback being
+    non-default, and the factory only offers its Databricks connect page to a
+    client that advertised the URL mode, so the capability has to be on for the
+    page to be named at all.
+
+    The recording is for older servers only. On 2026-07-28 elicitations arrive
+    inside an `InputRequiredResult`, which `Upstream.call_tool` takes in hand
+    rather than letting the SDK dispatch the embedded requests here, so nothing
+    reaches this callback. A server negotiating an earlier revision sends
+    `elicitation/create` as its own request, which does land here, and without
+    the recording its eventual result would carry the refusal with no page named.
+
+    Declining is the right answer either way. Answering an elicitation means
+    relaying it to the downstream client, and connecting production Databricks
+    under a personal identity should be a deliberate trip to a page rather than a
+    link offered mid tool call.
+    """
+
+    def __init__(self, origin: str) -> None:
+        self._origin = origin
+        self.declined_url_request = False
+        self.url: str | None = None
+
+    async def __call__(self, _context: Any, params: Any) -> types.ElicitResult:
+        if isinstance(params, types.ElicitRequestURLParams):
+            # What makes the call a refusal is the decline, not which host the URL
+            # named. Recording the two separately keeps the origin check out of the
+            # question of whether the tool ran.
+            self.declined_url_request = True
+            if self.url is None:
+                self.url = _connect_url(params, self._origin)
+        return types.ElicitResult(action="decline")
+
+
+def _relayable_requests(result: types.InputRequiredResult, origin: str) -> tuple[list[str], str | None]:
+    """The messages this router will repeat, and the first connect URL it will name.
+
+    A URL-mode request whose URL fails the origin check is dropped whole, its
+    message included: the router rejected the one claim in that request it could
+    check, so it repeats none of it. Requests in any other mode make no such
+    claim and keep their message, which is all there is to pass on.
+
+    `result.request_state` is dropped on purpose. It is the token for retrying the
+    same call once the input is supplied, and the router never retries: the connect
+    flow is a trip to a page in a browser, well outside the lifetime of this stdio
+    process and of the factory's own state TTL.
+    """
+    messages: list[str] = []
+    url: str | None = None
+    for request in (result.input_requests or {}).values():
+        params = getattr(request, "params", None)
+        if isinstance(params, types.ElicitRequestURLParams):
+            found = _connect_url(params, origin)
+            if found is None:
+                continue
+            if url is None:
+                url = found
+        message = getattr(params, "message", None)
+        if isinstance(message, str) and message:
+            messages.append(message)
+    return messages, url
+
+
 class Upstream:
     """One factory environment's `/mcp` endpoint, reached with its own `if-cli` profile.
 
@@ -79,11 +181,14 @@ class Upstream:
         self.profile = profile
         self.timeout = timeout
 
-    async def _run(self, action):
+    async def _run(self, action, *, elicitation_callback=None):
         url = f"{self.profile['host']}/mcp"
         try:
             async with httpx2.AsyncClient(auth=ProfileBearerAuth(self.profile), timeout=self.timeout) as http_client:
-                async with Client(streamable_http_client(url, http_client=http_client)) as client:
+                async with Client(
+                    streamable_http_client(url, http_client=http_client),
+                    elicitation_callback=elicitation_callback,
+                ) as client:
                     return await action(client)
         except _BaseExceptionGroup as error:
             raise _leaf_exception(error) from error
@@ -104,4 +209,64 @@ class Upstream:
         return await self._run(collect)
 
     async def call_tool(self, name: str, arguments: dict[str, Any]) -> types.CallToolResult:
-        return await self._run(lambda client: client.call_tool(name, arguments))
+        async def call(client: Client):
+            # `allow_input_required` hands back the factory's `InputRequiredResult`
+            # instead of letting the SDK answer the embedded requests and retry.
+            # The router has to drive this itself: the factory re-elicits on every
+            # retry that is still unconnected, so the SDK's automatic loop spins to
+            # `input_required_max_rounds` and raises before any result comes back.
+            return await client.session.call_tool(name, arguments, allow_input_required=True)
+
+        recorder = ConnectUrlRecorder(self.profile["host"])
+        result = await self._run(call, elicitation_callback=recorder)
+        if isinstance(result, types.InputRequiredResult):
+            lines, url = _relayable_requests(result, self.profile["host"])
+            return self._connect_refusal(lines, url)
+        if recorder.declined_url_request:
+            # The older-revision path. The server elicited in band and carried on
+            # once the router declined, so the connect page is in the recorder
+            # rather than in the result, and the result is whatever the tool says
+            # for an identity it never got. Anything it carried beyond text goes:
+            # the router declined, so the call did not run and there is no result
+            # to preserve.
+            return self._connect_refusal(_result_texts(result), recorder.url)
+        return result
+
+    def _connect_refusal(self, lines: list[str], url: str | None) -> types.CallToolResult:
+        """Turn the factory's request for input into a refusal naming the page to visit.
+
+        Some factory tools (`run_sql_query` and the other Databricks-backed ones)
+        run under the caller's *personal* Databricks identity, which each factory
+        stores separately. When that identity is not linked the factory asks for
+        the connect flow to be completed, offering its own connect page as a
+        URL-mode elicitation.
+
+        The router never relays that. It reports the refusal instead, naming the
+        page, which beats hardcoding a frontend route that will move.
+
+        The result is marked as an error because it is one: the connect never
+        happened and the tool never ran, and saying otherwise invites a caller to
+        read a refusal as a result. The code prefix matches the one
+        `Router.call_tool` puts on raised errors; an upstream *result* carrying
+        `is_error` never passes through that path, so without this the line would
+        not say which environment it came from.
+
+        One content block, not one per line, matching `_error_result` in `server`
+        and every other refusal the router produces. A client that renders only
+        the first text block would otherwise show the factory's message and drop
+        the connect line, which is the experience this exists to end.
+
+        With no usable URL the fallback names the environment's own host instead.
+        That address is the router's, built from the profile rather than taken
+        from the factory, so it gives the caller somewhere to start without
+        loosening what the origin check refuses to print.
+        """
+        connect = (
+            f"[{self.code}] Connect at {url}, then retry."
+            if url is not None
+            else (f"[{self.code}] This factory needs input the router cannot relay. Start at {self.profile['host']}.")
+        )
+        return types.CallToolResult(
+            content=[types.TextContent(text="\n".join([*lines, connect]))],
+            is_error=True,
+        )

{insightfactory_cli-1.0.3.dev20.dist-info → insightfactory_cli-1.0.3.dev21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: insightfactory-cli
-Version: 1.0.3.dev20
+Version: 1.0.3.dev21
 Summary: Profile-based authentication CLI for the InsightFactory Interfaces API
 Project-URL: Homepage, https://insightfactory.ai
 Author-email: "insightfactory.ai Support" <support@insightfactory.ai>
@@ -304,6 +304,12 @@ Passing dev-only writes to production means changing an argument value, not
 connecting to a different server, so keep `--writable` scoped to the
 environments meant to be written by hand.
 
+A tool the factory will not run until someone finishes a step in a browser, such
+as linking a personal Databricks identity, comes back as a failed call naming the
+page to visit rather than as a prompt. The router never relays the factory's
+request for input to the model, and it names a page only on that environment's
+own origin, logging a `WARN` line on stderr when it drops one that is not.
+
 ## Development
 
 ```bash

{insightfactory_cli-1.0.3.dev20.dist-info → insightfactory_cli-1.0.3.dev21.dist-info}/RECORD

@@ -17,17 +17,18 @@ if_cli/commands/api.py,sha256=XeVhhD39Oho4xNbMJIGh1I6vi53on5EGGsAtsb_5TAg,9016
 if_cli/commands/config.py,sha256=1KAxjme897NIbXTGBw1rNJlXnFvhbEUf5MAli8A93ns,1724
 if_cli/commands/login.py,sha256=vxsYcRZWsaNEzekyN1zy4ROJO-OCGUpjaVUBhtbK1LY,3255
 if_cli/commands/logout.py,sha256=TW0P4_tXcTtiHHR73xVPHyhlbOWD1jBnkZsMImCiCBw,668
-if_cli/commands/mcp.py,sha256=nXc6qT-psryLDm8Yjmu_2IFDOEnNIAjCkCT5UTDZP4M,6553
+if_cli/commands/mcp.py,sha256=uU70j13n1WwkiyQigUTHPIIpc1B2PZO2O4wLIFDB87k,6586
 if_cli/commands/profiles.py,sha256=tgZP5sMqzbFHXlfvglL2plsGdU0M3joo3wvQKX45J1U,3950
 if_cli/commands/set_token.py,sha256=BVyv_QmByvllr04pE2sz8JFEscHbIgOC-7ZPg61PRoc,1886
 if_cli/commands/token.py,sha256=CyiXkyH7vxgH91-n-XJzeHnLI6mZJwO9Js5AHvfHaeM,1120
 if_cli/router/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 if_cli/router/catalog.py,sha256=Er2ZbWTwDUVU-qBGCvyA0bIlFk3UYw_6sVUlYwBhMpI,4992
+if_cli/router/log.py,sha256=YLWeHUb05HUnS3XHubCwy7oLZAUEGAiHcZysz_YMAAo,412
 if_cli/router/policy.py,sha256=CclbjuOA5mwwoQiNDa17iQeN9eXRbfy11bS9JFd8gL4,2840
-if_cli/router/server.py,sha256=kTQwvUVyco8QjOfjPHZF8LYUmHi8R5DdIk-Wxr5yHVA,12176
-if_cli/router/upstream.py,sha256=qFWSQ0lDTXM_8Q7vq8X5sWP2cMWXx5Hn-WwiLL7r3UM,4631
-insightfactory_cli-1.0.3.dev20.dist-info/METADATA,sha256=o78rj9GHshhGzIAZfPSRhyuGh-RMdlvOsk-PKaqCpkk,17509
-insightfactory_cli-1.0.3.dev20.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-insightfactory_cli-1.0.3.dev20.dist-info/entry_points.txt,sha256=UlX854D7f-7dBj5F0wGdakVy6vopvP9hA1BN-gv739w,44
-insightfactory_cli-1.0.3.dev20.dist-info/licenses/LICENSE,sha256=8eZ1YAABL398qESVJc_FlK1voYQ0GAh-R_rNBQK6QH8,234
-insightfactory_cli-1.0.3.dev20.dist-info/RECORD,,
+if_cli/router/server.py,sha256=RkS6Ddann-vAU0ZQAe2QaEB9dLBvEC33V9O-G4WSIy8,12116
+if_cli/router/upstream.py,sha256=dmwS7qSLnHiY7dEYpVENkfYIHs3DxkhhMB1SV66lE2Y,13104
+insightfactory_cli-1.0.3.dev21.dist-info/METADATA,sha256=ieTLsUPspC42Fn07s2uGN7Ra5r01bYzCMr6Xne2yE5M,17904
+insightfactory_cli-1.0.3.dev21.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+insightfactory_cli-1.0.3.dev21.dist-info/entry_points.txt,sha256=UlX854D7f-7dBj5F0wGdakVy6vopvP9hA1BN-gv739w,44
+insightfactory_cli-1.0.3.dev21.dist-info/licenses/LICENSE,sha256=8eZ1YAABL398qESVJc_FlK1voYQ0GAh-R_rNBQK6QH8,234
+insightfactory_cli-1.0.3.dev21.dist-info/RECORD,,