infinium-o2 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Xyen Digital
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,550 @@
+# Infinium SDK for Node.js
+
+A production-ready Node.js SDK for interacting with the Infinium Hosted MCP Bridge API.
+
+## Features
+
+- **Synchronous and Asynchronous Support**: Choose the right approach for your application
+- **Automatic Retries**: Built-in exponential backoff for failed requests
+- **Rate Limiting**: Client-side rate limiting to prevent API abuse
+- **Comprehensive Error Handling**: Meaningful exceptions for different error types
+- **Input Validation**: Thorough validation of all inputs before sending to API
+- **Type Safety**: Full TypeScript types for better IDE support and code quality
+- **Flexible Data Structures**: Support for various task types and specialized data sections
+- **Batch Operations**: Send multiple tasks efficiently (concurrent or sequential)
+- **Production Ready**: Designed for enterprise use with proper logging and monitoring
+
+## Installation
+
+```bash
+npm install infinium
+```
+
+For development:
+
+```bash
+npm install infinium --save-dev
+```
+
+## Quick Start
+
+### Basic Usage
+
+```typescript
+import { InfiniumClient, AgentType } from "infinium";
+
+// Initialize client
+const client = new InfiniumClient({
+  agentId: "your-agent-id",
+  agentSecret: "your-agent-secret",
+});
+
+// Send a simple task
+const response = client.sendTask({
+  name: "Process customer inquiry",
+  description: "Handled customer question about pricing",
+  duration: 120.5,
+  agentType: AgentType.CUSTOMER_SUPPORT_ASSISTANT,
+});
+
+console.log("Success:", response.success);
+```
+
+### Async Usage
+
+```typescript
+import { AsyncInfiniumClient, AgentType } from "infinium";
+
+async function example() {
+  const client = new AsyncInfiniumClient({
+    agentId: "your-agent-id",
+    agentSecret: "your-agent-secret",
+  });
+
+  try {
+    // Test connection
+    const health = await client.testConnection();
+    console.log("Connected:", health.agentName);
+
+    // Send a task
+    const response = await client.sendTask({
+      name: "Marketing campaign analysis",
+      description: "Analyzed Q3 campaign performance",
+      duration: 300.0,
+      agentType: AgentType.MARKETING_ASSISTANT,
+    });
+
+    console.log("Task sent:", response.success);
+  } finally {
+    await client.close();
+  }
+}
+```
+
+## Configuration
+
+### Client Configuration
+
+```typescript
+const client = new InfiniumClient({
+  agentId: "your-agent-id", // Required: Your agent ID
+  agentSecret: "your-agent-secret", // Required: Your agent secret
+  baseUrl: "https://api.i42m.ai/api/v1", // Optional: API base URL
+  timeout: 30000, // Optional: Request timeout (ms)
+  maxRetries: 3, // Optional: Max retry attempts
+  enableRateLimiting: true, // Optional: Enable client-side rate limiting
+  requestsPerSecond: 10, // Optional: Rate limit (requests/second)
+  userAgent: "my-app/1.0.0", // Optional: Custom user agent
+  enableLogging: true, // Optional: Enable SDK logging
+  logLevel: "INFO", // Optional: Log level (DEBUG, INFO, WARN, ERROR)
+});
+```
+
+### Environment Variables
+
+```bash
+# .env file
+INFINIUM_AGENT_ID=your-agent-id
+INFINIUM_AGENT_SECRET=your-agent-secret
+```
+
+```typescript
+const client = new InfiniumClient({
+  agentId: process.env.INFINIUM_AGENT_ID!,
+  agentSecret: process.env.INFINIUM_AGENT_SECRET!,
+});
+```
+
+## API Reference
+
+### InfiniumClient (Synchronous)
+
+#### Constructor
+
+```typescript
+new InfiniumClient(config: ClientConfig)
+```
+
+#### Methods
+
+##### `sendTask(task)`
+
+Send a single task to the API.
+
+```typescript
+const response = client.sendTask({
+  name: "Task name",
+  description: "Task description",
+  duration: 120.5,
+  agentType: AgentType.CUSTOMER_SUPPORT_ASSISTANT,
+  // ... additional optional fields
+});
+```
+
+##### `sendTaskData(taskData)`
+
+Send a pre-built TaskData object.
+
+```typescript
+const taskData: TaskData = {
+  name: "Process inquiry",
+  description: "Handled customer question",
+  currentDatetime: client.getCurrentIsoDatetime(),
+  duration: 120,
+  agentType: AgentType.CUSTOMER_SUPPORT_ASSISTANT,
+};
+
+const response = client.sendTaskData(taskData);
+```
+
+##### `sendBatch(tasks)`
+
+Send multiple tasks in batch (up to 100 tasks).
+
+```typescript
+const tasks: TaskData[] = [
+  { name: 'Task 1', /* ... */ },
+  { name: 'Task 2', /* ... */ },
+  // ...
+];
+
+const batchResult = client.sendBatch(tasks);
+console.log(\`\${batchResult.successfulTasks}/\${batchResult.totalTasks} successful\`);
+```
+
+##### `testConnection()`
+
+Test API connectivity and authentication.
+
+```typescript
+const health = client.testConnection();
+console.log("Agent:", health.agentName);
+console.log("Status:", health.status);
+```
+
+##### `getInterpretedTaskResult(taskId)`
+
+Get AI-interpreted results for a task.
+
+```typescript
+const result = client.getInterpretedTaskResult("task-uuid");
+```
+
+### AsyncInfiniumClient (Asynchronous)
+
+The async client has the same methods as the synchronous client, but all methods return Promises:
+
+```typescript
+const response = await client.sendTask(taskData);
+const health = await client.testConnection();
+const batchResult = await client.sendBatch(tasks);
+```
+
+#### Additional Async Methods
+
+##### `sendBatchSequential(tasks)`
+
+Send tasks sequentially (better for strict rate limiting).
+
+```typescript
+const batchResult = await client.sendBatchSequential(tasks);
+```
+
+##### `close()`
+
+Close the client and cleanup resources.
+
+```typescript
+await client.close();
+```
+
+## Data Structures
+
+### AgentType
+
+```typescript
+enum AgentType {
+  OTHER = "OTHER",
+  EXECUTIVE_ASSISTANT = "EXECUTIVE_ASSISTANT",
+  MARKETING_ASSISTANT = "MARKETING_ASSISTANT",
+  DATA_ANALYST = "DATA_ANALYST",
+  RESEARCH_ASSISTANT = "RESEARCH_ASSISTANT",
+  CUSTOMER_SUPPORT_ASSISTANT = "CUSTOMER_SUPPORT_ASSISTANT",
+  CONTENT_CREATOR = "CONTENT_CREATOR",
+  SALES_ASSISTANT = "SALES_ASSISTANT",
+  PROJECT_MANAGER = "PROJECT_MANAGER",
+  DEVELOPMENT_ASSISTANT = "DEVELOPMENT_ASSISTANT",
+}
+```
+
+### TaskData Structure
+
+```typescript
+interface TaskData {
+  name: string; // Required: Task name
+  description: string; // Required: Task description
+  currentDatetime: string; // Required: ISO 8601 timestamp
+  duration: number; // Required: Duration in seconds
+  agentType?: AgentType; // Optional: Agent type
+
+  // Optional specialized sections
+  timeTracking?: TimeTracking;
+  customer?: Customer;
+  support?: Support;
+  sales?: Sales;
+  marketing?: Marketing;
+  content?: Content;
+  research?: Research;
+  project?: Project;
+  development?: Development;
+  executive?: Executive;
+  general?: General;
+}
+```
+
+### Specialized Data Sections
+
+#### Customer Information
+
+```typescript
+interface Customer {
+  customerName?: string;
+  customerEmail?: string;
+  customerPhone?: string;
+  customerAddress?: string;
+  clientCompany?: string;
+  clientIndustry?: string;
+}
+```
+
+#### Support Information
+
+```typescript
+interface Support {
+  callId?: string;
+  issueDescription?: string;
+  issueType?: string;
+  resolution?: string;
+  status?: string;
+  priority?: string;
+  followUpRequired?: boolean;
+  agentNotes?: string;
+}
+```
+
+#### Sales Information
+
+```typescript
+interface Sales {
+  leadSource?: string;
+  salesStage?: string;
+  dealValue?: number;
+  conversionRate?: number;
+  salesNotes?: string;
+}
+```
+
+#### Marketing Information
+
+```typescript
+interface Marketing {
+  campaignName?: string;
+  campaignType?: string;
+  targetAudience?: string;
+  marketingChannel?: string;
+  engagementMetrics?: string;
+  conversionMetrics?: string;
+}
+```
+
+[Additional interfaces for Content, Research, Project, Development, Executive, and General sections...]
+
+## Error Handling
+
+The SDK provides comprehensive error handling with specific error types:
+
+### Error Types
+
+```typescript
+import {
+  InfiniumError, // Base error class
+  AuthenticationError, // 401/403 errors
+  ValidationError, // Input validation errors
+  RateLimitError, // Rate limit exceeded
+  NetworkError, // Network/connection errors
+  TimeoutError, // Request timeout
+  ServerError, // Server errors (5xx)
+  NotFoundError, // 404 errors
+  BatchError, // Batch operation errors
+} from "infinium";
+```
+
+### Error Handling Examples
+
+```typescript
+try {
+  const response = await client.sendTask(taskData);
+} catch (error) {
+  if (error instanceof AuthenticationError) {
+    console.error("Check your credentials");
+  } else if (error instanceof ValidationError) {
+    console.error("Invalid input:", error.field);
+  } else if (error instanceof RateLimitError) {
+    console.error("Rate limited, retry after:", error.retryAfter);
+  } else if (error instanceof NetworkError) {
+    console.error("Network issue:", error.originalError);
+  } else {
+    console.error("Unknown error:", error);
+  }
+}
+```
+
+## Advanced Usage
+
+### Rate Limiting
+
+```typescript
+// Configure rate limiting
+const client = new AsyncInfiniumClient({
+  agentId: "your-agent-id",
+  agentSecret: "your-agent-secret",
+  enableRateLimiting: true,
+  requestsPerSecond: 5, // 5 requests per second
+});
+
+// Rate limiting is handled automatically
+for (let i = 0; i < 10; i++) {
+  await client.sendTask(taskData); // Will automatically throttle
+}
+```
+
+### Batch Processing
+
+```typescript
+// Concurrent batch (faster, but may hit rate limits)
+const concurrentResult = await client.sendBatch(tasks);
+
+// Sequential batch (slower, but respects rate limits)
+const sequentialResult = await client.sendBatchSequential(tasks);
+```
+
+### Custom Request Configuration
+
+```typescript
+const response = await client.sendTask(taskData, {
+  timeout: 60000, // 60 second timeout
+  headers: {
+    "X-Custom-Header": "value",
+  },
+});
+```
+
+### Logging
+
+```typescript
+const client = new InfiniumClient({
+  agentId: "your-agent-id",
+  agentSecret: "your-agent-secret",
+  enableLogging: true,
+  logLevel: "DEBUG", // DEBUG, INFO, WARN, ERROR
+});
+
+// Logs will include:
+// - Request/response details
+// - Rate limiting information
+// - Retry attempts
+// - Error details
+```
+
+## Examples
+
+See the `examples/` directory for complete usage examples:
+
+- `examples/basicUsage.ts` - Synchronous client examples
+- `examples/asyncUsage.ts` - Asynchronous client examples with advanced patterns
+
+## Testing
+
+```bash
+# Run tests
+npm test
+
+# Run with coverage
+npm run test:coverage
+
+# Watch mode
+npm run test:watch
+```
+
+## Building from Source
+
+```bash
+# Install dependencies
+npm install
+
+# Build TypeScript
+npm run build
+
+# Lint code
+npm run lint
+
+# Format code
+npm run format
+```
+
+## Authentication
+
+The SDK authenticates with the Infinium API using your agent ID and agent secret:
+
+1. Sign up for an Infinium account
+2. Create an agent and get your credentials
+3. Use the credentials in your SDK configuration
+
+**Security Note**: Never commit your credentials to version control. Use environment variables or secure configuration management.
+
+## API Endpoints
+
+The SDK communicates with these API endpoints:
+
+- `POST /agent/{agentId}/task` - Send task data
+- `GET /agent/{agentId}/health` - Health check
+- `GET /agent-tasks/{taskId}/interpreted-result` - Get interpreted results
+- `GET /agent-tasks/{taskId}/custom-result` - Get custom schemas
+
+## Rate Limits
+
+- Default: 10 requests per second
+- Configurable via `requestsPerSecond` option
+- Automatic retry with exponential backoff
+- Client-side rate limiting prevents server-side limits
+
+## TypeScript Support
+
+The SDK is written in TypeScript and provides complete type definitions:
+
+```typescript
+import { InfiniumClient, TaskData, AgentType, ApiResponse } from 'infinium';
+
+// Full IntelliSense support
+const client: InfiniumClient = new InfiniumClient({...});
+const response: ApiResponse = client.sendTask({...});
+```
+
+## Browser Support
+
+This SDK is designed for Node.js environments. For browser usage, consider:
+
+- Server-side proxy to avoid CORS issues
+- Environment variable substitution for credentials
+- Bundle size optimization
+
+## Migration from Python SDK
+
+The Node.js SDK follows the same patterns as the Python SDK:
+
+```python
+# Python
+from infinium_sdk import InfiniumClient, AgentType
+
+client = InfiniumClient(agent_id="...", agent_secret="...")
+response = client.send_task(name="...", duration=120, ...)
+```
+
+```typescript
+// Node.js
+import { InfiniumClient, AgentType } from 'infinium';
+
+const client = new InfiniumClient({agentId: "...", agentSecret: "..."});
+const response = client.sendTask({name: "...", duration: 120, ...});
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests for new functionality
+5. Run `npm run lint` and `npm test`
+6. Submit a pull request
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Support
+
+For support and questions:
+
+- 📧 Email: support@xyendigital.com
+- 🐛 Issues: [GitHub Issues](https://github.com/yourusername/infinium-npm-sdk/issues)
+- 📚 Documentation: See this README for complete usage guide
+
+## API Information
+
+- **Base URL**: `https://api.i42m.ai/api/v1`
+- **Authentication**: Agent ID and Agent Secret
+- **Version**: v1
+
+---
+
+**Made with ❤️ by XyenDigital**

