Skip to content

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

Add comprehensive agent building skills for Claude Code (#2537)

Musthaq Ahamade387f1eda6e3
diff --git a/.cursor/commands/api-update.md b/.claude/commands/api-update.md
similarity index 100%
rename from .cursor/commands/api-update.md
rename to .claude/commands/api-update.md
diff --git a/.cursor/commands/changelog.md b/.claude/commands/changelog.md
similarity index 100%
rename from .cursor/commands/changelog.md
rename to .claude/commands/changelog.md
diff --git a/.cursor/rules/bug-fix-testing.mdc b/.claude/rules/bug-fix-testing.mdc
similarity index 100%
rename from .cursor/rules/bug-fix-testing.mdc
rename to .claude/rules/bug-fix-testing.mdc
diff --git a/.claude/skills/building-agents-using-anthropic/SKILL.md b/.claude/skills/building-agents-using-anthropic/SKILL.md
new file mode 100644
index 000000000..83406c1f9
--- /dev/null
+++ b/.claude/skills/building-agents-using-anthropic/SKILL.md
@@ -0,0 +1,134 @@
+# Building Agents using Anthropic with Composio
+
+Build AI agents using Anthropic's Claude API with Composio tools.
+
+## Installation
+
+```bash
+npm install @composio/core @composio/anthropic @anthropic-ai/sdk
+npm install @composio/claude-agent-sdk @anthropic-ai/claude-agent-sdk # For Agent SDK
+```
+
+```bash
+pip install composio-anthropic
+```
+
+**Find Latest Versions:**
+```bash
+npm view @anthropic-ai/sdk version
+pip index versions anthropic | grep "Available versions" | head -1
+```
+
+## Integration Method
+
+**Anthropic Messages API is non-agentic** - uses direct tools. **Claude Agent SDK is agentic** - uses Tool Router.
+
+### Messages API (Non-Agentic)
+
+```typescript
+import { Composio } from '@composio/core';
+import { AnthropicProvider } from '@composio/anthropic';
+import Anthropic from '@anthropic-ai/sdk';
+
+const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+const composio = new Composio({
+ apiKey: process.env.COMPOSIO_API_KEY,
+ provider: new AnthropicProvider({ cacheTools: true }),
+});
+
+// Get tools
+const tools = await composio.tools.get('default', { toolkits: ['github'] });
+
+// Use with Claude
+const message = await anthropic.messages.create({
+ model: 'claude-3-7-sonnet-latest',
+ max_tokens: 1024,
+ tools: tools,
+ messages: [{ role: 'user', content: 'Create a GitHub issue' }],
+});
+
+// Handle tool calls
+const toolResults = await composio.provider.handleToolCalls('default', message);
+```
+
+```python
+from composio_anthropic import ComposioToolSet, Action
+from anthropic import Anthropic
+
+client = Anthropic(api_key="YOUR_KEY")
+composio_toolset = ComposioToolSet(api_key="YOUR_KEY")
+
+# Get tools
+tools = composio_toolset.get_tools(actions=[Action.GITHUB_CREATE_ISSUE])
+
+# Use with Claude
+message = client.messages.create(
+ model="claude-3-7-sonnet-latest",
+ max_tokens=1024,
+ tools=tools,
+ messages=[{"role": "user", "content": "Create a GitHub issue"}]
+)
+
+# Handle tool calls
+tool_results = composio_toolset.handle_tool_calls(message)
+```
+
+### Claude Agent SDK (Agentic - Requires Tool Router)
+
+```typescript
+import { Composio } from '@composio/core';
+import { ClaudeAgentSDKProvider } from '@composio/claude-agent-sdk';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+
+const composio = new Composio({
+ apiKey: process.env.COMPOSIO_API_KEY,
+ provider: new ClaudeAgentSDKProvider()
+});
+
+async function runAgent(userId: string, prompt: string) {
+ // Create session
+ const session = await composio.create(userId, {
+ toolkits: ['github'],
+ manageConnections: true
+ });
+
+ const tools = await session.tools();
+
+ // Use with Claude Agent SDK
+ const stream = await query({
+ prompt,
+ options: {
+ model: 'claude-sonnet-4-5-20250929',
+ permissionMode: 'bypassPermissions',
+ tools
+ }
+ });
+
+ for await (const event of stream) {
+ if (event.type === 'result' && event.subtype === 'success') {
+ console.log(event.result);
+ }
+ }
+}
+```
+
+## Key Resources
+
+- **Anthropic Docs**: https://docs.anthropic.com/
+- **Tool Use Guide**: https://docs.anthropic.com/en/docs/build-with-claude/tool-use
+- **Claude Agent SDK**: https://docs.anthropic.com/en/docs/agents
+- **Messages API (Non-Agentic)**: Direct tools
+- **Claude Agent SDK (Agentic)**: Use Tool Router
+
+## Environment Variables
+
+```bash
+ANTHROPIC_API_KEY=sk-ant-...
+COMPOSIO_API_KEY=...
+```
+
+## Next Steps
+
+1. For Agent SDK (agentic), use `/building-agents`
+2. Check `ts/examples/anthropic/` for complete examples
+3. See [Anthropic docs](https://docs.anthropic.com/) for Claude features
diff --git a/.claude/skills/building-agents-using-autogen/SKILL.md b/.claude/skills/building-agents-using-autogen/SKILL.md
new file mode 100644
index 000000000..67e674f8e
--- /dev/null
+++ b/.claude/skills/building-agents-using-autogen/SKILL.md
@@ -0,0 +1,143 @@
+# Building Agents using Microsoft AutoGen with Composio
+
+Build multi-agent conversational systems using AutoGen with Composio Tool Router.
+
+## Installation
+
+```bash
+# For AgentChat (conversational agents)
+pip install composio-autogen autogen-agentchat autogen-ext[openai]
+
+# For AutoGen Studio (UI-based)
+pip install autogenstudio
+```
+
+**Find Latest Versions:**
+```bash
+pip index versions autogen-agentchat | grep "Available versions" | head -1
+pip index versions composio-autogen | grep "Available versions" | head -1
+```
+
+## Integration Method
+
+**AutoGen is an agentic provider** - use Tool Router for user isolation.
+
+### Native Tools with Tool Router
+
+```python
+import asyncio
+from autogen_agentchat.agents import AssistantAgent
+from autogen_ext.models.openai import OpenAIChatCompletionClient
+from composio_autogen import ComposioToolSet, App
+
+toolset = ComposioToolSet()
+
+async def create_agent(user_id: str):
+ # Create session
+ session = toolset.create(
+ user_id=user_id,
+ toolkits=["github"],
+ manage_connections=True
+ )
+
+ tools = session.tools()
+
+ # Create agent with tools
+ agent = AssistantAgent(
+ name="github_agent",
+ model_client=OpenAIChatCompletionClient(model="gpt-4o"),
+ tools=tools,
+ system_message="You manage GitHub repositories"
+ )
+
+ return agent
+
+async def main():
+ agent = await create_agent("user_123")
+ result = await agent.run(task="Create a GitHub issue titled 'Bug Report'")
+ print(result)
+
+asyncio.run(main())
+```
+
+### Multi-Agent Conversation
+
+```python
+import asyncio
+from autogen_agentchat.agents import AssistantAgent
+from autogen_agentchat.teams import RoundRobinGroupChat
+from autogen_ext.models.openai import OpenAIChatCompletionClient
+from composio_autogen import ComposioToolSet, App
+
+toolset = ComposioToolSet()
+
+async def create_team(user_id: str):
+ # Create session
+ session = toolset.create(
+ user_id=user_id,
+ toolkits=["github", "slack"],
+ manage_connections=True
+ )
+
+ tools = session.tools()
+
+ # Create specialized agents
+ github_agent = AssistantAgent(
+ name="github_agent",
+ model_client=OpenAIChatCompletionClient(model="gpt-4o"),
+ tools=tools,
+ system_message="You manage GitHub"
+ )
+
+ slack_agent = AssistantAgent(
+ name="slack_agent",
+ model_client=OpenAIChatCompletionClient(model="gpt-4o"),
+ tools=tools,
+ system_message="You manage Slack"
+ )
+
+ # Create team
+ team = RoundRobinGroupChat(
+ [github_agent, slack_agent],
+ max_turns=10
+ )
+
+ return team
+
+async def main():
+ team = await create_team("user_123")
+ result = await team.run(
+ task="Create a GitHub issue and notify team on Slack"
+ )
+ print(result)
+
+asyncio.run(main())
+```
+
+## Key Features
+
+- **Multi-Agent Conversations**: Agents collaborate and communicate
+- **AutoGen Studio**: No-code UI for prototyping
+- **Multiple Layers**: Studio, AgentChat, Core for different needs
+- **Team Patterns**: RoundRobin, Swarm, custom orchestration
+
+## Key Resources
+
+- **AutoGen Docs**: https://microsoft.github.io/autogen/stable/
+- **Tool Router Guide**: `/building-agents`
+- **GitHub**: https://github.com/microsoft/autogen
+- **Microsoft Agent Framework**: Successor to AutoGen
+
+## Environment Variables
+
+```bash
+OPENAI_API_KEY=sk-... # Or other LLM provider
+COMPOSIO_API_KEY=...
+```
+
+## Next Steps
+
+1. Use `/building-agents` for comprehensive guide
+2. Check `python/providers/autogen/` for complete examples
+3. See [AutoGen docs](https://microsoft.github.io/autogen/stable/) for conversation patterns
+4. Consider [Microsoft Agent Framework](https://learn.microsoft.com/en-us/agent-framework/) for new projects
diff --git a/.claude/skills/building-agents-using-cloudflare/SKILL.md b/.claude/skills/building-agents-using-cloudflare/SKILL.md
new file mode 100644
index 000000000..b8da7fb90
--- /dev/null
+++ b/.claude/skills/building-agents-using-cloudflare/SKILL.md
@@ -0,0 +1,124 @@
+# Building Agents using Cloudflare with Composio
+
+Build edge-deployed AI agents using Cloudflare Workers AI with Composio Tool Router.
+
+## Installation
+
+```bash
+npm install @composio/core @composio/cloudflare agents @cloudflare/ai-utils
+npm install wrangler -D # For development
+```
+
+**Find Latest Versions:**
+```bash
+npm view agents version
+npm view @composio/cloudflare version
+```
+
+## Integration Method
+
+**Cloudflare is an agentic provider** - use Tool Router for user isolation.
+
+### Native Tools with Tool Router
+
+```typescript
+import { Agent } from 'agents';
+import { Composio } from '@composio/core';
+import { CloudflareProvider } from '@composio/cloudflare';
+
+export class MyAgent extends Agent {
+ private composio: Composio;
+
+ constructor(state: DurableObjectState, env: Env) {
+ super(state, env);
+
+ this.composio = new Composio({
+ apiKey: env.COMPOSIO_API_KEY,
+ provider: new CloudflareProvider(),
+ });
+ }
+
+ async onStart() {
+ // Initialize with user-specific session
+ const session = await this.composio.create(this.userId, {
+ toolkits: ['github'],
+ manageConnections: true
+ });
+
+ this.tools = await session.tools();
+ }
+
+ async handleMessage(message: string) {
+ // Use tools with Cloudflare AI
+ const response = await this.ai.run('@cf/meta/llama-3.1-70b-instruct', {
+ messages: [
+ { role: 'system', content: 'You are a helpful assistant' },
+ { role: 'user', content: message },
+ ],
+ tools: this.tools,
+ });
+
+ return response;
+ }
+}
+```
+
+### wrangler.toml Configuration
+
+```toml
+name = "my-agent"
+main = "src/index.ts"
+compatibility_date = "2024-01-01"
+
+[[durable_objects.bindings]]
+name = "MY_AGENT"
+class_name = "MyAgent"
+
+[ai]
+binding = "AI"
+
+[vars]
+COMPOSIO_API_KEY = "your-key-here"
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["MyAgent"]
+```
+
+## Key Features
+
+- **Edge Deployment**: Low-latency worldwide
+- **Durable Objects**: Persistent agent state
+- **Workers AI**: Run models at the edge
+- **Embedded Function Calling**: AI executes functions automatically
+
+## Key Resources
+
+- **Cloudflare Agents SDK**: https://developers.cloudflare.com/agents/
+- **Tool Router Guide**: `/building-agents`
+- **Workers AI**: https://developers.cloudflare.com/workers-ai/
+- **Function Calling**: https://developers.cloudflare.com/workers-ai/features/function-calling/
+
+## Environment Variables
+
+```bash
+COMPOSIO_API_KEY=...
+CLOUDFLARE_ACCOUNT_ID=...
+CLOUDFLARE_API_TOKEN=...
+```
+
+## Deployment
+
+```bash
+# Deploy with Wrangler
+npx wrangler deploy
+
+# Tail logs
+npx wrangler tail
+```
+
+## Next Steps
+
+1. Use `/building-agents` for comprehensive guide
+2. Check `ts/examples/cloudflare-wrangler/` for complete examples
+3. See [Cloudflare docs](https://developers.cloudflare.com/agents/) for edge features
diff --git a/.claude/skills/building-agents-using-crewai/SKILL.md b/.claude/skills/building-agents-using-crewai/SKILL.md
new file mode 100644
index 000000000..019a021d3
--- /dev/null
+++ b/.claude/skills/building-agents-using-crewai/SKILL.md
@@ -0,0 +1,147 @@
+# Building Agents using CrewAI with Composio
+
+Build multi-agent teams using CrewAI with Composio Tool Router.
+
+## Installation
+
+```bash
+pip install composio-crewai crewai crewai-tools
+```
+
+**Find Latest Versions:**
+```bash
+pip index versions crewai | grep "Available versions" | head -1
+pip index versions composio-crewai | grep "Available versions" | head -1
+```
+
+## Integration Method
+
+**CrewAI is an agentic provider** - use MCP for multi-agent teams.
+
+### MCP Integration
+
+```python
+from crewai import Agent, Task, Crew
+from crewai.mcp import MCPServerHTTP
+from composio import Composio
+
+composio = Composio()
+
+def create_crew(user_id: str):
+ # Create session
+ session = composio.create(user_id=user_id, toolkits=["github"])
+
+ # Create agent with MCP server
+ agent = Agent(
+ role="GitHub Manager",
+ goal="Manage GitHub repositories",
+ backstory="You are an expert at GitHub operations",
+ mcps=[
+ MCPServerHTTP(
+ url=session.mcp.url,
+ headers=session.mcp.headers
+ )
+ ]
+ )
+
+ # Define task
+ task = Task(
+ description="Create a GitHub issue titled 'Bug Report'",
+ expected_output="Confirmation of issue creation",
+ agent=agent
+ )
+
+ # Execute crew
+ crew = Crew(agents=[agent], tasks=[task])
+ return crew
+
+crew = create_crew("user_123")
+result = crew.kickoff()
+print(result)
+```
+
+### Multi-Agent Team Example
+
+```python
+from crewai import Agent, Task, Crew, Process
+from crewai.mcp import MCPServerHTTP
+from composio import Composio
+
+composio = Composio()
+
+def create_team(user_id: str):
+ session = composio.create(user_id=user_id, toolkits=["github", "slack"])
+
+ # Create MCP server connection
+ mcp_server = MCPServerHTTP(
+ url=session.mcp.url,
+ headers=session.mcp.headers
+ )
+
+ # Create specialized agents
+ researcher = Agent(
+ role="GitHub Researcher",
+ goal="Analyze repositories",
+ backstory="Expert at code analysis",
+ mcps=[mcp_server]
+ )
+
+ reporter = Agent(
+ role="Report Writer",
+ goal="Create reports",
+ backstory="Expert at documentation",
+ mcps=[mcp_server]
+ )
+
+ # Define tasks
+ research_task = Task(
+ description="Analyze the repository",
+ expected_output="Analysis report",
+ agent=researcher
+ )
+
+ report_task = Task(
+ description="Create a summary report",
+ expected_output="Markdown report",
+ agent=reporter,
+ context=[research_task]
+ )
+
+ crew = Crew(
+ agents=[researcher, reporter],
+ tasks=[research_task, report_task],
+ process=Process.sequential
+ )
+
+ return crew
+
+team = create_team("user_123")
+result = team.kickoff()
+```
+
+## Key Features
+
+- **Multi-Agent Teams**: Agents collaborate on tasks
+- **Task Dependencies**: Sequential or hierarchical execution
+- **YAML Configs**: Clean agent/task definitions
+- **Production Ready**: Mature framework
+
+## Key Resources
+
+- **CrewAI Docs**: https://docs.crewai.com/
+- **Tool Router Guide**: `/building-agents`
+- **Quickstart**: https://docs.crewai.com/en/quickstart
+- **GitHub**: https://github.com/crewAIInc/crewAI
+
+## Environment Variables
+
+```bash
+OPENAI_API_KEY=sk-... # Or other LLM provider
+COMPOSIO_API_KEY=...
+```
+
+## Next Steps
+
+1. Use `/building-agents` for comprehensive guide
+2. Check `python/providers/crewai/` for complete examples
+3. See [CrewAI docs](https://docs.crewai.com/) for multi-agent patterns
diff --git a/.claude/skills/building-agents-using-google/SKILL.md b/.claude/skills/building-agents-using-google/SKILL.md
new file mode 100644
index 000000000..9df3f64e5
--- /dev/null
+++ b/.claude/skills/building-agents-using-google/SKILL.md
@@ -0,0 +1,107 @@
+# Building Agents using Google Gemini with Composio
+
+Build AI agents using Google's Gemini API with Composio tools.
+
+## Installation
+
+```bash
+npm install @composio/core @composio/google @google/genai
+```
+
+```bash
+pip install composio-google google-genai
+```
+
+**Find Latest Versions:**
+```bash
+npm view @google/genai version
+pip index versions google-genai | grep "Available versions" | head -1
+```
+
+## Integration Method
+
+**Google Gemini is a non-agentic provider** - uses direct tools (no Tool Router support).
+
+### TypeScript Example
+
+```typescript
+import { Composio } from '@composio/core';
+import { GoogleProvider } from '@composio/google';
+import { GoogleGenAI } from '@google/genai';
+
+const genai = new GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY });
+const composio = new Composio({
+ apiKey: process.env.COMPOSIO_API_KEY,
+ provider: new GoogleProvider(),
+});
+
+// Get tools
+const tools = await composio.tools.get('default', { toolkits: ['github'] });
+
+// Use with Gemini
+const response = await genai.models.generateContent({
+ model: 'gemini-3-flash-preview',
+ contents: 'Create a GitHub issue',
+ config: {
+ tools: tools,
+ temperature: 1.0 // Required for Gemini 3
+ },
+});
+
+// Handle function calls
+if (response.functionCalls) {
+ const results = await composio.provider.handleToolCalls('default', response);
+}
+```
+
+### Python Example
+
+```python
+from composio_google import ComposioToolSet, Action
+from google import genai
+from google.genai import types
+
+client = genai.Client(api_key="YOUR_KEY")
+composio_toolset = ComposioToolSet(api_key="YOUR_KEY")
+
+# Get tools
+tools = composio_toolset.get_tools(actions=[Action.GITHUB_CREATE_ISSUE])
+
+# Use with Gemini
+response = client.models.generate_content(
+ model="gemini-3-flash-preview",
+ contents="Create a GitHub issue",
+ config=types.GenerateContentConfig(
+ tools=tools,
+ temperature=1.0
+ )
+)
+
+# Handle function calls
+tool_results = composio_toolset.handle_tool_calls(response)
+```
+
+## Key Features
+
+- **Compositional Function Calling**: Chain multiple functions automatically
+- **Parallel Execution**: Execute independent functions simultaneously
+- **Internal Thinking**: Gemini 3 models reason through complex requests
+
+## Key Resources
+
+- **Gemini API Docs**: https://ai.google.dev/gemini-api/docs
+- **Function Calling**: https://ai.google.dev/gemini-api/docs/function-calling
+- **Available Models**: Gemini 3 Pro/Flash, Gemini 2.5 Pro/Flash
+
+## Environment Variables
+
+```bash
+GOOGLE_API_KEY=...
+COMPOSIO_API_KEY=...
+```
+
+## Next Steps
+
+1. Check `ts/examples/google/` for complete examples
+2. See [Gemini docs](https://ai.google.dev) for API features
+3. Note: Temperature must be 1.0 for Gemini 3 models
diff --git a/.claude/skills/building-agents-using-langchain/SKILL.md b/.claude/skills/building-agents-using-langchain/SKILL.md
new file mode 100644
index 000000000..bc7648da1
--- /dev/null
+++ b/.claude/skills/building-agents-using-langchain/SKILL.md
@@ -0,0 +1,123 @@
+# Building Agents using LangChain with Composio
+
+Build AI agents using LangChain/LangGraph with Composio Tool Router.
+
+## Installation
+
+```bash
+npm install @composio/core @composio/langchain langchain @langchain/core @langchain/openai
+```
+
+```bash
+pip install composio-langchain langchain langchain-openai
+```
+
+**Find Latest Versions:**
+```bash
+npm view langchain version
+pip index versions langchain | grep "Available versions" | head -1
+```
+
+## Integration Method
+
+**LangChain is an agentic provider** - use Tool Router (or MCP for flexibility).
+
+### Native Tools with Tool Router
+
+```typescript
+import { ChatOpenAI } from '@langchain/openai';
+import { Composio } from '@composio/core';
+import { LangchainProvider } from '@composio/langchain';
+
+const composio = new Composio({
+ apiKey: process.env.COMPOSIO_API_KEY,
+ provider: new LangchainProvider(),
+});
+
+async function runAgent(userId: string, prompt: string) {
+ // Create session
+ const session = await composio.create(userId, {
+ toolkits: ['github'],
+ manageConnections: true
+ });
+
+ const tools = await session.tools();
+
+ // Use with LangChain
+ const llm = new ChatOpenAI({ model: 'gpt-4o' });
+ const agent = llm.bindTools(tools);
+
+ const result = await agent.invoke(prompt);
+ return result;
+}
+```
+
+```python
+from langchain_openai import ChatOpenAI
+from composio_langchain import ComposioToolSet, App
+
+composio_toolset = ComposioToolSet()
+
+def run_agent(user_id: str, prompt: str):
+ # Create session
+ session = composio_toolset.create(
+ user_id=user_id,
+ toolkits=["github"],
+ manage_connections=True
+ )
+
+ tools = session.tools()
+
+ # Use with LangChain
+ llm = ChatOpenAI(model="gpt-4o")
+ agent = llm.bind_tools(tools)
+
+ result = agent.invoke(prompt)
+ return result
+```
+
+### MCP Integration
+
+```typescript
+import { MultiServerMCPClient } from '@langchain/mcp-adapters';
+import { Composio } from '@composio/core';
+
+const composio = new Composio();
+
+async function runAgentMCP(userId: string) {
+ const session = await composio.create(userId, {
+ toolkits: ['github']
+ });
+
+ const client = new MultiServerMCPClient({
+ composio: {
+ transport: 'http',
+ url: session.mcp.url,
+ headers: session.mcp.headers
+ }
+ });
+
+ const tools = await client.getTools();
+ // Use tools with LangChain
+}
+```
+
+## Key Resources
+
+- **LangChain Docs**: https://python.langchain.com/docs/introduction/
+- **Tool Router Guide**: `/building-agents`
+- **Agents Documentation**: https://docs.langchain.com/oss/python/langchain/agents
+- **Use LangGraph for production**: More flexible agent runtime
+
+## Environment Variables
+
+```bash
+OPENAI_API_KEY=sk-... # Or other LLM provider
+COMPOSIO_API_KEY=...
+```
+
+## Next Steps
+
+1. Use `/building-agents` for comprehensive guide
+2. Use `/building-agents-using-langgraph` for stateful agents
+3. Check `ts/examples/langchain/` for complete examples
diff --git a/.claude/skills/building-agents-using-langgraph/SKILL.md b/.claude/skills/building-agents-using-langgraph/SKILL.md
new file mode 100644
index 000000000..a290d4531
--- /dev/null
+++ b/.claude/skills/building-agents-using-langgraph/SKILL.md
@@ -0,0 +1,140 @@
+# Building Agents using LangGraph with Composio
+
+Build stateful, durable AI agents using LangGraph with Composio Tool Router.
+
+## Installation
+
+```bash
+npm install @composio/core @composio/langchain @langchain/langgraph @langchain/core
+```
+
+```bash
+pip install composio-langchain langgraph langgraph-checkpoint-sqlite
+```
+
+**Find Latest Versions:**
+```bash
+npm view @langchain/langgraph version
+pip index versions langgraph | grep "Available versions" | head -1
+```
+
+## Integration Method
+
+**LangGraph is an agentic provider** - use Tool Router for user isolation.
+
+### Python Example with Tool Router
+
+```python
+from langgraph.graph import StateGraph, MessagesAnnotation, START, END
+from langgraph.prebuilt import ToolNode
+from langgraph.checkpoint.sqlite import SqliteSaver
+from langchain_openai import ChatOpenAI
+from composio_langchain import ComposioToolSet
+
+toolset = ComposioToolSet()
+
+def create_agent(user_id: str):
+ # Create session
+ session = toolset.create(
+ user_id=user_id,
+ toolkits=["github"],
+ manage_connections=True
+ )
+
+ tools = session.tools()
+
+ # Create graph
+ tool_node = ToolNode(tools)
+ model = ChatOpenAI(model="gpt-4o").bind_tools(tools)
+
+ def should_continue(state):
+ last_message = state["messages"][-1]
+ return "tools" if hasattr(last_message, "tool_calls") and last_message.tool_calls else END
+
+ def call_model(state):
+ return {"messages": [model.invoke(state["messages"])]}
+
+ workflow = StateGraph(MessagesAnnotation)
+ workflow.add_node("agent", call_model)
+ workflow.add_node("tools", tool_node)
+ workflow.add_edge(START, "agent")
+ workflow.add_edge("tools", "agent")
+ workflow.add_conditional_edges("agent", should_continue)
+
+ # Compile with checkpointer for durability
+ memory = SqliteSaver.from_conn_string(":memory:")
+ app = workflow.compile(checkpointer=memory)
+
+ return app
+
+# Use with thread_id for persistence
+app = create_agent("user_123")
+result = app.invoke(
+ {"messages": [{"role": "user", "content": "Create a GitHub issue"}]},
+ config={"configurable": {"thread_id": "user-123"}}
+)
+```
+
+### TypeScript Example with Tool Router
+
+```typescript
+import { StateGraph, MessagesAnnotation, START, END } from '@langchain/langgraph';
+import { ToolNode } from '@langchain/langgraph/prebuilt';
+import { ChatOpenAI } from '@langchain/openai';
+import { Composio } from '@composio/core';
+import { LangchainProvider } from '@composio/langchain';
+
+const composio = new Composio({
+ apiKey: process.env.COMPOSIO_API_KEY,
+ provider: new LangchainProvider(),
+});
+
+async function createAgent(userId: string) {
+ const session = await composio.create(userId, {
+ toolkits: ['github'],
+ manageConnections: true
+ });
+
+ const tools = await session.tools();
+ const toolNode = new ToolNode(tools);
+ const model = new ChatOpenAI({ model: 'gpt-4o' }).bindTools(tools);
+
+ const workflow = new StateGraph(MessagesAnnotation)
+ .addNode('agent', async (state) => ({ messages: [await model.invoke(state.messages)] }))
+ .addNode('tools', toolNode)
+ .addEdge(START, 'agent')
+ .addEdge('tools', 'agent')
+ .addConditionalEdges('agent', (state) => {
+ const last = state.messages[state.messages.length - 1];
+ return last.tool_calls?.length ? 'tools' : END;
+ });
+
+ return workflow.compile();
+}
+```
+
+## Key Features
+
+- **Durable Execution**: Agents persist through failures
+- **Human-in-the-Loop**: Pause for approvals
+- **Persistent Memory**: State saved across sessions
+- **Production Ready**: v1.0 released late 2025
+
+## Key Resources
+
+- **LangGraph Docs**: https://docs.langchain.com/oss/python/langgraph/
+- **Tool Router Guide**: `/building-agents`
+- **LangGraph v1.0**: https://www.blog.langchain.com/langchain-langgraph-1dot0/
+
+## Environment Variables
+
+```bash
+OPENAI_API_KEY=sk-...
+COMPOSIO_API_KEY=...
+```
+
+## Next Steps
+
+1. Use `/building-agents` for comprehensive guide
+2. Check `ts/examples/langchain/` for complete examples
+3. See [LangGraph docs](https://docs.langchain.com/oss/python/langgraph/) for advanced features
diff --git a/.claude/skills/building-agents-using-llamaindex/SKILL.md b/.claude/skills/building-agents-using-llamaindex/SKILL.md
new file mode 100644
index 000000000..12bdf1bdc
--- /dev/null
+++ b/.claude/skills/building-agents-using-llamaindex/SKILL.md
@@ -0,0 +1,128 @@
+# Building Agents using LlamaIndex with Composio
+
+Build RAG-enhanced AI agents using LlamaIndex with Composio Tool Router.
+
+## Installation
+
+```bash
+npm install @composio/core @composio/llamaindex llamaindex
+```
+
+```bash
+pip install composio-llamaindex llama-index llama-index-llms-openai
+```
+
+**Find Latest Versions:**
+```bash
+npm view llamaindex version
+pip index versions llama-index | grep "Available versions" | head -1
+```
+
+## Integration Method
+
+**LlamaIndex is an agentic provider** - use Tool Router for user isolation.
+
+### Python Example with Tool Router
+
+```python
+from llama_index.core.agent import ReActAgent
+from llama_index.llms.openai import OpenAI
+from composio_llamaindex import ComposioToolSet, App
+
+toolset = ComposioToolSet()
+
+def create_agent(user_id: str):
+ # Create session
+ session = toolset.create(
+ user_id=user_id,
+ toolkits=["github"],
+ manage_connections=True
+ )
+
+ tools = session.tools()
+
+ # Create agent
+ llm = OpenAI(model="gpt-4o")
+ agent = ReActAgent.from_tools(tools, llm=llm, verbose=True)
+
+ return agent
+
+agent = create_agent("user_123")
+response = agent.chat("Create a GitHub issue titled 'Bug Report'")
+print(response)
+```
+
+### TypeScript Example with Tool Router
+
+```typescript
+import { Composio } from '@composio/core';
+import { LlamaIndexProvider } from '@composio/llamaindex';
+import { OpenAI, FunctionCallingAgent } from 'llamaindex';
+
+const composio = new Composio({
+ apiKey: process.env.COMPOSIO_API_KEY,
+ provider: new LlamaIndexProvider(),
+});
+
+async function createAgent(userId: string) {
+ // Create session
+ const session = await composio.create(userId, {
+ toolkits: ['github'],
+ manageConnections: true
+ });
+
+ const tools = await session.tools();
+
+ // Create agent
+ const llm = new OpenAI({ model: 'gpt-4o' });
+ const agent = new FunctionCallingAgent({
+ llm,
+ tools,
+ verbose: true,
+ });
+
+ return agent;
+}
+
+const agent = await createAgent('user_123');
+const response = await agent.chat({ message: 'Create a GitHub issue' });
+```
+
+### MCP Integration
+
+```python
+# LlamaIndex also supports MCP for framework flexibility
+from composio import Composio
+
+composio = Composio()
+session = composio.create(user_id="user_123", toolkits=["github"])
+
+# Use session.mcp.url with LlamaIndex MCP adapters
+```
+
+## Key Features
+
+- **ReAct Agents**: Reasoning + Acting pattern
+- **RAG + Tools**: Combine retrieval with actions
+- **Workflows 1.0**: Event-driven orchestration
+- **Query Engines**: Tools for advanced RAG
+
+## Key Resources
+
+- **LlamaIndex Docs**: https://developers.llamaindex.ai/python/framework/
+- **Tool Router Guide**: `/building-agents`
+- **Agents Guide**: https://developers.llamaindex.ai/python/framework/use_cases/agents/
+- **Workflows**: https://www.llamaindex.ai/blog/announcing-workflows-1-0-a-lightweight-framework-for-agentic-systems
+
+## Environment Variables
+
+```bash
+OPENAI_API_KEY=sk-...
+COMPOSIO_API_KEY=...
+```
+
+## Next Steps
+
+1. Use `/building-agents` for comprehensive guide
+2. Check `ts/examples/llamaindex/` for complete examples
+3. See [LlamaIndex docs](https://developers.llamaindex.ai/) for RAG patterns
diff --git a/.claude/skills/building-agents-using-mastra/SKILL.md b/.claude/skills/building-agents-using-mastra/SKILL.md
new file mode 100644
index 000000000..70504248b
--- /dev/null
+++ b/.claude/skills/building-agents-using-mastra/SKILL.md
@@ -0,0 +1,121 @@
+# Building Agents using Mastra with Composio
+
+Build AI agents using Mastra with Composio Tool Router.
+
+## Installation
+
+```bash
+npm install @composio/core @composio/mastra @mastra/core
+```
+
+**Find Latest Versions:**
+```bash
+npm view @mastra/core version
+npm view @composio/mastra version
+```
+
+## Integration Method
+
+**Mastra is an agentic provider** - use Tool Router for user isolation.
+
+### Native Tools with Tool Router
+
+```typescript
+import { Composio } from '@composio/core';
+import { MastraProvider } from '@composio/mastra';
+import { Agent } from '@mastra/core/agent';
+
+const composio = new Composio({
+ apiKey: process.env.COMPOSIO_API_KEY,
+ provider: new MastraProvider(),
+});
+
+async function createAgent(userId: string) {
+ // Create session
+ const session = await composio.create(userId, {
+ toolkits: ['github'],
+ manageConnections: true
+ });
+
+ const tools = await session.tools();
+
+ // Create agent
+ const agent = new Agent({
+ id: 'github-agent',
+ name: 'GitHub Agent',
+ instructions: 'You manage GitHub repositories',
+ model: 'openai/gpt-4o',
+ tools: {
+ ...tools, // Spread Composio tools
+ },
+ });
+
+ return agent;
+}
+
+const agent = await createAgent('user_123');
+const result = await agent.generate({
+ prompt: 'Create a GitHub issue titled "Bug Report"',
+});
+
+console.log(result.text);
+```
+
+### Streaming with Tool Router
+
+```typescript
+async function streamAgent(userId: string, prompt: string) {
+ const session = await composio.create(userId, {
+ toolkits: ['github'],
+ manageConnections: true
+ });
+
+ const tools = await session.tools();
+
+ const agent = new Agent({
+ id: 'agent',
+ model: 'openai/gpt-4o',
+ tools: { ...tools },
+ maxSteps: 10,
+ });
+
+ // Stream response
+ const stream = await agent.stream({
+ prompt,
+ onStepFinish: (step) => {
+ console.log('Step completed:', step);
+ },
+ });
+
+ for await (const chunk of stream) {
+ process.stdout.write(chunk);
+ }
+}
+```
+
+## Key Features
+
+- **40+ Model Providers**: OpenAI, Anthropic, Google, Mistral, Groq, etc.
+- **Autonomous Agents**: Solve open-ended tasks
+- **Streaming Support**: Real-time responses
+- **v1.0 Released**: January 2026 - production ready
+
+## Key Resources
+
+- **Mastra Docs**: https://mastra.ai/docs
+- **Tool Router Guide**: `/building-agents`
+- **Agents Guide**: https://mastra.ai/docs/agents/overview
+- **GitHub**: https://github.com/mastra-ai/mastra
+
+## Environment Variables
+
+```bash
+OPENAI_API_KEY=sk-... # Or other model provider
+COMPOSIO_API_KEY=...
+```
+
+## Next Steps
+
+1. Use `/building-agents` for comprehensive guide
+2. Check `ts/examples/mastra/` for complete examples
+3. See [Mastra docs](https://mastra.ai/docs) for multi-provider routing
diff --git a/.claude/skills/building-agents-using-openai/SKILL.md b/.claude/skills/building-agents-using-openai/SKILL.md
new file mode 100644
index 000000000..762054a95
--- /dev/null
+++ b/.claude/skills/building-agents-using-openai/SKILL.md
@@ -0,0 +1,125 @@
+# Building Agents using OpenAI with Composio
+
+Build AI agents using OpenAI's APIs with Composio tools.
+
+## Installation
+
+```bash
+npm install @composio/core @composio/openai openai
+npm install @composio/openai-agents @openai/agents # For Agents API
+```
+
+```bash
+pip install composio-openai
+```
+
+**Find Latest Versions:**
+```bash
+npm view openai version
+pip index versions openai | grep "Available versions" | head -1
+```
+
+## Integration Method
+
+**OpenAI is a non-agentic provider** - uses direct tools (no Tool Router support).
+
+### Chat Completions API
+
+```typescript
+import { Composio } from '@composio/core';
+import { OpenAI } from 'openai';
+
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+const composio = new Composio({ apiKey: process.env.COMPOSIO_API_KEY });
+
+// Get tools
+const tools = await composio.tools.get('default', { toolkits: ['github'] });
+
+// Use with OpenAI
+const response = await openai.chat.completions.create({
+ model: 'gpt-4o',
+ messages: [{ role: 'user', content: 'Create a GitHub issue' }],
+ tools: tools,
+});
+
+// Handle tool calls
+if (response.choices[0].message.tool_calls) {
+ const result = await composio.provider.handleToolCalls('default', response);
+}
+```
+
+```python
+from composio_openai import ComposioToolSet, Action
+from openai import OpenAI
+
+openai_client = OpenAI(api_key="YOUR_KEY")
+composio_toolset = ComposioToolSet(api_key="YOUR_KEY")
+
+# Get tools
+tools = composio_toolset.get_tools(actions=[Action.GITHUB_CREATE_ISSUE])
+
+# Use with OpenAI
+response = openai_client.chat.completions.create(
+ model="gpt-4o",
+ messages=[{"role": "user", "content": "Create a GitHub issue"}],
+ tools=tools,
+)
+
+# Handle tool calls
+result = composio_toolset.handle_tool_calls(response)
+```
+
+### OpenAI Agents API (Agentic - Requires Tool Router)
+
+```typescript
+import { Composio } from '@composio/core';
+import { OpenAIAgentsProvider } from '@composio/openai-agents';
+import { Agent, run } from '@openai/agents';
+
+const composio = new Composio({
+ apiKey: process.env.COMPOSIO_API_KEY,
+ provider: new OpenAIAgentsProvider()
+});
+
+async function createAgent(userId: string) {
+ // Create session for user
+ const session = await composio.create(userId, {
+ toolkits: ['github'],
+ manageConnections: true
+ });
+
+ const tools = await session.tools();
+
+ const agent = new Agent({
+ name: 'GitHub Agent',
+ model: 'gpt-4o',
+ instructions: 'You help with GitHub operations',
+ tools
+ });
+
+ return agent;
+}
+
+const agent = await createAgent('user_123');
+const result = await run(agent, 'Create a GitHub issue');
+```
+
+## Key Resources
+
+- **OpenAI Docs**: https://platform.openai.com/docs
+- **Function Calling**: https://platform.openai.com/docs/guides/function-calling
+- **Agents API**: https://platform.openai.com/docs/agents
+- **OpenAI Agents SDK (Agentic)**: Use Tool Router with `@composio/openai-agents`
+
+## Environment Variables
+
+```bash
+OPENAI_API_KEY=sk-...
+COMPOSIO_API_KEY=...
+```
+
+## Next Steps
+
+1. For Agents API (agentic), use `/building-agents`
+2. Check `ts/examples/openai/` for complete examples
+3. See [OpenAI docs](https://platform.openai.com/docs) for API features
diff --git a/.claude/skills/building-agents-using-vercel/SKILL.md b/.claude/skills/building-agents-using-vercel/SKILL.md
new file mode 100644
index 000000000..05b264779
--- /dev/null
+++ b/.claude/skills/building-agents-using-vercel/SKILL.md
@@ -0,0 +1,116 @@
+# Building Agents using Vercel AI SDK with Composio
+
+Build AI agents using Vercel AI SDK with Composio Tool Router for user-isolated tool sessions.
+
+## Installation
+
+```bash
+npm install @composio/core @composio/vercel ai @ai-sdk/openai
+```
+
+**Find Latest Versions:**
+```bash
+npm view ai version
+npm view @composio/vercel version
+```
+
+## Integration Method
+
+**Vercel AI SDK is an agentic provider** - use Tool Router for user isolation.
+
+### Native Tools (Recommended)
+
+```typescript
+import { Composio } from '@composio/core';
+import { VercelProvider } from '@composio/vercel';
+import { openai } from '@ai-sdk/openai';
+import { generateText } from 'ai';
+
+const composio = new Composio({
+ apiKey: process.env.COMPOSIO_API_KEY,
+ provider: new VercelProvider(),
+});
+
+async function runAgent(userId: string, prompt: string) {
+ // Create user session
+ const session = await composio.create(userId, {
+ toolkits: ['github'],
+ manageConnections: true
+ });
+
+ // Get native Vercel-formatted tools
+ const tools = await session.tools();
+
+ // Use with Vercel AI SDK
+ const result = await generateText({
+ model: openai('gpt-4o'),
+ prompt,
+ tools,
+ maxSteps: 10,
+ });
+
+ return result.text;
+}
+
+await runAgent('user_123', 'Create a GitHub issue');
+```
+
+### MCP Integration (Optional)
+
+```typescript
+import { Composio } from '@composio/core';
+import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
+import { streamText } from 'ai';
+
+const composio = new Composio();
+
+async function runAgentMCP(userId: string, prompt: string) {
+ // Create session
+ const session = await composio.create(userId, {
+ toolkits: ['github'],
+ manageConnections: true
+ });
+
+ // Connect via MCP
+ const client = await createMCPClient({
+ transport: {
+ type: 'http',
+ url: session.mcp.url,
+ headers: session.mcp.headers
+ }
+ });
+
+ const tools = await client.tools();
+
+ // Use with any framework
+ const stream = await streamText({
+ model: openai('gpt-4o'),
+ prompt,
+ tools,
+ });
+
+ for await (const chunk of stream.textStream) {
+ process.stdout.write(chunk);
+ }
+}
+```
+
+## Key Resources
+
+- **Vercel AI SDK Docs**: https://ai-sdk.dev/docs/introduction
+- **Tool Router Guide**: `/building-agents`
+- **Building Agents Guide**: https://vercel.com/kb/guide/how-to-build-ai-agents-with-vercel-and-the-ai-sdk
+- **Native vs MCP**: Use native tools for better performance, MCP for framework flexibility
+
+## Environment Variables
+
+```bash
+COMPOSIO_API_KEY=...
+OPENAI_API_KEY=... # Or other model provider
+```
+
+## Next Steps
+
+1. Use `/building-agents` for comprehensive Tool Router documentation
+2. Check `ts/examples/vercel/` for complete examples
+3. See [Vercel AI SDK docs](https://ai-sdk.dev) for framework-specific features
diff --git a/.claude/skills/building-agents/SKILL.md b/.claude/skills/building-agents/SKILL.md
new file mode 100644
index 000000000..f5bb7c8dc
--- /dev/null
+++ b/.claude/skills/building-agents/SKILL.md
@@ -0,0 +1,440 @@
+# Building AI Agents with Composio SDK
+
+This skill provides comprehensive guidance for building AI agents using Composio SDK with various provider frameworks.
+
+## Overview
+
+Composio integrates with 10+ major AI agent frameworks, allowing you to add tools and external integrations to your agents. Each framework-specific skill provides:
+- Installing and setting up the provider SDK
+- Finding latest SDK versions (NPM/PyPI)
+- Official documentation links and latest examples
+- Code examples for building agents with Composio tools
+- Best practices and troubleshooting tips
+
+## Installing Composio Packages
+
+### Working in Composio SDK Repository (This Workspace)
+
+If you're working within the Composio SDK repository itself, install packages from the workspace:
+
+**TypeScript:**
+```bash
+pnpm i @composio/core @composio/<provider> --workspace
+```
+
+**Example:**
+```bash
+pnpm i @composio/core @composio/openai --workspace
+```
+
+### External Projects (Outside SDK Repository)
+
+For projects outside the Composio SDK repository, install from NPM/PyPI:
+
+**TypeScript:**
+```bash
+npm install @composio/core @composio/<provider>
+```
+
+**Python:**
+```bash
+pip install composio-<provider>
+# or
+uv pip install composio-<provider>
+```
+
+**Examples:**
+```bash
+# TypeScript
+npm install @composio/core @composio/openai
+
+# Python
+pip install composio-openai
+```
+
+## Available Framework Skills
+
+Use `/building-agents-using-<framework>` to access specific guides:
+
+### 1. **building-agents-using-openai**
+Build agents using OpenAI's Chat Completions API, Assistants API, and Agents API.
+- **Languages**: TypeScript, Python
+- **Key Features**: Function calling, streaming, parallel tool calls
+- **Models**: GPT-4o, GPT-4o-mini, GPT-4 Turbo
+- **Use Cases**: General-purpose agents, chatbots, automation
+
+**Invoke:** `/building-agents-using-openai`
+
+### 2. **building-agents-using-anthropic**
+Build agents using Anthropic's Claude API and Claude Agent SDK.
+- **Languages**: TypeScript, Python
+- **Key Features**: Prompt caching, long context, thinking blocks
+- **Models**: Claude 3.7 Sonnet, Claude 3.5 Sonnet, Claude 3 Opus
+- **Use Cases**: Complex reasoning, code analysis, long documents
+
+**Invoke:** `/building-agents-using-anthropic`
+
+### 3. **building-agents-using-langchain**
+Build agents using LangChain and LangGraph for production workflows.
+- **Languages**: TypeScript, Python
+- **Key Features**: Graph-based agents, middleware, state management
+- **Framework**: LangGraph recommended for production
+- **Use Cases**: Multi-step workflows, RAG with actions, complex agents
+
+**Invoke:** `/building-agents-using-langchain`
+
+### 4. **building-agents-using-langgraph**
+Build stateful, durable agents using LangGraph (v1.0).
+- **Languages**: TypeScript, Python
+- **Key Features**: Durable execution, human-in-the-loop, persistent memory
+- **Status**: Production-ready (v1.0 released late 2025)
+- **Use Cases**: Long-running workflows, supervised agents, multi-agent systems
+
+**Invoke:** `/building-agents-using-langgraph`
+
+### 5. **building-agents-using-google**
+Build agents using Google's Gemini API and GenAI SDK.
+- **Languages**: TypeScript, Python
+- **Key Features**: Compositional function calling, parallel execution, thinking
+- **Models**: Gemini 3 Flash/Pro, Gemini 2.5 Flash/Pro
+- **Use Cases**: Multi-step workflows, location-based services, data analysis
+
+**Invoke:** `/building-agents-using-google`
+
+### 6. **building-agents-using-vercel**
+Build agents using Vercel AI SDK for TypeScript/JavaScript applications.
+- **Languages**: TypeScript, JavaScript
+- **Key Features**: ToolLoopAgent, streaming, multi-provider support (40+)
+- **Frameworks**: Next.js, Node.js, React, Vue, Svelte
+- **Use Cases**: AI chatbots, web applications, full-stack AI
+
+**Invoke:** `/building-agents-using-vercel`
+
+### 7. **building-agents-using-llamaindex**
+Build RAG-enhanced agents using LlamaIndex.
+- **Languages**: TypeScript, Python
+- **Key Features**: ReAct agents, query engines as tools, workflows
+- **Framework**: Workflows 1.0 for complex agentic systems
+- **Use Cases**: RAG + actions, documentation bots, code assistants
+
+**Invoke:** `/building-agents-using-llamaindex`
+
+### 8. **building-agents-using-mastra**
+Build agents using Mastra, the modern TypeScript framework from the Gatsby team.
+- **Languages**: TypeScript
+- **Key Features**: Autonomous agents, 40+ model providers, streaming
+- **Status**: v1.0 released January 2026
+- **Use Cases**: GitHub automation, web search, multi-tool workflows
+
+**Invoke:** `/building-agents-using-mastra`
+
+### 9. **building-agents-using-cloudflare**
+Build edge-deployed agents using Cloudflare Workers AI and Agents SDK.
+- **Languages**: TypeScript, JavaScript
+- **Key Features**: Edge deployment, embedded function calling, Durable Objects
+- **Platform**: Cloudflare Workers, Workers AI
+- **Use Cases**: Low-latency agents, real-time chat, API orchestration
+
+**Invoke:** `/building-agents-using-cloudflare`
+
+### 10. **building-agents-using-crewai**
+Build multi-agent teams using CrewAI for collaborative AI.
+- **Languages**: Python
+- **Key Features**: Role-based agents, task dependencies, YAML configs
+- **Framework**: Lean, fast, independent of LangChain
+- **Use Cases**: Research & reporting, content creation, data analysis
+
+**Invoke:** `/building-agents-using-crewai`
+
+### 11. **building-agents-using-autogen**
+Build multi-agent conversational systems using Microsoft AutoGen.
+- **Languages**: Python
+- **Key Features**: Multi-agent chat, AutoGen Studio, event-driven core
+- **Status**: Microsoft Agent Framework is the successor
+- **Use Cases**: Multi-agent conversations, research, customer support
+
+**Invoke:** `/building-agents-using-autogen`
+
+## Finding Latest SDK Versions
+
+Each skill includes commands to find the latest versions of both Composio packages and provider SDKs.
+
+### Find Latest Composio Package Version
+
+**NPM (TypeScript):**
+```bash
+npm view @composio/<provider> version
+# Example
+npm view @composio/openai version
+```
+
+**PyPI (Python):**
+```bash
+pip index versions composio-<provider> | grep "Available versions" | head -1
+# Example
+pip index versions composio-openai | grep "Available versions" | head -1
+```
+
+### Find Latest Provider SDK Version
+
+**NPM (TypeScript):**
+```bash
+npm view <provider-package> version
+# Example
+npm view openai version
+```
+
+**PyPI (Python):**
+```bash
+pip index versions <provider-package> | grep "Available versions" | head -1
+# Example
+pip index versions openai | grep "Available versions" | head -1
+```
+
+## Tool Router vs Direct Tools
+
+Composio SDK supports two integration methods based on the provider type:
+
+### πŸ€– Agentic Providers (Tool Router ONLY)
+
+These frameworks support full modifier capabilities and **MUST use Tool Router** for user-isolated sessions:
+
+| Framework | Package | Why Tool Router |
+|-----------|---------|----------------|
+| **Vercel AI SDK** | `@composio/vercel` | Multi-agent support, modifiers |
+| **LangChain** | `@composio/langchain` | Complex chains, state management |
+| **LangGraph** | `@composio/langchain` | Stateful workflows, durability |
+| **Mastra** | `@composio/mastra` | Multi-provider routing |
+| **LlamaIndex** | `@composio/llamaindex` | RAG + agents, workflows |
+| **Claude Agent SDK** | `@composio/claude-agent-sdk` | Claude agents framework |
+| **OpenAI Agents** | `@composio/openai-agents` | OpenAI Agents API |
+| **Cloudflare** | `@composio/cloudflare` | Edge agents, Durable Objects |
+| **CrewAI** | Python | Multi-agent teams |
+| **AutoGen** | Python | Multi-agent conversations |
+
+**Tool Router Benefits:**
+- βœ… **User Isolation**: Each user gets their own tool session
+- βœ… **Auto-Authentication**: In-chat OAuth flows
+- βœ… **Scoped Access**: Control toolkits per user
+- βœ… **Connection Management**: Automatic OAuth handling
+- βœ… **Production Ready**: Built for multi-user applications
+
+### πŸ“¦ Non-Agentic Providers (Direct Tools)
+
+These providers only support schema modifiers and use **direct tools** approach:
+
+| Framework | Package | Why Direct Tools |
+|-----------|---------|-----------------|
+| **OpenAI** | `@composio/openai` | Chat Completions, Assistants API |
+| **Anthropic** | `@composio/anthropic` | Claude Messages API |
+| **Google Gemini** | `@composio/google` | GenAI SDK |
+
+**Direct Tools Characteristics:**
+- βœ… Simpler for single-user apps
+- βœ… No session management needed
+- ⚠️ Not suitable for multi-user production apps
+- ⚠️ Manual authentication required
+
+### Tool Router Quick Start
+
+```typescript
+import { Composio } from '@composio/core';
+import { OpenAI } from 'openai';
+
+const composio = new Composio();
+const openai = new OpenAI();
+
+async function runAgent(userId: string, prompt: string) {
+ // Create isolated session for user
+ const session = await composio.create(userId, {
+ toolkits: ['github'],
+ manageConnections: true // Enable auto-authentication
+ });
+
+ // Get tools from session
+ const tools = await session.tools();
+
+ // Use with OpenAI
+ const response = await openai.chat.completions.create({
+ model: 'gpt-4o',
+ messages: [{ role: 'user', content: prompt }],
+ tools: tools,
+ });
+
+ // Handle tool calls
+ if (response.choices[0].message.tool_calls) {
+ const result = await composio.provider.handleToolCalls(userId, response);
+ return result;
+ }
+}
+
+// Each user gets isolated tools
+await runAgent('user_123', 'Create a GitHub issue');
+await runAgent('user_456', 'Check my Gmail'); // Different user, different session
+```
+
+### Tool Router with Framework Integration
+
+Each framework skill includes Tool Router examples. See:
+- `/building-agents-using-openai` - Tool Router with OpenAI
+- `/building-agents-using-anthropic` - Tool Router with Claude
+- `/building-agents-using-vercel` - Tool Router with Vercel AI SDK
+- And all other framework skills
+
+### Learn More About Tool Router
+
+For comprehensive Tool Router documentation, use:
+```bash
+/composio-tool-router
+```
+
+## Quick Start Example
+
+Here's a quick example using OpenAI with direct tools (single-user):
+
+### TypeScript
+
+```typescript
+import { Composio } from '@composio/core';
+import { OpenAI } from 'openai';
+
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+const composio = new Composio({ apiKey: process.env.COMPOSIO_API_KEY });
+
+// Get tools
+const tools = await composio.tools.get('default', { toolkits: ['github'] });
+
+// Use with OpenAI
+const response = await openai.chat.completions.create({
+ model: 'gpt-4o',
+ messages: [{ role: 'user', content: 'Create a GitHub issue' }],
+ tools: tools,
+});
+
+// Handle tool calls
+if (response.choices[0].message.tool_calls) {
+ const result = await composio.provider.handleToolCalls('default', response);
+ console.log(result);
+}
+```
+
+### Python
+
+```python
+from composio_openai import ComposioToolSet, Action
+from openai import OpenAI
+
+openai_client = OpenAI(api_key="YOUR_OPENAI_KEY")
+composio_toolset = ComposioToolSet(api_key="YOUR_COMPOSIO_KEY")
+
+# Get tools
+tools = composio_toolset.get_tools(actions=[Action.GITHUB_CREATE_ISSUE])
+
+# Use with OpenAI
+response = openai_client.chat.completions.create(
+ model="gpt-4o",
+ messages=[{"role": "user", "content": "Create a GitHub issue"}],
+ tools=tools,
+)
+
+# Handle tool calls
+result = composio_toolset.handle_tool_calls(response)
+```
+
+## Provider Comparison
+
+| Provider | Languages | Best For | Complexity | Maturity |
+|----------|-----------|----------|------------|----------|
+| OpenAI | TS, Py | General purpose, function calling | Low | Mature |
+| Anthropic | TS, Py | Complex reasoning, long context | Low | Mature |
+| LangChain | TS, Py | Prototyping multi-agent workflows | Medium | Mature |
+| LangGraph | TS, Py | Production stateful agents | High | Mature (v1.0) |
+| Google Gemini | TS, Py | Compositional function calling | Low | Mature |
+| Vercel AI SDK | TS | Full-stack web applications | Low | Mature (v6.0) |
+| LlamaIndex | TS, Py | RAG + agents | Medium | Mature |
+| Mastra | TS | Modern TypeScript apps | Low | New (v1.0 2026) |
+| Cloudflare | TS | Edge-deployed agents | Medium | Growing |
+| CrewAI | Py | Multi-agent teams | Medium | Mature |
+| AutoGen | Py | Research multi-agent systems | High | Mature |
+
+## Common Composio Features
+
+All frameworks support these Composio features:
+
+### 1. Tool Management
+```typescript
+// Get tools by app
+const tools = await composio.tools.get('default', { apps: ['github', 'slack'] });
+
+// Get specific actions
+const tools = await composio.tools.get('default', { actions: ['GITHUB_CREATE_ISSUE'] });
+
+// Get by toolkit
+const tools = await composio.tools.get('default', { toolkits: ['github'] });
+```
+
+### 2. Connected Accounts
+```typescript
+// Manage user integrations
+const account = await composio.connectedAccounts.initiate({
+ integrationId: 'github',
+ entityId: 'user-123',
+});
+```
+
+### 3. Custom Tools
+```typescript
+// Create custom tools
+const customTool = await composio.tools.createCustomTool({
+ name: 'My Tool',
+ description: 'Tool description',
+ execute: async (input) => {
+ // Implementation
+ return { data: 'result' };
+ },
+});
+```
+
+## Environment Variables
+
+Most examples require:
+
+```bash
+# Composio
+COMPOSIO_API_KEY=...
+
+# LLM Provider (choose one or more)
+OPENAI_API_KEY=sk-...
+ANTHROPIC_API_KEY=sk-ant-...
+GOOGLE_API_KEY=...
+```
+
+## Documentation Resources
+
+- **Composio Docs**: https://docs.composio.dev/
+- **Composio GitHub**: https://github.com/composiohq/composio-sdk
+- **API Reference**: https://docs.composio.dev/api-reference
+- **Examples**: Check `ts/examples/` and `python/examples/` in this repository
+
+## Getting Help
+
+- **Discord**: https://discord.gg/composio
+- **GitHub Issues**: https://github.com/composiohq/composio-sdk/issues
+- **Documentation**: https://docs.composio.dev/
+
+## Next Steps
+
+1. Choose a framework from the list above
+2. Invoke the corresponding skill (e.g., `/building-agents-using-openai`)
+3. Follow the installation and setup instructions
+4. Try the code examples
+5. Build your agent!
+
+## Tips
+
+- **Start simple** - Begin with OpenAI or Anthropic for easiest setup
+- **Use LangGraph** for production stateful agents
+- **Try Vercel AI SDK** for full-stack web applications
+- **Use CrewAI** for multi-agent collaborative systems
+- **Check examples** in the repository for working code
+- **Read framework docs** linked in each skill for advanced features
diff --git a/.claude/skills/test-sdk-in-realworld/SKILL.md b/.claude/skills/test-sdk-in-realworld/SKILL.md
new file mode 100644
index 000000000..d8174c6c0
--- /dev/null
+++ b/.claude/skills/test-sdk-in-realworld/SKILL.md
@@ -0,0 +1,216 @@
+# Testing Composio SDK in Real-World Scenarios
+
+Test the Composio SDK viability using ephemeral test projects. Never commit these tests.
+
+## Overview
+
+This skill helps validate SDK functionality by creating temporary test projects that:
+- Test both agentic (Tool Router) and non-agentic (Direct Tools) approaches
+- Use non-auth apps like HackerNews for quick validation
+- Identify bugs and quality issues in SDK or providers
+- Clean up automatically - never committed to repository
+
+## Testing Approach
+
+### 1. Create Ephemeral Test Project
+
+Always use the .agent_cache directory for tests:
+```bash
+# Create test directory in .agent_cache (gitignored)
+TEST_DIR=".agent_cache/sdk-test-$(date +%s)"
+mkdir -p "$TEST_DIR"
+cd "$TEST_DIR"
+
+# Initialize project
+npm init -y
+npm install @composio/core openai
+```
+
+### 2. Test Non-Agentic Providers (Direct Tools)
+
+Test simple tool execution without Tool Router:
+
+```typescript
+// test-direct-tools.ts
+import { Composio } from '@composio/core';
+import OpenAI from 'openai';
+
+const composio = new Composio({ apiKey: process.env.COMPOSIO_API_KEY });
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+async function testDirectTools() {
+ // Get HackerNews tools (no auth required)
+ const tools = await composio.tools.get('default', {
+ toolkits: ['hackernews']
+ });
+
+ console.log(`βœ“ Got ${tools.length} HackerNews tools`);
+
+ // Test with OpenAI
+ const response = await openai.chat.completions.create({
+ model: 'gpt-5.2',
+ messages: [{ role: 'user', content: 'Get top 5 HackerNews stories' }],
+ tools: tools,
+ });
+
+ // Handle tool calls
+ if (response.choices[0].message.tool_calls) {
+ const result = await composio.provider.handleToolCalls('default', response);
+ console.log('βœ“ Tool execution successful');
+ return result;
+ }
+}
+
+testDirectTools().catch(console.error);
+```
+
+### 3. Test Agentic Providers (Tool Router)
+
+Test user-isolated sessions with Tool Router:
+
+```typescript
+// test-tool-router.ts
+import { Composio } from '@composio/core';
+import { VercelProvider } from '@composio/vercel';
+import { openai } from '@ai-sdk/openai';
+import { generateText } from 'ai';
+
+const composio = new Composio({
+ apiKey: process.env.COMPOSIO_API_KEY,
+ provider: new VercelProvider(),
+});
+
+async function testToolRouter() {
+ // Create session for test user
+ const session = await composio.create('test-user-001', {
+ toolkits: ['hackernews'],
+ manageConnections: false, // Non-auth app
+ });
+
+ console.log('βœ“ Created Tool Router session');
+
+ const tools = await session.tools();
+ console.log(`βœ“ Got ${Object.keys(tools).length} tools from session`);
+
+ // Test with Vercel AI SDK
+ const result = await generateText({
+ model: openai('gpt-5.2'),
+ prompt: 'Get the top 3 HackerNews stories',
+ tools,
+ maxSteps: 5,
+ });
+
+ console.log('βœ“ Tool Router execution successful');
+ return result.text;
+}
+
+testToolRouter().catch(console.error);
+```
+
+### 4. Test MCP Integration
+
+Test MCP protocol compatibility:
+
+```typescript
+// test-mcp.ts
+import { Composio } from '@composio/core';
+
+const composio = new Composio({ apiKey: process.env.COMPOSIO_API_KEY });
+
+async function testMCP() {
+ const session = await composio.create('test-user-mcp', {
+ toolkits: ['hackernews'],
+ manageConnections: false,
+ });
+
+ console.log('βœ“ MCP Session created');
+ console.log(' URL:', session.mcp.url);
+ console.log(' Headers:', Object.keys(session.mcp.headers));
+
+ // Test MCP endpoint accessibility
+ const response = await fetch(session.mcp.url + '/tools', {
+ headers: session.mcp.headers,
+ });
+
+ console.log('βœ“ MCP endpoint accessible:', response.ok);
+ return response.ok;
+}
+
+testMCP().catch(console.error);
+```
+
+## Running Tests
+
+```bash
+# Run direct tools test
+npx tsx test-direct-tools.ts
+
+# Run Tool Router test
+npm install @composio/vercel ai @ai-sdk/openai
+npx tsx test-tool-router.ts
+
+# Run MCP test
+npx tsx test-mcp.ts
+
+# Clean up (always run after testing)
+cd .. && rm -rf "$TEST_DIR"
+```
+
+## What to Test
+
+1. **Installation**: Does `npm install @composio/core` work?
+2. **Type Safety**: Are TypeScript types correct?
+3. **Tool Discovery**: Can we fetch tools from toolkits?
+4. **Tool Execution**: Do tools execute successfully?
+5. **Error Handling**: Are errors informative?
+6. **Session Management**: Does Tool Router create sessions?
+7. **MCP Protocol**: Is MCP endpoint accessible?
+8. **Provider Integration**: Do provider packages work?
+
+## Reporting Issues
+
+When you find bugs or quality issues:
+
+1. **SDK Core Issues**: Report in GitHub Issues with:
+ - Minimal reproduction code
+ - Expected vs actual behavior
+ - SDK version and environment
+
+2. **Provider Issues**: Note which provider package has issues
+
+3. **Documentation Issues**: Flag missing or incorrect docs
+
+## Best Practices
+
+- **Always use .agent_cache**: Never create tests in the main repository
+- **Use non-auth apps**: HackerNews, Public APIs for quick testing
+- **Test incrementally**: Start with simple tools, then complex workflows
+- **Clean up**: Always delete test directory after testing
+- **Check latest versions**: Use `npm view @composio/core version`
+
+## Available Environment Variables
+
+Assume these are available:
+```bash
+COMPOSIO_API_KEY # Composio API key
+OPENAI_API_KEY # OpenAI API key
+ANTHROPIC_API_KEY # Anthropic API key
+```
+
+## Quick Test Template
+
+```bash
+# One-liner to create and test
+TEST_DIR=".agent_cache/sdk-test-$(date +%s)" && \
+mkdir -p "$TEST_DIR" && cd "$TEST_DIR" && \
+npm init -y && npm install @composio/core openai && \
+echo "console.log('SDK Test Ready')" > test.ts && \
+npx tsx test.ts && \
+cd .. && rm -rf "$TEST_DIR"
+```
+
+## Next Steps
+
+1. Read `/building-agents` for comprehensive Tool Router documentation
+2. Check provider-specific skills for integration examples
+3. Report any bugs found during testing to the team