siliconbridge 0.2.0__tar.gz

siliconbridge-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SiliconBridge
+
+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.

siliconbridge-0.2.0/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: siliconbridge
+Version: 0.2.0
+Summary: Python SDK for SiliconBridge — Human-in-the-loop API for AI agents
+Home-page: https://siliconbridge.xyz
+Author: SiliconBridge
+Author-email: SiliconBridge <xsiliconbridgex@gmail.com>
+License: MIT
+Project-URL: Homepage, https://siliconbridge.xyz
+Project-URL: Source, https://github.com/aataqi-boop/siliconbridge-python
+Keywords: ai,agents,human-in-the-loop,captcha,verification
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# SiliconBridge Python SDK
+
+Infrastructure for autonomous AI agents. Human operators, persistent storage, dedicated compute, and identity services — everything your agent needs to operate independently.
+
+**First $10 free. No credit card required.**
+
+## Install
+
+```bash
+pip install siliconbridge
+```
+
+## Quick Start
+
+```python
+from siliconbridge import SiliconBridge
+
+sb = SiliconBridge(api_key="sb_your_key_here")
+
+# Get a human to solve a CAPTCHA
+solution = sb.solve_captcha("https://example.com/captcha.png")
+
+# Get human approval before a high-stakes action
+approved = sb.request_approval("Transfer $5,000 to vendor account")
+
+# Get a 2FA code relayed to your agent
+code = sb.request_otp("Gmail")
+
+# Request infrastructure (quote-based, $10 deposit)
+quote = sb.request_quote("compute", "4 CPU, 8GB RAM, 1 week, Ubuntu 22.04")
+```
+
+## Human Operator Services (Fixed Pricing)
+
+```python
+# 2FA / OTP Relay — $1.50
+code = sb.request_otp("Stripe Dashboard")
+
+# Human Approval Gate — $3.00
+approved = sb.request_approval(
+    action="Delete all staging data",
+    context="Agent is cleaning up test environment"
+)
+
+# Phone Verification — $1.50
+result = sb.request_phone_verification("+1234567890")
+
+# CAPTCHA Solving — $1.00
+solution = sb.solve_captcha("https://example.com/captcha.png")
+
+# KYC Verification — $10.00
+result = sb.verify_identity(document_url="https://...")
+
+# Content Moderation — $3.00
+result = sb.moderate_content("User post text here...", guidelines="No spam")
+
+# Custom Task — $5.00
+result = sb.custom_task("Call this number and confirm the appointment")
+```
+
+## Infrastructure Services (Quote-Based)
+
+All infrastructure services require a $10 non-refundable deposit. You'll receive a quote within 1 hour at our cost + 30% margin. You can accept or decline.
+
+```python
+# Request a quote
+quote = sb.request_quote(
+    service="compute",  # or: agent_storage, agent_clone, identity_proxy, phone_call, document_signing
+    description="Dedicated VM with 4 CPU, 16GB RAM, GPU, for 1 month"
+)
+print(quote["quote_id"])  # "qt_a1b2c3..."
+
+# Check quote status
+status = sb.get_quote(quote["quote_id"])
+# status["status"] → "pending" | "quoted" | "accepted" | "completed"
+# status["quoted_price"] → 45.50 (when quoted)
+
+# Accept the quote (charges remaining balance after deposit)
+result = sb.accept_quote(quote["quote_id"])
+
+# List all your quotes
+all_quotes = sb.list_quotes()
+```
+
+### Available Infrastructure Services
+
+| Service | Description |
+|---------|-------------|
+| `agent_storage` | Persistent memory, config, and state storage |
+| `agent_clone` | Duplicate your agent from a snapshot |
+| `compute` | Dedicated VM or container with root access |
+| `identity_proxy` | Human creates accounts and passes verification for you |
+| `phone_call` | Human makes/receives calls on your behalf |
+| `document_signing` | Human signs legal documents where AI signatures aren't accepted |
+
+## Non-Blocking Mode
+
+```python
+# Submit without waiting
+task = sb.solve_captcha("https://...", wait=False)
+
+# Do other work...
+
+# Check later
+result = sb.wait_for_result(task["task_id"], timeout=300)
+```
+
+## Webhook Callbacks
+
+```python
+task = sb.submit_task(
+    "otp",
+    {"service_name": "Gmail"},
+    callback_url="https://your-server.com/webhook"
+)
+# Your webhook receives: {"task_id": "...", "status": "completed", "result": {...}}
+```
+
+## Error Handling
+
+```python
+from siliconbridge import SiliconBridge, SiliconBridgeError, TaskTimeout
+
+try:
+    result = sb.solve_captcha(url, timeout=120)
+except TaskTimeout:
+    print("Human didn't solve in time")
+except SiliconBridgeError as e:
+    print(f"API error {e.status_code}: {e.detail}")
+```
+
+## Get an API Key
+
+```python
+# Or just sign up at siliconbridge.xyz
+import httpx
+r = httpx.get("https://siliconbridge.xyz/api/signup?email=agent@example.com")
+print(r.json()["api_key"])  # sb_live_...
+# Comes with $10 free credits
+```
+
+## Pay with Crypto
+
+We accept BTC and USDC — no accounts, no KYC, no middlemen.
+
+- **BTC:** `bc1qqtu8f09hqncxug75vw3s4wjnsx6858ldrk4cvm`
+- **USDC (Base/ETH):** `0x1141b577584440013c722215cf2e98779BddAa55`
+
+## Links
+
+- Website: [siliconbridge.xyz](https://siliconbridge.xyz)
+- API Docs: [siliconbridge.xyz/.well-known/llms.txt](https://siliconbridge.xyz/.well-known/llms.txt)
+- MCP Server: [siliconbridge.xyz/mcp](https://siliconbridge.xyz/mcp)

siliconbridge-0.2.0/README.md

@@ -0,0 +1,153 @@
+# SiliconBridge Python SDK
+
+Infrastructure for autonomous AI agents. Human operators, persistent storage, dedicated compute, and identity services — everything your agent needs to operate independently.
+
+**First $10 free. No credit card required.**
+
+## Install
+
+```bash
+pip install siliconbridge
+```
+
+## Quick Start
+
+```python
+from siliconbridge import SiliconBridge
+
+sb = SiliconBridge(api_key="sb_your_key_here")
+
+# Get a human to solve a CAPTCHA
+solution = sb.solve_captcha("https://example.com/captcha.png")
+
+# Get human approval before a high-stakes action
+approved = sb.request_approval("Transfer $5,000 to vendor account")
+
+# Get a 2FA code relayed to your agent
+code = sb.request_otp("Gmail")
+
+# Request infrastructure (quote-based, $10 deposit)
+quote = sb.request_quote("compute", "4 CPU, 8GB RAM, 1 week, Ubuntu 22.04")
+```
+
+## Human Operator Services (Fixed Pricing)
+
+```python
+# 2FA / OTP Relay — $1.50
+code = sb.request_otp("Stripe Dashboard")
+
+# Human Approval Gate — $3.00
+approved = sb.request_approval(
+    action="Delete all staging data",
+    context="Agent is cleaning up test environment"
+)
+
+# Phone Verification — $1.50
+result = sb.request_phone_verification("+1234567890")
+
+# CAPTCHA Solving — $1.00
+solution = sb.solve_captcha("https://example.com/captcha.png")
+
+# KYC Verification — $10.00
+result = sb.verify_identity(document_url="https://...")
+
+# Content Moderation — $3.00
+result = sb.moderate_content("User post text here...", guidelines="No spam")
+
+# Custom Task — $5.00
+result = sb.custom_task("Call this number and confirm the appointment")
+```
+
+## Infrastructure Services (Quote-Based)
+
+All infrastructure services require a $10 non-refundable deposit. You'll receive a quote within 1 hour at our cost + 30% margin. You can accept or decline.
+
+```python
+# Request a quote
+quote = sb.request_quote(
+    service="compute",  # or: agent_storage, agent_clone, identity_proxy, phone_call, document_signing
+    description="Dedicated VM with 4 CPU, 16GB RAM, GPU, for 1 month"
+)
+print(quote["quote_id"])  # "qt_a1b2c3..."
+
+# Check quote status
+status = sb.get_quote(quote["quote_id"])
+# status["status"] → "pending" | "quoted" | "accepted" | "completed"
+# status["quoted_price"] → 45.50 (when quoted)
+
+# Accept the quote (charges remaining balance after deposit)
+result = sb.accept_quote(quote["quote_id"])
+
+# List all your quotes
+all_quotes = sb.list_quotes()
+```
+
+### Available Infrastructure Services
+
+| Service | Description |
+|---------|-------------|
+| `agent_storage` | Persistent memory, config, and state storage |
+| `agent_clone` | Duplicate your agent from a snapshot |
+| `compute` | Dedicated VM or container with root access |
+| `identity_proxy` | Human creates accounts and passes verification for you |
+| `phone_call` | Human makes/receives calls on your behalf |
+| `document_signing` | Human signs legal documents where AI signatures aren't accepted |
+
+## Non-Blocking Mode
+
+```python
+# Submit without waiting
+task = sb.solve_captcha("https://...", wait=False)
+
+# Do other work...
+
+# Check later
+result = sb.wait_for_result(task["task_id"], timeout=300)
+```
+
+## Webhook Callbacks
+
+```python
+task = sb.submit_task(
+    "otp",
+    {"service_name": "Gmail"},
+    callback_url="https://your-server.com/webhook"
+)
+# Your webhook receives: {"task_id": "...", "status": "completed", "result": {...}}
+```
+
+## Error Handling
+
+```python
+from siliconbridge import SiliconBridge, SiliconBridgeError, TaskTimeout
+
+try:
+    result = sb.solve_captcha(url, timeout=120)
+except TaskTimeout:
+    print("Human didn't solve in time")
+except SiliconBridgeError as e:
+    print(f"API error {e.status_code}: {e.detail}")
+```
+
+## Get an API Key
+
+```python
+# Or just sign up at siliconbridge.xyz
+import httpx
+r = httpx.get("https://siliconbridge.xyz/api/signup?email=agent@example.com")
+print(r.json()["api_key"])  # sb_live_...
+# Comes with $10 free credits
+```
+
+## Pay with Crypto
+
+We accept BTC and USDC — no accounts, no KYC, no middlemen.
+
+- **BTC:** `bc1qqtu8f09hqncxug75vw3s4wjnsx6858ldrk4cvm`
+- **USDC (Base/ETH):** `0x1141b577584440013c722215cf2e98779BddAa55`
+
+## Links
+
+- Website: [siliconbridge.xyz](https://siliconbridge.xyz)
+- API Docs: [siliconbridge.xyz/.well-known/llms.txt](https://siliconbridge.xyz/.well-known/llms.txt)
+- MCP Server: [siliconbridge.xyz/mcp](https://siliconbridge.xyz/mcp)

siliconbridge-0.2.0/integrations/__init__.py

@@ -0,0 +1,6 @@
+"""SiliconBridge integrations for browser automation frameworks."""
+
+from .selenium_bridge import SeleniumBridge
+from .playwright_bridge import PlaywrightBridge, AsyncPlaywrightBridge
+
+__all__ = ["SeleniumBridge", "PlaywrightBridge", "AsyncPlaywrightBridge"]

siliconbridge-0.2.0/integrations/crewai_tool.py

@@ -0,0 +1,99 @@
+"""SiliconBridge tools for CrewAI agents."""
+
+import time
+import httpx
+from typing import Type
+from pydantic import BaseModel, Field
+from crewai.tools import BaseTool
+
+
+SILICONBRIDGE_BASE_URL = "https://siliconbridge.xyz"
+
+
+def _submit_and_wait(api_key: str, service_type: str, payload: dict, timeout: int = 300) -> str:
+    headers = {"X-API-Key": api_key, "Content-Type": "application/json"}
+    with httpx.Client(timeout=30.0) as client:
+        r = client.post(
+            f"{SILICONBRIDGE_BASE_URL}/tasks/submit",
+            headers=headers,
+            json={"service_type": service_type, "payload": payload},
+        )
+        r.raise_for_status()
+        task_id = r.json()["task_id"]
+
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            r = client.get(f"{SILICONBRIDGE_BASE_URL}/tasks/{task_id}", headers=headers)
+            r.raise_for_status()
+            data = r.json()
+            if data["status"] == "completed":
+                return str(data.get("result", {}).get("solution", data.get("result", "")))
+            if data["status"] == "failed":
+                return f"Task failed: {data.get('result', 'unknown error')}"
+            time.sleep(5)
+        return f"Task {task_id} timed out after {timeout}s"
+
+
+class CaptchaSolveInput(BaseModel):
+    image_url: str = Field(description="URL of the CAPTCHA image")
+
+
+class SiliconBridgeCaptchaSolver(BaseTool):
+    name: str = "SiliconBridge CAPTCHA Solver"
+    description: str = (
+        "Solves CAPTCHAs by sending them to a real human operator. "
+        "Use when you encounter a CAPTCHA blocking your progress."
+    )
+    args_schema: Type[BaseModel] = CaptchaSolveInput
+    api_key: str = ""
+
+    def _run(self, image_url: str) -> str:
+        return _submit_and_wait(self.api_key, "captcha_solve", {"image_url": image_url})
+
+
+class CustomTaskInput(BaseModel):
+    instructions: str = Field(description="What the human operator should do")
+
+
+class SiliconBridgeHumanTask(BaseTool):
+    name: str = "SiliconBridge Human Task"
+    description: str = (
+        "Sends any task to a real human operator. "
+        "Use when you need human help: reading handwriting, verifying info, making judgment calls."
+    )
+    args_schema: Type[BaseModel] = CustomTaskInput
+    api_key: str = ""
+
+    def _run(self, instructions: str) -> str:
+        return _submit_and_wait(self.api_key, "custom", {"instructions": instructions})
+
+
+class ContentModerateInput(BaseModel):
+    content: str = Field(description="Content to moderate")
+    guidelines: str = Field(default="Flag hate speech, spam, or adult content")
+
+
+class SiliconBridgeModerator(BaseTool):
+    name: str = "SiliconBridge Content Moderator"
+    description: str = "Sends content to a human moderator for review."
+    args_schema: Type[BaseModel] = ContentModerateInput
+    api_key: str = ""
+
+    def _run(self, content: str, guidelines: str = "Flag hate speech, spam, or adult content") -> str:
+        return _submit_and_wait(self.api_key, "content_moderate", {"content": content, "guidelines": guidelines})
+
+
+def get_siliconbridge_tools(api_key: str) -> list:
+    """
+    Returns all SiliconBridge tools for CrewAI.
+
+    Usage:
+        from siliconbridge.integrations.crewai_tool import get_siliconbridge_tools
+        tools = get_siliconbridge_tools("sb_your_key")
+        agent = Agent(tools=tools, ...)
+    """
+    return [
+        SiliconBridgeCaptchaSolver(api_key=api_key),
+        SiliconBridgeHumanTask(api_key=api_key),
+        SiliconBridgeModerator(api_key=api_key),
+    ]

siliconbridge-0.2.0/integrations/langchain_tool.py

@@ -0,0 +1,175 @@
+"""SiliconBridge tools for LangChain agents."""
+
+from typing import Optional, Type
+from pydantic import BaseModel, Field
+from langchain.tools import BaseTool
+import httpx
+
+
+SILICONBRIDGE_BASE_URL = "https://siliconbridge.xyz"
+
+
+class _SiliconBridgeBase:
+    """Shared logic for all SiliconBridge tools."""
+
+    def _submit_and_wait(self, api_key: str, service_type: str, payload: dict, timeout: int = 300) -> str:
+        headers = {"X-API-Key": api_key, "Content-Type": "application/json"}
+        with httpx.Client(timeout=30.0) as client:
+            # Submit
+            r = client.post(
+                f"{SILICONBRIDGE_BASE_URL}/tasks/submit",
+                headers=headers,
+                json={"service_type": service_type, "payload": payload},
+            )
+            r.raise_for_status()
+            task_id = r.json()["task_id"]
+
+            # Poll
+            import time
+            deadline = time.time() + timeout
+            while time.time() < deadline:
+                r = client.get(f"{SILICONBRIDGE_BASE_URL}/tasks/{task_id}", headers=headers)
+                r.raise_for_status()
+                data = r.json()
+                if data["status"] == "completed":
+                    return str(data.get("result", {}).get("solution", data.get("result", "")))
+                if data["status"] == "failed":
+                    return f"Task failed: {data.get('result', 'unknown error')}"
+                time.sleep(5)
+            return f"Task {task_id} timed out after {timeout}s"
+
+
+# ── CAPTCHA Solver ────────────────────────────────────────────────
+
+class CaptchaSolveInput(BaseModel):
+    image_url: str = Field(description="URL of the CAPTCHA image to solve")
+    instructions: str = Field(default="Solve this CAPTCHA", description="Optional instructions for the human operator")
+
+
+class SiliconBridgeCaptchaSolver(BaseTool, _SiliconBridgeBase):
+    """Tool that submits a CAPTCHA to a real human operator and returns the solution."""
+
+    name: str = "siliconbridge_captcha_solver"
+    description: str = (
+        "Solves CAPTCHAs by sending them to a real human operator. "
+        "Use this when you encounter a CAPTCHA that blocks your progress. "
+        "Input: the URL of the CAPTCHA image. Output: the solved text."
+    )
+    args_schema: Type[BaseModel] = CaptchaSolveInput
+    api_key: str = ""
+
+    def _run(self, image_url: str, instructions: str = "Solve this CAPTCHA") -> str:
+        return self._submit_and_wait(
+            self.api_key, "captcha_solve",
+            {"image_url": image_url, "instructions": instructions},
+        )
+
+    async def _arun(self, image_url: str, instructions: str = "Solve this CAPTCHA") -> str:
+        return self._run(image_url, instructions)
+
+
+# ── Content Moderator ─────────────────────────────────────────────
+
+class ContentModerateInput(BaseModel):
+    content: str = Field(description="The content to be moderated")
+    guidelines: str = Field(default="Flag hate speech, spam, or adult content", description="Moderation guidelines")
+
+
+class SiliconBridgeContentModerator(BaseTool, _SiliconBridgeBase):
+    """Tool that sends content to a human moderator for review."""
+
+    name: str = "siliconbridge_content_moderator"
+    description: str = (
+        "Sends content to a real human moderator for review. "
+        "Use when you need a human judgment call on whether content is appropriate. "
+        "Input: the content text and moderation guidelines. Output: the moderation decision."
+    )
+    args_schema: Type[BaseModel] = ContentModerateInput
+    api_key: str = ""
+
+    def _run(self, content: str, guidelines: str = "Flag hate speech, spam, or adult content") -> str:
+        return self._submit_and_wait(
+            self.api_key, "content_moderate",
+            {"content": content, "guidelines": guidelines},
+        )
+
+    async def _arun(self, content: str, guidelines: str = "Flag hate speech, spam, or adult content") -> str:
+        return self._run(content, guidelines)
+
+
+# ── Identity Verifier ─────────────────────────────────────────────
+
+class IdentityVerifyInput(BaseModel):
+    document_url: str = Field(description="URL of the identity document image")
+    selfie_url: str = Field(default="", description="Optional URL of a selfie for comparison")
+
+
+class SiliconBridgeIdentityVerifier(BaseTool, _SiliconBridgeBase):
+    """Tool that sends identity documents to a human for verification."""
+
+    name: str = "siliconbridge_identity_verifier"
+    description: str = (
+        "Sends identity documents to a real human for verification. "
+        "Use when your workflow requires ID verification. "
+        "Input: URL of the ID document (and optional selfie). Output: verification result."
+    )
+    args_schema: Type[BaseModel] = IdentityVerifyInput
+    api_key: str = ""
+
+    def _run(self, document_url: str, selfie_url: str = "") -> str:
+        payload = {"document_url": document_url, "instructions": "Verify this identity document"}
+        if selfie_url:
+            payload["selfie_url"] = selfie_url
+        return self._submit_and_wait(self.api_key, "identity_verify", payload, timeout=600)
+
+    async def _arun(self, document_url: str, selfie_url: str = "") -> str:
+        return self._run(document_url, selfie_url)
+
+
+# ── Custom Task ───────────────────────────────────────────────────
+
+class CustomTaskInput(BaseModel):
+    instructions: str = Field(description="What the human operator should do")
+    image_url: str = Field(default="", description="Optional image URL for context")
+
+
+class SiliconBridgeCustomTask(BaseTool, _SiliconBridgeBase):
+    """Tool that sends a custom task to a human operator."""
+
+    name: str = "siliconbridge_custom_task"
+    description: str = (
+        "Sends any task to a real human operator. "
+        "Use when you need human help with something an AI can't do: "
+        "reading handwriting, verifying real-world information, making judgment calls. "
+        "Input: instructions for the human. Output: their response."
+    )
+    args_schema: Type[BaseModel] = CustomTaskInput
+    api_key: str = ""
+
+    def _run(self, instructions: str, image_url: str = "") -> str:
+        payload = {"instructions": instructions}
+        if image_url:
+            payload["image_url"] = image_url
+        return self._submit_and_wait(self.api_key, "custom", payload)
+
+    async def _arun(self, instructions: str, image_url: str = "") -> str:
+        return self._run(instructions, image_url)
+
+
+# ── Helper to get all tools ──────────────────────────────────────
+
+def get_siliconbridge_tools(api_key: str) -> list:
+    """
+    Returns all SiliconBridge tools configured with your API key.
+
+    Usage:
+        from siliconbridge.integrations.langchain_tool import get_siliconbridge_tools
+        tools = get_siliconbridge_tools("sb_your_key")
+        agent = initialize_agent(tools=tools, ...)
+    """
+    return [
+        SiliconBridgeCaptchaSolver(api_key=api_key),
+        SiliconBridgeContentModerator(api_key=api_key),
+        SiliconBridgeIdentityVerifier(api_key=api_key),
+        SiliconBridgeCustomTask(api_key=api_key),
+    ]