package/dist/cjs/asyncClient.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Asynchronous client for Infinium API.
+ */
+import { TaskData, ApiResponse, HealthCheck, BatchResult, ClientConfig } from './types';
+/**
+ * Asynchronous client for Infinium API.
+ *
+ * @example
+ * ```typescript
+ * import { AsyncInfiniumClient, AgentType } from 'infinium';
+ *
+ * const client = new AsyncInfiniumClient({
+ *   agentId: 'your-agent-id',
+ *   agentSecret: 'your-agent-secret'
+ * });
+ *
+ * // Send a simple task
+ * const response = await client.sendTask({
+ *   name: 'Process customer inquiry',
+ *   description: 'Handled customer question about pricing',
+ *   duration: 120.5
+ * });
+ *
+ * // Use with proper cleanup
+ * async function example() {
+ *   const client = new AsyncInfiniumClient({
+ *     agentId: 'your-agent-id',
+ *     agentSecret: 'your-agent-secret'
+ *   });
+ *
+ *   try {
+ *     const health = await client.testConnection();
+ *     console.log('Connected:', health.agentName);
+ *
+ *     const response = await client.sendTask({
+ *       name: 'Marketing campaign analysis',
+ *       description: 'Analyzed Q3 campaign performance',
+ *       duration: 300.0,
+ *       agentType: AgentType.MARKETING_ASSISTANT
+ *     });
+ *
+ *     console.log('Task sent:', response.success);
+ *   } finally {
+ *     await client.close();
+ *   }
+ * }
+ * ```
+ */
+export declare class AsyncInfiniumClient {
+    private readonly agentId;
+    private readonly agentSecret;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    private readonly userAgent;
+    private readonly logger;
+    private readonly rateLimiter;
+    private readonly httpClient;
+    private closed;
+    /**
+     * Initialize the async Infinium client.
+     */
+    constructor(config: ClientConfig);
+    /**
+     * Create and configure HTTP client.
+     */
+    private createHttpClient;
+    /**
+     * Make HTTP request with proper error handling.
+     */
+    private makeRequest;
+    /**
+     * Send task data to the API.
+     */
+    sendTask(task: Omit<TaskData, 'currentDatetime'> & {
+        currentDatetime?: string;
+    }): Promise<ApiResponse>;
+    /**
+     * Send pre-built TaskData object.
+     */
+    sendTaskData(taskData: TaskData): Promise<ApiResponse>;
+    /**
+     * Send multiple tasks in batch.
+     */
+    sendBatch(tasks: TaskData[]): Promise<BatchResult>;
+    /**
+     * Send tasks in sequential batch (for rate limiting).
+     */
+    sendBatchSequential(tasks: TaskData[]): Promise<BatchResult>;
+    /**
+     * Test connection to the API.
+     */
+    testConnection(): Promise<HealthCheck>;
+    /**
+     * Get interpreted task result.
+     */
+    getInterpretedTaskResult(taskId: string): Promise<ApiResponse>;
+    /**
+     * Get current ISO datetime string.
+     */
+    getCurrentIsoDatetime(): string;
+    /**
+     * Get client configuration.
+     */
+    getConfig(): Partial<ClientConfig>;
+    /**
+     * Check if client is closed.
+     */
+    isClosed(): boolean;
+    /**
+     * Close the client and cleanup resources.
+     */
+    close(): Promise<void>;
+    /**
+     * Clean payload by removing undefined values.
+     */
+    private cleanPayload;
+}
+//# sourceMappingURL=asyncClient.d.ts.map

