@passioncode-ai/fabric-agent-adapter 0.10.0 → 0.12.0

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric_interop.py

@@ -279,14 +279,17 @@ class JobStore:
         return dict(record["job"])
 
     def create(self, capability: str, arguments: Any, traceparent: Optional[str] = None,
-               poll_interval_ms: Optional[int] = None) -> Dict[str, Any]:
+               poll_interval_ms: Optional[int] = None, delegation: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """Start a job; returns the handle a job-capable tool puts in structuredContent."""
         job_id = "job_" + secrets.token_hex(12)
         job: Dict[str, Any] = {"id": job_id, "status": "working"}
         if poll_interval_ms:
             job["pollIntervalMs"] = int(poll_interval_ms)
-        self._save({"job": job, "private": {"capability": capability, "input": arguments,
-                                            "traceparent": traceparent if parse_traceparent(traceparent) else None}})
+        private: Dict[str, Any] = {"capability": capability, "input": arguments,
+                                   "traceparent": traceparent if parse_traceparent(traceparent) else None}
+        if delegation:  # DEC-0039: who started it; only they read, cancel or answer it
+            private["delegation"] = {"principal": delegation.get("principal"), "caller": delegation.get("caller")}
+        self._save({"job": job, "private": private})
         return {"job": {"id": job_id, "status": "working"}}
 
     def get(self, job_id: str) -> Dict[str, Any]:
@@ -361,16 +364,19 @@ class JobStore:
 class CallContext:
     """What a tool handler gets: the child span it runs in, and a way to start a job."""
 
-    def __init__(self, server: "McpToolServer", tool: str, arguments: Any, traceparent: str):
+    def __init__(self, server: "McpToolServer", tool: str, arguments: Any, traceparent: str,
+                 delegation: Optional[Dict[str, Any]] = None):
         self.server = server
         self.tool = tool
         self.arguments = arguments
         self.traceparent = traceparent
+        # DEC-0039: the accepted delegation (principal, caller, chain, claims) when the server has a gate.
+        self.delegation = delegation
 
     def start_job(self, poll_interval_ms: Optional[int] = None) -> Dict[str, Any]:
         if self.server.jobs is None:
             raise InteropError("This server has no job store.")
-        handle = self.server.jobs.create(self.tool, self.arguments, self.traceparent, poll_interval_ms)
+        handle = self.server.jobs.create(self.tool, self.arguments, self.traceparent, poll_interval_ms, self.delegation)
         self.server.job_started(handle["job"]["id"], self)
         return handle
 
@@ -471,7 +477,12 @@ class McpToolServer:
 
     def __init__(self, name: str, version: str, jobs: Optional[JobStore] = None,
                  on_job_started: Optional[Callable[[str, CallContext], None]] = None,
-                 on_input: Optional[OnInput] = None):
+                 on_input: Optional[OnInput] = None,
+                 authorize: Optional[Callable[[str, Any], Dict[str, Any]]] = None):
+        # authorize(tool, headers, tier=) runs before every handler (fabric_delegation.delegation_gate, DEC-0039):
+        # a refusal is answered in the DL-19 shape and the handler never runs. The built-in job tools are
+        # gated by the job's own capability, and answered only for the principal and caller that started it.
+        self._authorize = authorize
         self.info = {"name": name, "version": version}
         self.jobs = jobs
         self.tools: List[Dict[str, Any]] = []
@@ -506,10 +517,12 @@ class McpToolServer:
     def _error(rid: Any, code: int, message: str) -> Dict[str, Any]:
         return {"jsonrpc": "2.0", "id": rid, "error": {"code": code, "message": message}}
 
