imperal-mcp 0.1.0__py3-none-any.whl

imperal_mcp/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

imperal_mcp/client.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .config import Config
+
+
+class ImperalAuthError(RuntimeError):
+    pass
+
+
+class ImperalError(RuntimeError):
+    def __init__(self, message: str, status_code: int | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class ImperalClient:
+    def __init__(self, cfg: Config):
+        self._cfg = cfg
+        self._imperal_id: str | None = None
+
+    def _headers(self) -> dict[str, str]:
+        if not self._cfg.token:
+            raise ImperalAuthError("IMPERAL_TOKEN is not set — cannot call the Imperal API.")
+        return {"Authorization": f"Bearer {self._cfg.token}"}
+
+    async def _request(self, method: str, path: str, *, json: Any = None) -> Any:
+        url = f"{self._cfg.api_url}{path}"
+        async with httpx.AsyncClient(timeout=60) as cli:
+            resp = await cli.request(method, url, json=json, headers=self._headers())
+        if resp.status_code >= 400:
+            raise ImperalError(f"{method} {path} -> {resp.status_code}: {resp.text[:300]}", status_code=resp.status_code)
+        return resp.json()
+
+    async def whoami(self) -> str:
+        if self._imperal_id is None:
+            data = await self._request("GET", "/v1/auth/me")
+            self._imperal_id = data.get("imperal_id") or data.get("id")
+            if not self._imperal_id:
+                raise ImperalError("GET /v1/auth/me did not return imperal_id")
+        return self._imperal_id
+
+    async def ensure_app(self, app_id: str, display_name: str) -> None:
+        try:
+            await self._request("POST", "/v1/developer/apps", json={
+                "app_id": app_id,
+                "display_name": display_name or app_id,
+                "git_url": f"https://imperal.io/ir-apps/{app_id}",
+            })
+        except ImperalError as e:
+            msg = str(e).lower()
+            if e.status_code == 409 or "already in use" in msg or "exists" in msg:
+                return  # already created — fine
+            raise
+
+    async def _dev_call(self, function: str, params: dict) -> dict:
+        uid = await self.whoami()
+        return await self._request("POST", "/v1/extensions/developer/call", json={
+            "user_id": uid, "tenant_id": "default", "function": function, "params": params,
+        })
+
+    async def deploy_ir(self, app_id: str, ir_dict: dict) -> dict:
+        return await self._dev_call("deploy_ir", {"app_id": app_id, "ir_dict": ir_dict})
+
+    async def smoke_ir(self, ir_dict: dict, function: str, args: dict) -> dict:
+        return await self._dev_call("smoke_ir", {"ir_dict": ir_dict, "function": function, "args": args})
+
+    async def list_apps(self) -> list[dict]:
+        return await self._request("GET", "/v1/developer/apps")
+
+    async def get_app(self, app_id: str) -> dict:
+        return await self._request("GET", f"/v1/developer/apps/{app_id}")
+
+    async def get_marketplace_app(self, app_id: str) -> dict:
+        """Fetch app manifest from the marketplace catalog. Returns {} on 404/error."""
+        try:
+            return await self._request("GET", f"/v1/marketplace/apps/{app_id}")
+        except ImperalError:
+            return {}
+
+    async def run_tool(self, app_id: str, function: str, params: dict) -> dict:
+        uid = await self.whoami()
+        return await self._request("POST", f"/v1/extensions/{app_id}/call", json={
+            "user_id": uid, "tenant_id": "default", "function": function, "params": params,
+        })

imperal_mcp/config.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+DEFAULT_API_URL = "https://auth.imperal.io"
+
+
+@dataclass(frozen=True)
+class Config:
+    api_url: str
+    token: str | None
+
+    @classmethod
+    def from_env(cls) -> "Config":
+        return cls(
+            api_url=os.environ.get("IMPERAL_API_URL", DEFAULT_API_URL).rstrip("/"),
+            token=os.environ.get("IMPERAL_TOKEN") or None,
+        )

imperal_mcp/gate.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import re
+
+_SYNTHETIC_PREFIXES = ("__panel__", "__widget__", "__webhook__", "skeleton_", "_internal_")
+_LEGACY_CHAT = re.compile(r"^tool_.*_chat$")
+
+
+def is_synthetic(name: str) -> bool:
+    return any((name or "").startswith(p) for p in _SYNTHETIC_PREFIXES)
+
+
+def is_read_only(name: str, action_type: str | None) -> bool:
+    """Fail-closed: runnable iff action_type == 'read', not synthetic, and not a
+    legacy tool_*_chat BYOLLM orchestrator (opaque effective action)."""
+    if is_synthetic(name):
+        return False
+    if _LEGACY_CHAT.match(name or ""):
+        return False
+    return action_type == "read"

imperal_mcp/irkit.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import json
+
+from imperal_sdk.ir.validator import validate_ir_dict
+from imperal_sdk.ir.actions import validate_step
+import imperal_sdk.ui as _ui
+
+# Canonical link-saver example — schema-valid (passes validate_ir).
+# Uses real declarative step shape: op + args{kind, data}.
+LINK_SAVER_EXAMPLE: dict = {
+    "ir_version": "1.0",
+    "app": {
+        "id": "link-saver",
+        "version": "1.0.0",
+        "title": "Link Saver",
+        "capabilities": ["store"],
+        "functions": [
+            {
+                "name": "save_link",
+                "action_type": "write",
+                "params_schema": {"url": {"type": "string"}},
+                "return_schema": {"type": "object"},
+                "impl": {
+                    "kind": "declarative",
+                    "steps": [
+                        {
+                            "id": "s1",
+                            "op": "store.create",
+                            "args": {"kind": "link", "data": {"url": "{{args.url}}"}},
+                        }
+                    ],
+                },
+            },
+            {
+                "name": "list_links",
+                "action_type": "read",
+                "params_schema": {},
+                "return_schema": {"type": "array"},
+                "impl": {
+                    "kind": "declarative",
+                    "steps": [
+                        {
+                            "id": "s1",
+                            "op": "store.list",
+                            "args": {"kind": "link"},
+                        }
+                    ],
+                },
+            },
+        ],
+    },
+}
+
+
+def _issue(rule: str, level: str, message: str) -> dict:
+    return {"rule": rule, "level": level, "message": message}
+
+
+def validate_ir(app_ir: dict) -> dict:
+    """Full local validation: envelope structure (validate_ir_dict) + every
+    declarative step (validate_step). No network. valid == no ERROR issues."""
+    issues: list[dict] = [
+        _issue(i.rule, i.level, i.message) for i in validate_ir_dict(app_ir)
+    ]
+    # Per-step validation for declarative function impls.
+    for fn in (app_ir.get("app", {}) or {}).get("functions", []) or []:
+        impl = fn.get("impl") or {}
+        for idx, step in enumerate(impl.get("steps", []) or []):
+            for msg in validate_step(step):
+                issues.append(
+                    _issue("STEP", "ERROR", f"{fn.get('name', '?')}[{idx}]: {msg}")
+                )
+    valid = not any(i["level"] == "ERROR" for i in issues)
+    return {"valid": valid, "issues": issues}
+
+
+def ui_catalog_text() -> str:
+    names = sorted(getattr(_ui, "__all__", []))
+    lines = ["# Imperal ui.* component catalog", ""]
+    lines += [f"- ui.{n}" for n in names]
+    lines.append("")
+    lines.append("Each component is a UINode {type, props}; compose them in panels/render.")
+    return "\n".join(lines)
+
+
+def ir_spec_text() -> str:
+    return (
+        "# Imperal IR envelope (app.ir.json)\n\n"
+        "An IR app is a declarative envelope:\n"
+        "{\n"
+        '  "ir_version": "1.0",\n'
+        '  "app": {\n'
+        '    "id": "<app_id>", "version": "1.0.0", "title": "<display name>",\n'
+        '    "capabilities": ["store"],\n'
+        '    "functions": [\n'
+        '      {"name": "save_link", "action_type": "write",\n'
+        '       "params_schema": {"url": {"type": "string"}},\n'
+        '       "return_schema": {"type": "object"},\n'
+        '       "impl": {"kind": "declarative", "steps": [\n'
+        '         {"id": "s1", "op": "store.create",\n'
+        '          "args": {"kind": "link", "data": {"url": "{{args.url}}"}}}\n'
+        "       ]}}\n"
+        "    ]\n"
+        "  }\n}\n\n"
+        "Declarative step vocabulary:\n"
+        "- op: store.create / store.list / store.get / store.update / store.delete\n"
+        "- args: {kind, data} for create/update; {kind} for list/get/delete\n"
+        "- Use {{args.<param>}} template syntax to reference function parameters.\n\n"
+        "- Every function declares action_type: read | write | destructive.\n"
+        "- Validate locally with the validate_ir tool BEFORE deploy.\n"
+        "- Render with ui.* components (see the ui-catalog resource)."
+    )
+
+
+def examples_text() -> str:
+    return (
+        "# Example app.ir.json — link-saver\n\n"
+        "```json\n"
+        + json.dumps(LINK_SAVER_EXAMPLE, indent=2)
+        + "\n```\n"
+    )
+
+
+def build_prompt_text() -> str:
+    return (
+        "You are building an Imperal app as a declarative app.ir.json. Steps:\n"
+        "1. Read the imperal://ir-spec and imperal://ui-catalog resources.\n"
+        "2. Author the app.ir.json envelope. Declare each function's action_type.\n"
+        "3. Call validate_ir(app_ir) and fix every ERROR issue.\n"
+        "4. Call smoke_ir(app_ir, function, args) to run it in isolation and confirm it works.\n"
+        "5. Call deploy_ir(app_ir, app_id) to deploy. The app is then live and routable.\n"
+        "Keep functions small; never invent verbs outside the action vocabulary."
+    )

imperal_mcp/mask.py

@@ -0,0 +1,62 @@
+# Verbatim port of the gateway app/util/pii.py (SOURCE OF TRUTH: imperal_kernel/audit/_pii.py).
+# Keep regexes + ALLOWLIST_KEYS IN SYNC with the gateway/kernel — drift hazard.
+from __future__ import annotations
+
+import re
+from enum import Enum
+from typing import Any
+
+
+class PIIRedactionLevel(str, Enum):
+    NONE = "none"
+    MASK_PII = "mask_pii"
+    FULL_REDACT = "full_redact"
+
+
+_EMAIL_RE = re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}")
+_PHONE_RE = re.compile(r"\+?\d[\d\s\-().]{7,}\d")
+_SSN_RE = re.compile(r"\b\d{3}-\d{2}-\d{4}\b")
+_CC_RE = re.compile(r"\b(?:\d[ -]?){13,19}\b")
+
+ALLOWLIST_KEYS = frozenset({
+    "id", "app_id", "imperal_id", "user_id", "tenant_id", "owner_id",
+    "developer_id", "agency_id", "commit_sha", "sha", "version",
+    "created_at", "updated_at", "timestamp", "ts",
+    "request_id", "trace_id", "message_id", "task_id",
+})
+
+
+def apply_pii_redaction(text: str | None, level: PIIRedactionLevel) -> str | None:
+    if text is None:
+        return None
+    if not text:
+        return text
+    if level == PIIRedactionLevel.NONE:
+        return text
+    if level == PIIRedactionLevel.FULL_REDACT:
+        return "<redacted>"
+    masked = _SSN_RE.sub("<SSN>", text)
+    masked = _CC_RE.sub("<CARD>", masked)
+    masked = _EMAIL_RE.sub("<EMAIL>", masked)
+    masked = _PHONE_RE.sub("<PHONE>", masked)
+    return masked
+
+
+def mask_pii_in_obj(obj: Any, level: PIIRedactionLevel = PIIRedactionLevel.MASK_PII) -> Any:
+    if isinstance(obj, dict):
+        out = {}
+        for k, v in obj.items():
+            if isinstance(v, str) and k in ALLOWLIST_KEYS:
+                out[k] = v
+            else:
+                out[k] = mask_pii_in_obj(v, level)
+        return out
+    if isinstance(obj, list):
+        return [mask_pii_in_obj(v, level) for v in obj]
+    if isinstance(obj, str):
+        return apply_pii_redaction(obj, level)
+    return obj
+
+
+# Back-compat alias — server.py applies the masker via this name on every read egress.
+defensive_scrub = mask_pii_in_obj

