integrate-sdk 0.1.5 → 0.1.7

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Integrate SDK Contributors
+Copyright (c) 2025 Revyo Software, LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -6,35 +6,7 @@
 
 A type-safe TypeScript SDK for connecting to the Integrate MCP (Model Context Protocol) server. Access GitHub, Gmail, Notion, and other integrations through a simple, plugin-based API.
 
-**Server:** `https://mcp.integrate.dev/api/v1/mcp`
-
-## Table of Contents
-
-- [What is this SDK?](#what-is-this-sdk)
-- [Features](#features)
-- [Installation](#installation)
-- [Quick Start](#quick-start)
-- [Built-in Plugins](#built-in-plugins)
-  - [GitHub Plugin](#github-plugin)
-  - [Gmail Plugin](#gmail-plugin)
-- [Creating Custom Plugins](#creating-custom-plugins)
-- [Integration with Vercel AI SDK](#integration-with-vercel-ai-sdk)
-- [Advanced Usage](#advanced-usage)
-- [API Reference](#api-reference)
-- [Architecture](#architecture)
-- [How It Works](#how-it-works)
-
-## What is this SDK?
-
-This SDK is a **client library** that connects to the Integrate MCP server to access various third-party integrations.
-
-**Key concepts:**
-1. **Connect to the Integrate MCP server** - The SDK connects to `https://mcp.integrate.dev/api/v1/mcp`
-2. **Configure OAuth credentials** - You provide your own OAuth app credentials for each integration (GitHub, Gmail, etc.)
-3. **Call tools** - Execute actions like creating GitHub issues, sending emails, searching Notion pages
-4. **OAuth flow happens server-side** - The SDK sends your OAuth config to the server, which handles the actual authentication flow
-
-**Important:** You need to create your own OAuth apps (e.g., GitHub OAuth app, Google OAuth app) and provide the credentials to the SDK. The SDK does not provide OAuth credentials.
+**📚 [Full Documentation](https://integrate.dev)** | **Server:** `https://mcp.integrate.dev/api/v1/mcp`
 
 ## Features
 
@@ -56,7 +28,7 @@ bun add integrate-sdk
 ## Quick Start
 
 ```typescript
-import { createMCPClient, githubPlugin, gmailPlugin } from 'integrate-sdk';
+import { createMCPClient, githubPlugin } from "integrate-sdk";
 
 // Create a client with plugins
 const client = createMCPClient({
@@ -64,11 +36,7 @@ const client = createMCPClient({
     githubPlugin({
       clientId: process.env.GITHUB_CLIENT_ID!,
       clientSecret: process.env.GITHUB_CLIENT_SECRET!,
-      scopes: ['repo', 'user'],
-    }),
-    gmailPlugin({
-      clientId: process.env.GMAIL_CLIENT_ID!,
-      clientSecret: process.env.GMAIL_CLIENT_SECRET!,
+      scopes: ["repo", "user"],
     }),
   ],
 });
@@ -76,636 +44,123 @@ const client = createMCPClient({
 // Connect to the server
 await client.connect();
 
-// Call tools
-const result = await client.callTool('github_create_issue', {
-  repo: 'owner/repo',
-  title: 'Bug report',
-  body: 'Description of the bug',
+// Call a tool
+const result = await client.callTool("github_create_issue", {
+  repo: "owner/repo",
+  title: "Bug report",
+  body: "Description of the bug",
 });
 
-console.log('Issue created:', result);
+console.log("Issue created:", result);
 
 // Disconnect when done
 await client.disconnect();
 ```
 
+**Need help?** Check out the [complete documentation](https://integrate.dev) for detailed guides, examples, and API reference.
+
 ## Built-in Plugins
 
 ### GitHub Plugin
 
-```typescript
-import { createMCPClient, githubPlugin } from 'integrate-sdk';
+Access GitHub repositories, issues, pull requests, and more.
 
-const client = createMCPClient({
-  plugins: [
-    githubPlugin({
-      clientId: process.env.GITHUB_CLIENT_ID!,
-      clientSecret: process.env.GITHUB_CLIENT_SECRET!,
-      scopes: ['repo', 'user', 'read:org'], // Optional, defaults to ['repo', 'user']
-      redirectUri: 'http://localhost:3000/callback', // Optional
-    }),
-  ],
+```typescript
+githubPlugin({
+  clientId: process.env.GITHUB_CLIENT_ID!,
+  clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+  scopes: ["repo", "user"],
 });
 ```
 
-**Available Tools:**
-- `github_create_issue`
-- `github_list_issues`
-- `github_get_issue`
-- `github_update_issue`
-- `github_close_issue`
-- `github_create_pull_request`
-- `github_list_pull_requests`
-- `github_get_pull_request`
-- `github_merge_pull_request`
-- `github_list_repos`
-- `github_list_own_repos`
-- `github_get_repo`
-- `github_create_repo`
-- And more...
+[→ View GitHub plugin documentation](https://integrate.dev/docs/plugins/github)
 
 ### Gmail Plugin
 
-```typescript
-import { createMCPClient, gmailPlugin } from 'integrate-sdk';
+Send emails, manage labels, and search messages.
 
-const client = createMCPClient({
-  plugins: [
-    gmailPlugin({
-      clientId: process.env.GMAIL_CLIENT_ID!,
-      clientSecret: process.env.GMAIL_CLIENT_SECRET!,
-      scopes: [ // Optional, defaults to common Gmail scopes
-        'https://www.googleapis.com/auth/gmail.send',
-        'https://www.googleapis.com/auth/gmail.readonly',
-      ],
-    }),
-  ],
+```typescript
+gmailPlugin({
+  clientId: process.env.GMAIL_CLIENT_ID!,
+  clientSecret: process.env.GMAIL_CLIENT_SECRET!,
 });
 ```
 
-**Available Tools:**
-- `gmail_send_email`
-- `gmail_list_emails`
-- `gmail_get_email`
-- `gmail_delete_email`
-- `gmail_search_emails`
-- `gmail_mark_as_read`
-- `gmail_mark_as_unread`
-- `gmail_list_labels`
-- `gmail_create_label`
-- And more...
+[→ View Gmail plugin documentation](https://integrate.dev/docs/plugins/gmail)
 
-## Creating Custom Plugins
+### Custom Plugins
 
-### Using Generic OAuth Plugin
+Create your own plugins for any service.
 
 ```typescript
-import { createMCPClient, genericOAuthPlugin } from 'integrate-sdk';
+import { genericOAuthPlugin } from "integrate-sdk";
 
 const slackPlugin = genericOAuthPlugin({
-  id: 'slack',
-  provider: 'slack',
+  id: "slack",
+  provider: "slack",
   clientId: process.env.SLACK_CLIENT_ID!,
   clientSecret: process.env.SLACK_CLIENT_SECRET!,
-  scopes: ['chat:write', 'channels:read', 'users:read'],
-  tools: [
-    'slack_send_message',
-    'slack_list_channels',
-    'slack_get_channel',
-    'slack_invite_user',
-  ],
-  redirectUri: 'https://your-app.com/callback',
-});
-
-const client = createMCPClient({
-  plugins: [slackPlugin],
+  scopes: ["chat:write", "channels:read"],
+  tools: ["slack_send_message", "slack_list_channels"],
 });
 ```
 
-### Creating a Simple Plugin (No OAuth)
+[→ Learn how to create custom plugins](https://integrate.dev/docs/plugins/custom-plugins)
 
-For tools that don't require OAuth:
+## Vercel AI SDK Integration
 
-```typescript
-import { createSimplePlugin } from 'integrate-sdk';
-
-const mathPlugin = createSimplePlugin({
-  id: 'math',
-  tools: ['math_add', 'math_subtract', 'math_multiply', 'math_divide'],
-  onInit: async (client) => {
-    console.log('Math plugin initialized');
-  },
-});
-```
-
-### Creating a Custom Plugin from Scratch
+Give AI models access to all your integrations with built-in Vercel AI SDK support.
 
 ```typescript
-import type { MCPPlugin } from 'integrate-sdk';
-
-export function customPlugin(config: CustomConfig): MCPPlugin {
-  return {
-    id: 'custom',
-    tools: ['custom_tool1', 'custom_tool2'],
-    oauth: {
-      provider: 'custom-provider',
-      clientId: config.clientId,
-      clientSecret: config.clientSecret,
-      scopes: config.scopes,
-    },
-    
-    async onInit(client) {
-      // Called when plugin is initialized
-      console.log('Custom plugin initialized');
-    },
-    
-    async onBeforeConnect(client) {
-      // Called before connecting to server
-    },
-    
-    async onAfterConnect(client) {
-      // Called after successful connection
-    },
-    
-    async onDisconnect(client) {
-      // Called when disconnecting
-    },
-  };
-}
-```
+import { getVercelAITools } from "integrate-sdk";
+import { generateText } from "ai";
+import { openai } from "@ai-sdk/openai";
 
-## Integration with Vercel AI SDK
-
-The SDK includes built-in support for Vercel's AI SDK, allowing you to give AI models access to all your integrations.
-
-### Quick Example
-
-```typescript
-import { createMCPClient, githubPlugin, getVercelAITools } from 'integrate-sdk';
-import { generateText } from 'ai';
-import { openai } from '@ai-sdk/openai';
-
-// 1. Create and connect MCP client
-const mcpClient = createMCPClient({
-  plugins: [
-    githubPlugin({
-      clientId: process.env.GITHUB_CLIENT_ID!,
-      clientSecret: process.env.GITHUB_CLIENT_SECRET!,
-    }),
-  ],
-});
-
-await mcpClient.connect();
-
-// 2. Get tools in Vercel AI SDK format
+// Convert MCP tools to Vercel AI SDK format
 const tools = getVercelAITools(mcpClient);
 
-// 3. Use with AI models
+// Use with AI models
 const result = await generateText({
-  model: openai('gpt-4'),
-  prompt: 'Create a GitHub issue titled "Bug in login" in myrepo',
+  model: openai("gpt-5"),
+  prompt: "Create a GitHub issue about the login bug",
   tools,
   maxToolRoundtrips: 5,
 });
-
-console.log(result.text);
 ```
 
-### How It Works
-
-1. **`getVercelAITools(client)`** - Converts all enabled MCP tools to Vercel AI SDK format
-2. **Automatic execution** - When the AI calls a tool, it executes through your MCP client
-3. **Type-safe** - Full TypeScript support with proper types
-
-### Available Functions
-
-- **`getVercelAITools(client)`** - Get all enabled tools in Vercel AI SDK format
-- **`convertMCPToolsToVercelAI(client)`** - Same as above, alternative name
-- **`convertMCPToolToVercelAI(tool, client)`** - Convert a single MCP tool
-
-See `examples/vercel-ai-integration.ts` for a complete working example.
-
-## Advanced Usage
-
-### Accessing OAuth Configurations
-
-```typescript
-// Get OAuth config for a specific plugin
-const githubOAuth = client.getOAuthConfig('github');
-console.log('GitHub OAuth scopes:', githubOAuth?.scopes);
-
-// Get all OAuth configs
-const allConfigs = client.getAllOAuthConfigs();
-for (const [pluginId, config] of allConfigs) {
-  console.log(`${pluginId}: ${config.provider}`);
-}
-```
-
-### Listing Available Tools
-
-```typescript
-await client.connect();
-
-// Get all enabled tools (filtered by plugins)
-const enabledTools = client.getEnabledTools();
-console.log('Enabled tools:', enabledTools.map(t => t.name));
-
-// Get all available tools from server
-const allTools = client.getAvailableTools();
-console.log('All tools:', allTools.map(t => t.name));
-
-// Get a specific tool
-const tool = client.getTool('github_create_issue');
-console.log('Tool schema:', tool?.inputSchema);
-```
-
-### Handling Messages and Notifications
-
-```typescript
-// Listen for server messages and notifications
-const unsubscribe = client.onMessage((message) => {
-  console.log('Received message:', message);
-});
-
-// Unsubscribe when done
-unsubscribe();
-```
-
-### Error Handling
-
-```typescript
-try {
-  await client.connect();
-  const result = await client.callTool('github_create_issue', {
-    repo: 'owner/repo',
-    title: 'Bug report',
-  });
-} catch (error) {
-  if (error.message.includes('not enabled')) {
-    console.error('Tool is not enabled. Add the appropriate plugin.');
-  } else if (error.message.includes('not available')) {
-    console.error('Tool is not available on the server.');
-  } else {
-    console.error('Unexpected error:', error);
-  }
-}
-```
-
-### Custom Headers and Timeouts
-
-```typescript
-const client = createMCPClient({
-  plugins: [/* ... */],
-  
-  // Custom headers
-  headers: {
-    'Authorization': 'Bearer token',
-    'X-Custom-Header': 'value',
-  },
-  
-  // Request timeout (default: 30000ms)
-  timeout: 60000,
-  
-  // Custom client info
-  clientInfo: {
-    name: 'my-app',
-    version: '1.0.0',
-  },
-});
-```
-
-## API Reference
-
-### `createMCPClient(config)`
-
-Creates a new MCP client instance.
+[→ View Vercel AI SDK integration guide](https://integrate.dev/docs/integrations/vercel-ai)
 
-**Parameters:**
-- `config.plugins` (MCPPlugin[]): Array of plugins to enable
-- `config.headers` (object, optional): Custom HTTP headers
-- `config.timeout` (number, optional): Request timeout in milliseconds
-- `config.clientInfo` (object, optional): Client name and version
+## Documentation
 
-**Returns:** `MCPClient` instance
+For detailed guides, API reference, and examples, visit the [complete documentation](https://integrate.dev):
 
-### `MCPClient` Methods
-
-- `connect()`: Connect to the MCP server
-- `disconnect()`: Disconnect from the server
-- `callTool(name, args)`: Invoke a tool by name
-- `getTool(name)`: Get tool definition by name
-- `getEnabledTools()`: Get all enabled tools
-- `getAvailableTools()`: Get all available tools
-- `getOAuthConfig(pluginId)`: Get OAuth config for a plugin
-- `getAllOAuthConfigs()`: Get all OAuth configurations
-- `onMessage(handler)`: Register a message handler
-- `isConnected()`: Check if connected
-- `isInitialized()`: Check if initialized
-
-## Architecture
-
-The SDK is built with a modular architecture:
-
-```
-integrate-sdk/
-├── src/
-│   ├── client.ts           # Main MCPClient class
-│   ├── index.ts            # Public exports
-│   ├── config/
-│   │   └── types.ts        # Configuration types
-│   ├── transport/
-│   │   └── http-stream.ts  # HTTP streaming transport (NDJSON)
-│   ├── protocol/
-│   │   ├── messages.ts     # MCP message types
-│   │   └── jsonrpc.ts      # JSON-RPC implementation
-│   └── plugins/
-│       ├── types.ts        # Plugin interface
-│       ├── github.ts       # GitHub plugin
-│       ├── gmail.ts        # Gmail plugin
-│       └── generic.ts      # Generic OAuth plugin
-```
-
-**Transport Layer:**
-The SDK uses HTTP streaming with newline-delimited JSON (NDJSON) for bidirectional communication:
-- Single persistent HTTP connection
-- Messages sent as JSON followed by newline (`\n`)
-- Automatic heartbeat to keep connection alive
-- Compatible with MCP's `StreamableHTTPServer`
-
-## How It Works
-
-1. **Client Configuration**: You configure the SDK with plugins for the integrations you want to use (GitHub, Gmail, etc.)
-2. **Connection**: The SDK connects to `https://mcp.integrate.dev/api/v1/mcp` using HTTP streaming (NDJSON)
-3. **Tool Discovery**: The SDK fetches available tools from the server and filters them based on your enabled plugins
-4. **OAuth Configuration**: Your OAuth credentials are stored in the client configuration (not sent to the server yet)
-5. **Tool Calls**: When you call a tool, the SDK sends a JSON-RPC request to the server
-6. **OAuth Flow**: The server uses your OAuth configuration to authenticate and execute the tool
-
-## Server Information
-
-**Endpoint:** `https://mcp.integrate.dev/api/v1/mcp`  
-**Protocol:** MCP (Model Context Protocol) over HTTP streaming  
-**Format:** Newline-delimited JSON (NDJSON)  
-**Methods:** `initialize`, `tools/list`, `tools/call`
+- **[Getting Started](https://integrate.dev/docs/getting-started/installation)** - Installation and quick start
+- **[Plugins](https://integrate.dev/docs/plugins)** - Built-in and custom plugins
+- **[Vercel AI SDK](https://integrate.dev/docs/integrations/vercel-ai)** - AI model integration
+- **[Advanced Usage](https://integrate.dev/docs/guides/advanced-usage)** - Error handling, retries, and more
+- **[API Reference](https://integrate.dev/docs/reference/api-reference)** - Complete API documentation
+- **[Architecture](https://integrate.dev/docs/reference/architecture)** - How the SDK works
 
 ## TypeScript Support
 
-The SDK is built with TypeScript and provides full type safety:
-
-```typescript
-import { createMCPClient, githubPlugin } from 'integrate-sdk';
-import type { MCPToolCallResponse } from 'integrate-sdk';
-
-const client = createMCPClient({
-  plugins: [
-    githubPlugin({
-      clientId: process.env.GITHUB_CLIENT_ID!,
-      clientSecret: process.env.GITHUB_CLIENT_SECRET!,
-    }),
-  ],
-});
-
-// Full type inference and IntelliSense support
-await client.connect();
-const result: MCPToolCallResponse = await client.callTool('github_create_issue', {
-  repo: 'owner/repo',
-  title: 'Bug report',
-});
-```
+The SDK is built with TypeScript and provides full type safety with IntelliSense support out of the box.
 
 ## Contributing
 
-Contributions are welcome! Please see the tests in the `tests/` directory for examples of how to test new features.
+Contributions are welcome! Please check the [issues](https://github.com/Revyo/integrate-sdk/issues) for ways to contribute.
 
-## Test Structure
+## Testing
 
-```
-tests/
-├── protocol/           # Protocol and JSON-RPC tests
-│   └── jsonrpc.test.ts
-├── plugins/            # Plugin system tests
-│   └── plugin-system.test.ts
-├── client/             # Client functionality tests
-│   └── client.test.ts
-├── integration/        # Integration tests with mock server
-│   ├── mock-server.ts
-│   └── integration.test.ts
-├── setup.ts            # Test setup and utilities
-└── README.md           # This file
-```
-
-## Running Tests
-
-### All Tests
 ```bash
+# Run all tests
 bun test
-```
 
-### Unit Tests Only
-```bash
-bun run test:unit
-```
-
-### Integration Tests Only
-```bash
-bun run test:integration
-```
-
-### Watch Mode
-```bash
-bun run test:watch
-```
-
-### With Coverage
-```bash
+# Run with coverage
 bun run test:coverage
 ```
 
-## Test Categories
-
-### 1. Protocol Tests (`tests/protocol/`)
-Tests for JSON-RPC 2.0 protocol implementation:
-- Request/response formatting
-- Notification handling
-- Error responses
-- Message parsing and serialization
-- ID generation
-
-### 2. Plugin System Tests (`tests/plugins/`)
-Tests for the plugin architecture:
-- GitHub plugin configuration
-- Gmail plugin configuration
-- Generic OAuth plugin creation
-- Simple plugin creation
-- OAuth config type guards
-- Plugin lifecycle hooks
-
-### 3. Client Tests (`tests/client/`)
-Tests for the main MCP client:
-- Client creation and configuration
-- Plugin initialization
-- OAuth configuration management
-- Tool management
-- Connection state tracking
-- Error handling
-- Message handlers
-
-### 4. Integration Tests (`tests/integration/`)
-End-to-end tests with a mock MCP server:
-- Connection establishment
-- Tool discovery
-- Tool filtering by plugins
-- Tool invocation
-- Plugin lifecycle hooks
-- Concurrent requests
-- Error scenarios
-- Connection timeout
-
-## Mock Server
-
-The integration tests use a mock MCP server that:
-- Implements HTTP streaming with NDJSON
-- Supports `initialize`, `tools/list`, and `tools/call` methods
-- Returns configurable tools
-- Handles heartbeat/ping messages
-- Runs on a random port to avoid conflicts
-
-Example usage:
-```typescript
-import { MockMCPServer } from './tests/integration/mock-server';
-
-const server = new MockMCPServer({
-  port: 3456,
-  tools: [
-    {
-      name: 'test/echo',
-      description: 'Echo test tool',
-      inputSchema: { /* ... */ }
-    }
-  ]
-});
-
-await server.start();
-// Run tests...
-await server.stop();
-```
-
-## Writing New Tests
-
-### Unit Test Example
-
-```typescript
-import { describe, test, expect } from "bun:test";
-import { myFunction } from "../../src/module.js";
-
-describe("My Module", () => {
-  test("does something correctly", () => {
-    const result = myFunction("input");
-    expect(result).toBe("expected output");
-  });
-});
-```
-
-### Integration Test Example
-
-```typescript
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { createMCPClient } from "../../src/client.js";
-import { MockMCPServer } from "./mock-server.js";
-
-describe("Integration Test", () => {
-  let server: MockMCPServer;
-
-  beforeAll(async () => {
-    server = new MockMCPServer({ port: 3456 });
-    await server.start();
-  });
-
-  afterAll(async () => {
-    await server.stop();
-  });
-
-  test("connects and calls tool", async () => {
-    const client = createMCPClient({
-      plugins: [/* ... */],
-    });
-
-    await client.connect();
-    const result = await client.callTool("test/tool");
-    expect(result).toBeDefined();
-    await client.disconnect();
-  });
-});
-```
-
-## Test Coverage
-
-The test suite covers:
-- ✅ JSON-RPC protocol implementation
-- ✅ Plugin system and configuration
-- ✅ Client initialization and lifecycle
-- ✅ Tool discovery and filtering
-- ✅ Tool invocation
-- ✅ OAuth configuration management
-- ✅ Error handling
-- ✅ Connection management
-- ✅ Concurrent requests
-- ✅ Plugin lifecycle hooks
-
-## Debugging Tests
-
-Run tests with debug output:
-```bash
-DEBUG=1 bun test
-```
-
-Run specific test file:
-```bash
-bun test tests/protocol/jsonrpc.test.ts
-```
-
-Run specific test:
-```bash
-bun test -t "creates valid JSON-RPC request"
-```
-
-## Continuous Integration
-
-Tests run automatically on:
-- Push to `main` or `develop` branches
-- Pull requests to `main` or `develop`
-
-The CI pipeline runs:
-1. Type checking
-2. Unit tests
-3. Integration tests
-4. Build verification
-
-See `.github/workflows/test.yml` for details.
-
-## Common Issues
-
-### Port Already in Use
-Integration tests use port 3456. If this conflicts, modify `MockMCPServer` constructor.
-
-### Test Timeouts
-Integration tests have 10s timeout. Increase if needed:
-```typescript
-test("my test", async () => {
-  // test code
-}, 20000); // 20 second timeout
-```
-
-### Console Logs
-Console logs are suppressed during tests unless `DEBUG=1` is set.
-
-## Contributing
-
-When adding new features:
-1. Write unit tests for individual components
-2. Write integration tests for end-to-end flows
-3. Ensure all tests pass before submitting PR
-4. Maintain test coverage above 80%
-
+See the `tests/` directory for unit and integration test examples.
 
+## License
 
+MIT © [Revyo](https://github.com/Revyo)

package/dist/client.d.ts

@@ -5,6 +5,7 @@
 import type { MCPTool, MCPToolCallResponse } from "./protocol/messages.js";
 import type { MCPPlugin, OAuthConfig } from "./plugins/types.js";
 import type { MCPClientConfig } from "./config/types.js";
+import { type AuthenticationError } from "./errors.js";
 /**
  * Tool invocation options
  */
@@ -26,6 +27,9 @@ export declare class MCPClient<TPlugins extends readonly MCPPlugin[] = readonly
     private enabledToolNames;
     private initialized;
     private clientInfo;
+    private onReauthRequired?;
+    private maxReauthRetries;
+    private authState;
     constructor(config: MCPClientConfig<TPlugins>);
     /**
      * Initialize all plugins
@@ -44,9 +48,17 @@ export declare class MCPClient<TPlugins extends readonly MCPPlugin[] = readonly
      */
     private discoverTools;
     /**
-     * Call a tool by name
+     * Call a tool by name with automatic retry on authentication failure
      */
     callTool(name: string, args?: Record<string, unknown>): Promise<MCPToolCallResponse>;
+    /**
+     * Internal method to call a tool with retry logic
+     */
+    private callToolWithRetry;
+    /**
+     * Get the OAuth provider for a given tool
+     */
+    private getProviderForTool;
     /**
      * Get a tool by name
      */
@@ -83,6 +95,22 @@ export declare class MCPClient<TPlugins extends readonly MCPPlugin[] = readonly
      * Check if client is initialized
      */
     isInitialized(): boolean;
+    /**
+     * Get authentication state for a specific provider
+     */
+    getAuthState(provider: string): {
+        authenticated: boolean;
+        lastError?: AuthenticationError;
+    } | undefined;
+    /**
+     * Check if a specific provider is authenticated
+     */
+    isProviderAuthenticated(provider: string): boolean;
+    /**
+     * Manually trigger re-authentication for a specific provider
+     * Useful if you want to proactively refresh tokens
+     */
+    reauthenticate(provider: string): Promise<boolean>;
 }
 /**
  * Create a new MCP Client instance

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,OAAO,EAEP,mBAAmB,EAIpB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAOzD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED;;;;GAIG;AACH,qBAAa,SAAS,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,GAAG,SAAS,SAAS,EAAE;IACjF,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,cAAc,CAAmC;IACzD,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAoC;gBAE1C,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC;IAwB7C;;OAEG;YACW,iBAAiB;IAQ/B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB9B;;OAEG;YACW,UAAU;IAkBxB;;OAEG;YACW,aAAa;IAoB3B;;OAEG;IACG,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,OAAO,CAAC,mBAAmB,CAAC;IA8B/B;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAI1C;;OAEG;IACH,iBAAiB,IAAI,OAAO,EAAE;IAI9B;;OAEG;IACH,eAAe,IAAI,OAAO,EAAE;IAM5B;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAKzD;;OAEG;IACH,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC;IAU9C;;OAEG;IACH,SAAS,CACP,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAClC,MAAM,IAAI;IAIb;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAYjC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,aAAa,IAAI,OAAO;CAGzB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,EACnE,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,GAChC,SAAS,CAAC,QAAQ,CAAC,CAErB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,OAAO,EAEP,mBAAmB,EAIpB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,aAAa,CAAC;AAOrB;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED;;;;GAIG;AACH,qBAAa,SAAS,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,GAAG,SAAS,SAAS,EAAE;IACjF,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,cAAc,CAAmC;IACzD,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAoC;IACtD,OAAO,CAAC,gBAAgB,CAAC,CAAgB;IACzC,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,SAAS,CAAuF;gBAE5F,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC;IA+B7C;;OAEG;YACW,iBAAiB;IAQ/B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB9B;;OAEG;YACW,UAAU;IAkBxB;;OAEG;YACW,aAAa;IAoB3B;;OAEG;IACG,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,OAAO,CAAC,mBAAmB,CAAC;IAI/B;;OAEG;YACW,iBAAiB;IA4E/B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAI1C;;OAEG;IACH,iBAAiB,IAAI,OAAO,EAAE;IAI9B;;OAEG;IACH,eAAe,IAAI,OAAO,EAAE;IAM5B;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAKzD;;OAEG;IACH,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC;IAU9C;;OAEG;IACH,SAAS,CACP,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAClC,MAAM,IAAI;IAIb;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAYjC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG;QAAE,aAAa,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,mBAAmB,CAAA;KAAE,GAAG,SAAS;IAIvG;;OAEG;IACH,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIlD;;;OAGG;IACG,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CA2BzD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,EACnE,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,GAChC,SAAS,CAAC,QAAQ,CAAC,CAErB"}

package/dist/config/types.d.ts

@@ -3,6 +3,24 @@
  * Type-safe configuration with inference
  */
 import type { MCPPlugin } from "../plugins/types.js";
+import type { AuthenticationError } from "../errors.js";
+/**
+ * Re-authentication context provided to the callback
+ */
+export interface ReauthContext {
+    /** The plugin/provider that needs re-authentication */
+    provider: string;
+    /** The error that triggered re-authentication */
+    error: AuthenticationError;
+    /** The tool name that was being called (if applicable) */
+    toolName?: string;
+}
+/**
+ * Re-authentication handler function
+ * Called when authentication fails and user needs to re-authenticate
+ * Should return true if re-authentication was successful, false otherwise
+ */
+export type ReauthHandler = (context: ReauthContext) => Promise<boolean> | boolean;
 /**
  * Main client configuration
  */
@@ -18,6 +36,33 @@ export interface MCPClientConfig<TPlugins extends readonly MCPPlugin[]> {
         name: string;
         version: string;
     };
+    /**
+     * Handler called when authentication fails and re-authentication is needed
+     * This is typically called when OAuth tokens expire or become invalid
+     *
+     * @param context - Information about the authentication failure
+     * @returns Promise<boolean> - true if re-authentication was successful, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const client = createMCPClient({
+     *   plugins: [githubPlugin(...)],
+     *   onReauthRequired: async (context) => {
+     *     console.log(`Re-auth needed for ${context.provider}`);
+     *     // Trigger your OAuth flow here
+     *     // Return true if successful, false otherwise
+     *     return await triggerOAuthFlow(context.provider);
+     *   }
+     * });
+     * ```
+     */
+    onReauthRequired?: ReauthHandler;
+    /**
+     * Maximum number of automatic retry attempts when authentication fails
+     * Default: 1 (one retry after re-authentication)
+     * Set to 0 to disable automatic retries
+     */
+    maxReauthRetries?: number;
 }
 /**
  * Helper type to infer enabled tools from plugins

package/dist/config/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE;IACpE,iCAAiC;IACjC,OAAO,EAAE,QAAQ,CAAC;IAElB,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,yBAAyB;IACzB,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,IACjE,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,IAAI;KACnE,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;CAC/C,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,uDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,KAAK,EAAE,mBAAmB,CAAC;IAC3B,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE;IACpE,iCAAiC;IACjC,OAAO,EAAE,QAAQ,CAAC;IAElB,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,yBAAyB;IACzB,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IAEF;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gBAAgB,CAAC,EAAE,aAAa,CAAC;IAEjC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,IACjE,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,IAAI;KACnE,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;CAC/C,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Custom error types for the Integrate SDK
+ */
+/**
+ * Base error class for all SDK errors
+ */
+export declare class IntegrateSDKError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when authentication fails or tokens are invalid
+ */
+export declare class AuthenticationError extends IntegrateSDKError {
+    readonly statusCode?: number;
+    readonly provider?: string;
+    constructor(message: string, statusCode?: number, provider?: string);
+}
+/**
+ * Error thrown when access is forbidden (insufficient permissions)
+ */
+export declare class AuthorizationError extends IntegrateSDKError {
+    readonly statusCode?: number;
+    readonly requiredScopes?: string[];
+    constructor(message: string, statusCode?: number, requiredScopes?: string[]);
+}
+/**
+ * Error thrown when OAuth tokens have expired and need to be refreshed
+ */
+export declare class TokenExpiredError extends AuthenticationError {
+    constructor(message: string, provider?: string);
+}
+/**
+ * Error thrown when a connection to the server fails
+ */
+export declare class ConnectionError extends IntegrateSDKError {
+    readonly statusCode?: number;
+    constructor(message: string, statusCode?: number);
+}
+/**
+ * Error thrown when a tool call fails
+ */
+export declare class ToolCallError extends IntegrateSDKError {
+    readonly toolName: string;
+    readonly originalError?: unknown;
+    constructor(message: string, toolName: string, originalError?: unknown);
+}
+/**
+ * Helper function to determine if an error is an authentication error
+ */
+export declare function isAuthError(error: unknown): error is AuthenticationError;
+/**
+ * Helper function to determine if an error is a token expired error
+ */
+export declare function isTokenExpiredError(error: unknown): error is TokenExpiredError;
+/**
+ * Helper function to determine if an error is an authorization error
+ */
+export declare function isAuthorizationError(error: unknown): error is AuthorizationError;
+/**
+ * Helper function to parse error responses from the MCP server
+ * and convert them to appropriate error types
+ */
+export declare function parseServerError(error: any, context?: {
+    toolName?: string;
+    provider?: string;
+}): IntegrateSDKError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;gBAC9B,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,iBAAiB;IACxD,SAAgB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpC,SAAgB,QAAQ,CAAC,EAAE,MAAM,CAAC;gBAEtB,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAMpE;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,iBAAiB;IACvD,SAAgB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpC,SAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;gBAE9B,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,EAAE;CAM5E;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,mBAAmB;gBAC5C,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAI/C;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,iBAAiB;IACpD,SAAgB,UAAU,CAAC,EAAE,MAAM,CAAC;gBAExB,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;CAKjD;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,iBAAiB;IAClD,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,aAAa,CAAC,EAAE,OAAO,CAAC;gBAE5B,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,OAAO;CAMvE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAExE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAE9E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAEhF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,GAAG,EACV,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GACjD,iBAAiB,CA+FnB"}

package/dist/index.d.ts

@@ -4,7 +4,8 @@
  */
 export { MCPClient, createMCPClient } from "./client.js";
 export type { ToolInvocationOptions } from "./client.js";
-export type { MCPClientConfig } from "./config/types.js";
+export type { MCPClientConfig, ReauthContext, ReauthHandler } from "./config/types.js";
+export { IntegrateSDKError, AuthenticationError, AuthorizationError, TokenExpiredError, ConnectionError, ToolCallError, isAuthError, isTokenExpiredError, isAuthorizationError, parseServerError, } from "./errors.js";
 export type { MCPPlugin, OAuthConfig, ExtractPluginIds, ExtractPluginTools, } from "./plugins/types.js";
 export { githubPlugin } from "./plugins/github.js";
 export type { GitHubPluginConfig, GitHubTools } from "./plugins/github.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACzD,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAGzD,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,YAAY,EACV,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAE3E,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAExE,OAAO,EACL,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,YAAY,EACV,cAAc,EACd,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,OAAO,EACP,oBAAoB,EACpB,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,YAAY,EACV,cAAc,EACd,2BAA2B,GAC5B,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACzD,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAGzD,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvF,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,WAAW,EACX,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAE3E,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAExE,OAAO,EACL,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,YAAY,EACV,cAAc,EACd,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,OAAO,EACP,oBAAoB,EACpB,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,YAAY,EACV,cAAc,EACd,2BAA2B,GAC5B,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -1,3 +1,153 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/errors.ts
+var exports_errors = {};
+__export(exports_errors, {
+  parseServerError: () => parseServerError,
+  isTokenExpiredError: () => isTokenExpiredError,
+  isAuthorizationError: () => isAuthorizationError,
+  isAuthError: () => isAuthError,
+  ToolCallError: () => ToolCallError,
+  TokenExpiredError: () => TokenExpiredError,
+  IntegrateSDKError: () => IntegrateSDKError,
+  ConnectionError: () => ConnectionError,
+  AuthorizationError: () => AuthorizationError,
+  AuthenticationError: () => AuthenticationError
+});
+function isAuthError(error) {
+  return error instanceof AuthenticationError;
+}
+function isTokenExpiredError(error) {
+  return error instanceof TokenExpiredError;
+}
+function isAuthorizationError(error) {
+  return error instanceof AuthorizationError;
+}
+function parseServerError(error, context) {
+  if (error && typeof error === "object" && "jsonrpcError" in error) {
+    const jsonrpcError = error.jsonrpcError;
+    if (jsonrpcError && typeof jsonrpcError === "object") {
+      return parseServerError(jsonrpcError, context);
+    }
+  }
+  if (error && typeof error === "object" && "code" in error && "message" in error) {
+    const code = error.code;
+    const message = error.message || "Unknown error";
+    if (code === -32600) {
+      return new IntegrateSDKError(`Invalid request: ${message}`);
+    }
+    if (code === -32601) {
+      return new IntegrateSDKError(`Method not found: ${message}`);
+    }
+    if (code === -32602) {
+      return new IntegrateSDKError(`Invalid params: ${message}`);
+    }
+    if (code === 401 || code === -32001) {
+      if (message.toLowerCase().includes("expired") || message.toLowerCase().includes("token")) {
+        return new TokenExpiredError(message, context?.provider);
+      }
+      return new AuthenticationError(message, 401, context?.provider);
+    }
+    if (code === 403 || code === -32002) {
+      return new AuthorizationError(message, 403);
+    }
+    if (context?.toolName) {
+      return new ToolCallError(message, context.toolName, error);
+    }
+    return new IntegrateSDKError(message);
+  }
+  if (error instanceof Error) {
+    const message = error.message;
+    const statusCode = error.statusCode;
+    if (statusCode === 401) {
+      if (message.toLowerCase().includes("expired") || message.toLowerCase().includes("token")) {
+        return new TokenExpiredError(message, context?.provider);
+      }
+      return new AuthenticationError(message, 401, context?.provider);
+    }
+    if (statusCode === 403) {
+      return new AuthorizationError(message, 403);
+    }
+    if (message.includes("401") || message.includes("Unauthorized") || message.includes("unauthenticated")) {
+      if (message.toLowerCase().includes("expired") || message.toLowerCase().includes("token")) {
+        return new TokenExpiredError(message, context?.provider);
+      }
+      return new AuthenticationError(message, 401, context?.provider);
+    }
+    if (message.includes("403") || message.includes("Forbidden") || message.includes("unauthorized")) {
+      return new AuthorizationError(message, 403);
+    }
+    if (context?.toolName) {
+      return new ToolCallError(message, context.toolName, error);
+    }
+    return new IntegrateSDKError(message);
+  }
+  return new IntegrateSDKError(String(error));
+}
+var IntegrateSDKError, AuthenticationError, AuthorizationError, TokenExpiredError, ConnectionError, ToolCallError;
+var init_errors = __esm(() => {
+  IntegrateSDKError = class IntegrateSDKError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "IntegrateSDKError";
+    }
+  };
+  AuthenticationError = class AuthenticationError extends IntegrateSDKError {
+    statusCode;
+    provider;
+    constructor(message, statusCode, provider) {
+      super(message);
+      this.name = "AuthenticationError";
+      this.statusCode = statusCode;
+      this.provider = provider;
+    }
+  };
+  AuthorizationError = class AuthorizationError extends IntegrateSDKError {
+    statusCode;
+    requiredScopes;
+    constructor(message, statusCode, requiredScopes) {
+      super(message);
+      this.name = "AuthorizationError";
+      this.statusCode = statusCode;
+      this.requiredScopes = requiredScopes;
+    }
+  };
+  TokenExpiredError = class TokenExpiredError extends AuthenticationError {
+    constructor(message, provider) {
+      super(message, 401, provider);
+      this.name = "TokenExpiredError";
+    }
+  };
+  ConnectionError = class ConnectionError extends IntegrateSDKError {
+    statusCode;
+    constructor(message, statusCode) {
+      super(message);
+      this.name = "ConnectionError";
+      this.statusCode = statusCode;
+    }
+  };
+  ToolCallError = class ToolCallError extends IntegrateSDKError {
+    toolName;
+    originalError;
+    constructor(message, toolName, originalError) {
+      super(message);
+      this.name = "ToolCallError";
+      this.toolName = toolName;
+      this.originalError = originalError;
+    }
+  };
+});
+
 // src/protocol/jsonrpc.ts
 function parseMessage(message) {
   try {
@@ -55,7 +205,9 @@ class HttpSessionTransport {
       });
       clearTimeout(timeoutId);
       if (!response.ok) {
-        throw new Error(`Request failed: ${response.statusText}`);
+        const error = new Error(`Request failed: ${response.statusText}`);
+        error.statusCode = response.status;
+        throw error;
       }
       if (!this.sessionId) {
         const sid = response.headers.get("mcp-session-id");
@@ -67,11 +219,25 @@ class HttpSessionTransport {
       }
       const jsonResponse = await response.json();
       if ("error" in jsonResponse) {
-        throw new Error(`JSON-RPC Error ${jsonResponse.error.code}: ${jsonResponse.error.message}`);
+        const error = new Error(`JSON-RPC Error ${jsonResponse.error.code}: ${jsonResponse.error.message}`);
+        error.code = jsonResponse.error.code;
+        if (jsonResponse.error.data) {
+          error.data = jsonResponse.error.data;
+        }
+        error.jsonrpcError = jsonResponse.error;
+        throw error;
       }
       return jsonResponse.result;
     } catch (error) {
-      throw error;
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          const timeoutError = new Error("Request timeout");
+          timeoutError.code = -32000;
+          throw timeoutError;
+        }
+        throw error;
+      }
+      throw new Error(String(error));
     }
   }
   async startSSEListener() {
@@ -184,6 +350,7 @@ var MCPMethod;
 })(MCPMethod ||= {});
 
 // src/client.ts
+init_errors();
 var MCP_SERVER_URL = "https://mcp.integrate.dev/api/v1/mcp";
 
 class MCPClient {
@@ -193,6 +360,9 @@ class MCPClient {
   enabledToolNames = new Set;
   initialized = false;
   clientInfo;
+  onReauthRequired;
+  maxReauthRetries;
+  authState = new Map;
   constructor(config) {
     this.transport = new HttpSessionTransport({
       url: MCP_SERVER_URL,
@@ -204,10 +374,15 @@ class MCPClient {
       name: "integrate-sdk",
       version: "0.1.0"
     };
+    this.onReauthRequired = config.onReauthRequired;
+    this.maxReauthRetries = config.maxReauthRetries ?? 1;
     for (const plugin of this.plugins) {
       for (const toolName of plugin.tools) {
         this.enabledToolNames.add(toolName);
       }
+      if (plugin.oauth) {
+        this.authState.set(plugin.oauth.provider, { authenticated: true });
+      }
     }
     this.initializePlugins();
   }
@@ -254,6 +429,9 @@ class MCPClient {
     console.log(`Discovered ${response.tools.length} tools, ${enabledTools.length} enabled by plugins`);
   }
   async callTool(name, args) {
+    return await this.callToolWithRetry(name, args, 0);
+  }
+  async callToolWithRetry(name, args, retryCount = 0) {
     if (!this.initialized) {
       throw new Error("Client not initialized. Call connect() first.");
     }
@@ -267,7 +445,44 @@ class MCPClient {
       name,
       arguments: args
     };
-    return await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+    try {
+      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      const provider = this.getProviderForTool(name);
+      if (provider) {
+        this.authState.set(provider, { authenticated: true });
+      }
+      return response;
+    } catch (error) {
+      const provider = this.getProviderForTool(name);
+      const parsedError = parseServerError(error, { toolName: name, provider });
+      if (isAuthError(parsedError) && retryCount < this.maxReauthRetries) {
+        if (provider) {
+          this.authState.set(provider, {
+            authenticated: false,
+            lastError: parsedError
+          });
+        }
+        if (this.onReauthRequired && provider) {
+          const reauthSuccess = await this.onReauthRequired({
+            provider,
+            error: parsedError,
+            toolName: name
+          });
+          if (reauthSuccess) {
+            return await this.callToolWithRetry(name, args, retryCount + 1);
+          }
+        }
+      }
+      throw parsedError;
+    }
+  }
+  getProviderForTool(toolName) {
+    for (const plugin of this.plugins) {
+      if (plugin.tools.includes(toolName) && plugin.oauth) {
+        return plugin.oauth.provider;
+      }
+    }
+    return;
   }
   getTool(name) {
     return this.availableTools.get(name);
@@ -309,10 +524,38 @@ class MCPClient {
   isInitialized() {
     return this.initialized;
   }
+  getAuthState(provider) {
+    return this.authState.get(provider);
+  }
+  isProviderAuthenticated(provider) {
+    return this.authState.get(provider)?.authenticated ?? false;
+  }
+  async reauthenticate(provider) {
+    const state = this.authState.get(provider);
+    if (!state) {
+      throw new Error(`Provider "${provider}" not found in configured plugins`);
+    }
+    if (!this.onReauthRequired) {
+      throw new Error("No re-authentication handler configured. Set onReauthRequired in client config.");
+    }
+    const lastError = state.lastError || new (await Promise.resolve().then(() => (init_errors(), exports_errors))).AuthenticationError("Manual re-authentication requested", undefined, provider);
+    const success = await this.onReauthRequired({
+      provider,
+      error: lastError
+    });
+    if (success) {
+      this.authState.set(provider, { authenticated: true });
+    }
+    return success;
+  }
 }
 function createMCPClient(config) {
   return new MCPClient(config);
 }
+
+// src/index.ts
+init_errors();
+
 // src/plugins/github.ts
 var GITHUB_TOOLS = [
   "github_create_issue",
@@ -457,6 +700,10 @@ function getVercelAITools(client) {
   return convertMCPToolsToVercelAI(client);
 }
 export {
+  parseServerError,
+  isTokenExpiredError,
+  isAuthorizationError,
+  isAuthError,
   gmailPlugin,
   githubPlugin,
   getVercelAITools,
@@ -465,7 +712,13 @@ export {
   createMCPClient,
   convertMCPToolsToVercelAI,
   convertMCPToolToVercelAI,
+  ToolCallError,
+  TokenExpiredError,
   MCPMethod,
   MCPClient,
-  HttpSessionTransport
+  IntegrateSDKError,
+  HttpSessionTransport,
+  ConnectionError,
+  AuthorizationError,
+  AuthenticationError
 };

package/dist/integrations/vercel-ai.d.ts

@@ -42,7 +42,7 @@ export declare function convertMCPToolToVercelAI(mcpTool: MCPTool, client: MCPCl
  * const tools = convertMCPToolsToVercelAI(mcpClient);
  *
  * const result = await generateText({
- *   model: openai('gpt-4'),
+ *   model: openai('gpt-5'),
  *   prompt: 'Create a GitHub issue in my repo',
  *   tools,
  * });

package/dist/transport/http-session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-session.d.ts","sourceRoot":"","sources":["../../src/transport/http-session.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAEV,eAAe,EACf,mBAAmB,EACpB,MAAM,yBAAyB,CAAC;AAGjC,MAAM,MAAM,cAAc,GAAG,CAC3B,OAAO,EAAE,eAAe,GAAG,mBAAmB,KAC3C,IAAI,CAAC;AAEV,MAAM,WAAW,2BAA2B;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAC,CAAkB;IACxC,OAAO,CAAC,SAAS,CAAS;gBAEd,OAAO,EAAE,2BAA2B;IAMhD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAS9B;;OAEG;IACG,WAAW,CAAC,CAAC,GAAG,OAAO,EAC3B,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,OAAO,GACf,OAAO,CAAC,CAAC,CAAC;IAiEb;;OAEG;YACW,gBAAgB;IAiC9B;;OAEG;YACW,gBAAgB;IAiC9B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,IAAI;IAS9C;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBjC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,YAAY,IAAI,MAAM,GAAG,SAAS;CAGnC"}
+{"version":3,"file":"http-session.d.ts","sourceRoot":"","sources":["../../src/transport/http-session.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAEV,eAAe,EACf,mBAAmB,EACpB,MAAM,yBAAyB,CAAC;AAGjC,MAAM,MAAM,cAAc,GAAG,CAC3B,OAAO,EAAE,eAAe,GAAG,mBAAmB,KAC3C,IAAI,CAAC;AAEV,MAAM,WAAW,2BAA2B;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAC,CAAkB;IACxC,OAAO,CAAC,SAAS,CAAS;gBAEd,OAAO,EAAE,2BAA2B;IAMhD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAS9B;;OAEG;IACG,WAAW,CAAC,CAAC,GAAG,OAAO,EAC3B,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,OAAO,GACf,OAAO,CAAC,CAAC,CAAC;IAsFb;;OAEG;YACW,gBAAgB;IAiC9B;;OAEG;YACW,gBAAgB;IAiC9B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,IAAI;IAS9C;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBjC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,YAAY,IAAI,MAAM,GAAG,SAAS;CAGnC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "integrate-sdk",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Type-safe TypeScript SDK for MCP Client with plugin-based OAuth provider configuration",
   "type": "module",
   "main": "./dist/index.js",
@@ -51,5 +51,4 @@
   "peerDependencies": {
     "typescript": ">=5.0.0"
   }
-}
-
+}