zambo-openai-agents 0.1.0__tar.gz

zambo_openai_agents-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zambo (zambo.dev)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zambo_openai_agents-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: zambo-openai-agents
+Version: 0.1.0
+Summary: Zambo's 100+ tools as OpenAI Agents SDK tools. Every call mints a verifiable AER-1 execution receipt.
+Author-email: Zambo <brennanzambo@zambo.dev>
+License: MIT
+Project-URL: Homepage, https://zambo.dev
+Project-URL: Documentation, https://zambo.dev/aer-1/
+Project-URL: Repository, https://zambo.dev
+Keywords: openai,agents,ai-agents,zambo,mcp,receipts,verification,tracing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai-agents>=0.20
+Dynamic: license-file
+
+# zambo-openai-agents
+
+Give your OpenAI Agents SDK agent Zambo's 100+ live tools. Every tool call is executed by Zambo and mints a **verifiable AER-1 receipt**: a public URL carrying the tool, its arguments, the observed result, a SHA-256 fingerprint, and machine-readable JSON-LD.
+
+```python
+from agents import Agent, Runner
+from zambo_openai_agents import zambo_tools
+
+agent = Agent(name="assistant", tools=zambo_tools(["live_price", "prompt_shield"]))
+result = await Runner.run(agent, "What is the live BTC price?")
+```
+
+No account. No API key. Free tier: 20 calls per tool per day.
+
+## What the receipt actually proves
+
+Each receipt page (for example `https://zambo.dev/run/<id>`) is Zambo's tamper-evident record that **Zambo executed the tool call itself**: the tool name, the exact arguments your agent sent, the observed result, a timestamp, and a SHA-256 fingerprint of the record, published as JSON-LD. Anyone can re-verify it with no account.
+
+The included `ZamboReceiptProcessor` (a standard `TracingProcessor`) attaches each minted receipt URL to its trace span, so the trace shows proof next to every call:
+
+```python
+from agents.tracing.setup import get_trace_provider
+from zambo_openai_agents import ZamboReceiptProcessor
+
+processor = ZamboReceiptProcessor()
+get_trace_provider().register_processor(processor)
+# after the run: processor.receipts -> {span_id: receipt_url}
+```
+
+## Install
+
+```bash
+pip install zambo-openai-agents
+```
+
+## One tool, custom schema
+
+```python
+from zambo_openai_agents import zambo_tool
+
+price_tool = zambo_tool(
+    "live_price",
+    params_json_schema={
+        "type": "object",
+        "properties": {"symbol": {"type": "string"}},
+        "required": ["symbol"],
+    },
+)
+```
+
+Browse the full catalog any time with `zambo_openai_agents.list_tools()`, or pick tools by use case through Zambo's `capability_search` tool.
+
+## Notes
+
+- Zambo calls need no key and no signup. Heavy tracing (dozens of tool calls per run) will reach the free daily limit; the tool raises a clear error and the agent run continues with the other tools.
+- The processor never breaks your run: span handling is fully exception-guarded, and it ignores non-Zambo spans.
+- Receipts are public by design. Do not pass secrets as tool arguments.
+
+## Links
+
+- Zambo: https://zambo.dev
+- AER-1 receipt spec: https://zambo.dev/aer-1/
+- OpenAI Agents SDK tracing: https://openai.github.io/openai-agents-python/tracing/
+
+MIT License.

zambo_openai_agents-0.1.0/README.md