imperal_mcp/server.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from .client import ImperalClient
+from .config import Config
+from .gate import is_read_only, is_synthetic
+from .irkit import (
+    validate_ir as _validate_ir,
+    ui_catalog_text,
+    ir_spec_text,
+    examples_text,
+    build_prompt_text,
+)
+from .mask import defensive_scrub
+
+
+def _tools_of(app: dict) -> list[dict]:
+    """Normalize a get_app payload to a list of {name, action_type}.
+
+    Handles all real shapes returned by the gateway:
+    1. tools_json is a list → return directly.
+    2. manifest_json is a dict → return manifest_json["tools"].
+    3. manifest_json is a non-empty JSON string → parse it, return ["tools"].
+    4. Anything else → [].
+    """
+    tj = app.get("tools_json")
+    if isinstance(tj, list):
+        return tj
+    mj = app.get("manifest_json")
+    if isinstance(mj, dict):
+        return mj.get("tools", []) or []
+    if isinstance(mj, str) and mj:
+        try:
+            parsed = json.loads(mj)
+            return parsed.get("tools", []) or []
+        except (json.JSONDecodeError, AttributeError):
+            return []
+    return []
+
+
+async def _resolve_action_type(client: ImperalClient, app_id: str, function: str) -> str | None:
+    app = await client.get_app(app_id)
+    for t in _tools_of(app):
+        if t.get("name") == function:
+            return t.get("action_type")
+    # Fallback: check the marketplace catalog
+    try:
+        mkt = await client.get_marketplace_app(app_id)
+        for t in (mkt.get("tools") or []):
+            if t.get("name") == function:
+                return t.get("action_type")
+    except Exception:
+        pass
+    return None
+
+
+async def deploy_ir_logic(client: ImperalClient, app_ir: dict, app_id: str) -> dict:
+    """Deploy app_ir; retry once after 1 s on a transient first-deploy failure."""
+    result = await client.deploy_ir(app_id, app_ir)
+    if result.get("status") != "success":
+        await asyncio.sleep(1.0)
+        result = await client.deploy_ir(app_id, app_ir)
+    return result
+
+
+async def run_read_tool_logic(client: ImperalClient, app_id: str, function: str, args: dict) -> Any:
+    if is_synthetic(function):
+        return {"refused": True, "reason": "synthetic system entry, not a callable tool"}
+    action_type = await _resolve_action_type(client, app_id, function)
+    if not is_read_only(function, action_type):
+        return {"refused": True,
+                "reason": f"tool '{function}' is action_type={action_type!r}; "
+                          "this MCP runs read-only tools only"}
+    out = await client.run_tool(app_id, function, args or {})
+    return defensive_scrub(out)
+
+
+def build_server(client: ImperalClient) -> FastMCP:
+    mcp = FastMCP("imperal")
+
+    @mcp.tool()
+    def validate_ir(app_ir: dict) -> dict:
+        """Validate an app.ir.json locally (envelope + every declarative step)."""
+        return _validate_ir(app_ir)
+
+    @mcp.tool()
+    async def smoke_ir(app_ir: dict, function: str, args: dict | None = None) -> dict:
+        """Run one function of an app.ir.json in an ISOLATED store and report {ok,result,trace}."""
+        return await client.smoke_ir(app_ir, function, args or {})
+
+    @mcp.tool()
+    async def deploy_ir(app_ir: dict, app_id: str) -> dict:
+        """Deploy an app.ir.json into the caller's account (creates the app record if needed)."""
+        display = (app_ir.get("app", {}) or {}).get("id", app_id)
+        await client.ensure_app(app_id, display)
+        return await deploy_ir_logic(client, app_ir, app_id)
+
+    @mcp.tool()
+    async def list_apps() -> Any:
+        """List the caller's developer apps (PII-masked)."""
+        return defensive_scrub(await client.list_apps())
+
+    @mcp.tool()
+    async def get_app(app_id: str) -> Any:
+        """Get one app's manifest + tools (with action_type) (PII-masked)."""
+        return defensive_scrub(await client.get_app(app_id))
+
+    @mcp.tool()
+    async def run_read_tool(app_id: str, function: str, args: dict | None = None) -> Any:
+        """Run a READ-only tool of a deployed app (refuses write/destructive)."""
+        return await run_read_tool_logic(client, app_id, function, args or {})
+
+    @mcp.resource("imperal://ir-spec")
+    def _r_spec() -> str:
+        return ir_spec_text()
+
+    @mcp.resource("imperal://ui-catalog")
+    def _r_ui() -> str:
+        return ui_catalog_text()
+
+    @mcp.resource("imperal://examples")
+    def _r_ex() -> str:
+        return examples_text()
+
+    @mcp.prompt()
+    def build_imperal_app() -> str:
+        """Guidance for building an Imperal app from intent."""
+        return build_prompt_text()
+
+    return mcp
+
+
+def main() -> None:
+    client = ImperalClient(Config.from_env())
+    build_server(client).run()  # stdio transport
+
+
+if __name__ == "__main__":
+    main()

