pip install agents-arcade arcadepy

npm install @openai/agents @arcadeai/agents-arcade

import os
from arcadepy import AsyncArcade
from agents import Agent, Runner
from agents_arcade import get_arcade_tools
from agents_arcade.errors import AuthorizationError
 
# Set your API key
os.environ["ARCADE_API_KEY"] = "YOUR_ARCADE_API_KEY"
 
# Initialize the Arcade client
client = AsyncArcade()

# In your .env file
ARCADE_API_KEY=YOUR_ARCADE_API_KEY

import Arcade from '@arcadeai/arcadejs';
import { isAuthorizationRequiredError, toZod } from "@arcadeai/arcadejs/lib";
import { Agent, run, tool } from '@openai/agents';
 
const client = new Arcade();

# Get GitHub tools for this example
tools = await get_arcade_tools(client, toolkits=["github"])
 
# Create an agent with GitHub tools
github_agent = Agent(
    name="GitHub agent",
    instructions="You are a helpful assistant that can assist with GitHub API calls.",
    model="gpt-4o-mini",
    tools=tools,
)

const githubToolkit = await client.tools.list({ toolkit: "github", limit: 30 });
const arcadeTools = toZod({
  tools: githubToolkit.items,
  client,
  userId: "<YOUR_SYSTEM_USER_ID_2>", // Replace this with your application's user ID (e.g. email address, UUID, etc.)
})

try:
    result = await Runner.run(
        starting_agent=github_agent,
        input="Star the arcadeai/arcade-ai repo",
        # Pass a unique user_id for authentication
        context={"user_id": "{arcade_user_id}"},
    )
    print("Final output:\n\n", result.final_output)
except AuthorizationError as e:
    # Display the authorization URL to the user
    print(f"Please Login to GitHub: {e}")
    # The error contains the authorization URL that the user should visit

const arcadeTools = toZod({
  tools: githubToolkit.items,
  client,
  userId: "<YOUR_SYSTEM_USER_ID>", // Replace with your user ID
});

import { executeOrAuthorizeZodTool } from "@arcadeai/arcadejs/lib";
 
const arcadeTools = toZod({
  tools: githubToolkit.items,
  client,
  userId: "<YOUR_SYSTEM_USER_ID>", // Replace with your user ID
  executeFactory: executeOrAuthorizeZodTool,
});

import { isAuthorizationRequiredError } from "@arcadeai/arcadejs/lib";
 
const tools =  arcadeTools.map((arcadeTool) => {
  return tool({
    ...arcadeTool,
    errorFunction: async (_, error) => {
      if (error instanceof Error && isAuthorizationRequiredError(error)) {
        const response = await client.tools.authorize({
          tool_name: arcadeTool.name,
          user_id: "<YOUR_SYSTEM_USER_ID>",
        });
        return `Please login to Google: ${response.url}`;
      }
      return "Error executing tool"
    }
  })
});

from arcadepy import AsyncArcade
import asyncio
 
client = AsyncArcade()
 
async def handle_auth_flow(auth_id):
    # Display a message to the user
    print("Please visit the authorization URL in your browser")
 
 
    # Wait for the user to authenticate
    await client.auth.wait_for_completion(auth_id)
 
    # Check if authorization was successful
    if await is_authorized(auth_id):
        print("Authorization successful! You can now use the tool.")
        return True
    else:
        print("Authorization failed or timed out.")
        return False
 
# In your main function
try:
    # Run agent code
    # ...
except AuthorizationError as e:
    auth_id = e.auth_id
    if await handle_auth_flow(auth_id):
        # Try running the agent again
        result = await Runner.run(
            starting_agent=github_agent,
            input="Star the arcadeai/arcade-ai repo",
            context={"user_id": "{arcade_user_id}"},
        )
        print("Final output:\n\n", result.final_output)

