Anthropic Provider

npm install @composio/anthropic @anthropic-ai/sdk

import { Composio } from '@composio/core';
import { AnthropicProvider } from '@composio/anthropic';
import Anthropic from '@anthropic-ai/sdk';

const composio = new Composio({
  apiKey: 'your-composio-key',
  provider: new AnthropicProvider()
});

const tools = await composio.tools.get('default', {
  toolkits: ['github']
});

const anthropic = new Anthropic({ apiKey: 'your-anthropic-key' });

const message = await anthropic.messages.create({
  model: 'claude-3-opus-20240229',
  max_tokens: 1024,
  tools,
  messages: [
    { role: 'user', content: 'Create a GitHub issue titled "Bug Report"' }
  ]
});

// Handle tool use
const provider = new AnthropicProvider();
const toolResults = await provider.handleToolCalls('default', message);

import { Composio } from '@composio/core';
import { AnthropicProvider } from '@composio/anthropic';
import Anthropic from '@anthropic-ai/sdk';

const composio = new Composio({
  apiKey: process.env.COMPOSIO_API_KEY!,
  provider: new AnthropicProvider()
});

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY!
});

async function runAgent(userMessage: string) {
  const tools = await composio.tools.get('default', {
    toolkits: ['github']
  });

  const messages: Anthropic.Messages.MessageParam[] = [
    { role: 'user', content: userMessage }
  ];

  let response = await anthropic.messages.create({
    model: 'claude-3-opus-20240229',
    max_tokens: 4096,
    tools,
    messages
  });

  const provider = new AnthropicProvider();

  while (response.stop_reason === 'tool_use') {
    // Handle tool calls
    const toolResults = await provider.handleToolCalls(
      'default',
      response
    );

    // Add tool results to conversation
    messages.push(
      { role: 'assistant', content: response.content },
      ...toolResults
    );

    // Get next response
    response = await anthropic.messages.create({
      model: 'claude-3-opus-20240229',
      max_tokens: 4096,
      tools,
      messages
    });
  }

  // Extract final text response
  const textContent = response.content.find(
    block => block.type === 'text'
  );
  
  return textContent?.type === 'text' ? textContent.text : '';
}

const result = await runAgent('Create an issue in my repo');
console.log(result);

const composio = new Composio({
  apiKey: 'your-key',
  provider: new AnthropicProvider({
    cacheTools: true // Enable prompt caching
  })
});

const tools = await composio.tools.get('default', {
  toolkits: ['github']
});

// Tools will include cache_control markers
const message = await anthropic.messages.create({
  model: 'claude-3-opus-20240229',
  max_tokens: 1024,
  tools, // Tools are cached
  messages: [{ role: 'user', content: 'Create an issue' }]
});

const provider = new AnthropicProvider();

const toolResults = await provider.handleToolCalls(
  'user_123', // User ID
  message, // Claude's response
  { connectedAccountId: 'conn_abc123' }, // Options
  { // Modifiers
    beforeExecute: ({ toolSlug, params }) => {
      console.log(`Executing ${toolSlug}`);
      return params;
    }
  }
);

// Returns: Anthropic.Messages.MessageParam[]

interface AnthropicTool {
  name: string; // Tool slug
  description: string; // Tool description
  input_schema: JSONSchema; // Input parameters
  cache_control?: { type: 'ephemeral' }; // Optional caching
}

const stream = await anthropic.messages.stream({
  model: 'claude-3-opus-20240229',
  max_tokens: 1024,
  tools,
  messages
});

for await (const event of stream) {
  if (event.type === 'content_block_delta') {
    if (event.delta.type === 'text_delta') {
      process.stdout.write(event.delta.text);
    }
  }
  
  if (event.type === 'content_block_start') {
    if (event.content_block.type === 'tool_use') {
      console.log('Tool call:', event.content_block.name);
    }
  }
}

import type { Anthropic } from '@anthropic-ai/sdk';

// Tool collection type
type AnthropicToolCollection = AnthropicTool[];

// Single tool type
interface AnthropicTool {
  name: string;
  description: string;
  input_schema: InputSchema;
  cache_control?: { type: 'ephemeral' };
}