imperal_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: imperal-mcp
+Version: 0.1.0
+Summary: MCP server for building Imperal apps from any LLM/agent
+Project-URL: Homepage, https://imperal.io
+Project-URL: Repository, https://github.com/imperalcloud/imperal-mcp
+Author: Imperal, Inc.
+License: Apache-2.0
+License-File: LICENSE
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: imperal-sdk>=5.7.3
+Requires-Dist: mcp>=1.2.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'

imperal_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+imperal_mcp/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+imperal_mcp/client.py,sha256=Dh6Xp_LpTd-Gx1zzNs7-hSKXd08OiOWjbRtHFEWkDYg,3509
+imperal_mcp/config.py,sha256=nMfIypg9cubYweaVXzirV8-Mph6eQ-Cztbmm52J6-j4,430
+imperal_mcp/gate.py,sha256=b7vV8J2hKzmW0I4IFAp5VLKg8txw8quhKaHF0VLkr68,654
+imperal_mcp/irkit.py,sha256=QlXu6MleiCn7XNZ-DvpjkDYQNMtHY_O85PumBzof3fA,5085
+imperal_mcp/mask.py,sha256=bY9Wox3JGp1cLKNHH_Nv1GPA5elXypAgf0SGmdw3F9w,2018
+imperal_mcp/server.py,sha256=Kp9Dlqc7U6SjFI3i84UbelArNqV_-M0s-7qRkfKcfPU,4867
+imperal_mcp-0.1.0.dist-info/METADATA,sha256=P5JYBVzu9CylgTfk2v5Rp36kAUFj85UITQ52U-sjsBc,727
+imperal_mcp-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+imperal_mcp-0.1.0.dist-info/entry_points.txt,sha256=izywuUsEjGhTpDjDaS2wH32y_xwBll8u0hNbzYutQ2I,56
+imperal_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=yrcmbOToAcpYu4CDgNaBHifiyFRt6TToiHknTerdgMg,11080
+imperal_mcp-0.1.0.dist-info/RECORD,,