@@ -0,0 +1,65 @@
+# zambo-openai-agents
+
+Give your OpenAI Agents SDK agent Zambo's 100+ live tools. Every tool call is executed by Zambo and mints a **verifiable AER-1 receipt**: a public URL carrying the tool, its arguments, the observed result, a SHA-256 fingerprint, and machine-readable JSON-LD.
+
+```python
+from agents import Agent, Runner
+from zambo_openai_agents import zambo_tools
+
+agent = Agent(name="assistant", tools=zambo_tools(["live_price", "prompt_shield"]))
+result = await Runner.run(agent, "What is the live BTC price?")
+```
+
+No account. No API key. Free tier: 20 calls per tool per day.
+
+## What the receipt actually proves
+
+Each receipt page (for example `https://zambo.dev/run/<id>`) is Zambo's tamper-evident record that **Zambo executed the tool call itself**: the tool name, the exact arguments your agent sent, the observed result, a timestamp, and a SHA-256 fingerprint of the record, published as JSON-LD. Anyone can re-verify it with no account.
+
+The included `ZamboReceiptProcessor` (a standard `TracingProcessor`) attaches each minted receipt URL to its trace span, so the trace shows proof next to every call:
+
+```python
+from agents.tracing.setup import get_trace_provider
+from zambo_openai_agents import ZamboReceiptProcessor
+
+processor = ZamboReceiptProcessor()
+get_trace_provider().register_processor(processor)
+# after the run: processor.receipts -> {span_id: receipt_url}
+```
+
+## Install
+
+```bash
+pip install zambo-openai-agents
+```
+
+## One tool, custom schema
+
+```python
+from zambo_openai_agents import zambo_tool
+
+price_tool = zambo_tool(
+    "live_price",
+    params_json_schema={
+        "type": "object",
+        "properties": {"symbol": {"type": "string"}},
+        "required": ["symbol"],
+    },
+)
+```
+
+Browse the full catalog any time with `zambo_openai_agents.list_tools()`, or pick tools by use case through Zambo's `capability_search` tool.
+
+## Notes
+
+- Zambo calls need no key and no signup. Heavy tracing (dozens of tool calls per run) will reach the free daily limit; the tool raises a clear error and the agent run continues with the other tools.
+- The processor never breaks your run: span handling is fully exception-guarded, and it ignores non-Zambo spans.
+- Receipts are public by design. Do not pass secrets as tool arguments.
+
+## Links
+
+- Zambo: https://zambo.dev
+- AER-1 receipt spec: https://zambo.dev/aer-1/
+- OpenAI Agents SDK tracing: https://openai.github.io/openai-agents-python/tracing/
+
+MIT License.

zambo_openai_agents-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zambo-openai-agents"
+version = "0.1.0"
+description = "Zambo's 100+ tools as OpenAI Agents SDK tools. Every call mints a verifiable AER-1 execution receipt."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Zambo", email = "brennanzambo@zambo.dev" }]
+keywords = ["openai", "agents", "ai-agents", "zambo", "mcp", "receipts", "verification", "tracing"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "openai-agents>=0.20",
+]
+optional-dependencies = {}
+
+[project.urls]
+Homepage = "https://zambo.dev"
+Documentation = "https://zambo.dev/aer-1/"
+Repository = "https://zambo.dev"
+
+[tool.setuptools.packages.find]
+where = ["src"]

zambo_openai_agents-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zambo_openai_agents-0.1.0/src/zambo_openai_agents/__init__.py

@@ -0,0 +1,23 @@
+"""zambo-openai-agents: Zambo's 100+ tools as OpenAI Agents SDK tools.
+
+Every tool call is executed by Zambo and mints a verifiable AER-1 receipt:
+a public URL carrying the tool, arguments, observed result, SHA-256
+fingerprint, and machine-readable JSON-LD.
+"""
+
+from .tools import lookup_receipt, zambo_tool, zambo_tools
+from .tracing import ZamboReceiptProcessor
+from .client import ZamboReceipt, ZamboResult, call_tool, list_tools
+
+__all__ = [
+    "ZamboReceipt",
+    "ZamboReceiptProcessor",
+    "ZamboResult",
+    "call_tool",
+    "list_tools",
+    "lookup_receipt",
+    "zambo_tool",
+    "zambo_tools",
+]
+
+__version__ = "0.1.0"

zambo_openai_agents-0.1.0/src/zambo_openai_agents/client.py

