insightfactory-cli 1.1.2.dev28__py3-none-any.whl → 1.1.2.dev29__py3-none-any.whl

if_cli/commands/mcp.py

@@ -15,12 +15,15 @@ MCP_OPTIONS: Options = {
     "catalog": {"type": "string"},
     "allow-tool": {"type": "string", "repeat": True},
     "timeout": {"type": "string", "default": "120"},
+    "skills": {"type": "boolean"},
+    "no-skills": {"type": "boolean"},
 }
 
 MCP_USAGE = (
     "usage: if-cli mcp [FACTORY] [--env CODE=PROFILE ...]\n"
     "                   [--writable CODE ... | --read-only] [--catalog CODE]\n"
     "                   [--allow-tool NAME ...] [--timeout SECONDS]\n"
+    "                   [--skills | --no-skills]\n"
     "\n"
     "Runs one MCP server over stdio that fronts several factory environments: every\n"
     "tool gets a required 'environment' argument, routed to that environment's own\n"
@@ -29,7 +32,9 @@ MCP_USAGE = (
     "section. Without FACTORY, --env is required at least once. --catalog defaults\n"
     "to the first environment; environments not passed to --writable are read-only;\n"
     "--read-only forces every environment read-only and cannot be combined with\n"
-    "--writable.\n"
+    "--writable. --skills advertises the experimental skills extension; the\n"
+    "catalog environment's skill:// resources are served either way. It is off\n"
+    "unless the factory section says 'skills = true' or --skills is passed.\n"
 )
 
 MISSING_MCP_EXTRA = (
@@ -91,6 +96,9 @@ def mcp_command(argv: list[str]) -> None:
     if read_only and raw_writable is not None:
         die(f"--read-only cannot be combined with --writable\n\n{MCP_USAGE}")
 
+    if values["skills"] and values["no-skills"]:
+        die(f"--skills cannot be combined with --no-skills\n\n{MCP_USAGE}")
+
     config = load_config()
 
     # A dict, not a list of pairs: --env "adds or replaces that code's profile"
@@ -102,12 +110,14 @@ def mcp_command(argv: list[str]) -> None:
     mappings: dict[str, str] = {}
     writable_codes: frozenset[str] = frozenset()
     catalog_source: str | None = None
+    skills = False
 
     if factory_name is not None:
         factory = parse_factory_section(config, factory_name)
         mappings.update(factory["environments"])
         writable_codes = factory["writable"]
         catalog_source = factory["catalog"]
+        skills = factory["skills"]
 
     for raw in raw_envs:
         code, profile_name = _parse_env_mapping(raw)
@@ -125,6 +135,10 @@ def mcp_command(argv: list[str]) -> None:
         writable_codes = frozenset(raw_writable)
     if values["catalog"] is not None:
         catalog_source = values["catalog"]
+    if values["skills"]:
+        skills = True
+    elif values["no-skills"]:
+        skills = False
     if catalog_source is None:
         catalog_source = codes[0]
 
@@ -153,7 +167,7 @@ def mcp_command(argv: list[str]) -> None:
         f"{code}={mappings[code]} {profiles[code]['host']}{' (writable)' if code in writable_codes else ''}"
         for code in codes
     ]
-    log(f"{label}: {'; '.join(parts)}; catalog={catalog_source}")
+    log(f"{label}: {'; '.join(parts)}; catalog={catalog_source}; skills={'on' if skills else 'off'}")
 
     router = build_router(
         profiles=profiles,
@@ -161,5 +175,6 @@ def mcp_command(argv: list[str]) -> None:
         catalog_source=catalog_source,
         extra_read_only=extra_read_only,
         timeout=timeout,
+        skills=skills,
     )
     run_server(router)

if_cli/config.py

@@ -28,10 +28,13 @@ class Factory(TypedDict):
     environments: list[tuple[str, str]]
     writable: frozenset[str]
     catalog: str
+    skills: bool
 
 
 FACTORY_SECTION_PREFIX = "factory "
-FACTORY_RESERVED_KEYS = {"writable", "catalog"}
+FACTORY_RESERVED_KEYS = {"writable", "catalog", "skills"}
+FACTORY_TRUE = {"true", "yes", "on", "1"}
+FACTORY_FALSE = {"false", "no", "off", "0", ""}
 
 
 def config_dir() -> str:
@@ -217,7 +220,18 @@ def parse_factory_section(config: dict[str, dict[str, str]], name: str) -> Facto
     catalog_value = section.get("catalog")
     catalog = catalog_value.strip() if catalog_value is not None and catalog_value.strip() else codes[0]
 
-    return {"name": name, "environments": environments, "writable": writable, "catalog": catalog}
+    skills_value = section.get("skills", "").strip().lower()
+    if skills_value not in FACTORY_TRUE and skills_value not in FACTORY_FALSE:
+        die(f"factory '{name}' in {config_file()}: skills must be true or false (found '{skills_value}')")
+    skills = skills_value in FACTORY_TRUE
+
+    return {
+        "name": name,
+        "environments": environments,
+        "writable": writable,
+        "catalog": catalog,
+        "skills": skills,
+    }
 
 
 def get_factory(config: dict[str, dict[str, str]], name: str) -> Factory:

if_cli/router/content.py

@@ -0,0 +1,298 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping, Sequence
+from typing import Any
+from urllib.parse import unquote, unquote_plus, urlsplit, urlunsplit
+
+from if_cli.router.catalog import ENV_ARG, EnvironmentSpec
+
+# RFC 6570 query expansion. A client that expands the published template fills
+# `environment` like any other variable, so selecting the factory reads the same
+# way for a resource as the spliced enum does for a tool. Form style opens a
+# query with `?`; continuation style adds to one that is already open, and a
+# template carrying its own query needs the second (see `scope_template`).
+TEMPLATE_SUFFIX = "{?" + ENV_ARG + "}"
+TEMPLATE_CONTINUATION = "{&" + ENV_ARG + "}"
+
+# The variable expression inside a URI template, for reading its variable list
+# and for turning the template into a matcher.
+_EXPRESSION = re.compile(r"\{[^}]*\}")
+
+# The operator an expression may open with, and the modifiers a varspec may
+# carry: `{+path}`, `{?a,b}`, `{#frag}`, `{x:3}`, `{y*}`.
+_OPERATORS = "+#./;?&=,!@|"
+
+# An expression that expands into the fragment, where a `?` is no longer a query.
+_FRAGMENT = re.compile(r"\{#[^}]*\}")
+
+# An expression that continues a query rather than opening one.
+_CONTINUATION = re.compile(r"\{&[^}]*\}")
+
+
+class ContentError(Exception):
+    """A routing decision this router cannot make, reported to the client as an error.
+
+    Distinct from `CliError`: that ends the process at startup, this one answers
+    a single request and leaves the server running.
+    """
+
+
+def _variable_names(expression: str) -> list[str]:
+    """The variable names one RFC 6570 expression declares.
+
+    `{?deploy.environment}` declares `deploy.environment`, not `environment`:
+    a dot is legal in a varname, so matching on a word boundary would refuse a
+    template that never names ours. Modifiers are stripped, because `{x:3}` and
+    `{x*}` are both the variable `x`.
+
+    Names are decoded before they are compared, because a varname may be
+    percent-encoded and `split_environment` decodes the field name it reads.
+    The two have to agree about that, or a name claims our field without
+    tripping the guard.
+    """
+    body = expression[1:-1].lstrip(_OPERATORS)
+    return [unquote(name.split(":", 1)[0].rstrip("*")) for name in body.split(",") if name]
+
+
+def _literal_query_names(uri_template: str) -> list[str]:
+    """The names of the query fields a template spells out for itself.
+
+    `if://search?environment=fixed{&q}` declares no variable at all, so reading
+    the expressions alone would miss that it has already taken our field.
+    """
+    stem = _EXPRESSION.sub("", _split_fragment(uri_template)[0])
+    # Split on both delimiters: `if://x{?a}&environment=fixed` opens its query
+    # inside an expression, so partitioning on `?` alone would see no query at
+    # all. Neither character can appear in a path, so the first segment is the
+    # only one that is not a field.
+    return [unquote_plus(field.split("=", 1)[0]) for field in re.split(r"[?&]", stem)[1:] if field]
+
+
+def declares_environment(uri_template: str) -> bool:
+    if ENV_ARG in _literal_query_names(uri_template):
+        return True
+    return any(ENV_ARG in _variable_names(expression) for expression in _EXPRESSION.findall(uri_template))
+
+
+def _environment_list(environments: Sequence[EnvironmentSpec]) -> str:
+    return "; ".join(f"{env.code} = {env.label}{'' if env.writable else ' (read-only)'}" for env in environments)
+
+
+def split_environment(uri: str) -> tuple[str, str | None]:
+    """Peel `?environment=<code>` off a resource URI, returning the rest and the code.
+
+    Only this router's own parameter is removed, and every other field is
+    carried across as the exact bytes the client sent: the URI belongs to the
+    factory, which may parse or sign it, so decoding and re-encoding it would
+    hand upstream something the client never wrote. Only the field *name* is
+    decoded, and only to compare it.
+
+    A blank `environment=` is what an RFC 6570 client emits when it expands the
+    variable with nothing, so it counts as unset, but it is still stripped: it
+    is our field either way and the factory has no use for it.
+    """
+    parts = urlsplit(uri)
+    if not parts.query:
+        return uri, None
+    fields = parts.query.split("&")
+    # Last wins, and exactly one field is ours. The router appends its own
+    # variable after whatever the factory published, so when a URI carries two
+    # the later one is the client's and the earlier one belongs to the factory:
+    # removing both would delete a field this module exists to forward intact.
+    ours = [at for at, field in enumerate(fields) if unquote_plus(field.split("=", 1)[0]) == ENV_ARG]
+    if not ours:
+        return uri, None
+    mine = ours[-1]
+    _, _, value = fields[mine].partition("=")
+    kept = [field for at, field in enumerate(fields) if at != mine]
+    bare = urlunsplit((parts.scheme, parts.netloc, parts.path, "&".join(kept), parts.fragment))
+    # The blank is read after the pick, not used to choose: a client that
+    # expanded the variable with nothing has said "unset", and saying it last
+    # does not hand the choice back to an earlier field.
+    return bare, unquote_plus(value) if value else None
+
+
+def scope_template(template: Mapping[str, Any], environments: Sequence[EnvironmentSpec]) -> dict[str, Any]:
+    """Publish one resource template with `environment` appended as a variable.
+
+    A template is the only resource shape whose contents are per-environment:
+    `if://task-config-schemas/{taskType}` resolves to that factory's own
+    activity catalogue. Concrete resources are not scoped this way (see
+    `resolve_resource`), because `skill://` bodies cross-reference each other by
+    bare URI and rewriting them would leave those links pointing at nothing.
+    """
+    uri_template = template.get("uriTemplate") or ""
+    if not uri_template:
+        raise ContentError("resource template has no uriTemplate.")
+    if declares_environment(uri_template):
+        raise ContentError(
+            f'resource template "{uri_template}" already declares an "{ENV_ARG}" variable, which the router '
+            "reserves to select the factory environment."
+        )
+    # A template that already opens a query gets the continuation operator;
+    # a second `{?...}` would expand to a second literal `?` and the parameter
+    # would be read as part of the previous value.
+    stem, fragment = _split_fragment(uri_template)
+    suffix = TEMPLATE_CONTINUATION if _opens_a_query(stem) else TEMPLATE_SUFFIX
+    description = (template.get("description") or "").rstrip()
+    note = f"Set {ENV_ARG} to choose which factory environment answers: {_environment_list(environments)}."
+    return {
+        **template,
+        "uriTemplate": f"{stem}{suffix}{fragment}",
+        "description": f"{description}\n\n{note}" if description else note,
+    }
+
+
+def _split_fragment(uri_template: str) -> tuple[str, str]:
+    """Split a template before whatever expands into its fragment.
+
+    Everything after a `#` is the fragment, where a `?` is an ordinary
+    character rather than a query opener, so the router's own variable has to
+    go in front of it or it never reaches `split_environment`.
+    """
+    match = _FRAGMENT.search(uri_template)
+    cuts = [at for at in (match.start() if match else -1, uri_template.find("#")) if at >= 0]
+    if not cuts:
+        return uri_template, ""
+    cut = min(cuts)
+    return uri_template[:cut], uri_template[cut:]
+
+
+def _opens_a_query(uri_template: str) -> bool:
+    """Whether expanding this template can already have produced a `?`.
+
+    `{&x}` counts only alongside a reserved expansion, which is the one way a
+    query can be open without the template text saying so. On its own, `{&x}`
+    with no `?` anywhere is a template whose expansion has no query at all, and
+    there form style is right: it opens one rather than continuing it, so
+    `if://x{&q}{?environment}` expands to `if://x&q=1?environment=prd`, which
+    routes and hands the factory back exactly what its own template produces.
+    """
+    reduced = _EXPRESSION.sub(lambda match: match.group(0)[:2], uri_template)
+    return "?" in reduced or ("{&" in reduced and "{+" in reduced)
+
+
+def unscope_template(uri_template: str) -> str:
+    """Remove the variable `scope_template` added, wherever it was put.
+
+    Not a suffix strip: a template with a fragment carries it in the middle,
+    and the factory has never heard of it in any position.
+    """
+    return uri_template.replace(TEMPLATE_SUFFIX, "", 1).replace(TEMPLATE_CONTINUATION, "", 1)
+
+
+def template_matcher(uri_template: str) -> re.Pattern[str]:
+    """A matcher for URIs that are expansions of `uri_template`.
+
+    Deliberately loose: every variable expression becomes "any characters,
+    including none", because an undefined RFC 6570 variable expands to nothing
+    and `{id}{?format}` with no format is still an expansion. It is only ever
+    asked whether a URI *could* be one, and being loose makes it fail towards
+    refusing to guess an environment rather than towards silently answering
+    from the wrong factory.
+
+    A template of nothing but variables matches every URI, so it discriminates
+    nothing and is given a matcher that matches nothing instead. That guard is
+    for "matches literally everything", not for "too loose to be useful":
+    `if://{path}` keeps its scheme literal and so still claims the whole
+    `if://` space, which makes every static `if://` resource need an
+    environment. Refusing is the safe direction, but it is a real cost.
+
+    A reserved expansion (`{+var}`, `{#var}`) can expand into `?` and `#`
+    itself, so whether a URI opens a query is not decidable from the template
+    text. Everything here is a heuristic over the literal characters.
+
+    The matcher is built from the catalogue source's templates alone, so a
+    template only another environment publishes is invisible here. A client can
+    only learn of one out of band, since `resources/templates/list` publishes
+    the catalogue source's, so the gap is narrow; it is the reason this is a
+    routing hint rather than a guarantee.
+    """
+    literals = _EXPRESSION.split(uri_template)
+    if not any(literals):
+        return re.compile(r"(?!)")
+    return re.compile(".*".join(re.escape(literal) for literal in literals))
+
+
+def resolve_resource(
+    uri: str,
+    *,
+    templates: Sequence[str],
+    catalog_source: str,
+    codes: Sequence[str],
+    reserved: Sequence[str] = (),
+) -> tuple[str, str]:
+    """Which environment answers `uri`, and the URI to ask it for.
+
+    Two cases, and the URI itself says which. A template expansion is
+    per-environment content (`if://task-config-schemas/AZSQL` is that factory's
+    own activity catalogue), so it is read from the environment its query names
+    and refused without one rather than answered from the wrong factory.
+    Anything else is static content the release publishes identically
+    everywhere (the `skill://` bodies), so it is read from the catalogue source.
+
+    Membership of `resources/list` is deliberately not the test: a skill body
+    may link to a sibling document the factory never advertised, and such a link
+    carries no `environment` and could not be given one.
+    """
+    bare, chosen = split_environment(uri)
+    if chosen is not None:
+        if chosen not in codes:
+            # A template this router refused to publish takes the field for
+            # itself, so what looks like a bad environment code is the
+            # factory's own value. The operator reads that on stderr when the
+            # listing skips it; the client deserves the same sentence.
+            claimed = next((template for template in reserved if template_matcher(template).fullmatch(uri)), None)
+            if claimed is not None:
+                raise ContentError(
+                    f'"{uri}" expands the resource template "{claimed}", which takes the "{ENV_ARG}" field for '
+                    "itself. This router reserves that field to select the factory environment, so it cannot "
+                    "route this template and does not publish it."
+                )
+            raise ContentError(f'Unknown environment "{chosen}". Choose one of: {", ".join(codes)}')
+        return bare, chosen
+    matched = next((template for template in templates if template_matcher(template).fullmatch(bare)), None)
+    if matched is not None:
+        raise ContentError(
+            f'"{bare}" expands the resource template "{matched}", whose contents differ per factory, so it needs '
+            f"an environment: append ?{ENV_ARG}=<code> to the URI. Choose one of: {', '.join(codes)}"
+        )
+    return bare, catalog_source
+
+
+def splice_prompt_environment(prompt: Mapping[str, Any], environments: Sequence[EnvironmentSpec]) -> dict[str, Any]:
+    """Publish one prompt with `environment` added as a required argument."""
+    arguments = [dict(argument) for argument in (prompt.get("arguments") or [])]
+    if any(argument.get("name") == ENV_ARG for argument in arguments):
+        raise ContentError(
+            f'prompt "{prompt.get("name")}" already declares an "{ENV_ARG}" argument, which the router reserves '
+            "to select the factory environment."
+        )
+    arguments.append(
+        {
+            "name": ENV_ARG,
+            "description": f"Which factory environment to run this against. {_environment_list(environments)}.",
+            "required": True,
+        }
+    )
+    return {**prompt, "arguments": arguments}
+
+
+def environment_instruction(code: str, label: str) -> str:
+    """The line the router prepends to a rendered prompt.
+
+    The factory writes its prompts for a client talking to one factory, so they
+    name tools without an environment. Through the router every one of those
+    calls needs the argument, and a model following the prompt verbatim would
+    omit it on the first call and be told off for it.
+
+    Prepended rather than appended, and attributed: the factory's own last turn
+    may be an assistant prefill, which a trailing user turn would silently end,
+    and a bare instruction in the factory's voice is indistinguishable from the
+    prompt it is wrapping.
+    """
+    return (
+        f'[if-cli router] Every tool call while following this prompt must pass {ENV_ARG}="{code}" ({label}). '
+        "This router fronts several factory environments and the instructions below do not name one."
+    )

if_cli/router/server.py

@@ -1,19 +1,22 @@
 from __future__ import annotations
 
 import os
+from collections.abc import Awaitable
 from dataclasses import dataclass
 from importlib.metadata import version
-from typing import Any
+from typing import Any, TypeVar
 
 import anyio
 import mcp_types as types
 from mcp.server import Server
 from mcp.server.context import ServerRequestContext
 from mcp.server.stdio import stdio_server
+from mcp.shared.exceptions import MCPError
 
 from if_cli.config import Profile
-from if_cli.router import catalog, policy
+from if_cli.router import catalog, content, policy
 from if_cli.router.catalog import ENV_ARG, EnvironmentSpec
+from if_cli.router.content import ContentError
 from if_cli.router.log import log
 from if_cli.router.upstream import Upstream
 from if_cli.runtime import CliError
@@ -21,8 +24,18 @@ from if_cli.runtime import CliError
 SERVER_NAME = "if-cli-mcp-router"
 SERVER_VERSION = version("insightfactory-cli")
 
+# SEP-2640, still experimental; the factory gates its own half behind
+# Mcp:ExperimentalSkills.
+SKILLS_EXTENSION = "io.modelcontextprotocol/skills"
+
 DEFAULT_CATALOG_RETRY_WINDOW_S = 5.0
 
+T = TypeVar("T")
+
+
+def _tag(code: str, message: str) -> str:
+    return message if message.startswith(f"[{code}]") else f"[{code}] {message}"
+
 
 def _catalog_retry_window_seconds() -> float:
     """Read the catalogue-rebuild retry window, in milliseconds, from the environment.
@@ -41,6 +54,20 @@ def _catalog_retry_window_seconds() -> float:
     return value / 1000.0 if value > 0 else DEFAULT_CATALOG_RETRY_WINDOW_S
 
 
+def _restore_uri(result: types.ReadResourceResult, target: str, uri: str) -> types.ReadResourceResult:
+    """Give the contents back the URI the client asked for.
+
+    `ResourceContents.uri` is how a client identifies what it just read, and
+    the same template expansion read from two environments would otherwise come
+    back under one identity, cacheable as one document. Only the entry for the
+    URI we rewrote is restored; anything else the factory returned is its own.
+    """
+    contents = [
+        block.model_copy(update={"uri": uri}) if str(block.uri) == target else block for block in result.contents
+    ]
+    return result.model_copy(update={"contents": contents})
+
+
 def _error_result(text: str) -> types.CallToolResult:
     return types.CallToolResult(content=[types.TextContent(text=text)], is_error=True)
 
@@ -50,6 +77,7 @@ class RouterConfig:
     environments: list[EnvironmentSpec]
     catalog_source: str
     extra_read_only: frozenset[str]
+    skills: bool = False
 
 
 class Router:
@@ -79,6 +107,12 @@ class Router:
         self._catalog_retry_window = catalog_retry_window
         self._catalog_error: Exception | None = None
         self._catalog_error_at: float = float("-inf")
+        self.templates: list[str] | None = None
+        # Items the listing had to skip, kept so the surface that can still be
+        # asked for one says why rather than failing obscurely.
+        self.reserved_templates: list[str] = []
+        self.unroutable_prompts: set[str] = set()
+        self._templates_lock = anyio.Lock()
 
     def _label(self, code: str) -> str:
         return next(env.label for env in self.config.environments if env.code == code)
@@ -166,8 +200,7 @@ class Router:
         try:
             remote = await self.upstreams[code].list_tools()
         except Exception as error:
-            message = str(error)
-            return _error_result(message if message.startswith(f"[{code}]") else f"[{code}] {message}")
+            return _error_result(_tag(code, str(error)))
 
         self.catalogues[code] = remote
         self.unverified.discard(code)
@@ -223,8 +256,177 @@ class Router:
             return await self.upstreams[code].call_tool(name, args)
         except Exception as error:
             # Prefix so a per-environment permission failure never reads as a router bug.
-            message = str(error)
-            return _error_result(message if message.startswith(f"[{code}]") else f"[{code}] {message}")
+            return _error_result(_tag(code, str(error)))
+
+    # ── resources, prompts and completion ────────────────────────────────────
+    #
+    # Tools are merged across every environment because the same tool exists on
+    # each one. The rest of the surface is not merged: `skill://` bodies are
+    # release-scoped documentation that cross-reference each other by bare URI,
+    # so they are served from the catalogue source as published, and only a
+    # resource TEMPLATE (whose contents really are per-factory) carries the
+    # `environment` variable. See `router.content`.
+
+    def _source(self) -> Upstream:
+        return self.upstreams[self.config.catalog_source]
+
+    async def _fetch_templates(self) -> list[dict[str, Any]]:
+        templates = await self._prefixed(self.config.catalog_source, self._source().list_resource_templates())
+        self.templates = [str(template["uriTemplate"]) for template in templates if template.get("uriTemplate")]
+        return templates
+
+    async def _templates_for_routing(self) -> list[dict[str, Any]]:
+        """`_fetch_templates`, but a factory that serves no templates is not an error.
+
+        `resources/templates/list` is the least-implemented half of the
+        resources capability, and a `-32601` from it must not take down a read
+        of a static `skill://` body: no templates means every URI is static,
+        which is exactly how this routed before templates existed.
+        """
+        try:
+            return await self._fetch_templates()
+        except MCPError as error:
+            if error.code != types.METHOD_NOT_FOUND:
+                raise
+            log(f"{self.config.catalog_source} serves no resources/templates/list; routing every URI as static")
+            self.templates = []
+            return []
+
+    async def _ensure_templates(self) -> list[str]:
+        """Learn which URIs are template expansions before routing a read.
+
+        Only the branch that has no `environment` needs this, and it needs the
+        published templates rather than the published resources: a `skill://`
+        body may link to a sibling the factory never advertised, and that link
+        is still static content the catalogue source can serve. Fetched once
+        and kept, because a template list changes only with a release.
+        """
+        async with self._templates_lock:
+            if self.templates is None:
+                await self._templates_for_routing()
+            return self.templates or []
+
+    async def list_resources(self) -> list[types.Resource]:
+        resources = await self._prefixed(self.config.catalog_source, self._source().list_resources())
+        return [types.Resource.model_validate(resource) for resource in resources]
+
+    async def list_resource_templates(self) -> list[types.ResourceTemplate]:
+        async with self._templates_lock:
+            templates = await self._fetch_templates()
+        self.reserved_templates = [
+            str(template["uriTemplate"])
+            for template in templates
+            if template.get("uriTemplate") and content.declares_environment(str(template["uriTemplate"]))
+        ]
+        return [
+            types.ResourceTemplate.model_validate(scoped)
+            for scoped in self._each(content.scope_template, templates, "resource template")
+        ]
+
+    async def read_resource(self, uri: str) -> types.ReadResourceResult:
+        # `split_environment` is pure and local, so a read that names its
+        # environment never waits on, or fails with, the catalogue source.
+        templates = [] if content.split_environment(uri)[1] is not None else await self._ensure_templates()
+        target, code = content.resolve_resource(
+            uri,
+            templates=templates,
+            catalog_source=self.config.catalog_source,
+            codes=list(self.upstreams),
+            reserved=self.reserved_templates,
+        )
+        result = await self._prefixed(code, self.upstreams[code].read_resource(target))
+        return result if target == uri else _restore_uri(result, target, uri)
+
+    async def list_prompts(self) -> list[types.Prompt]:
+        prompts = await self._prefixed(self.config.catalog_source, self._source().list_prompts())
+        spliced = self._each(content.splice_prompt_environment, prompts, "prompt")
+        kept = {prompt.get("name") for prompt in spliced}
+        self.unroutable_prompts = {str(prompt["name"]) for prompt in prompts if prompt.get("name") not in kept}
+        return [types.Prompt.model_validate(prompt) for prompt in spliced]
+
+    async def get_prompt(self, name: str, raw_arguments: dict[str, str] | None) -> types.GetPromptResult:
+        args = dict(raw_arguments or {})
+        if name in self.unroutable_prompts:
+            # The listing skipped it, but a client holding a cached list can
+            # still ask. Routing eats the `environment` argument, so forwarding
+            # it would silently deprive the factory of its own.
+            raise ContentError(
+                f'prompt "{name}" declares its own "{ENV_ARG}" argument, which this router reserves to select the '
+                "factory environment, so it cannot route it and does not publish it."
+            )
+        code = self._required_environment(args.pop(ENV_ARG, None))
+        result = await self._prefixed(code, self.upstreams[code].get_prompt(name, args))
+        instruction = types.PromptMessage(
+            role="user",
+            content=types.TextContent(text=content.environment_instruction(code, self._label(code))),
+        )
+        return result.model_copy(update={"messages": [instruction, *result.messages]})
+
+    async def complete(self, params: types.CompleteRequestParams) -> types.CompleteResult:
+        context_arguments = dict(params.context.arguments or {}) if params.context is not None else {}
+        chosen = context_arguments.pop(ENV_ARG, None)
+
+        if params.argument.name == ENV_ARG:
+            # The router owns this variable, so it answers for it rather than
+            # asking a factory about an argument it has never heard of.
+            values = [code for code in self.upstreams if code.startswith(params.argument.value or "")]
+            return types.CompleteResult(completion=types.Completion(values=values, total=len(values), has_more=False))
+
+        ref = params.ref
+        from_ref = None
+        if isinstance(ref, types.ResourceTemplateReference):
+            bare, from_ref = content.split_environment(ref.uri)
+            # Not a suffix strip: a template with a fragment carries the
+            # router's variable in the middle, and the factory has never heard
+            # of it in any position.
+            ref = ref.model_copy(update={"uri": content.unscope_template(bare)})
+        # A half-filled context argument is the normal state of a completion
+        # request, so a blank or half-typed `environment` falls back rather than
+        # refusing; an already-expanded ref that names one is the next-best
+        # answer. Completion degrades, it does not fail.
+        named = chosen or from_ref
+        code = named if named in self.upstreams else self.config.catalog_source
+        argument = {"name": params.argument.name, "value": params.argument.value}
+        return await self._prefixed(code, self.upstreams[code].complete(ref, argument, context_arguments or None))
+
+    def _each(self, splice, items: list[dict[str, Any]], kind: str) -> list[dict[str, Any]]:
+        """Splice `environment` into each item, dropping the ones that cannot take it.
+
+        A factory item that already reserves the name is one item's problem.
+        Failing the whole call would answer a client that asked for twelve with
+        none of them, and say nothing about which one was at fault.
+        """
+        spliced = []
+        for item in items:
+            try:
+                spliced.append(splice(item, self.config.environments))
+            except ContentError as error:
+                log(f"skipping a {kind} from {self.config.catalog_source}: {error}")
+        return spliced
+
+    def _required_environment(self, code: str | None) -> str:
+        if not code:
+            raise ContentError(f'"{ENV_ARG}" is required. Choose one of: {", ".join(self.upstreams)}')
+        if code not in self.upstreams:
+            raise ContentError(f'Unknown environment "{code}". Choose one of: {", ".join(self.upstreams)}')
+        return code
+
+    async def _prefixed(self, code: str, awaitable: Awaitable[T]) -> T:
+        """Await an upstream call, tagging its failure with the environment it came from.
+
+        Same reason as the prefix in `call_tool`: a per-environment permission
+        failure or expired login must not read as a router bug.
+
+        A JSON-RPC error keeps its code. "no such prompt" and "the router
+        broke" are different answers, and a client that branches on the code
+        cannot tell them apart if everything arrives as INTERNAL_ERROR.
+        """
+        try:
+            return await awaitable
+        except MCPError as error:
+            raise MCPError(code=error.code, message=_tag(code, error.message), data=error.data) from error
+        except Exception as error:
+            raise RuntimeError(_tag(code, str(error))) from error
 
 
 def build_router(
@@ -234,13 +436,19 @@ def build_router(
     catalog_source: str,
     extra_read_only: frozenset[str],
     timeout: float,
+    skills: bool = False,
 ) -> Router:
     environments = [
         EnvironmentSpec(code=code, label=profile["name"], writable=code in writable_codes)
         for code, profile in profiles.items()
     ]
     upstreams = {code: Upstream(code, profile, timeout=timeout) for code, profile in profiles.items()}
-    config = RouterConfig(environments=environments, catalog_source=catalog_source, extra_read_only=extra_read_only)
+    config = RouterConfig(
+        environments=environments,
+        catalog_source=catalog_source,
+        extra_read_only=extra_read_only,
+        skills=skills,
+    )
     return Router(config, upstreams, catalog_retry_window=_catalog_retry_window_seconds())
 
 
@@ -256,13 +464,95 @@ async def _on_call_tool(
     return await router.call_tool(params.name, params.arguments)
 
 
+def _as_mcp_error(error: Exception) -> MCPError:
+    """Carry a router refusal to the client instead of losing it.
+
+    An ordinary exception out of a handler is logged and answered as a bare
+    "Internal server error" (`mcp.server.runner.modern_error_data`), which would
+    throw away the one sentence saying what to fix. `MCPError` reaches the wire
+    intact, so every refusal this router can explain is raised as one.
+
+    `tools/call` needs none of this: it has a result shape that carries
+    `is_error` with the text, which is why `call_tool` returns rather than raises.
+    """
+    if isinstance(error, ContentError):
+        return MCPError(code=types.INVALID_PARAMS, message=str(error))
+    return MCPError(code=types.INTERNAL_ERROR, message=str(error))
+
+
+async def _guarded(action):
+    try:
+        return await action
+    except MCPError:
+        raise
+    except Exception as error:
+        raise _as_mcp_error(error) from error
+
+
+async def _on_list_resources(
+    router: Router, _ctx: ServerRequestContext[Any], _params: types.PaginatedRequestParams | None
+) -> types.ListResourcesResult:
+    return types.ListResourcesResult(resources=await _guarded(router.list_resources()))
+
+
+async def _on_list_resource_templates(
+    router: Router, _ctx: ServerRequestContext[Any], _params: types.PaginatedRequestParams | None
+) -> types.ListResourceTemplatesResult:
+    return types.ListResourceTemplatesResult(resource_templates=await _guarded(router.list_resource_templates()))
+
+
+async def _on_read_resource(
+    router: Router, _ctx: ServerRequestContext[Any], params: types.ReadResourceRequestParams
+) -> types.ReadResourceResult:
+    return await _guarded(router.read_resource(params.uri))
+
+
+async def _on_list_prompts(
+    router: Router, _ctx: ServerRequestContext[Any], _params: types.PaginatedRequestParams | None
+) -> types.ListPromptsResult:
+    return types.ListPromptsResult(prompts=await _guarded(router.list_prompts()))
+
+
+async def _on_get_prompt(
+    router: Router, _ctx: ServerRequestContext[Any], params: types.GetPromptRequestParams
+) -> types.GetPromptResult:
+    return await _guarded(router.get_prompt(params.name, params.arguments))
+
+
+async def _on_completion(
+    router: Router, _ctx: ServerRequestContext[Any], params: types.CompleteRequestParams
+) -> types.CompleteResult:
+    return await _guarded(router.complete(params))
+
+
+def advertised_extensions(router: Router) -> dict[str, dict[str, Any]]:
+    """What this router claims to support at the handshake.
+
+    The handshake is answered before any factory has been reached (see
+    `prime_catalog`), so the router cannot ask the catalogue source whether it
+    serves skills in time to repeat the claim. An explicit opt-in is the honest
+    way to make it: `skills = true` in the factory section, or --skills.
+    """
+    return {SKILLS_EXTENSION: {}} if router.config.skills else {}
+
+
 async def _serve(router: Router) -> None:
     server: Server[Any] = Server(
         SERVER_NAME,
         version=SERVER_VERSION,
         on_list_tools=lambda ctx, params: _on_list_tools(router, ctx, params),
         on_call_tool=lambda ctx, params: _on_call_tool(router, ctx, params),
+        on_list_resources=lambda ctx, params: _on_list_resources(router, ctx, params),
+        on_list_resource_templates=lambda ctx, params: _on_list_resource_templates(router, ctx, params),
+        on_read_resource=lambda ctx, params: _on_read_resource(router, ctx, params),
+        on_list_prompts=lambda ctx, params: _on_list_prompts(router, ctx, params),
+        on_get_prompt=lambda ctx, params: _on_get_prompt(router, ctx, params),
+        on_completion=lambda ctx, params: _on_completion(router, ctx, params),
     )
+    # Set on the server rather than passed to `create_initialization_options`:
+    # the handshake rebuilds its capabilities from `server.extensions` once the
+    # protocol version is known, and ignores the ones computed here.
+    server.extensions = advertised_extensions(router)
     # Answer `initialize` immediately: the catalogue build runs as a background
     # task so one hung factory reads as a slow tools/list, not a failed
     # handshake (clients cap startup time).

if_cli/router/upstream.py

@@ -193,14 +193,24 @@ class Upstream:
         except _BaseExceptionGroup as error:
             raise _leaf_exception(error) from error
 
-    async def list_tools(self) -> list[dict[str, Any]]:
+    async def _list(self, fetch, attribute: str) -> list[dict[str, Any]]:
+        """Page through one list endpoint, dumping each item the way the router wants it.
+
+        Dicts rather than models: the merge rules in `catalog` and `content`
+        rewrite what the factory published (an `environment` enum spliced into a
+        schema, a variable appended to a URI template), and doing that to plain
+        JSON keeps every field the factory sent, including ones this `mcp_types`
+        version does not model. `server` validates the result on the way out.
+        """
+
         async def collect(client: Client) -> list[dict[str, Any]]:
             collected: list[dict[str, Any]] = []
             cursor: str | None = None
             while True:
-                result = await client.list_tools(cursor=cursor)
+                result = await fetch(client, cursor)
                 collected.extend(
-                    tool.model_dump(by_alias=True, mode="json", exclude_unset=True) for tool in result.tools
+                    item.model_dump(by_alias=True, mode="json", exclude_unset=True)
+                    for item in getattr(result, attribute)
                 )
                 if not result.next_cursor:
                     return collected
@@ -208,6 +218,54 @@ class Upstream:
 
         return await self._run(collect)
 
+    async def list_tools(self) -> list[dict[str, Any]]:
+        return await self._list(lambda client, cursor: client.list_tools(cursor=cursor), "tools")
+
+    async def list_resources(self) -> list[dict[str, Any]]:
+        return await self._list(lambda client, cursor: client.list_resources(cursor=cursor), "resources")
+
+    async def list_resource_templates(self) -> list[dict[str, Any]]:
+        return await self._list(
+            lambda client, cursor: client.list_resource_templates(cursor=cursor), "resource_templates"
+        )
+
+    async def list_prompts(self) -> list[dict[str, Any]]:
+        return await self._list(lambda client, cursor: client.list_prompts(cursor=cursor), "prompts")
+
+    async def read_resource(self, uri: str) -> types.ReadResourceResult:
+        async def read(client: Client):
+            return await client.read_resource(uri)
+
+        return self._require_result(await self._run(read))
+
+    async def get_prompt(self, name: str, arguments: dict[str, str]) -> types.GetPromptResult:
+        async def get(client: Client):
+            return await client.get_prompt(name, arguments)
+
+        return self._require_result(await self._run(get))
+
+    async def complete(
+        self, ref: Any, argument: dict[str, str], context_arguments: dict[str, str] | None
+    ) -> types.CompleteResult:
+        async def complete(client: Client):
+            return await client.complete(ref, argument, context_arguments)
+
+        return self._require_result(await self._run(complete))
+
+    def _require_result(self, result: Any) -> Any:
+        """Turn a factory's request for input into an error, for the calls that cannot carry one.
+
+        `call_tool` answers an `InputRequiredResult` with a refusal that names the
+        connect page, because a tool result has somewhere to put it. A resource,
+        a prompt and a completion have no such shape: the protocol expects the
+        content or an error. So the same text is raised, and the caller reports
+        it as an error rather than inventing an empty body.
+        """
+        if isinstance(result, types.InputRequiredResult):
+            lines, url = _relayable_requests(result, self.profile["host"])
+            raise RuntimeError(self._connect_text(lines, url))
+        return result
+
     async def call_tool(self, name: str, arguments: dict[str, Any]) -> types.CallToolResult:
         async def call(client: Client):
             # `allow_input_required` hands back the factory's `InputRequiredResult`
@@ -261,12 +319,16 @@ class Upstream:
         from the factory, so it gives the caller somewhere to start without
         loosening what the origin check refuses to print.
         """
+        return types.CallToolResult(
+            content=[types.TextContent(text=self._connect_text(lines, url))],
+            is_error=True,
+        )
+
+    def _connect_text(self, lines: list[str], url: str | None) -> str:
+        """The factory's relayable messages plus the line naming where to connect."""
         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,
-        )
+        return "\n".join([*lines, connect])

