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.

Update readme for openai agents

haxzie5c844b7d89d9
diff --git a/packages/providers/openai-agents/README.md b/packages/providers/openai-agents/README.md
index dad7fb19c..0c6be6d1c 100644
--- a/packages/providers/openai-agents/README.md
+++ b/packages/providers/openai-agents/README.md
@@ -1,24 +1,22 @@
-# @composio/vercel
+# @composio/openai-agents
-The Vercel AI SDK provider for Composio SDK, providing seamless integration with Vercel's AI SDK and tools.
+The OpenAI Agents API provider for Composio SDK, providing seamless integration with OpenAI's Agents API and tools.
## Features
-- **Vercel AI SDK Integration**: Seamless integration with Vercel's AI SDK
-- **Streaming Support**: First-class support for streaming responses
-- **Model Agnostic**: Works with any model supported by Vercel AI SDK (OpenAI, Anthropic, etc.)
-- **UI Components**: Integration with Vercel's React components for chat interfaces
-- **Tool Execution**: Execute tools with proper parameter handling and streaming
+- **OpenAI Agents Integration**: Seamless integration with OpenAI's Agents SDK
+- **Tool Integration**: Easy integration of Composio tools with OpenAI Agents
- **Type Safety**: Full TypeScript support with proper type definitions
+- **Strict Mode**: Support for strict mode tool parameter validation
## Installation
```bash
-npm install @composio/vercel ai
+npm install @composio/openai-agents @openai/agents
# or
-yarn add @composio/vercel ai
+yarn add @composio/openai-agents @openai/agents
# or
-pnpm add @composio/vercel ai
+pnpm add @composio/openai-agents @openai/agents
```
## Environment Variables
@@ -26,213 +24,55 @@ pnpm add @composio/vercel ai
Required environment variables:
- `COMPOSIO_API_KEY`: Your Composio API key
+- `OPENAI_API_KEY`: Your OpenAI API key
-Optional environment variables (based on model choice):
-
-- `OPENAI_API_KEY`: Your OpenAI API key (if using OpenAI)
-- `ANTHROPIC_API_KEY`: Your Anthropic API key (if using Anthropic)
-- `GEMINI_API_KEY`: Your Google AI API key (if using Gemini)
-
-## Quick Start
+## Example
```typescript
+import { OpenAIAgentsProvider } from '@composio/openai-agents';
import { Composio } from '@composio/core';
-import { VercelProvider } from '@composio/vercel';
+import { Agent, run } from '@openai/agents';
-// Initialize Composio with Vercel provider
const composio = new Composio({
- apiKey: 'your-composio-api-key',
- provider: new VercelProvider(),
-});
-
-// Get available tools
-const tools = await composio.tools.get('user123', {
- toolkits: ['gmail', 'googlecalendar'],
- limit: 10,
+ provider: new OpenAIAgentsProvider(),
});
-// Get a specific tool
-const sendEmailTool = await composio.tools.get('user123', 'GMAIL_SEND_EMAIL');
-```
-
-## Examples
-
-Check out our complete example implementations:
-
-- [Basic Vercel Integration](../../examples/vercel/src/index.ts)
-
-### Basic Chat Completion with Streaming
-
-```typescript
-import { Composio } from '@composio/core';
-import { VercelProvider } from '@composio/vercel';
-import { useChat } from 'ai/react';
-
-// Initialize Composio with Vercel provider
-const composio = new Composio({
- apiKey: process.env.COMPOSIO_API_KEY,
- provider: new VercelProvider()
+// Fetch tools from Composio
+const tools = await composio.tools.get('default', 'HACKERNEWS_GET_USER', {
+ beforeExecute: async (toolSlug, toolkitSlug, params) => {
+ console.log(`πŸ”„ Executing tool ${toolSlug} from toolkit ${toolkitSlug}...`);
+ return params;
+ },
+ afterExecute: async (toolSlug, toolkitSlug, result) => {
+ console.log(`βœ… Tool ${toolSlug} executed`);
+ return result;
+ },
});
-// In your React component
-function ChatComponent() {
- const { messages, input, handleInputChange, handleSubmit } = useChat({
- api: '/api/chat',
- });
-
- return (
- <div>
- {messages.map(m => (
- <div key={m.id}>
- {m.role === 'user' ? 'User: ' : 'AI: '}
- {m.content}
- </div>
- ))}
-
- <form onSubmit={handleSubmit}>
- <input
- value={input}
- onChange={handleInputChange}
- placeholder="Say something..."
- />
- <button type="submit">Send</button>
- </form>
- </div>
- );
-}
-
-// In your API route (e.g. app/api/chat/route.ts)
-import { streamText } from 'ai';
-import { openai } from '@ai-sdk/openai';
-
-export async function POST(req: Request) {
- const { messages } = await req.json();
- const tools = await composio.tools.get('user123', {
- toolkits: ['gmail'],
- });
-
- const result = streamText({
- model: openai('gpt-4'),
- messages,
- tools,
- });
-
- return result.toDataStreamResponse();
-}
-```
-
-### Tool Execution with Streaming
-
-```typescript
-import { Composio } from '@composio/core';
-import { VercelProvider } from '@composio/vercel';
-import { streamText } from 'ai';
-
-const composio = new Composio({
- apiKey: process.env.COMPOSIO_API_KEY,
- provider: new VercelProvider(),
+// Create an agent with the tools
+const agent = new Agent({
+ name: 'Hackernews assistant',
+ tools: tools,
});
-// Example API route that handles tool execution
-export async function POST(req: Request) {
- const { messages } = await req.json();
- const tools = await composio.tools.get('user123', {
- toolkits: ['gmail', 'googlecalendar'],
- });
-
- const stream = streamText({
- model: openai('gpt-4'),
- messages,
- tools,
- callbacks: {
- onToolCall: async tool => {
- // Execute the tool and return result
- return await composio.provider.executeToolCall(tool);
- },
- },
- });
-
- return stream.toDataStreamResponse();
-}
+// Run the agent with a query
+const result = await run(agent, 'Tell me about the user `pg` in hackernews');
```
## Provider Configuration
-The Vercel provider can be configured with various options:
-
-```typescript
-const provider = new VercelProvider({
- // Default model configuration
- model: openai('gpt-4'),
- // Custom execution modifiers
- modifiers: {
- beforeExecute: params => {
- // Transform parameters before execution
- return params;
- },
- afterExecute: response => {
- // Transform response after execution
- return response;
- },
- },
-});
-```
-
-### Strict Mode
-
-When using tools with Vercel AI SDK, you might need to ensure that all tool parameters are marked as required. This is because Vercel AI SDK's function calling implementation requires all fields to be marked as required. You can enable strict mode when fetching tools to automatically remove all non-required properties from both input and output parameters:
+The OpenAI Agents provider can be configured with various options:
```typescript
-// Get tools with strict mode enabled
-const tools = await composio.tools.get('user123', {
- toolkits: ['gmail', 'googlecalendar'],
- strict: true, // This will remove all non-required properties from tool parameters
-});
-
-// Use these tools with Vercel AI SDK
-const stream = streamText({
- model: openai('gpt-4'),
- messages,
- tools, // These tools will only have required parameters
+const provider = new OpenAIAgentsProvider({
+ strict: true, // Enable strict mode for tool parameters
});
```
-For more information about strict mode in function calling, see [OpenAI's documentation](https://platform.openai.com/docs/guides/function-calling#strict-mode).
-
-## API Reference
-
-### VercelProvider Class
-
-The `VercelProvider` class extends `BaseComposioProvider` and provides Vercel AI SDK-specific functionality.
-
-#### Methods
-
-##### `executeToolCall(tool: ToolCall): Promise<string>`
-
-Executes a tool call and returns the result.
-
-```typescript
-const result = await provider.executeToolCall(toolCall);
-```
-
-##### `handleToolCalls(stream: AIStream): AsyncGenerator<AIStreamEvent>`
-
-Handles tool calls from a stream and yields events.
-
-```typescript
-for await (const event of provider.handleToolCalls(stream)) {
- // Handle events
-}
-```
-
-## Contributing
-
-We welcome contributions! Please see our [Contributing Guide](../../CONTRIBUTING.md) for more details.
-
-## License
-
-ISC License
+## Documentation
-## Support
+For more information about OpenAI Agents and how to use them, see:
-For support, please visit our [Documentation](https://docs.composio.dev) or join our [Discord Community](https://discord.gg/composio).
+- [OpenAI Strict Mode](https://openai.github.io/openai-agents-js/guides/tools/#options-reference)
+- [OpenAI Agents SDK Documentation](https://openai.github.io/openai-agents-js/)
+- [OpenAI Agents SDK GitHub](https://github.com/openai/openai-agents-js)
diff --git a/packages/providers/openai/README.md b/packages/providers/openai/README.md
index 921171428..f8a2c4c94 100644
--- a/packages/providers/openai/README.md
+++ b/packages/providers/openai/README.md
@@ -10,6 +10,7 @@ The OpenAI provider for Composio SDK, providing seamless integration with OpenAI
- **Tool Execution**: Execute tools with proper parameter handling
- **Type Safety**: Full TypeScript support with proper type definitions
- **Model Support**: Support for all OpenAI models (GPT-4, GPT-3.5-turbo, etc.)
+- **Responses API Support**: First-class support for OpenAI's Responses API
## Installation
@@ -37,12 +38,14 @@ Optional environment variables:
```typescript
import { Composio } from '@composio/core';
-import { OpenAIProvider } from '@composio/openai';
+import { OpenAIProvider, OpenAIResponsesProvider } from '@composio/openai';
// Initialize Composio with OpenAI provider
const composio = new Composio({
apiKey: 'your-composio-api-key',
- provider: new OpenAIProvider(),
+ provider: new OpenAIProvider(), // For Chat Completions API
+ // OR
+ provider: new OpenAIResponsesProvider(), // For Responses API
});
// Get available tools
@@ -63,6 +66,7 @@ Check out our complete example implementations:
- [Chat Completions Example](../../examples/openai/src/chat-completions.ts)
- [Assistants Example](../../examples/openai/src/assistants.ts)
- [Tools Example](../../examples/openai/src/tools.ts)
+- [Responses API Example](../../examples/openai/src/responses-api/index.ts)
### Basic Chat Completion with Streaming
@@ -98,6 +102,59 @@ export async function POST(req: Request) {
}
```
+### Using the Responses API
+
+```typescript
+import { Composio } from '@composio/core';
+import { OpenAIResponsesProvider } from '@composio/openai';
+import OpenAI from 'openai';
+
+const openai = new OpenAI();
+const composio = new Composio({
+ provider: new OpenAIResponsesProvider(),
+});
+
+// Get tools from Composio
+const tools = await composio.tools.get('default', 'HACKERNEWS_GET_USER');
+
+// Generate initial response from OpenAI
+const initialResponse = await openai.responses.create({
+ model: 'gpt-4.1',
+ input: 'Tell me about the user `pg` in hackernews',
+ tools,
+});
+
+// Handle tool calls from response
+const modelInputs = await composio.provider.handleResponse(
+ 'default',
+ initialResponse,
+ {},
+ {
+ beforeExecute: async (toolSlug, toolkitSlug, params) => {
+ console.log(`πŸ”„ Executing tool ${toolSlug} from toolkit ${toolkitSlug}...`);
+ return params;
+ },
+ afterExecute: async (toolSlug, toolkitSlug, result) => {
+ console.log(`βœ… Tool ${toolSlug} executed`);
+ return result;
+ },
+ }
+);
+
+// Submit tool outputs back to OpenAI
+const finalResponse = await openai.responses.create({
+ model: 'gpt-4.1',
+ input: [...initialResponse.output, ...modelInputs],
+ tools,
+});
+
+// Process the final response
+const finalContent = finalResponse.output[0];
+if (finalContent.type === 'message' && finalContent.content[0].type === 'output_text') {
+ console.log(finalContent.content[0].text);
+}
+```
+
### Tool Execution with Streaming
```typescript
@@ -145,110 +202,65 @@ export async function POST(req: Request) {
}
```
-### JSON Mode Example
+## Provider Configuration
+
+The OpenAI providers can be configured with various options:
```typescript
-import { Composio } from '@composio/core';
-import { OpenAIProvider } from '@composio/openai';
-import OpenAI from 'openai';
+// For Chat Completions API
+const provider = new OpenAIProvider();
-const composio = new Composio({
- apiKey: process.env.COMPOSIO_API_KEY,
- provider: new OpenAIProvider(),
+// For Responses API
+const responsesProvider = new OpenAIResponsesProvider({
+ // Whether to enforce strict parameter validation
+ strict: true, // Default: false
});
+```
-// Example API route that returns JSON
-export async function POST(req: Request) {
- const { messages } = await req.json();
- const tools = await composio.tools.get('user123', {
- toolkits: ['gmail'],
- });
+## API Reference
- const completion = await openai.chat.completions.create({
- model: 'gpt-4',
- messages,
- tools,
- response_format: { type: 'json_object' },
- });
+### OpenAIProvider Class
- return Response.json(JSON.parse(completion.choices[0].message.content || '{}'));
-}
-```
+The `OpenAIProvider` class extends `BaseComposioProvider` and provides OpenAI-specific functionality for the Chat Completions API.
-### Vision Example
+#### Methods
-```typescript
-import { Composio } from '@composio/core';
-import { OpenAIProvider } from '@composio/openai';
-import OpenAI from 'openai';
+##### `executeToolCall(tool: ToolCall): Promise<string>`
-const composio = new Composio({
- apiKey: process.env.COMPOSIO_API_KEY,
- provider: new OpenAIProvider(),
-});
+Executes a tool call and returns the result.
-// Example API route that handles image analysis
-export async function POST(req: Request) {
- const { messages, image } = await req.json();
- const tools = await composio.tools.get('user123', {
- toolkits: ['gmail'],
- });
+```typescript
+const result = await provider.executeToolCall(toolCall);
+```
- const completion = await openai.chat.completions.create({
- model: 'gpt-4-vision-preview',
- messages: [
- ...messages,
- {
- role: 'user',
- content: [
- { type: 'text', text: 'What do you see in this image?' },
- { type: 'image_url', image_url: image },
- ],
- },
- ],
- tools,
- max_tokens: 500,
- });
+### OpenAIResponsesProvider Class
- return Response.json({
- content: completion.choices[0].message.content,
- });
-}
-```
+The `OpenAIResponsesProvider` class extends `BaseNonAgenticProvider` and provides OpenAI-specific functionality for the Responses API.
-## Provider Configuration
+#### Methods
+
+##### `handleResponse(userId: string, response: OpenAI.Responses.Response, options?: ExecuteToolFnOptions, modifiers?: ExecuteToolModifiers): Promise<OpenAI.Responses.ResponseInputItem.FunctionCallOutput[]>`
-The OpenAI provider can be configured with various options:
+Handles tool calls from an OpenAI response and returns the tool outputs.
```typescript
-const provider = new OpenAIProvider({
- // Custom base URL for Azure OpenAI
- baseURL: 'https://your-azure-endpoint.openai.azure.com',
- // Organization ID
- organization: 'org-123',
- // Default model to use
- defaultModel: 'gpt-4',
- // Custom headers
- headers: {
- 'api-key': process.env.OPENAI_API_KEY,
- },
-});
+const outputs = await provider.handleResponse('user123', response);
```
-## API Reference
+##### `handleToolCalls(userId: string, toolCalls: OpenAI.Responses.ResponseOutputItem[], options?: ExecuteToolFnOptions, modifiers?: ExecuteToolModifiers): Promise<OpenAI.Responses.ResponseInputItem.FunctionCallOutput[]>`
-### OpenAIProvider Class
+Handles specific tool calls from an OpenAI response.
-The `OpenAIProvider` class extends `BaseComposioProvider` and provides OpenAI-specific functionality.
-
-#### Methods
+```typescript
+const outputs = await provider.handleToolCalls('user123', toolCalls);
+```
-##### `executeToolCall(tool: ToolCall): Promise<string>`
+##### `executeToolCall(userId: string, tool: OpenAI.Responses.ResponseFunctionToolCall, options?: ExecuteToolFnOptions, modifiers?: ExecuteToolModifiers): Promise<string>`
-Executes a tool call and returns the result.
+Executes a single tool call and returns the result.
```typescript
-const result = await provider.executeToolCall(toolCall);
+const result = await provider.executeToolCall('user123', toolCall);
```
## Contributing