const tools =  arcadeTools.map((arcadeTool) => {
  return tool({
    ...arcadeTool,
    errorFunction: (_, error) => { throw error } // Throw the error to the agent for handling
  })
});
 
while (true) {
    try {
      const result = await run(googleAgent, "What are my latest emails?");
      console.log(result.finalOutput);
    } catch (error) {
      // Catch the authorization error and wait for completion
      if (error instanceof Error && isAuthorizationRequiredError(error)) {
        const response = await client.tools.authorize({
          tool_name: "Gmail_ListEmails",
          user_id: "<YOUR_SYSTEM_USER_ID_2>",
        });
        if (response.status !== "completed") {
          console.log(`Please complete the authorization challenge in your browser: ${response.url}`);
        }
 
        // Wait for the authorization to complete
        await client.auth.waitForCompletion(response);
        console.log("Authorization completed, retrying...");
      }
    }
  }

from arcadepy.auth import wait_for_authorization_completion
 
import time
 
from agents import Agent, Runner
from arcadepy import AsyncArcade
 
from agents_arcade import get_arcade_tools
from agents_arcade.errors import AuthorizationError
 
 
async def main():
    client = AsyncArcade()
    # Use the "github" toolkit for this example
    tools = await get_arcade_tools(client, toolkits=["github"])
 
    github_agent = Agent(
        name="GitHub agent",
        instructions="You are a helpful assistant that can assist with GitHub API calls.",
        model="gpt-4o-mini",
        tools=tools,
    )
 
    user_id = "{arcade_user_id}"  # Make sure to use a unique user ID
 
    while True:
        try:
            result = await Runner.run(
                starting_agent=github_agent,
                input="Star the arcadeai/arcade-ai repo",
                # Pass the user_id for auth
                context={"user_id": user_id},
            )
            print("Final output:\n\n", result.final_output)
            break  # Exit the loop if successful
 
        except AuthorizationError as e:
            auth_url = str(e)
            print(f"{auth_url}.  Please authenticate to continue.")
 
            # Wait for the user to authenticate
            await client.auth.wait_for_completion(e.result.id)
 
 
if __name__ == "__main__":
    import asyncio
 
    asyncio.run(main())

import Arcade from '@arcadeai/arcadejs';
import { isAuthorizationRequiredError, toZod } from "@arcadeai/arcadejs/lib";
import { Agent, run, tool } from '@openai/agents';
 
async function main() {
  // 1) Initialize Arcade client
  const client = new Arcade();
 
  // 2) Fetch Gmail toolkit from Arcade and prepare tools for OpenAI Agents
  const googleToolkit = await client.tools.list({ toolkit: "gmail", limit: 30 });
  const tools = toZod({
    tools: googleToolkit.items,
    client,
    userId: "<YOUR_SYSTEM_USER_ID_2>", // Replace this with your application's user ID (e.g. email address, UUID, etc.)
  }).map(tool);
 
  // 3) Create a new agent with the Gmail toolkit
  const googleAgent = new Agent({
    name: "Gmail agent",
    instructions: "You are a helpful assistant that can assist with Google API calls.",
    model: "gpt-4o-mini",
    tools
  });
 
  // 4) Run the agent, if authorization is required, wait for it to complete and retry
  while (true) {
    try {
      const result = await run(googleAgent, "What are my latest emails?");
      console.log(result.finalOutput);
      break; // Exit the loop if the result is successful
    } catch (error) {
      if (error instanceof Error && isAuthorizationRequiredError(error)) {
        const response = await client.tools.authorize({
          tool_name: "Gmail_ListEmails",
          user_id: "<YOUR_SYSTEM_USER_ID_2>",
        });
        if (response.status !== "completed") {
          console.log(`Please complete the authorization challenge in your browser: ${response.url}`);
        }
 
        // Wait for the authorization to complete
        await client.auth.waitForCompletion(response);
        console.log("Authorization completed, retrying...");
      }
    }
  }
}
 
main();