@hasna/connectors 1.3.2 → 1.3.3

package/connectors/connect-onesimpleapi/src/api/client.ts

@@ -1,213 +1,26 @@
-import type { ConnectorConfig, OutputFormat } from '../types';
-import { ConnectorApiError, parseApiError } from '../types';
+import type { OneSimpleAPIConfig } from '../types';
+import { OneSimpleAPIApiError } from '../types';
 
-// TODO: Replace with your API's base URL
-const DEFAULT_BASE_URL = 'https://api.example.com';
-
-export interface RequestOptions {
-  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-  params?: Record<string, string | number | boolean | undefined>;
-  body?: Record<string, unknown> | unknown[] | string;
-  headers?: Record<string, string>;
-  format?: OutputFormat;
-  /** Number of retries for failed requests (default: 3) */
-  retries?: number;
-  /** Timeout in milliseconds (default: 30000) */
-  timeout?: number;
-}
-
-export class ConnectorClient {
+export class OneSimpleAPIClient {
   private readonly apiKey: string;
-  private readonly apiSecret?: string;
-  private readonly baseUrl: string;
+  private readonly baseUrl = 'https://onesimpleapi.com/api';
 
-  constructor(config: ConnectorConfig) {
-    // Support both 'apiKey' and 'token' for flexibility
-    // Also support 'accessToken' for OAuth2
-    const key = config.apiKey || config.token || config.accessToken;
-    if (!key) {
-      throw new Error('API key, token, or accessToken is required');
-    }
-    this.apiKey = key;
-    this.apiSecret = config.apiSecret;
-    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+  constructor(config: OneSimpleAPIConfig) {
+    if (!config.apiKey) throw new Error('One Simple API apiKey is required');
+    this.apiKey = config.apiKey;
   }
 
-  private buildUrl(path: string, params?: Record<string, string | number | boolean | undefined>): string {
+  async request<T>(path: string, params?: Record<string, string | number | undefined>): Promise<T> {
     const url = new URL(`${this.baseUrl}${path}`);
-
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null && value !== '') {
-          url.searchParams.append(key, String(value));
-        }
-      });
-    }
-
-    return url.toString();
-  }
-
-  /**
-   * Sleep for a given number of milliseconds
-   */
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Calculate delay for exponential backoff
-   */
-  private getRetryDelay(attempt: number, baseDelay: number = 1000): number {
-    // Exponential backoff with jitter: base * 2^attempt + random(0-1000)ms
-    return baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
-  }
-
-  /**
-   * Check if error is retryable
-   */
-  private isRetryableStatus(status: number): boolean {
-    // Retry on rate limit (429) and server errors (5xx)
-    return status === 429 || (status >= 500 && status < 600);
-  }
-
-  /**
-   * Make an authenticated request to the API
-   * TODO: Adjust authentication method for your API:
-   * - Bearer token: Authorization: Bearer <token>
-   * - API Key header: X-API-Key: <key>
-   * - Basic auth: Authorization: Basic <base64(key:secret)>
-   */
-  async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
-    const { method = 'GET', params, body, headers = {}, retries = 3, timeout = 30000 } = options;
-
-    const url = this.buildUrl(path, params);
-
-    // TODO: Adjust authentication header for your API
-    const requestHeaders: Record<string, string> = {
-      'Authorization': `Bearer ${this.apiKey}`,
-      'Accept': 'application/json',
-      ...headers,
-    };
-
-    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
-      requestHeaders['Content-Type'] = 'application/json';
-    }
-
-    const fetchOptions: RequestInit = {
-      method,
-      headers: requestHeaders,
-    };
-
-    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
-      fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
-    }
-
-    let lastError: Error | null = null;
-    let lastStatus: number = 0;
-
-    for (let attempt = 0; attempt <= retries; attempt++) {
-      try {
-        // Create abort controller for timeout
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-        const response = await fetch(url, {
-          ...fetchOptions,
-          signal: controller.signal,
-        });
-
-        clearTimeout(timeoutId);
-        lastStatus = response.status;
-
-        // Handle 204 No Content
-        if (response.status === 204) {
-          return {} as T;
-        }
-
-        // Parse response
-        let data: unknown;
-        const contentType = response.headers.get('content-type') || '';
-
-        if (contentType.includes('application/json')) {
-          const text = await response.text();
-          if (text) {
-            try {
-              data = JSON.parse(text);
-            } catch {
-              data = text;
-            }
-          }
-        } else {
-          data = await response.text();
-        }
-
-        // Handle errors
-        if (!response.ok) {
-          // Check if we should retry
-          if (this.isRetryableStatus(response.status) && attempt < retries) {
-            // Check for Retry-After header
-            const retryAfter = response.headers.get('retry-after');
-            const delay = retryAfter
-              ? parseInt(retryAfter, 10) * 1000
-              : this.getRetryDelay(attempt);
-
-            await this.sleep(delay);
-            continue;
-          }
-
-          throw parseApiError(data, response.status);
-        }
-
-        return data as T;
-      } catch (err) {
-        lastError = err instanceof Error ? err : new Error(String(err));
-
-        // Handle timeout errors
-        if (lastError.name === 'AbortError') {
-          lastError = new Error(`Request timeout after ${timeout}ms`);
-        }
-
-        // Retry on network errors
-        if (attempt < retries && !(err instanceof ConnectorApiError)) {
-          await this.sleep(this.getRetryDelay(attempt));
-          continue;
-        }
-
-        throw err;
-      }
-    }
-
-    // Should not reach here, but just in case
-    throw lastError || new ConnectorApiError('Request failed', lastStatus);
-  }
-
-  async get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'GET', params });
-  }
-
-  async post<T>(path: string, body?: Record<string, unknown> | unknown[] | string | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'POST', body: body as Record<string, unknown>, params });
-  }
-
-  async put<T>(path: string, body?: Record<string, unknown> | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'PUT', body: body as Record<string, unknown>, params });
-  }
-
-  async patch<T>(path: string, body?: Record<string, unknown> | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'PATCH', body: body as Record<string, unknown>, params });
-  }
-
-  async delete<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'DELETE', params });
-  }
-
-  /**
-   * Get a preview of the API key (for display/debugging)
-   */
-  getApiKeyPreview(): string {
-    if (this.apiKey.length > 10) {
-      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+    url.searchParams.append('token', this.apiKey);
+    if (params) Object.entries(params).forEach(([k, v]) => { if (v !== undefined) url.searchParams.append(k, String(v)); });
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+      const data = await response.json().catch(() => ({}));
+      throw new OneSimpleAPIApiError((data as { message?: string })?.message || response.statusText, response.status);
     }
-    return '***';
+    const contentType = response.headers.get('content-type') || '';
+    if (contentType.includes('application/json')) return (await response.json()) as T;
+    return { url: url.toString() } as T;
   }
 }

