# Using npm
npm install @composio/core

# Using yarn
yarn add @composio/core

# Using pnpm
pnpm add @composio/core

import { Composio } from '@composio/core';

// Initialize the SDK
const composio = new Composio({
  apiKey: 'your-api-key',
});

import { Composio } from '@composio/core';
import { OpenAIProvider } from '@composio/openai';

// Initialize with custom provider and options
const composio = new Composio({
  apiKey: 'your-api-key',
  baseURL: 'https://api.composio.dev', // Optional: Custom API endpoint
  allowTracking: true, // Optional: Enable/disable telemetry
  provider: new OpenAIProvider(), // Optional: Custom provider
  toolkitVersions: { github: '12082025_00', slack: 'latest' }, // Optional: Toolkit versions
});

const composio = new Composio({
  toolkitVersions: {
    github: '12082025_00',
    slack: '10082025_01',
    gmail: 'latest', // You can mix specific versions with 'latest'
  }
});

# Set specific versions for individual toolkits
export COMPOSIO_TOOLKIT_VERSION_GITHUB=12082025_00
export COMPOSIO_TOOLKIT_VERSION_SLACK=10082025_01
export COMPOSIO_TOOLKIT_VERSION_GMAIL=latest

const composio = new Composio({
  apiKey: 'your-api-key'
  // Will automatically use environment variables
});

const composio = new Composio({
  apiKey: 'your-api-key',
  // since omitted, this will use `latest` for all toolkits
})

import { Composio } from '@composio/core';

// Production setup with pinned versions
const composio = new Composio({
  apiKey: process.env.COMPOSIO_API_KEY,
  toolkitVersions: {
    // Pin critical toolkits to stable versions
    github: '12082025_00',
    slack: '10082025_01',
    gmail: '15082025_00',
    // Use latest for non-critical toolkits
    hackernews: 'latest'
  }
});

// Get all toolkits
const allToolkits = await composio.toolkits.get({});
console.log(allToolkits.items);

// Get toolkits by category
const devToolkits = await composio.toolkits.get({
  category: 'developer-tools',
});

// Get all tools from the GitHub toolkit
const githubTools = await composio.tools.get('default', {
  toolkits: ['github'],
});

// Get a specific tool by slug
const getRepoTool = await composio.tools.get('default', 'GITHUB_GET_REPO');

// Execute a GitHub tool
const result = await composio.tools.execute('GITHUB_GET_REPO', {
  userId: 'default',
  arguments: {
    owner: 'composio',
    repo: 'sdk',
  },
});

// Check if the execution was successful
if (result.successful) {
  console.log('Repository details:', result.data);
} else {
  console.error('Error:', result.error);
}

// Step 1: Authorize the toolkit
const connectionRequest = await composio.toolkits.authorize('user123', 'github');

// This gives you a redirect URL
console.log('Redirect the user to:', connectionRequest.redirectUrl);

// Step 2: Wait for the connection to be established
// This should be called after the user completes the auth flow
const connectedAccount = await composio.connectedAccounts.waitForConnection(connectionRequest.id);
console.log('Connected account:', connectedAccount);

// Execute a tool with a connected account
const result = await composio.tools.execute('GITHUB_GET_REPOS', {
  userId: 'user123',
  connectedAccountId: connectedAccount.id,
  arguments: {},
});

import { Composio } from '@composio/core';
import OpenAI from 'openai';

// Initialize Composio and OpenAI
const composio = new Composio({
  apiKey: 'your-composio-api-key',
});

const openai = new OpenAI({
  apiKey: 'your-openai-api-key',
});

// Get tools from the GitHub toolkit
const tools = await composio.tools.get('default', {
  toolkits: ['github'],
});

// Create a chat completion with OpenAI using the tools
const completion = await openai.chat.completions.create({
  model: 'gpt-5',
  messages: [
    { role: 'system', content: 'You are a helpful assistant with access to GitHub tools.' },
    { role: 'user', content: 'List the repositories in the Composio organization' },
  ],
  tools, // Pass the tools to OpenAI
});

// If the assistant wants to use a tool
if (completion.choices[0].message.tool_calls) {
  // Execute each tool call
  for (const toolCall of completion.choices[0].message.tool_calls) {
    // Parse the arguments
    const args = JSON.parse(toolCall.function.arguments);

    // Execute the tool
    const result = await composio.tools.execute(toolCall.function.name, {
      userId: 'default',
      arguments: args,
    });

    // Use the result in your application
    console.log(`Tool ${toolCall.function.name} result:`, result.data);
  }
}

import { z } from 'zod';

// Create a custom tool
const customTool = await composio.tools.createCustomTool({
  name: 'Weather Forecast',
  description: 'Get the weather forecast for a location',
  slug: 'WEATHER_FORECAST',
  inputParams: z.object({
    location: z.string().describe('The location to get the forecast for'),
    days: z.number().optional().default(3).describe('Number of days for the forecast')
  }),
  execute: async (input) => {
    try {
      const { location, days = 3 } = input;

      // Here you would call your weather API
      const forecast = await getWeatherForecast(location, days);

      return {
        data: { forecast },
        error: null,
        successful: true,
      };
    } catch (error) {
      return {
        data: {},
        successful: false,
        error: error.message,
      };
    }
  },
});

// Now you can use your custom tool
const result = await composio.tools.execute('WEATHER_FORECAST', {
  userId: 'default',
  arguments: {
    location: 'San Francisco, CA',
    days: 5,
  },
});

console.log(result.data.forecast);