-    def handle(self, message: Any, headers: Any = None) -> Optional[Dict[str, Any]]:
+    def handle(self, message: Any, headers: Any = None, tier: str = "T2") -> Optional[Dict[str, Any]]:
         """One JSON-RPC message. Pass the HTTP request headers so the 2026-07-28 standard headers
         are checked (`mcp_header_problem`); a mismatch answers HEADER_MISMATCH even for a
-        notification, so the transport can return HTTP 400."""
+        notification, so the transport can return HTTP 400. `tier` is the caller's origin for the
+        authorize gate (DL-25: T0 local and authenticated by the service's floor, T1 an enrolled
+        machine of the owner, T2 anything else); a gate never requires a token from T0 or T1."""
         if not isinstance(message, dict) or message.get("jsonrpc") != "2.0" or not isinstance(message.get("method"), str):
             return self._error(message.get("id") if isinstance(message, dict) else None, -32600, "Invalid request.")
         problem = mcp_header_problem(message, headers)
@@ -540,17 +553,39 @@ class McpToolServer:
         name = params.get("name")
         arguments = params.get("arguments") or {}
         if name in ("fabric.job.get", "fabric.job.cancel") and self.jobs is not None:
-            return {"jsonrpc": "2.0", "id": rid, "result": self._job_call(name, arguments, span)}
+            verdict = None
+            if self._authorize is not None:
+                job_id = str(arguments.get("id", ""))
+                try:
+                    private = self.jobs.private(job_id)
+                except UnknownJob:
+                    return {"jsonrpc": "2.0", "id": rid, "result": unknown_job_result(job_id, traceparent=span)}
+                verdict = self._authorize(private["capability"], headers, tier=tier)
+                owner = private.get("delegation")
+                if verdict.get("ok") and owner and (owner.get("principal"), owner.get("caller")) != (verdict.get("principal"), verdict.get("caller")):
+                    verdict = {"ok": False, "code": "scope-not-granted", "detail": "job-of-another-caller"}
+                if not verdict.get("ok"):
+                    import fabric_delegation as _fd  # noqa: E402 - only a gated server needs it
+                    return {"jsonrpc": "2.0", "id": rid, "result": _fd.refusal_tool_result(verdict, traceparent=span)}
+            return {"jsonrpc": "2.0", "id": rid, "result": self._job_call(name, arguments, span, verdict)}
         handler = self.handlers.get(name)
         if handler is None:
             return self._error(rid, -32602, "Unknown tool: %s." % name)
+        delegation = None
+        if self._authorize is not None:
+            verdict = self._authorize(name, headers, tier=tier)
+            if not verdict.get("ok"):
+                import fabric_delegation as _fd  # noqa: E402 - only a gated server needs it
+                return {"jsonrpc": "2.0", "id": rid, "result": _fd.refusal_tool_result(verdict, traceparent=span)}
+            delegation = verdict
         try:
-            structured = handler(arguments, CallContext(self, name, arguments, span))
+            structured = handler(arguments, CallContext(self, name, arguments, span, delegation))
         except InteropError as exc:
             return {"jsonrpc": "2.0", "id": rid, "result": tool_result({"error": {"code": "tool-error", "message": str(exc)}}, is_error=True, traceparent=span)}
         return {"jsonrpc": "2.0", "id": rid, "result": tool_result(structured, traceparent=span)}
 
-    def _job_call(self, name: str, arguments: Dict[str, Any], span: str) -> Dict[str, Any]:
+    def _job_call(self, name: str, arguments: Dict[str, Any], span: str,
+                  delegation: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         job_id = str(arguments.get("id", ""))
         try:
             job_span = self.jobs.traceparent(job_id) or span
@@ -566,7 +601,7 @@ class McpToolServer:
                 matched = self.jobs.answer(job_id, responses)
                 if matched and self._on_input:
                     private = self.jobs.private(job_id)
-                    self._on_input(job_id, matched, CallContext(self, private["capability"], private["input"], job_span))
+                    self._on_input(job_id, matched, CallContext(self, private["capability"], private["input"], job_span, delegation))
             return tool_result({"job": self.jobs.get(job_id)}, traceparent=job_span)
         except UnknownJob:
             return unknown_job_result(job_id, traceparent=span)

package/plugins/fabric-agent-adapter/skills/creating-fabric-agents/SKILL.md

@@ -5,9 +5,9 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned fabric-agent-contract checkout (a public repository). Works without those tools in an explicitly degraded structural-check mode. Ships in one plugin with adapting-projects-to-fabric, whose scripts it reuses.
 metadata:
   author: PassionCode.ai
-  version: "0.10.0"
+  version: "0.12.0"
   contract-version: "0.1.0"
-  contract-commit: "8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5"
+  contract-commit: "2eb91c00e852d9c31d804310d38fad91589fcbac"
 ---
 
 # Creating Fabric-compatible agents
@@ -119,7 +119,7 @@ python3 <plugin-dir>/skills/adapting-projects-to-fabric/scripts/adapt_project.py
   --schema-base <immutable-base-uri>
 ```
 
-Pin exactly contract `0.1.0` at commit `8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5` and
+Pin exactly contract `0.1.0` at commit `2eb91c00e852d9c31d804310d38fad91589fcbac` and
 read the pinned guide before implementing protocol details. If this skill is installed
 without its sibling, the scaffolder is absent: create the bundle by hand from the pinned
 contract's `docs/guides/connecting-compatible-agents.md` and mark the structural check