कैसे कैपसॉल्वर को कॉम्पोसियो एआई ब्राउज़र स्वचालन के साथ एकीकृत करें

स्क्रिप्ट चलाएं
  -> ओपनएआई एजेंट सीडीके निर्णय लेता है कि कौन सा टूल कॉल करना है
  -> कॉम्पोसियो कस्टम टूल: complete_recaptcha_v2
       -> प्लेयराइट पेज खोलता है
       -> capsolver.solve(...) ग्रेकैपचा रिस्पॉन्स लौटाता है
       -> टोकन को g-रिकैपचा-रिस्पॉन्स में लागू करें
       -> प्लेयराइट जमा करता है और पेज की प्रतीक्षा करता है
       -> पेज को पढ़ें और स्वीकृति निर्धारित करें
  -> टूल {"स्वीकृत": ..., "संदेश": ...} लौटाता है
  -> एजेंट स्वीकृति से परिणाम रिपोर्ट करता है

pip install composio composio-openai-agents openai-agents capsolver pydantic playwright
playwright install chromium

# एपीआई कुंजियाँ।
COMPOSIO_API_KEY = "ak_..."
OPENAI_API_KEY = "sk-..."          # आपका आधिकारिक ओपनएआई एपीआई कुंजी।
os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY   # ओपनएआई सीडीके एपीआई कुंजी को वातावरण से पढ़ता है।

# कैपसॉल्वर और कॉम्पोसियो को कॉन्फ़िगर करें।
capsolver.api_key = "CAP-..."
composio = Composio(
    api_key=COMPOSIO_API_KEY,
    provider=OpenAIAgentsProvider(),
)

import os
from typing import List, cast
import capsolver
from agents import Agent, Runner, SQLiteSession
from composio import Composio
from composio.core.models.custom_tool import CustomTool
from composio.core.models.tool_router import ToolRouterExperimentalConfig
from composio_openai_agents import OpenAIAgentsProvider
from playwright.sync_api import sync_playwright
from pydantic import BaseModel, Field

# एपीआई कुंजियाँ।
COMPOSIO_API_KEY = "ak_..."
OPENAI_API_KEY = "sk-..."          # आपका आधिकारिक ओपनएआई एपीआई कुंजी।
os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY

# कैपसॉल्वर और कॉम्पोसियो को कॉन्फ़िगर करें।
capsolver.api_key = "CAP-..."
composio = Composio(
    api_key=COMPOSIO_API_KEY,
    provider=OpenAIAgentsProvider(),
)


# कस्टम टूल के लिए इनपुट स्कीमा; कॉम्पोसियो के लिए पायडेंट बेसमॉडल आवश्यक है।
class CompleteRecaptchaInput(BaseModel):
    target_url: str = Field(
        default="https://www.google.com/recaptcha/api2/demo",
        description="reCAPTCHA v2 डेमो वाला पेज URL",
    )
    website_key: str = Field(
        default="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
        description="वर्तमान पृष्ठ से reCAPTCHA v2 वेबसाइट कुंजी",
    )


# पूरा फ्लो एक कॉम्पोसियो टूल के रूप में पंजीकृत करें जिसे एजेंट कॉल कर सकता है।
# पहले पैरामीटर के प्रकार अनोटेशन की आवश्यकता होती है क्योंकि कॉम्पोसियो इसके माध्यम से स्कीमा निर्मित करता है।
@composio.experimental.tool(preload=True)
def complete_recaptcha_v2(input: CompleteRecaptchaInput, _ctx):
    """प्लेयराइट के साथ पृष्ठ खोलें, reCAPTCHA v2 हल करें, जमा करें और सत्यापित करें।"""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)  # headless=True खिड़की छिपाने के लिए सेट करें।
        page = browser.new_page()
        try:
            page.goto(input.target_url)
            # कैपसॉल्वर से reCAPTCHA v2 चुनौती हल करने के लिए पूछें।
            solution = capsolver.solve(
                {
                    "type": "ReCaptchaV2TaskProxyLess",
                    "websiteURL": input.target_url,
                    "websiteKey": input.website_key,
                }
            )
            token = solution.get("gRecaptchaResponse")
            page.evaluate(
                """
                (token) => {
                    const textarea = document.getElementById('g-recaptcha-response');
                    if (textarea) {
                        textarea.value = token;
                    }
                }
                """,
                token,
            )
            page.click("#recaptcha-demo-submit")
            page.wait_for_load_state("networkidle")
            result_page = page.content()
            # सफलता केवल तभी होती है जब पृष्ठ वास्तव में सफलता पाठ दिखाता है
            accepted = "Verification Success" in result_page
            return {
                "accepted": accepted,
                "message": (
                    "Verification Success"
                    if accepted
                    else "पृष्ठ ने Verification Success रिपोर्ट नहीं किया"
                ),
            }
        finally:
            browser.close()