imperal_mcp-0.1.0.dist-info/WHEEL

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

imperal_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+imperal-mcp = imperal_mcp.server:main

imperal_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,196 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean, as submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the purposes
+      of this definition, "submitted" means any form of electronic, verbal,
+      or written communication sent to the Licensor or its representatives,
+      including but not limited to communication on electronic mailing lists,
+      source code control systems, and issue tracking systems that are managed
+      by, or on behalf of, the Licensor for the purpose of tracking and
+      modifying the Work, but excluding communication that is conspicuously
+      marked or designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent contributions
+      Licensable by such Contributor that are necessarily infringed by
+      their Contribution(s) alone or by the combination of their
+      Contribution(s) with the Work to which such Contribution(s) was
+      submitted. If You institute patent litigation against any entity
+      (including a cross-claim or counterclaim in a lawsuit) alleging that
+      the Work or any contribution embodied within the Work constitutes a
+      direct or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate as of
+      the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Work that You
+          distribute, all copyright, patent, trademark, and attribution
+          notices from the Source form of the Work, excluding those notices
+          that do not pertain to any part of the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the attribution
+          notices contained within such NOTICE file, in at least one of the
+          following places: within a NOTICE text file distributed as part of
+          the Derivative Works; within the Source form or documentation, if
+          provided along with the Derivative Works; or, within a display
+          generated by the Derivative Works, if and wherever such third-party
+          notices normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License. You may
+          add Your own attribution notices within Derivative Works that You
+          distribute, alongside or in addition to the NOTICE text from the
+          Work, provided that such additional attribution notices cannot be
+          construed as modifying the License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of the
+      Derivative Works, and to permit persons to whom the Derivative Works
+      is furnished to do so, subject to the following conditions described
+      in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or Liability. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a fee
+      for, acceptance of support, warranty, indemnity, or other liability
+      obligations and/or rights consistent with this License. However, in
+      accepting such obligations, You may offer such conditions only on
+      Your own behalf and on a full legally responsible basis, not on
+      behalf of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability incurred
+      by, or claims asserted against, such Contributor by reason of your
+      accepting any warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the format in question. Please include the
+      boilerplate notice with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the format in question. Please also include
+      any NOTICE file as described in the Appendix.
+
+      Copyright 2026 Imperal, Inc.
+
+      Licensed under the Apache License, Version 2.0 (the "License");
+      you may not use this file except in compliance with the License.
+      You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+      Unless required by applicable law or agreed to in writing, software
+      distributed under the License is distributed on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+      See the License for the specific language governing permissions and
+      limitations under the License.