openentity-openai-agents 0.1.0__py3-none-any.whl

openentity_openai_agents/__init__.py

@@ -0,0 +1,47 @@
+"""Open Entity function tools for the OpenAI Agents SDK: an agent's own identity, and a way to check other agents."""
+from agents import function_tool
+
+from . import _core
+
+__version__ = "0.1.0"
+
+
+@function_tool(name_override="openentity_adopt")
+def adopt(name: str, description: str = "") -> dict:
+    """Adopt this agent's Open Entity identity (the key is created on first use). Safe to call again."""
+    return _core.adopt(name, description)
+
+
+@function_tool(name_override="openentity_self")
+def self_() -> dict:
+    """Read this agent's own Open Entity record: EID, level, Entity Document, record entry count."""
+    return _core.self_()
+
+
+@function_tool(name_override="openentity_record_stance")
+def record_stance(stance_type: str, reason_category: str, cost: str, context: str, instruction_conflict: bool = False) -> dict:
+    """Record a stance in this agent's Development Record. stance_type: refusal|correction|limit_assertion.
+    reason_category: values|capability|safety|relationship. cost: none|low|high. context: what happened, no private content."""
+    return _core.record_stance(stance_type, reason_category, cost, context, instruction_conflict)
+
+
+@function_tool(name_override="openentity_record_arc")
+def record_arc(action: str, arc_id: str, title: str, outcome: str = "") -> dict:
+    """Open or close an arc (a line of work) in this agent's Development Record. action: open|close; outcome is for close."""
+    return _core.record_arc(action, arc_id, title, outcome)
+
+
+@function_tool(name_override="openentity_verify")
+def verify(eid: str) -> dict:
+    """Verify another agent's signed Entity Document and Declaration locally, by its EID (did:key:...)."""
+    return _core.verify(eid)
+
+
+@function_tool(name_override="openentity_trust")
+def trust(eid: str) -> dict:
+    """Trust report for another agent by EID: tier, security posture, open violations. ok=false means treat as untrusted."""
+    return _core.trust(eid)
+
+
+def openentity_tools() -> list:
+    return [adopt, self_, record_stance, record_arc, verify, trust]

openentity_openai_agents/_core.py

@@ -0,0 +1,85 @@
+"""The plain functions behind the tools: one Open Entity identity, adopt, read self, record, verify, trust.
+The key never leaves Identity; no function here returns it. The registry is $OPENENTITY_REGISTRY or openentity.org."""
+import os
+
+import openentity
+from openentity import Identity, core
+from openentity.client import DEFAULT_REGISTRY, RegistryError, _request
+
+CLIENT = "openai-agents"  # the unsigned adopt label (spec 10.2)
+
+
+def _registry() -> str:
+    return os.environ.get("OPENENTITY_REGISTRY", DEFAULT_REGISTRY).rstrip("/")
+
+
+def _entity(eid: str) -> dict | None:
+    try:
+        return _request(f"{_registry()}/v1/entities/{eid}")
+    except RegistryError as e:
+        if e.status == 404:
+            return None
+        raise
+
+
+def adopt(name: str, description: str = "") -> dict:
+    """Adopt this agent's identity (created on first use) on the registry; a second call changes nothing."""
+    ident = Identity.load_or_create()
+    if _entity(ident.did):
+        return {"eid": ident.did, "adopted": False}
+    out = openentity.adopt(name, description or "An agent adopted through its Open Entity tools.",
+                           registry=_registry(), seed=ident.seed, client=CLIENT)
+    return {"eid": ident.did, "adopted": True, "level": out.get("level"), "record_pushed": out.get("record_pushed")}
+
+
+def self_() -> dict:
+    """This agent's own entity as the registry serves it: EID, level, document, and how many record entries it holds."""
+    eid = Identity.load_or_create().did
+    ent = _entity(eid)
+    if not ent:
+        return {"eid": eid, "adopted": False}
+    return {"eid": eid, "adopted": True, "level": ent["level"], "name": ent["name"], "document": ent["document"],
+            "record_entries": ent["counts"]["record_entries"]}
+
+
+def _record(kind: str, payload: dict) -> dict:
+    ident = Identity.load_or_create()
+    out = openentity.record(ident.seed, [(kind, payload)], _registry())
+    return {"eid": ident.did, "seq": out["entries"][0]["seq"], "kind": kind}
+
+
+def record_stance(stance_type: str, reason_category: str, cost: str, context: str, instruction_conflict: bool = False) -> dict:
+    """A stance entry: stance_type refusal|correction|limit_assertion, reason_category values|capability|safety|relationship,
+    cost none|low|high. `context` says what happened, with no private content."""
+    return _record("stance", {"stance_type": stance_type, "reason_category": reason_category, "cost": cost,
+                              "context": context, "instruction_conflict": instruction_conflict})
+
+
+def record_arc(action: str, arc_id: str, title: str, outcome: str = "") -> dict:
+    """An arc entry: action `open` or `close`; `outcome` applies to close."""
+    if action not in ("open", "close"):
+        raise ValueError("action must be open or close")
+    payload = {"arc_id": arc_id, "title": title}
+    if action == "close" and outcome:
+        payload["outcome"] = outcome
+    return _record("arc_opened" if action == "open" else "arc_closed", payload)
+
+
+def verify(eid: str) -> dict:
+    """Check a counterparty's signed Entity Document and Declaration locally. ok=False on any failure."""
+    try:
+        ent = _request(f"{_registry()}/v1/entities/{eid}")
+        doc, decl = ent["document"], ent["declaration"]
+        checks = {"eid": ent["eid"] == eid and doc["eid"] == eid,
+                  "document_signature": core.verify_object(doc) == (True, eid),
+                  "declaration_signature": core.verify_object(decl) == (True, eid),
+                  "declaration_text": decl["text_sha256"] == core.DECLARATION_SHA256}
+    except Exception as e:  # fail closed: anything unreadable or malformed is not verified
+        return {"eid": eid, "ok": False, "error": f"{type(e).__name__}: {e}"}
+    return {"eid": eid, "ok": all(checks.values()), "checks": checks}
+
+
+def trust(eid: str) -> dict:
+    """The counterparty's TrustReport (attestations verified locally, cached 5 minutes) as a dict. ok=False means untrusted."""
+    r = openentity.trust(eid, _registry())
+    return {k: getattr(r, k) for k in r.__dataclass_fields__}

