@cobbl-ai/sdk 0.1.0 → 0.1.2

package/src/client.ts

@@ -1,257 +0,0 @@
-/**
- * CobblClient - SDK for the Cobbl platform
- *
- * Provides methods to run prompts and submit feedback to the Cobbl API.
- */
-
-import type { PromptInput, PromptVersionClient } from '@prompti/shared'
-import type {
-  RunPromptResponse,
-  SubmitFeedbackResponse,
-  CobblConfig,
-  TokenUsage,
-  FeedbackSubmission,
-} from './types'
-import { CobblError } from './errors'
-
-const REQUEST_TIMEOUT_MS = 30_000
-
-export class CobblClient {
-  private readonly apiKey: string
-
-  /**
-   * Initialize the Cobbl SDK client
-   *
-   * @param config - Configuration object
-   * @param config.apiKey - Your Cobbl API key
-   *
-   * @example
-   * ```typescript
-   * const client = new CobblClient({
-   *   apiKey: process.env.COBBL_API_KEY
-   * })
-   * ```
-   */
-  constructor(config: CobblConfig) {
-    if (!config.apiKey || config.apiKey.trim().length === 0) {
-      throw new CobblError('API key is required', 'INVALID_CONFIG')
-    }
-
-    this.apiKey = config.apiKey
-  }
-
-  /**
-   * Execute a prompt with the given input variables
-   *
-   * @param promptSlug - The unique slug identifier for the prompt
-   * @param input - Input variables to populate the prompt template
-   * @returns Promise containing the prompt execution results
-   *
-   * @throws {CobblError} When the request fails or API returns an error
-   *
-   * @example
-   * ```typescript
-   * const result = await client.runPrompt('sales_summary', {
-   *   topic: 'Q4 Results',
-   *   tone: 'friendly',
-   *   audience: 'investors'
-   * })
-   *
-   * console.log(result.output) // AI-generated response
-   * console.log(result.runId) // Save this to link feedback later
-   * ```
-   */
-  async runPrompt(
-    promptSlug: string,
-    input: PromptInput
-  ): Promise<RunPromptResponse> {
-    if (!promptSlug || promptSlug.trim().length === 0) {
-      throw new CobblError('promptSlug is required', 'INVALID_REQUEST')
-    }
-
-    try {
-      const response = await this.makeRequest('/prompt/run', {
-        method: 'POST',
-        body: JSON.stringify({
-          promptSlug: promptSlug.trim(),
-          input,
-        }),
-      })
-
-      if (!response.ok) {
-        await this.handleErrorResponse(response)
-      }
-
-      const data = (await response.json()) as {
-        runId: string
-        output: string
-        tokenUsage: TokenUsage
-        renderedPrompt: string
-        promptVersion: PromptVersionClient
-      }
-
-      return {
-        runId: data.runId,
-        output: data.output,
-        tokenUsage: data.tokenUsage,
-        renderedPrompt: data.renderedPrompt,
-        promptVersion: data.promptVersion,
-      }
-    } catch (error) {
-      if (error instanceof CobblError) {
-        throw error
-      }
-      throw new CobblError(
-        `Failed to run prompt: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        'NETWORK_ERROR'
-      )
-    }
-  }
-
-  /**
-   * Submit user feedback for a prompt run
-   *
-   * @param feedback - Feedback submission data
-   * @param feedback.runId - The run ID from a previous runPrompt call
-   * @param feedback.helpful - Whether the output was helpful ('helpful' or 'not_helpful')
-   * @param feedback.userFeedback - Detailed feedback message from the user
-   * @returns Promise containing the created feedback ID
-   *
-   * @throws {CobblError} When the request fails or API returns an error
-   *
-   * @example
-   * ```typescript
-   * await client.submitFeedback({
-   *   runId: result.runId,
-   *   helpful: 'not_helpful',
-   *   userFeedback: 'The response was too formal and lengthy'
-   * })
-   * ```
-   */
-  async submitFeedback(
-    feedback: FeedbackSubmission
-  ): Promise<SubmitFeedbackResponse> {
-    if (!feedback.runId || feedback.runId.trim().length === 0) {
-      throw new CobblError('runId is required', 'INVALID_REQUEST')
-    }
-
-    if (!feedback.userFeedback || feedback.userFeedback.trim().length === 0) {
-      throw new CobblError('userFeedback is required', 'INVALID_REQUEST')
-    }
-
-    if (
-      !feedback.helpful ||
-      !['helpful', 'not_helpful'].includes(feedback.helpful)
-    ) {
-      throw new CobblError(
-        'helpful must be either "helpful" or "not_helpful"',
-        'INVALID_REQUEST'
-      )
-    }
-
-    try {
-      const response = await this.makeRequest('/feedback', {
-        method: 'POST',
-        body: JSON.stringify({
-          runId: feedback.runId.trim(),
-          helpful: feedback.helpful,
-          userFeedback: feedback.userFeedback.trim(),
-        }),
-      })
-
-      if (!response.ok) {
-        await this.handleErrorResponse(response)
-      }
-
-      const data = (await response.json()) as {
-        feedbackId: string
-        message: string
-      }
-
-      return {
-        feedbackId: data.feedbackId,
-        message: data.message,
-      }
-    } catch (error) {
-      if (error instanceof CobblError) {
-        throw error
-      }
-      throw new CobblError(
-        `Failed to submit feedback: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        'NETWORK_ERROR'
-      )
-    }
-  }
-
-  /**
-   * Make an HTTP request to the Cobbl API
-   * @private
-   */
-  private async makeRequest(
-    path: string,
-    options: RequestInit
-  ): Promise<Response> {
-    const baseUrl = process.env.COBBL_API_URL || 'https://api.cobbl.ai'
-    const url = `${baseUrl}${path}`
-
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS)
-
-    try {
-      const response = await fetch(url, {
-        ...options,
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${this.apiKey}`,
-          ...options.headers,
-        },
-        signal: controller.signal,
-      })
-
-      return response
-    } finally {
-      clearTimeout(timeoutId)
-    }
-  }
-
-  /**
-   * Handle error responses from the API
-   * @private
-   */
-  private async handleErrorResponse(response: Response): Promise<never> {
-    let errorData: any
-    try {
-      errorData = await response.json()
-    } catch {
-      throw new CobblError(
-        `HTTP ${response.status}: ${response.statusText}`,
-        'API_ERROR',
-        { status: response.status }
-      )
-    }
-
-    const message = errorData.error || errorData.message || 'Unknown error'
-    const details = errorData.details
-
-    switch (response.status) {
-      case 400:
-        throw new CobblError(message, 'INVALID_REQUEST', details)
-      case 401:
-        throw new CobblError(message, 'UNAUTHORIZED', details)
-      case 404:
-        throw new CobblError(message, 'NOT_FOUND', details)
-      case 429:
-        throw new CobblError(message, 'RATE_LIMIT_EXCEEDED', details)
-      case 500:
-      case 502:
-      case 503:
-      case 504:
-        throw new CobblError(message, 'SERVER_ERROR', details)
-      default:
-        throw new CobblError(message, 'API_ERROR', {
-          status: response.status,
-          ...details,
-        })
-    }
-  }
-}