@synova-cloud/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,620 @@
+// src/errors/index.ts
+var SynovaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SynovaError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ApiSynovaError = class extends SynovaError {
+  code;
+  httpCode;
+  requestId;
+  timestamp;
+  constructor(response) {
+    super(response.message);
+    this.name = "ApiSynovaError";
+    this.code = response.code;
+    this.httpCode = response.httpCode;
+    this.requestId = response.requestId;
+    this.timestamp = response.timestamp;
+  }
+};
+var AuthSynovaError = class extends SynovaError {
+  constructor(message = "Invalid or missing API key") {
+    super(message);
+    this.name = "AuthSynovaError";
+  }
+};
+var NotFoundSynovaError = class extends SynovaError {
+  resourceType;
+  resourceId;
+  constructor(resourceType, resourceId) {
+    super(`${resourceType} not found: ${resourceId}`);
+    this.name = "NotFoundSynovaError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+};
+var RateLimitSynovaError = class extends SynovaError {
+  retryAfterMs;
+  constructor(message = "Rate limit exceeded", retryAfterMs) {
+    super(message);
+    this.name = "RateLimitSynovaError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var TimeoutSynovaError = class extends SynovaError {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`);
+    this.name = "TimeoutSynovaError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var NetworkSynovaError = class extends SynovaError {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "NetworkSynovaError";
+    this.cause = cause;
+  }
+};
+var ServerSynovaError = class extends SynovaError {
+  httpCode;
+  retryable;
+  constructor(httpCode, message) {
+    super(message || `Server error: ${httpCode}`);
+    this.name = "ServerSynovaError";
+    this.httpCode = httpCode;
+    this.retryable = true;
+  }
+};
+
+// src/utils/http.ts
+var HttpClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async request(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const { maxRetries } = this.config.retry;
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        if (attempt > 0) {
+          const delay = this.calculateRetryDelay(attempt, lastError);
+          this.log(
+            `Retry attempt ${attempt}/${maxRetries} after ${delay}ms (strategy: ${this.config.retry.strategy})`
+          );
+          await this.sleep(delay);
+        }
+        return await this.makeRequest(url, options);
+      } catch (error) {
+        lastError = error;
+        if (!this.isRetryable(error)) {
+          throw error;
+        }
+        if (attempt === maxRetries) {
+          throw error;
+        }
+        this.log(`Request failed, will retry: ${error.message}`);
+      }
+    }
+    throw lastError;
+  }
+  async upload(options) {
+    const url = this.buildUrl(options.path);
+    const { maxRetries } = this.config.retry;
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        if (attempt > 0) {
+          const delay = this.calculateRetryDelay(attempt, lastError);
+          this.log(
+            `Retry attempt ${attempt}/${maxRetries} after ${delay}ms (strategy: ${this.config.retry.strategy})`
+          );
+          await this.sleep(delay);
+        }
+        return await this.makeUploadRequest(url, options.formData);
+      } catch (error) {
+        lastError = error;
+        if (!this.isRetryable(error)) {
+          throw error;
+        }
+        if (attempt === maxRetries) {
+          throw error;
+        }
+        this.log(`Upload failed, will retry: ${error.message}`);
+      }
+    }
+    throw lastError;
+  }
+  async makeRequest(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    this.log(`${options.method} ${url}`);
+    try {
+      const response = await fetch(url, {
+        method: options.method,
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "Content-Type": "application/json",
+          "User-Agent": "synova-cloud-sdk-node/0.1.0"
+        },
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      const data = await response.json();
+      this.log(`Response: ${response.status}`);
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new TimeoutSynovaError(this.config.timeout);
+      }
+      if (error instanceof ApiSynovaError || error instanceof AuthSynovaError || error instanceof NotFoundSynovaError || error instanceof RateLimitSynovaError || error instanceof ServerSynovaError) {
+        throw error;
+      }
+      throw new NetworkSynovaError(
+        `Network request failed: ${error.message}`,
+        error
+      );
+    }
+  }
+  async makeUploadRequest(url, formData) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    this.log(`POST (upload) ${url}`);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "User-Agent": "synova-cloud-sdk-node/0.1.0"
+          // Note: Content-Type is not set for FormData - browser/node sets it with boundary
+        },
+        body: formData,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      const data = await response.json();
+      this.log(`Response: ${response.status}`);
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new TimeoutSynovaError(this.config.timeout);
+      }
+      if (error instanceof ApiSynovaError || error instanceof AuthSynovaError || error instanceof NotFoundSynovaError || error instanceof RateLimitSynovaError || error instanceof ServerSynovaError) {
+        throw error;
+      }
+      throw new NetworkSynovaError(
+        `Upload request failed: ${error.message}`,
+        error
+      );
+    }
+  }
+  async handleErrorResponse(response) {
+    const status = response.status;
+    let errorBody = null;
+    try {
+      errorBody = await response.json();
+    } catch {
+    }
+    if (status === 401) {
+      throw new AuthSynovaError(errorBody?.message);
+    }
+    if (status === 404) {
+      throw new NotFoundSynovaError("Resource", errorBody?.message || "unknown");
+    }
+    if (status === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      const retryAfterMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : void 0;
+      throw new RateLimitSynovaError(errorBody?.message, retryAfterMs);
+    }
+    if (status >= 500) {
+      throw new ServerSynovaError(status, errorBody?.message);
+    }
+    if (errorBody) {
+      throw new ApiSynovaError(errorBody);
+    }
+    throw new ApiSynovaError({
+      code: "UNKNOWN_ERROR",
+      httpCode: status,
+      message: `HTTP ${status}: ${response.statusText}`,
+      requestId: "unknown",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  buildUrl(path, query) {
+    const url = new URL(path, this.config.baseUrl);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, value);
+        }
+      }
+    }
+    return url.toString();
+  }
+  isRetryable(error) {
+    if (error instanceof RateLimitSynovaError) return true;
+    if (error instanceof ServerSynovaError) return true;
+    if (error instanceof NetworkSynovaError) return true;
+    if (error instanceof TimeoutSynovaError) return true;
+    return false;
+  }
+  calculateRetryDelay(attempt, error) {
+    const { strategy, initialDelayMs, maxDelayMs, backoffMultiplier } = this.config.retry;
+    if (error instanceof RateLimitSynovaError && error.retryAfterMs) {
+      return Math.min(error.retryAfterMs, maxDelayMs);
+    }
+    let baseDelay;
+    if (strategy === "linear") {
+      baseDelay = initialDelayMs * attempt;
+    } else {
+      baseDelay = initialDelayMs * Math.pow(backoffMultiplier, attempt - 1);
+    }
+    const jitter = baseDelay * 0.1 * (Math.random() * 2 - 1);
+    const delay = baseDelay + jitter;
+    return Math.min(Math.max(delay, 0), maxDelayMs);
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  log(message) {
+    if (this.config.debug) {
+      this.config.logger.debug(`[Synova SDK] ${message}`);
+    }
+  }
+};
+
+// src/resources/prompts.ts
+var PromptsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get a prompt by ID (returns version with 'latest' tag)
+   *
+   * @param promptId - The prompt ID (e.g., 'prm_abc123')
+   * @param options - Optional settings
+   * @returns The prompt data
+   *
+   * @example
+   * ```ts
+   * // Get default (latest) version
+   * const prompt = await client.prompts.get('prm_abc123');
+   *
+   * // Get by specific tag
+   * const production = await client.prompts.get('prm_abc123', { tag: 'production' });
+   *
+   * // Get specific version
+   * const v2 = await client.prompts.get('prm_abc123', { version: '2.0.0' });
+   * ```
+   */
+  async get(promptId, options) {
+    if (options?.version) {
+      return this.http.request({
+        method: "GET",
+        path: `/api/v1/prompts/${promptId}/versions/${options.version}`
+      });
+    }
+    const tag = options?.tag || "latest";
+    if (tag === "latest") {
+      return this.http.request({
+        method: "GET",
+        path: `/api/v1/prompts/${promptId}`
+      });
+    }
+    return this.http.request({
+      method: "GET",
+      path: `/api/v1/prompts/${promptId}/tags/${tag}`
+    });
+  }
+  /**
+   * Execute a prompt with 'latest' tag
+   *
+   * @param promptId - The prompt ID
+   * @param options - Execution options including provider, model and variables
+   * @returns The execution response
+   *
+   * @example
+   * ```ts
+   * const result = await client.prompts.execute('prm_abc123', {
+   *   provider: 'openai',
+   *   model: 'gpt-4o',
+   *   variables: { topic: 'TypeScript' },
+   * });
+   *
+   * if (result.type === 'message') {
+   *   console.log(result.content);
+   * }
+   *
+   * // Image generation
+   * const imageResult = await client.prompts.execute('prm_image123', {
+   *   provider: 'google',
+   *   model: 'gemini-2.0-flash-exp',
+   *   variables: { style: 'modern' },
+   * });
+   *
+   * if (imageResult.type === 'image') {
+   *   console.log('Generated images:', imageResult.files);
+   * }
+   * ```
+   */
+  async execute(promptId, options) {
+    const body = {
+      provider: options.provider,
+      model: options.model
+    };
+    if (options.variables !== void 0) body.variables = options.variables;
+    if (options.messages !== void 0) body.messages = options.messages;
+    if (options.tag !== void 0) body.tag = options.tag;
+    if (options.version !== void 0) body.version = options.version;
+    if (options.metadata !== void 0) body.metadata = options.metadata;
+    if (options.parameters !== void 0) body.parameters = options.parameters;
+    if (options.responseSchema !== void 0) body.responseSchema = options.responseSchema;
+    return this.http.request({
+      method: "POST",
+      path: `/api/v1/prompts/${promptId}/run`,
+      body
+    });
+  }
+  /**
+   * Execute a prompt by tag
+   *
+   * @param promptId - The prompt ID
+   * @param tag - The tag (e.g., 'latest', 'production', 'staging')
+   * @param options - Execution options
+   * @returns The execution response
+   *
+   * @example
+   * ```ts
+   * const result = await client.prompts.executeByTag('prm_abc123', 'production', {
+   *   provider: 'openai',
+   *   model: 'gpt-4o',
+   *   variables: { topic: 'TypeScript' },
+   * });
+   * ```
+   */
+  async executeByTag(promptId, tag, options) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/v1/prompts/${promptId}/run`,
+      body: {
+        tag,
+        provider: options.provider,
+        model: options.model,
+        variables: options.variables,
+        messages: options.messages,
+        metadata: options.metadata,
+        parameters: options.parameters
+      }
+    });
+  }
+  /**
+   * Execute a prompt by version
+   *
+   * @param promptId - The prompt ID
+   * @param version - The semantic version (e.g., '1.0.0', '2.1.0')
+   * @param options - Execution options
+   * @returns The execution response
+   *
+   * @example
+   * ```ts
+   * const result = await client.prompts.executeByVersion('prm_abc123', '1.2.0', {
+   *   provider: 'openai',
+   *   model: 'gpt-4o',
+   *   variables: { topic: 'TypeScript' },
+   * });
+   * ```
+   */
+  async executeByVersion(promptId, version, options) {
+    return this.http.request({
+      method: "POST",
+      path: `/api/v1/prompts/${promptId}/run`,
+      body: {
+        version,
+        provider: options.provider,
+        model: options.model,
+        variables: options.variables,
+        messages: options.messages,
+        metadata: options.metadata,
+        parameters: options.parameters
+      }
+    });
+  }
+};
+
+// src/resources/models.ts
+var ModelsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all available models
+   *
+   * @param options - Optional filters
+   * @returns List of providers with their models
+   *
+   * @example
+   * ```ts
+   * // Get all models
+   * const { providers } = await client.models.list();
+   *
+   * // Filter by type
+   * const imageModels = await client.models.list({ type: 'image' });
+   *
+   * // Filter by capability
+   * const functionCallingModels = await client.models.list({
+   *   capability: 'function_calling',
+   * });
+   *
+   * // Filter by provider
+   * const openaiModels = await client.models.list({ provider: 'openai' });
+   * ```
+   */
+  async list(options) {
+    return this.http.request({
+      method: "GET",
+      path: "/api/v1/models",
+      query: {
+        type: options?.type,
+        capability: options?.capability,
+        provider: options?.provider
+      }
+    });
+  }
+  /**
+   * Get models for a specific provider
+   *
+   * @param provider - Provider ID (e.g., 'openai', 'anthropic')
+   * @returns List of models for the provider
+   *
+   * @example
+   * ```ts
+   * const { models } = await client.models.getByProvider('openai');
+   * ```
+   */
+  async getByProvider(provider) {
+    const response = await this.http.request({
+      method: "GET",
+      path: `/api/v1/models/${provider}`
+    });
+    return response.models;
+  }
+  /**
+   * Get a specific model
+   *
+   * @param provider - Provider ID
+   * @param model - Model ID
+   * @returns Model details
+   *
+   * @example
+   * ```ts
+   * const model = await client.models.get('openai', 'gpt-4o');
+   * console.log(model.capabilities);
+   * console.log(model.limits);
+   * ```
+   */
+  async get(provider, model) {
+    return this.http.request({
+      method: "GET",
+      path: `/api/v1/models/${provider}/${model}`
+    });
+  }
+};
+
+// src/resources/files.ts
+var FilesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Upload files for use in prompt execution
+   *
+   * @param files - Array of File or Blob objects to upload
+   * @param options - Upload options including projectId
+   * @returns Upload response with file metadata
+   *
+   * @example
+   * ```ts
+   * // Upload files
+   * const result = await client.files.upload(
+   *   [file1, file2],
+   *   { projectId: 'prj_abc123' }
+   * );
+   *
+   * console.log('Uploaded files:', result.data);
+   *
+   * // Use uploaded file in prompt execution
+   * const response = await client.prompts.execute('prm_abc123', {
+   *   provider: 'openai',
+   *   model: 'gpt-4o',
+   *   messages: [
+   *     {
+   *       role: 'user',
+   *       content: 'Describe this image',
+   *       files: [{ fileId: result.data[0].id }],
+   *     },
+   *   ],
+   * });
+   * ```
+   */
+  async upload(files, options) {
+    const formData = new FormData();
+    for (const file of files) {
+      formData.append("files", file);
+    }
+    formData.append("projectId", options.projectId);
+    return this.http.upload({
+      path: "/api/v1/files/upload",
+      formData
+    });
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.synova.cloud";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRY = {
+  maxRetries: 3,
+  strategy: "exponential",
+  initialDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  backoffMultiplier: 2
+};
+var DEFAULT_LOGGER = {
+  debug: (message, ...args) => console.debug(message, ...args),
+  info: (message, ...args) => console.info(message, ...args),
+  warn: (message, ...args) => console.warn(message, ...args),
+  error: (messageOrError, ...args) => console.error(messageOrError, ...args)
+};
+var SynovaCloudSdk = class {
+  prompts;
+  models;
+  files;
+  http;
+  /**
+   * Create a new Synova Cloud SDK client
+   *
+   * @param apiKey - Your Synova API key
+   * @param config - Optional configuration
+   */
+  constructor(apiKey, config) {
+    if (!apiKey) {
+      throw new Error("API key is required");
+    }
+    this.http = new HttpClient({
+      baseUrl: config?.baseUrl ?? DEFAULT_BASE_URL,
+      apiKey,
+      timeout: config?.timeout ?? DEFAULT_TIMEOUT,
+      retry: {
+        maxRetries: config?.retry?.maxRetries ?? DEFAULT_RETRY.maxRetries,
+        strategy: config?.retry?.strategy ?? DEFAULT_RETRY.strategy,
+        initialDelayMs: config?.retry?.initialDelayMs ?? DEFAULT_RETRY.initialDelayMs,
+        maxDelayMs: config?.retry?.maxDelayMs ?? DEFAULT_RETRY.maxDelayMs,
+        backoffMultiplier: config?.retry?.backoffMultiplier ?? DEFAULT_RETRY.backoffMultiplier
+      },
+      debug: config?.debug ?? false,
+      logger: config?.logger ?? DEFAULT_LOGGER
+    });
+    this.prompts = new PromptsResource(this.http);
+    this.models = new ModelsResource(this.http);
+    this.files = new FilesResource(this.http);
+  }
+};
+
+export { ApiSynovaError, AuthSynovaError, NetworkSynovaError, NotFoundSynovaError, RateLimitSynovaError, ServerSynovaError, SynovaCloudSdk, SynovaError, TimeoutSynovaError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map