{insightfactory_cli-1.1.2.dev28.dist-info → insightfactory_cli-1.1.2.dev29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: insightfactory-cli
-Version: 1.1.2.dev28
+Version: 1.1.2.dev29
 Summary: Profile-based authentication CLI for the InsightFactory Interfaces API
 Project-URL: Homepage, https://insightfactory.ai
 Author-email: "insightfactory.ai Support" <support@insightfactory.ai>
@@ -255,9 +255,10 @@ tst = example-tst
 writable = dev
 ```
 
-Every key except `writable` and `catalog` is `<environment code> = <profile name>`; file
-order is the environment order. `writable` is a comma-separated list of codes (default
-none); `catalog` is one code (default the first environment). Then:
+Every key except `writable`, `catalog` and `skills` is `<environment code> = <profile name>`;
+file order is the environment order. `writable` is a comma-separated list of codes (default
+none); `catalog` is one code (default the first environment); `skills` is `true` or `false`
+(default false). Then:
 
 ```bash
 uv tool install 'insightfactory-cli[mcp]'
@@ -290,6 +291,7 @@ passed at all, replace the section's value outright, and `--allow-tool` is alway
 | `--read-only` | Forces every environment read-only, overriding both the section's `writable` and any `--writable`. Cannot be combined with `--writable`. |
 | `--catalog CODE` (default: the first environment) | Whose tool list is published; its schemas are the reference every environment is checked against. |
 | `--allow-tool NAME` (repeatable) | Extra tool names treated as read-only, beyond the shipped list. |
+| `--skills` / `--no-skills` | Whether to advertise the experimental skills extension. Off unless the section says `skills = true` or `--skills` is passed. The two cannot be combined. |
 | `--timeout SECONDS` (default `120`) | Per upstream request; higher than the `api` command's default because some tools are slow. |
 
 `mcp`'s `--timeout` does not read `INSIGHTFACTORY_REQUEST_TIMEOUT`: it parses the flag with
@@ -304,6 +306,62 @@ 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.
 
+### Resources, prompts and completion
+
+Resources and prompts are not merged across environments the way tools are, because
+a factory's non-tool content splits in two.
+
+`skill://` bodies are documentation that belongs to a release, identical on every
+environment running it, and they cross-reference each other by bare URI. So they are
+served from the `--catalog` environment exactly as published. Rewriting those URIs to
+carry an environment would leave every link inside them pointing at nothing.
+
+A resource template is the other half: `if://task-config-schemas/{taskType}` resolves
+to one factory's own activity catalogue, not to a shared document. The router
+republishes each template with its own variable appended, so the client chooses the
+environment when it expands the URI:
+
+```text
+if://task-config-schemas/{taskType}{?environment}
+```
+
+A template that already opens a query gets `{&environment}` instead, and one that
+ends in a fragment gets the variable in front of it, because a `?` after a `#` is an
+ordinary character rather than a query. A template that already declares an
+`environment` variable is skipped with a line on stderr, so one nonconforming item
+does not hide the rest of the list.
+
+Reading a URI with no `?environment=` is answered by the catalogue environment,
+unless the URI could be an expansion of a published template, which is refused
+naming the codes to choose from. Membership of `resources/list` is deliberately not
+the test: a skill body may link to a sibling document the factory never advertised,
+and such a link carries no `environment` and could not be given one.
+`completion/complete` reads the environment from the request's context arguments,
+then from the reference URI, and falls back to the catalogue environment for anything
+it does not recognise, because a half-typed context value is the normal state of a
+completion request and completion should degrade rather than fail. The router answers
+for the `environment` variable itself rather than asking a factory about an argument
+it has never heard of.
+
+Prompts gain a required `environment` argument like tools. The router also prepends a
+line to every rendered prompt naming the environment chosen, because a factory writes
+its prompts for a client talking to one factory and they tell the model to call tools
+without one. Prepended rather than appended, and marked `[if-cli router]`: the
+factory's own last turn may be an assistant prefill, which a trailing user turn would
+silently end.
+
+`--skills` only controls the advertisement. The handshake is answered before any
+factory has been reached, so the router cannot ask the catalogue environment whether
+it serves skills in time to repeat the claim, and an experimental capability is not
+worth guessing at. The `skill://` resources are served either way.
+
+The advertisement reaches only a client on MCP protocol 2026-07-28 or later.
+`capabilities.extensions` was added in that revision, and the `initialize` handshake
+every current client opens with negotiates a 2025 revision whose capability schema
+has no such field, so the SDK strips it before it reaches the wire. Against
+`foundryaz-dev` with `--skills` on, Claude Code sees no extension and still finds
+every skill through `resources/list`, which is how clients discover them today.
+
 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

{insightfactory_cli-1.1.2.dev28.dist-info → insightfactory_cli-1.1.2.dev29.dist-info}/RECORD

@@ -4,7 +4,7 @@ if_cli/cache.py,sha256=UfvHs3GQIVg0sVfKYWw4UGlq8d-8BEXuZIDfC1hwwjA,6587
 if_cli/callback_page.py,sha256=lTHd3-vzlT9ndAL7XYonBfy97lBW7apRw3V7SmhNObo,5907
 if_cli/cli.py,sha256=fF7HvsUgpKhkLFdXLMJ1JXHGjp3RwJt2YmPSEW0d8gY,6270
 if_cli/colour.py,sha256=2hbaM4ubTHGja6YZRD886eqnB7T2IaZyW5rvfOjxe4M,682
-if_cli/config.py,sha256=YFnegm_-e051bL0vyTFIkVrKamjgY08DVCqK0VgFNvA,10129
+if_cli/config.py,sha256=QiphIhVLDN3sp39xMWKwXEyJWxx4IhXT28oEtmPc0ew,10601
 if_cli/constants.py,sha256=RW43KupAdhXfBsX6MxzZdJ-R57brX0q0TgIq8xXgvPs,269
 if_cli/http.py,sha256=W8HL3uZLeOu5MgmsOavM1Y6x4AcrInIQsAr5hx-j8AE,7671
 if_cli/main.py,sha256=pn-X2wrHNplc8ceT5_nEv5XlrTN3KgpK8UU4gAmBiWY,3212
@@ -17,18 +17,19 @@ 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=uU70j13n1WwkiyQigUTHPIIpc1B2PZO2O4wLIFDB87k,6586
+if_cli/commands/mcp.py,sha256=SVF4egfA9RzjY5GHRlbk0mVi0HtmKfMh8v-SSYHjs98,7270
 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/content.py,sha256=POL2n5NIY8yenQHJe8pUbTuTNpPSUSm0Y6Txbvehzhs,14487
 if_cli/router/log.py,sha256=YLWeHUb05HUnS3XHubCwy7oLZAUEGAiHcZysz_YMAAo,412
 if_cli/router/policy.py,sha256=CclbjuOA5mwwoQiNDa17iQeN9eXRbfy11bS9JFd8gL4,2840
-if_cli/router/server.py,sha256=RkS6Ddann-vAU0ZQAe2QaEB9dLBvEC33V9O-G4WSIy8,12116
-if_cli/router/upstream.py,sha256=dmwS7qSLnHiY7dEYpVENkfYIHs3DxkhhMB1SV66lE2Y,13104
-insightfactory_cli-1.1.2.dev28.dist-info/METADATA,sha256=lrvEqTY6PVwH8Y0TZJXWSJ2XGiDsDaYE9l7oMM3sk0w,20159
-insightfactory_cli-1.1.2.dev28.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-insightfactory_cli-1.1.2.dev28.dist-info/entry_points.txt,sha256=UlX854D7f-7dBj5F0wGdakVy6vopvP9hA1BN-gv739w,44
-insightfactory_cli-1.1.2.dev28.dist-info/licenses/LICENSE,sha256=8eZ1YAABL398qESVJc_FlK1voYQ0GAh-R_rNBQK6QH8,234
-insightfactory_cli-1.1.2.dev28.dist-info/RECORD,,
+if_cli/router/server.py,sha256=JZ-7xbNyDadSY1VVLHpSVTjfx6vxI_uumxFaD22Pl0Y,26449
+if_cli/router/upstream.py,sha256=2V78k6SXnOJ9Epc0tnhTuUPVBrYuW5vwflT-d3xKwVc,16122
+insightfactory_cli-1.1.2.dev29.dist-info/METADATA,sha256=4M5zoiKKqT52vOoEOrx42CE_TsGyFawx1-4CLa7v5JE,23695
+insightfactory_cli-1.1.2.dev29.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+insightfactory_cli-1.1.2.dev29.dist-info/entry_points.txt,sha256=UlX854D7f-7dBj5F0wGdakVy6vopvP9hA1BN-gv739w,44
+insightfactory_cli-1.1.2.dev29.dist-info/licenses/LICENSE,sha256=8eZ1YAABL398qESVJc_FlK1voYQ0GAh-R_rNBQK6QH8,234
+insightfactory_cli-1.1.2.dev29.dist-info/RECORD,,

{insightfactory_cli-1.1.2.dev28.dist-info → insightfactory_cli-1.1.2.dev29.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.0
+Generator: hatchling 1.32.3
 Root-Is-Purelib: true
 Tag: py3-none-any