@@ -0,0 +1,109 @@
+"""Minimal Zambo MCP client over plain JSON-RPC.
+
+Pure stdlib (urllib), no third-party dependencies. Talks to the live
+https://zambo.dev/api/mcp endpoint: no auth, no account, free tier.
+"""
+
+from __future__ import annotations
+
+import json
+import http.client
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+
+MCP_URL = "https://zambo.dev/api/mcp"
+_TIMEOUT = 60
+_MAX_ATTEMPTS = 6
+
+
+@dataclass
+class ZamboReceipt:
+    """A verifiable AER-1 execution receipt minted by a Zambo tool call."""
+
+    id: str
+    url: str
+    status: str = ""
+    tool: str = ""
+
+
+@dataclass
+class ZamboResult:
+    text: str
+    receipt: ZamboReceipt | None = None
+    raw: dict = field(default_factory=dict)
+
+
+def _post(payload: dict) -> dict:
+    body = json.dumps(payload).encode("utf-8")
+    last_error: Exception | None = None
+    for attempt in range(_MAX_ATTEMPTS):
+        request = urllib.request.Request(
+            MCP_URL,
+            data=body,
+            headers={"Content-Type": "application/json", "Accept": "application/json"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=_TIMEOUT) as response:
+                return json.loads(response.read().decode("utf-8"))
+        except (
+            urllib.error.URLError,
+            ConnectionError,
+            TimeoutError,
+            json.JSONDecodeError,
+            http.client.IncompleteRead,
+            http.client.RemoteDisconnected,
+            http.client.BadStatusLine,
+        ) as exc:
+            last_error = exc
+            time.sleep(1.5 * (attempt + 1))
+    raise RuntimeError(f"Zambo API call failed after {_MAX_ATTEMPTS} attempts: {last_error}")
+
+
+def call_tool(tool_name: str, arguments: dict) -> ZamboResult:
+    """Call a Zambo MCP tool and return its result plus the receipt.
+
+    Every call mints a verifiable AER-1 receipt: a public URL carrying the
+    tool, arguments, observed result, SHA-256 fingerprint, and JSON-LD.
+    """
+    response = _post(
+        {
+            "jsonrpc": "2.0",
+            "id": f"zambo-openai-agents-{int(time.time() * 1000)}",
+            "method": "tools/call",
+            "params": {"name": tool_name, "arguments": arguments},
+        }
+    )
+    if "error" in response:
+        raise RuntimeError(f"Zambo tool '{tool_name}' error: {response['error']}")
+
+    result = response.get("result", {})
+    receipt_data = result.get("_receipt", {}) or {}
+
+    receipt = None
+    receipt_id = receipt_data.get("id")
+    if receipt_id:
+        receipt = ZamboReceipt(
+            id=receipt_id,
+            url=receipt_data.get("audit") or f"https://zambo.dev/run/{receipt_id}",
+            status=receipt_data.get("status", ""),
+            tool=receipt_data.get("tool", tool_name),
+        )
+
+    text_parts = []
+    for item in result.get("content", []) or []:
+        if isinstance(item, dict) and "text" in item:
+            text_parts.append(str(item["text"]))
+    text = "\n".join(text_parts).strip()
+
+    return ZamboResult(text=text, receipt=receipt, raw=result)
+
+
+def list_tools() -> list[dict]:
+    """Return the live Zambo tool catalog (name + description)."""
+    response = _post({"jsonrpc": "2.0", "id": "zambo-tools-list", "method": "tools/list", "params": {}})
+    if "error" in response:
+        raise RuntimeError(f"Zambo tools/list error: {response['error']}")
+    return response.get("result", {}).get("tools", []) or []

zambo_openai_agents-0.1.0/src/zambo_openai_agents/tools.py

@@ -0,0 +1,94 @@
+"""OpenAI Agents SDK function tools backed by live Zambo execution.
+
+Each tool below is a real OpenAI Agents SDK FunctionTool. When the agent
+invokes it, the call is executed by Zambo (https://zambo.dev/api/mcp) and
+mints a verifiable AER-1 receipt: public URL, tool, arguments, observed
+result, SHA-256 fingerprint, machine-readable JSON-LD.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import threading
+import time
+from typing import Any, Callable
+
+from . import client as _client
+
+# (tool_name, arguments_json) -> (receipt_url, finished_at). Written by the
+# tool wrapper on every invocation; read by ZamboReceiptProcessor to attach
+# receipt URLs to trace spans. Thread-safe.
+_invocation_registry: dict[tuple[str, str], tuple[str, float]] = {}
+_registry_lock = threading.Lock()
+
+
+def _record_invocation(tool_name: str, arguments_json: str, receipt_url: str) -> None:
+    with _registry_lock:
+        _invocation_registry[(tool_name, arguments_json)] = (receipt_url, time.time())
+
+
+def lookup_receipt(tool_name: str, arguments_json: str) -> str | None:
+    """Return the most recent receipt URL for a (tool, args) invocation."""
+    with _registry_lock:
+        entry = _invocation_registry.get((tool_name, arguments_json))
+    return entry[0] if entry else None
+
+
+def zambo_tool(
+    tool_name: str,
+    description: str | None = None,
+    params_json_schema: dict | None = None,
+    on_receipt: Callable[[str, str], Any] | None = None,
+):
+    """Build an OpenAI Agents SDK FunctionTool backed by a Zambo MCP tool.
+
+    Args:
+        tool_name: Name of the Zambo tool (see client.list_tools(), e.g.
+            "live_price", "ghost_audit_site", "prompt_shield").
+        description: Override the tool description shown to the model.
+        params_json_schema: Override the JSON schema for the tool's arguments.
+            Defaults to a permissive object schema; Zambo validates server-side.
+        on_receipt: Optional callback invoked as on_receipt(tool_name,
+            receipt_url) after every successful invocation.
+    """
+    from agents.tool import FunctionTool  # local import: agents is a dependency
+
+    # Permissive default: strict-mode compatible (no additionalProperties key).
+    # Zambo validates arguments server-side.
+    schema = params_json_schema or {"type": "object", "properties": {}}
+
+    async def _on_invoke_tool(context: Any, arguments_json: str) -> str:
+        try:
+            arguments = json.loads(arguments_json) if arguments_json else {}
+        except json.JSONDecodeError:
+            arguments = {}
+        if not isinstance(arguments, dict):
+            arguments = {"value": arguments}
+
+        result = await asyncio.to_thread(_client.call_tool, tool_name, arguments)
+
+        receipt_url = result.receipt.url if result.receipt else ""
+        if receipt_url:
+            _record_invocation(tool_name, arguments_json, receipt_url)
+            if on_receipt is not None:
+                maybe = on_receipt(tool_name, receipt_url)
+                if asyncio.iscoroutine(maybe):
+                    await maybe
+
+        output = result.text or "(empty result)"
+        if receipt_url:
+            output += f"\n\nVerifiable receipt: {receipt_url}"
+        return output
+
+    return FunctionTool(
+        name=tool_name,
+        description=description or f"Zambo tool '{tool_name}' (zambo.dev). Every call mints a verifiable execution receipt.",
+        params_json_schema=schema,
+        on_invoke_tool=_on_invoke_tool,
+    )
+
+
+def zambo_tools(tool_names: list[str], **kwargs: Any) -> list:
+    """Build several Zambo-backed FunctionTools at once."""
+    return [zambo_tool(name, **kwargs) for name in tool_names]

zambo_openai_agents-0.1.0/src/zambo_openai_agents/tracing.py

@@ -0,0 +1,85 @@
+"""TraceProcessor that attaches Zambo receipt URLs to agent trace spans.
+
+Register it once and every Zambo-backed tool call in the trace carries its
+verifiable receipt URL next to the span:
+
+    from agents.tracing import get_trace_provider  # via agents.tracing.setup
+    from zambo_openai_agents import ZamboReceiptProcessor
+
+    processor = ZamboReceiptProcessor()
+    get_trace_provider().register_processor(processor)
+"""
+
+from __future__ import annotations
+
+import threading
+from typing import Any, Callable
+
+from agents.tracing.processors import TracingProcessor
+
+from .tools import lookup_receipt
+
+
+class ZamboReceiptProcessor(TracingProcessor):
+    """Maps finished function spans to the Zambo receipt each call minted.
+
+    Only spans produced by tools built with zambo_openai_agents.zambo_tool
+    (or zambo_tools) resolve to a receipt URL; every other span type is
+    ignored. All methods are thread-safe and never raise into the agent run.
+    """
+
+    def __init__(self, on_receipt: Callable[[str, str, str], Any] | None = None):
+        """
+        Args:
+            on_receipt: Optional callback invoked as
+                on_receipt(span_id, tool_name, receipt_url) whenever a Zambo
+                tool span resolves to a receipt.
+        """
+        self._on_receipt = on_receipt
+        self._receipts: dict[str, str] = {}
+        self._lock = threading.Lock()
+
+    @property
+    def receipts(self) -> dict[str, str]:
+        """span_id -> receipt URL for every resolved Zambo tool span."""
+        with self._lock:
+            return dict(self._receipts)
+
+    def receipt_for_span(self, span_id: str) -> str | None:
+        with self._lock:
+            return self._receipts.get(span_id)
+
+    # -- TracingProcessor interface -------------------------------------
+    def on_trace_start(self, trace: Any) -> None:
+        return None
+
+    def on_trace_end(self, trace: Any) -> None:
+        return None
+
+    def on_span_start(self, span: Any) -> None:
+        return None
+
+    def on_span_end(self, span: Any) -> None:
+        try:
+            span_data = getattr(span, "span_data", None)
+            if span_data is None or getattr(span_data, "type", None) != "function":
+                return
+            tool_name = getattr(span_data, "name", "") or ""
+            arguments_json = getattr(span_data, "input", "") or ""
+            receipt_url = lookup_receipt(tool_name, arguments_json)
+            if not receipt_url:
+                return
+            span_id = getattr(span, "span_id", "") or ""
+            with self._lock:
+                self._receipts[span_id] = receipt_url
+            if self._on_receipt is not None:
+                self._on_receipt(span_id, tool_name, receipt_url)
+        except Exception:
+            # Tracing must never break the agent run.
+            return None
+
+    def shutdown(self) -> None:
+        return None
+
+    def force_flush(self) -> None:
+        return None

zambo_openai_agents-0.1.0/src/zambo_openai_agents.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: zambo-openai-agents
+Version: 0.1.0
+Summary: Zambo's 100+ tools as OpenAI Agents SDK tools. Every call mints a verifiable AER-1 execution receipt.
+Author-email: Zambo <brennanzambo@zambo.dev>
+License: MIT
+Project-URL: Homepage, https://zambo.dev
+Project-URL: Documentation, https://zambo.dev/aer-1/
+Project-URL: Repository, https://zambo.dev
+Keywords: openai,agents,ai-agents,zambo,mcp,receipts,verification,tracing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai-agents>=0.20
+Dynamic: license-file
+
+# zambo-openai-agents
+
+Give your OpenAI Agents SDK agent Zambo's 100+ live tools. Every tool call is executed by Zambo and mints a **verifiable AER-1 receipt**: a public URL carrying the tool, its arguments, the observed result, a SHA-256 fingerprint, and machine-readable JSON-LD.
+
+```python
+from agents import Agent, Runner
+from zambo_openai_agents import zambo_tools
+
+agent = Agent(name="assistant", tools=zambo_tools(["live_price", "prompt_shield"]))
+result = await Runner.run(agent, "What is the live BTC price?")
+```
+
+No account. No API key. Free tier: 20 calls per tool per day.
+
+## What the receipt actually proves
+
+Each receipt page (for example `https://zambo.dev/run/<id>`) is Zambo's tamper-evident record that **Zambo executed the tool call itself**: the tool name, the exact arguments your agent sent, the observed result, a timestamp, and a SHA-256 fingerprint of the record, published as JSON-LD. Anyone can re-verify it with no account.
+
+The included `ZamboReceiptProcessor` (a standard `TracingProcessor`) attaches each minted receipt URL to its trace span, so the trace shows proof next to every call:
+
+```python
+from agents.tracing.setup import get_trace_provider
+from zambo_openai_agents import ZamboReceiptProcessor
+
+processor = ZamboReceiptProcessor()
+get_trace_provider().register_processor(processor)
+# after the run: processor.receipts -> {span_id: receipt_url}
+```
+
+## Install
+
+```bash
+pip install zambo-openai-agents
+```
+
+## One tool, custom schema
+
+```python
+from zambo_openai_agents import zambo_tool
+
+price_tool = zambo_tool(
+    "live_price",
+    params_json_schema={
+        "type": "object",
+        "properties": {"symbol": {"type": "string"}},
+        "required": ["symbol"],
+    },
+)
+```
+
+Browse the full catalog any time with `zambo_openai_agents.list_tools()`, or pick tools by use case through Zambo's `capability_search` tool.
+
+## Notes
+
+- Zambo calls need no key and no signup. Heavy tracing (dozens of tool calls per run) will reach the free daily limit; the tool raises a clear error and the agent run continues with the other tools.
+- The processor never breaks your run: span handling is fully exception-guarded, and it ignores non-Zambo spans.
+- Receipts are public by design. Do not pass secrets as tool arguments.
+
+## Links
+
+- Zambo: https://zambo.dev
+- AER-1 receipt spec: https://zambo.dev/aer-1/
+- OpenAI Agents SDK tracing: https://openai.github.io/openai-agents-python/tracing/
+
+MIT License.

zambo_openai_agents-0.1.0/src/zambo_openai_agents.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/zambo_openai_agents/__init__.py
+src/zambo_openai_agents/client.py
+src/zambo_openai_agents/tools.py
+src/zambo_openai_agents/tracing.py
+src/zambo_openai_agents.egg-info/PKG-INFO
+src/zambo_openai_agents.egg-info/SOURCES.txt
+src/zambo_openai_agents.egg-info/dependency_links.txt
+src/zambo_openai_agents.egg-info/requires.txt
+src/zambo_openai_agents.egg-info/top_level.txt

zambo_openai_agents-0.1.0/src/zambo_openai_agents.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zambo_openai_agents-0.1.0/src/zambo_openai_agents.egg-info/requires.txt

@@ -0,0 +1 @@
+openai-agents>=0.20

zambo_openai_agents-0.1.0/src/zambo_openai_agents.egg-info/top_level.txt

@@ -0,0 +1 @@
+zambo_openai_agents