def main():
    experimental: ToolRouterExperimentalConfig = {
        "custom_tools": cast(List[CustomTool], [complete_recaptcha_v2]),
    }
    session = composio.sessions.create(
        user_id="playwright-recaptcha-demo-user",
        experimental=experimental,
        sandbox={"enable": False},  # टूल को इस प्रक्रिया में चलाएं, एक सैंडबॉक्स में नहीं।
    )
    agent = Agent(
        name="Playwright reCAPTCHA सहायक",
        instructions=(
            "जब उपयोगकर्ता डेमो चलाने के लिए कहता है, तो डिफ़ॉल्ट मानों के साथ complete_recaptcha_v2 कॉल करें। स्वीकृति सत्य होने पर ही सफलता रिपोर्ट करें।"
        ),
        model="gpt-5.2",
        tools=session.tools(),
    )
    # बहु-बार बातचीत के लिए मेमोरी
    memory = SQLiteSession("conversation")
    print("Composio + Playwright reCAPTCHA v2 डेमो एक बार चल रहा है...")
    user_input = (
        "डिफ़ॉल्ट target_url और website_key के साथ complete_recaptcha_v2 अब कॉल करें। पुष्टि न मांगें।"
    )
    result = Runner.run_sync(
        starting_agent=agent,
        input=user_input,
        session=memory,
    )
    print(f"सहायक: {result.final_output}\n")
if __name__ == "__main__":
    main()

image_src = page.locator("#demoCaptcha_CaptchaImage").get_attribute("src")
if not image_src or "," not in image_src:
    raise RuntimeError("एक वैध कैप्चा छवि डेटा यूआरएल नहीं मिला")
base64_image = image_src.split(",", 1)[1]  # "data:image/...;base64," प्रारूप को हटाएं।

class CompleteImageCaptchaInput(BaseModel):
    target_url: str = Field(
        default="https://captcha.com/demos/features/captcha-demo.aspx",
        description="छवि कैप्चा डेमो पृष्ठ URL",
    )
    module: str = Field(
        default="common",
        description="कैपसॉल्वर ImageToTextTask स्वीकृति मॉड्यूल",
    )

@composio.experimental.tool(preload=True)
def complete_image_captcha(input: CompleteImageCaptchaInput, _ctx):
    """प्लेयराइट के साथ पृष्ठ खोलें, छवि कैप्चा स्वीकृति करें, जमा करें और सत्यापित करें।"""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        try:
            page.goto(input.target_url)
            page.wait_for_selector("#demoCaptcha_CaptchaImage", state="visible")

            # छवि स्रोत पहले से ही डेटा यूआरएल है; प्रारूप को हटाकर बेस64 प्राप्त करें।
            image_src = page.locator("#demoCaptcha_CaptchaImage").get_attribute("src")
            if not image_src or "," not in image_src:
                raise RuntimeError("एक वैध कैप्चा छवि डेटा यूआरएल नहीं मिला")
            base64_image = image_src.split(",", 1)[1]
            solution = capsolver.solve(
                {
                    "type": "ImageToTextTask",
                    "websiteURL": input.target_url,
                    "module": input.module,
                    "body": base64_image,
                }
            )
            captcha_text = solution.get("text")
            if not isinstance(captcha_text, str) or not captcha_text:
                raise RuntimeError("कैपसॉल्वर ने पहचाने गए पाठ नहीं लौटाया")
            page.fill("#captchaCode", captcha_text)      # पहचाने गए पाठ लिखें।
            page.click("#validateCaptchaButton")
            page.wait_for_load_state("networkidle")
            result_page = page.content()
            # डेमो पृष्ठ "Correct!" पर सफलता दिखाता है, "Incorrect!" पर असफलता।
            accepted = "Correct!" in result_page
            return {
                "accepted": accepted,
                "recognized_text": captcha_text,
                "message": "Correct!" if accepted else "पृष्ठ ने Correct! रिपोर्ट नहीं किया",
            }
        finally:
            browser.close()

प्लेयराइट कैप्चा पृष्ठ खोलता है
  -> #demoCaptcha_CaptchaImage दृश्य होने तक प्रतीक्षा करें
  -> src (डेटा यूआरएल) पढ़ें और प्रारूप हटाएं ताकि बेस64 मिले
  -> capsolver.solve(ImageToTextTask) पाठ लौटाता है
  -> page.fill रिकॉर्ड किए गए पाठ को #captchaCode में लिखता है
  -> page.click #validateCaptchaButton को सक्रिय करता है
  -> page.content Correct! या Incorrect! जांचता है
  -> finally ब्राउज़र बंद करता है

solution = capsolver.solve({
    "type": "ImageToTextTask",
    "module": "number",
    "images": [base64_image],
})

answers = solution["answers"]

experimental.tool: "complete_recaptcha_v2" के पहला पैरामीटर एक पायडेंट बेसमॉडल सबक्लास के साथ एनोटेट किया जाना चाहिए। प्राप्त: <class 'inspect._empty'>

403 APIKey_InsufficientPermissions
इस रूट के लिए "सेशन" लिखने की अनुमति की आवश्यकता है

कॉम्पोसियो टूल = प्लेयराइट पृष्ठ क्रियाएं + कैपसॉल्वर परिणाम + पृष्ठ-स्थिति सत्यापन