package/dist/cjs/asyncClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncClient.d.ts","sourceRoot":"","sources":["../../src/asyncClient.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAEL,QAAQ,EACR,WAAW,EACX,WAAW,EACX,WAAW,EACX,YAAY,EAab,MAAM,SAAS,CAAC;AA+BjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAErC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IAEpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAEhC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IAEjD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAE3C,OAAO,CAAC,MAAM,CAAS;IAEvB;;OAEG;gBACS,MAAM,EAAE,YAAY;IAiChC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA0FxB;;OAEG;YACW,WAAW;IA2BzB;;OAEG;IACG,QAAQ,CACZ,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,iBAAiB,CAAC,GAAG;QAAE,eAAe,CAAC,EAAE,MAAM,CAAA;KAAE,GACrE,OAAO,CAAC,WAAW,CAAC;IAmDvB;;OAEG;IACG,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC;IAI5D;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAoExD;;OAEG;IACG,mBAAmB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAgElE;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC;IAkB5C;;OAEG;IACG,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAWpE;;OAEG;IACH,qBAAqB,IAAI,MAAM;IAI/B;;OAEG;IACH,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;IAWlC;;OAEG;IACH,QAAQ,IAAI,OAAO;IAInB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;OAEG;IACH,OAAO,CAAC,YAAY;CAkBrB"}