package/connectors/connect-onesimpleapi/src/api/index.ts

@@ -1,51 +1,38 @@
-import type { ConnectorConfig } from '../types';
-import { ConnectorClient } from './client';
-import { ExampleApi } from './example';
-
-/**
- * Main Connector class
- * TODO: Rename to your API name (e.g., Perplexity, Twitter, etc.)
- */
-export class Connector {
-  private readonly client: ConnectorClient;
-
-  // API modules - add more as needed
-  public readonly example: ExampleApi;
-
-  constructor(config: ConnectorConfig) {
-    this.client = new ConnectorClient(config);
-    this.example = new ExampleApi(this.client);
+// One Simple API Connector — Utility APIs for screenshots, PDFs, and scraping
+import { OneSimpleAPIClient } from './client';
+import type { OneSimpleAPIConfig, OSScreenshot, OSPdf, OSScrape, OSQRCode, OSExchangeRate } from '../types';
+export { OneSimpleAPIClient } from './client';
+
+export class OneSimpleAPI {
+  private readonly client: OneSimpleAPIClient;
+  constructor(config: OneSimpleAPIConfig) { this.client = new OneSimpleAPIClient(config); }
+  static fromEnv(): OneSimpleAPI {
+    const apiKey = process.env.ONESIMPLEAPI_API_KEY;
+    if (!apiKey) throw new Error('ONESIMPLEAPI_API_KEY is required');
+    return new OneSimpleAPI({ apiKey });
   }
 
-  /**
-   * Create a client from environment variables
-   * TODO: Update env var names for your API
-   * Looks for CONNECTOR_API_KEY and optionally CONNECTOR_API_SECRET
-   */
-  static fromEnv(): Connector {
-    const apiKey = process.env.CONNECTOR_API_KEY;
-    const apiSecret = process.env.CONNECTOR_API_SECRET;
-
-    if (!apiKey) {
-      throw new Error('CONNECTOR_API_KEY environment variable is required');
-    }
-    return new Connector({ apiKey, apiSecret });
+  async screenshot(url: string, options?: { full_page?: boolean; width?: number; height?: number; format?: string }): Promise<OSScreenshot> {
+    return this.client.request<OSScreenshot>('/screenshot', { url, full_page: options?.full_page ? 'true' : undefined, width: options?.width, height: options?.height, output: options?.format });
   }
 
-  /**
-   * Get a preview of the API key (for debugging)
-   */
-  getApiKeyPreview(): string {
-    return this.client.getApiKeyPreview();
+  async urlToPdf(url: string, options?: { format?: string; landscape?: boolean }): Promise<OSPdf> {
+    return this.client.request<OSPdf>('/pdf', { url, format: options?.format, landscape: options?.landscape ? 'true' : undefined });
   }
 
-  /**
-   * Get the underlying client for direct API access
-   */
-  getClient(): ConnectorClient {
-    return this.client;
+  async scrape(url: string): Promise<OSScrape> { return this.client.request<OSScrape>('/scrape', { url }); }
+
+  async generateQRCode(data: string, options?: { size?: number }): Promise<OSQRCode> {
+    return this.client.request<OSQRCode>('/qr_code', { data, size: options?.size });
+  }
+
+  async getExchangeRate(base: string, target: string): Promise<OSExchangeRate> {
+    return this.client.request<OSExchangeRate>('/exchange_rate', { base, target });
   }
-}
 
-export { ConnectorClient } from './client';
-export { ExampleApi } from './example';
+  async shortenUrl(url: string): Promise<{ short_url: string }> {
+    return this.client.request('/shorten', { url });
+  }
+
+  getClient(): OneSimpleAPIClient { return this.client; }
+}

package/connectors/connect-onesimpleapi/src/types/index.ts

@@ -1,237 +1,12 @@
-// Scaffold Connector Types
-// Replace CONNECTOR with your API name (e.g., Perplexity, Twitter, etc.)
+export interface OneSimpleAPIConfig { apiKey: string; }
 
-// ============================================
-// Configuration
-// ============================================
+export interface OSScreenshot { url: string; image_url: string; }
+export interface OSPdf { url: string; pdf_url: string; }
+export interface OSScrape { url: string; text: string; html: string; title: string; description: string; }
+export interface OSQRCode { data: string; image_url: string; }
+export interface OSExchangeRate { base: string; target: string; rate: number; date: string; }
 
-export interface ConnectorConfig {
-  apiKey?: string;      // For API key authentication
-  token?: string;       // Alias for apiKey (some APIs use 'token')
-  apiSecret?: string;   // Optional - some APIs need only a key
-  accessToken?: string; // For OAuth2 authentication
-  baseUrl?: string;     // Override default base URL
-}
-
-// ============================================
-// OAuth2 Types
-// ============================================
-
-export interface OAuth2Config {
-  clientId: string;
-  clientSecret: string;
-  redirectUri?: string;
-}
-
-export interface OAuth2Tokens {
-  accessToken: string;
-  refreshToken?: string;
-  expiresAt: number;
-  tokenType?: string;
-  scope?: string;
-}
-
-// ============================================
-// Common Types
-// ============================================
-
-export type OutputFormat = 'json' | 'pretty';
-
-export interface PaginatedResponse<T> {
-  data: T[];
-  nextToken?: string;
-  hasMore: boolean;
-}
-
-// ============================================
-// Example Resource Types
-// ============================================
-
-// Replace with your API's resource types
-export interface ExampleResource {
-  id: string;
-  name: string;
-  createdAt: string;
-  updatedAt: string;
-  // Add more fields as needed
-}
-
-export interface ExampleListResponse {
-  items: ExampleResource[];
-  nextPageToken?: string;
-  total?: number;
-}
-
-export interface ExampleCreateParams {
-  name: string;
-  // Add more params as needed
-}
-
-// ============================================
-// API Error Types
-// ============================================
-
-export interface ApiErrorDetail {
-  code: string;
-  message: string;
-  field?: string;
-  resource?: string;
-}
-
-export class ConnectorApiError extends Error {
+export class OneSimpleAPIApiError extends Error {
   public readonly statusCode: number;
-  public readonly errors?: ApiErrorDetail[];
-  public readonly documentationUrl?: string;
-  public readonly requestId?: string;
-
-  constructor(
-    message: string,
-    statusCode: number,
-    options?: {
-      errors?: ApiErrorDetail[];
-      documentationUrl?: string;
-      requestId?: string;
-    }
-  ) {
-    super(message);
-    this.name = 'ConnectorApiError';
-    this.statusCode = statusCode;
-    this.errors = options?.errors;
-    this.documentationUrl = options?.documentationUrl;
-    this.requestId = options?.requestId;
-  }
-
-  /**
-   * Check if this is a rate limit error
-   */
-  isRateLimited(): boolean {
-    return this.statusCode === 429;
-  }
-
-  /**
-   * Check if this is a server error
-   */
-  isServerError(): boolean {
-    return this.statusCode >= 500 && this.statusCode < 600;
-  }
-
-  /**
-   * Check if this is a client error
-   */
-  isClientError(): boolean {
-    return this.statusCode >= 400 && this.statusCode < 500;
-  }
-
-  /**
-   * Check if this is an authentication error
-   */
-  isAuthError(): boolean {
-    return this.statusCode === 401 || this.statusCode === 403;
-  }
-
-  /**
-   * Check if this is a not found error
-   */
-  isNotFound(): boolean {
-    return this.statusCode === 404;
-  }
-
-  /**
-   * Get a user-friendly error message
-   */
-  getUserMessage(): string {
-    switch (this.statusCode) {
-      case 400:
-        return 'Bad request. Please check your input.';
-      case 401:
-        return 'Authentication failed. Please check your API key or login again.';
-      case 403:
-        return 'Access denied. You do not have permission to perform this action.';
-      case 404:
-        return 'Resource not found.';
-      case 429:
-        return 'Rate limit exceeded. Please wait and try again.';
-      case 500:
-        return 'Server error. Please try again later.';
-      case 502:
-      case 503:
-      case 504:
-        return 'Service temporarily unavailable. Please try again later.';
-      default:
-        return this.message;
-    }
-  }
-
-  /**
-   * Convert to JSON for logging/debugging
-   */
-  toJSON(): Record<string, unknown> {
-    return {
-      name: this.name,
-      message: this.message,
-      statusCode: this.statusCode,
-      errors: this.errors,
-      documentationUrl: this.documentationUrl,
-      requestId: this.requestId,
-    };
-  }
-}
-
-/**
- * Parse an API error response into a ConnectorApiError
- * Handles various common API error response formats
- */
-export function parseApiError(
-  response: unknown,
-  statusCode: number
-): ConnectorApiError {
-  // Handle string responses
-  if (typeof response === 'string') {
-    return new ConnectorApiError(response, statusCode);
-  }
-
-  // Handle null/undefined
-  if (!response || typeof response !== 'object') {
-    return new ConnectorApiError(`HTTP ${statusCode} Error`, statusCode);
-  }
-
-  const data = response as Record<string, unknown>;
-
-  // Extract message from various common formats
-  const message =
-    (data.message as string) ||
-    (data.error as string) ||
-    ((data.error as Record<string, unknown>)?.message as string) ||
-    (data.error_description as string) ||
-    (data.detail as string) ||
-    `HTTP ${statusCode} Error`;
-
-  // Extract errors array if present
-  let errors: ApiErrorDetail[] | undefined;
-  if (Array.isArray(data.errors)) {
-    errors = data.errors.map((e: Record<string, unknown>) => ({
-      code: String(e.code || e.error || 'unknown'),
-      message: String(e.message || e.description || 'Unknown error'),
-      field: e.field as string,
-      resource: e.resource as string,
-    }));
-  }
-
-  // Extract documentation URL
-  const documentationUrl =
-    (data.documentation_url as string) ||
-    (data.docs_url as string) ||
-    (data.help_url as string);
-
-  // Extract request ID
-  const requestId =
-    (data.request_id as string) ||
-    (data.requestId as string) ||
-    (data.trace_id as string);
-
-  return new ConnectorApiError(message, statusCode, {
-    errors,
-    documentationUrl,
-    requestId,
-  });
+  constructor(message: string, statusCode: number) { super(message); this.name = 'OneSimpleAPIApiError'; this.statusCode = statusCode; }
 }

package/connectors/connect-openai/src/api/chat.ts

@@ -6,8 +6,8 @@ import type {
   ChatOptions,
   OpenAIModel,
   Tool,
-  DEFAULT_CHAT_MODEL,
 } from '../types';
+import { DEFAULT_CHAT_MODEL } from '../types';
 
 /**
  * Chat Completions API
@@ -23,7 +23,7 @@ export class ChatApi {
     options: ChatOptions = {}
   ): Promise<ChatCompletionResponse> {
     const request: ChatCompletionRequest = {
-      model: options.model || 'gpt-4o-mini',
+      model: options.model || DEFAULT_CHAT_MODEL,
       messages,
       stream: false,
     };

package/connectors/connect-openai/src/api/images.ts

@@ -5,8 +5,20 @@ import type {
   ImageOptions,
 } from '../types';
 
+/** Models that use the new gpt-image API (different params than DALL-E) */
+const GPT_IMAGE_MODELS = ['gpt-image-1'];
+
+function isGptImage(model: string): boolean {
+  return GPT_IMAGE_MODELS.some((m) => model.startsWith(m));
+}
+
 /**
- * Images API (DALL-E)
+ * Images API — supports both DALL-E 3 and gpt-image-1
+ *
+ * gpt-image-1 differences:
+ *   - Uses `output_format` instead of `response_format`
+ *   - Does NOT support `style` parameter
+ *   - Does NOT support `response_format` parameter
  */
 export class ImagesApi {
   constructor(private readonly client: OpenAIClient) {}
@@ -18,13 +30,29 @@ export class ImagesApi {
     prompt: string,
     options: ImageOptions = {}
   ): Promise<ImageResponse> {
+    const model = options.model || 'dall-e-3';
+
+    if (isGptImage(model)) {
+      // gpt-image-1: different parameter set
+      const request: Record<string, unknown> = {
+        model,
+        prompt,
+        n: options.n || 1,
+      };
+      if (options.size !== undefined) request.size = options.size;
+      if (options.quality !== undefined) request.quality = options.quality;
+      // gpt-image-1 uses output_format, not response_format. No style param.
+      request.output_format = 'url';
+      return this.client.post<ImageResponse>('/images/generations', request);
+    }
+
+    // DALL-E 3: original parameter set
     const request: ImageGenerateRequest = {
-      model: options.model || 'dall-e-3',
+      model,
       prompt,
       n: options.n || 1,
       response_format: 'url',
     };
-
     if (options.size !== undefined) request.size = options.size;
     if (options.quality !== undefined) request.quality = options.quality;
     if (options.style !== undefined) request.style = options.style;
@@ -54,22 +82,38 @@ export class ImagesApi {
     prompt: string,
     options: Omit<ImageOptions, 'n'> = {}
   ): Promise<string> {
+    const model = options.model || 'dall-e-3';
+
+    if (isGptImage(model)) {
+      const request: Record<string, unknown> = {
+        model,
+        prompt,
+        n: 1,
+        output_format: 'b64_json',
+      };
+      if (options.size !== undefined) request.size = options.size;
+      if (options.quality !== undefined) request.quality = options.quality;
+
+      const response = await this.client.post<ImageResponse>('/images/generations', request);
+      const b64 = response.data[0]?.b64_json;
+      if (!b64) throw new Error('No image data in response');
+      return b64;
+    }
+
+    // DALL-E 3
     const request: ImageGenerateRequest = {
-      model: options.model || 'dall-e-3',
+      model,
       prompt,
       n: 1,
       response_format: 'b64_json',
     };
-
     if (options.size !== undefined) request.size = options.size;
     if (options.quality !== undefined) request.quality = options.quality;
     if (options.style !== undefined) request.style = options.style;
 
     const response = await this.client.post<ImageResponse>('/images/generations', request);
     const b64 = response.data[0]?.b64_json;
-    if (!b64) {
-      throw new Error('No image data in response');
-    }
+    if (!b64) throw new Error('No image data in response');
     return b64;
   }
 }