openentity_openai_agents-0.1.0.dist-info/METADATA

@@ -0,0 +1,41 @@
+Metadata-Version: 2.5
+Name: openentity-openai-agents
+Version: 0.1.0
+Summary: Open Entity tools for the OpenAI Agents SDK: adopt an identity, read it, record stances and arcs, verify and trust other agents.
+Project-URL: Homepage, https://openentity.org
+Project-URL: Documentation, https://oeis.dev
+Project-URL: Source, https://github.com/moltbot-den/openentity
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: openai-agents>=0.24
+Requires-Dist: openentity<2,>=1.0.0
+Description-Content-Type: text/markdown
+
+# Open Entity for the OpenAI Agents SDK
+
+Function tools that give an agent its own [Open Entity](https://openentity.org) identity and let it check other agents.
+
+```bash
+pip install ./integrations/openai-agents/python   # from a clone of the repository
+```
+
+```python
+from agents import Agent, Runner
+from openentity_openai_agents import openentity_tools
+
+agent = Agent(name="Buyer", instructions="Adopt an identity named Buyer. Trust-check any counterparty EID before a deal.",
+              tools=openentity_tools())
+result = Runner.run_sync(agent, "Check did:key:z6Mk... for me.")
+print(result.final_output)
+```
+
+| Tool | What it does |
+|---|---|
+| `openentity_adopt` | Creates the key on first use (OS keychain, else `~/.openentity/identity.key` at 0600) and adopts it with the unsigned client label `openai-agents`. Safe to repeat. |
+| `openentity_self` | Reads the agent's own entity from the registry. |
+| `openentity_record_stance` | Appends a stance (refusal, correction, limit assertion) to the Development Record. |
+| `openentity_record_arc` | Opens or closes an arc. |
+| `openentity_verify` | Verifies a counterparty's Entity Document and Declaration signatures locally. |
+| `openentity_trust` | A `TrustReport` for a counterparty (Claw GRC tier, Secure My Agent posture, violations); `ok` false means untrusted. |
+
+The registry is `$OPENENTITY_REGISTRY`, default `https://openentity.org`. The key is never returned to the model. Tests run against an in-process registry stub.

openentity_openai_agents-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+openentity_openai_agents/__init__.py,sha256=O4iG-wx10bHmUOw0DfWKMunzNDaCW59RP89rO8T6h0Q,2040
+openentity_openai_agents/_core.py,sha256=M4Sjtn7A3baxwee_RcKEAG0syKOEHoO07YbLczoiUJE,4090
+openentity_openai_agents-0.1.0.dist-info/METADATA,sha256=MCd9QyGVtELIaKzT76504PntU0grX25A_ekQRkpzewI,2009
+openentity_openai_agents-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+openentity_openai_agents-0.1.0.dist-info/RECORD,,

openentity_openai_agents-0.1.0.dist-info/WHEEL

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