@amigo-ai/sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,739 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/core/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  AmigoError: () => AmigoError,
+  AuthenticationError: () => AuthenticationError,
+  BadRequestError: () => BadRequestError,
+  ConfigurationError: () => ConfigurationError,
+  ConflictError: () => ConflictError,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  ParseError: () => ParseError,
+  PermissionError: () => PermissionError,
+  RateLimitError: () => RateLimitError,
+  ServerError: () => ServerError,
+  ServiceUnavailableError: () => ServiceUnavailableError,
+  ValidationError: () => ValidationError,
+  createApiError: () => createApiError,
+  createErrorMiddleware: () => createErrorMiddleware,
+  isAmigoError: () => isAmigoError
+});
+
+// src/core/utils.ts
+async function extractData(responsePromise) {
+  const result = await responsePromise;
+  const data = result.data;
+  if (data === void 0 || data === null) {
+    throw new ParseError("Expected response data to be present for successful request", "response");
+  }
+  return data;
+}
+async function* parseNdjsonStream(response) {
+  const body = response.body;
+  if (!body) return;
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let bufferedText = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bufferedText += decoder.decode(value, { stream: true });
+      let newlineIndex;
+      while ((newlineIndex = bufferedText.indexOf("\n")) !== -1) {
+        const line = bufferedText.slice(0, newlineIndex).trim();
+        bufferedText = bufferedText.slice(newlineIndex + 1);
+        if (!line) continue;
+        try {
+          yield JSON.parse(line);
+        } catch (err) {
+          throw new ParseError("Failed to parse NDJSON line", "json", err);
+        }
+      }
+    }
+    const trailing = bufferedText.trim();
+    if (trailing) {
+      try {
+        yield JSON.parse(trailing);
+      } catch (err) {
+        throw new ParseError("Failed to parse trailing NDJSON line", "json", err);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function parseResponseBody(response) {
+  try {
+    const text = await response.text();
+    if (!text) return void 0;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function isNetworkError(error) {
+  if (!(error instanceof Error)) return false;
+  return error instanceof TypeError || error.message.includes("fetch") || error.message.includes("Failed to fetch") || error.message.includes("Network request failed") || error.message.includes("ECONNREFUSED") || error.message.includes("ETIMEDOUT") || error.message.includes("ENOTFOUND") || error.message.includes("network");
+}
+
+// src/core/errors.ts
+var AmigoError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    /**
+     * Unique error code for programmatic error handling
+     */
+    __publicField(this, "errorCode");
+    /**
+     * HTTP status code if applicable
+     */
+    __publicField(this, "statusCode");
+    /**
+     * Additional context data
+     */
+    __publicField(this, "context");
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    Object.assign(this, options);
+  }
+  /**
+   * Returns a JSON-serializable representation of the error
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.errorCode,
+      statusCode: this.statusCode,
+      context: this.context,
+      stack: this.stack
+    };
+  }
+};
+var BadRequestError = class extends AmigoError {
+};
+var AuthenticationError = class extends AmigoError {
+};
+var PermissionError = class extends AmigoError {
+};
+var NotFoundError = class extends AmigoError {
+};
+var ConflictError = class extends AmigoError {
+};
+var RateLimitError = class extends AmigoError {
+};
+var ServerError = class extends AmigoError {
+};
+var ServiceUnavailableError = class extends ServerError {
+};
+var ConfigurationError = class extends AmigoError {
+  constructor(message, field) {
+    super(message);
+    this.field = field;
+    this.context = { field };
+  }
+};
+var ValidationError = class extends BadRequestError {
+  constructor(msg, fieldErrors) {
+    super(msg);
+    this.fieldErrors = fieldErrors;
+  }
+};
+var NetworkError = class extends AmigoError {
+  constructor(message, originalError, request) {
+    super(message, { cause: originalError });
+    this.originalError = originalError;
+    this.request = request;
+    this.context = { request };
+  }
+};
+var ParseError = class extends AmigoError {
+  constructor(message, parseType, originalError) {
+    super(message, { cause: originalError });
+    this.parseType = parseType;
+    this.originalError = originalError;
+    this.context = { parseType };
+  }
+};
+function isAmigoError(error) {
+  return error instanceof AmigoError;
+}
+function createApiError(response, body) {
+  const map = {
+    400: BadRequestError,
+    401: AuthenticationError,
+    403: PermissionError,
+    404: NotFoundError,
+    409: ConflictError,
+    422: ValidationError,
+    429: RateLimitError,
+    500: ServerError,
+    503: ServiceUnavailableError
+  };
+  const errorMessageKeys = ["message", "error", "detail"];
+  const ErrorClass = map[response.status] ?? AmigoError;
+  let message = `HTTP ${response.status} ${response.statusText}`;
+  if (body && typeof body === "object") {
+    for (const key of errorMessageKeys) {
+      if (key in body) {
+        message = String(body[key]);
+        break;
+      }
+    }
+  }
+  const options = {
+    status: response.status,
+    code: body && typeof body === "object" && "code" in body ? body.code : void 0,
+    response: body
+  };
+  const error = new ErrorClass(message, options);
+  return error;
+}
+function createErrorMiddleware() {
+  return {
+    onResponse: async ({ response }) => {
+      if (!response.ok) {
+        const body = await parseResponseBody(response);
+        throw createApiError(response, body);
+      }
+    },
+    onError: async ({ error, request }) => {
+      if (isNetworkError(error)) {
+        throw new NetworkError(
+          `Network error: ${error instanceof Error ? error.message : String(error)}`,
+          error instanceof Error ? error : new Error(String(error)),
+          {
+            url: request?.url,
+            method: request?.method
+          }
+        );
+      }
+      throw error;
+    }
+  };
+}
+
+// src/core/openapi-client.ts
+import createClient from "openapi-fetch";
+
+// src/core/auth.ts
+async function getBearerToken(config) {
+  const url = `${config.baseUrl}/v1/${config.orgId}/user/signin_with_api_key`;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "x-api-key": config.apiKey,
+        "x-api-key-id": config.apiKeyId,
+        "x-user-id": config.userId
+      }
+    });
+    if (!response.ok) {
+      const body = await parseResponseBody(response);
+      const apiError = createApiError(response, body);
+      if (response.status === 401) {
+        throw new AuthenticationError(`Authentication failed: ${apiError.message}`, {
+          ...apiError,
+          context: { ...apiError.context, endpoint: "signin_with_api_key" }
+        });
+      }
+      throw apiError;
+    }
+    return await response.json();
+  } catch (err) {
+    if (err instanceof AmigoError) {
+      throw err;
+    }
+    if (isNetworkError(err)) {
+      throw new NetworkError("Failed to connect to authentication endpoint", err, {
+        url,
+        method: "POST"
+      });
+    }
+    throw new ParseError(
+      "Failed to parse authentication response",
+      "json",
+      err instanceof Error ? err : new Error(String(err))
+    );
+  }
+}
+function createAuthMiddleware(config) {
+  let token = null;
+  let refreshPromise = null;
+  const shouldRefreshToken = (tokenData) => {
+    if (!tokenData.expires_at) return false;
+    const expiryTime = new Date(tokenData.expires_at).getTime();
+    const currentTime = Date.now();
+    const timeUntilExpiry = expiryTime - currentTime;
+    const refreshThreshold = 5 * 60 * 1e3;
+    return timeUntilExpiry <= refreshThreshold;
+  };
+  const ensureValidToken = async () => {
+    if (!token || shouldRefreshToken(token)) {
+      if (!refreshPromise) {
+        refreshPromise = getBearerToken(config);
+        try {
+          token = await refreshPromise;
+        } finally {
+          refreshPromise = null;
+        }
+      } else {
+        token = await refreshPromise;
+      }
+    }
+    return token;
+  };
+  return {
+    onRequest: async ({ request }) => {
+      try {
+        const validToken = await ensureValidToken();
+        if (validToken?.id_token) {
+          request.headers.set("Authorization", `Bearer ${validToken.id_token}`);
+        }
+      } catch (error) {
+        token = null;
+        throw error;
+      }
+      return request;
+    },
+    onResponse: async ({ response }) => {
+      if (response.status === 401) {
+        token = null;
+      }
+    },
+    onError: async ({ error }) => {
+      token = null;
+      throw error;
+    }
+  };
+}
+
+// src/core/retry.ts
+var DEFAULT_RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var DEFAULT_RETRYABLE_METHODS = /* @__PURE__ */ new Set(["GET"]);
+function resolveRetryOptions(options) {
+  return {
+    maxAttempts: options?.maxAttempts ?? 3,
+    backoffBaseMs: options?.backoffBaseMs ?? 250,
+    maxDelayMs: options?.maxDelayMs ?? 3e4,
+    retryOnStatus: new Set(options?.retryOnStatus ?? DEFAULT_RETRYABLE_STATUS),
+    retryOnMethods: new Set(options?.retryOnMethods ?? DEFAULT_RETRYABLE_METHODS)
+  };
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function parseRetryAfterMs(headerValue, maxDelayMs) {
+  if (!headerValue) return null;
+  const seconds = Number(headerValue);
+  if (Number.isFinite(seconds)) {
+    return clamp(seconds * 1e3, 0, maxDelayMs);
+  }
+  const date = new Date(headerValue);
+  const ms = date.getTime() - Date.now();
+  if (Number.isFinite(ms)) {
+    return clamp(ms, 0, maxDelayMs);
+  }
+  return null;
+}
+function computeBackoffWithJitterMs(attemptIndexZeroBased, baseMs, capMs) {
+  const windowMs = Math.min(capMs, baseMs * Math.pow(2, attemptIndexZeroBased));
+  return Math.random() * windowMs;
+}
+function isAbortError(err) {
+  return typeof err === "object" && err !== null && "name" in err && err["name"] === "AbortError";
+}
+function isNetworkError2(err) {
+  return err instanceof TypeError && !isAbortError(err);
+}
+async function abortableSleep(ms, signal) {
+  if (ms <= 0) {
+    signal?.throwIfAborted?.();
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    const rejectWith = signal?.reason instanceof Error ? signal.reason : signal?.reason ?? new Error("AbortError");
+    if (signal?.aborted) {
+      reject(rejectWith);
+      return;
+    }
+    const t = setTimeout(() => {
+      off();
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      off();
+      clearTimeout(t);
+      reject(rejectWith);
+    };
+    const off = () => signal?.removeEventListener("abort", onAbort);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function createRetryingFetch(retryOptions, baseFetch) {
+  const resolved = resolveRetryOptions(retryOptions);
+  const underlying = baseFetch ?? globalThis.fetch;
+  const retryingFetch = async (input, init) => {
+    const inputMethod = typeof Request !== "undefined" && input instanceof Request ? input.method : void 0;
+    const method = (init?.method ?? inputMethod ?? "GET").toUpperCase();
+    const signal = init?.signal;
+    const isMethodRetryableByDefault = resolved.retryOnMethods.has(method);
+    const maxAttempts = Math.max(1, resolved.maxAttempts);
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      let response = null;
+      let error = null;
+      try {
+        response = await underlying(input, init);
+      } catch (err) {
+        error = err;
+      }
+      if (!error && response && response.ok) {
+        return response;
+      }
+      let shouldRetry = false;
+      let delayMs = null;
+      if (isNetworkError2(error)) {
+        shouldRetry = isMethodRetryableByDefault;
+        if (shouldRetry) {
+          delayMs = computeBackoffWithJitterMs(
+            attempt - 1,
+            resolved.backoffBaseMs,
+            resolved.maxDelayMs
+          );
+        }
+      } else if (response) {
+        const status = response.status;
+        if (method === "POST") {
+          if (status === 429) {
+            const ra = response.headers.get("Retry-After");
+            const parsed = parseRetryAfterMs(ra, resolved.maxDelayMs);
+            if (parsed !== null) {
+              shouldRetry = true;
+              delayMs = parsed;
+            }
+          }
+        } else if (isMethodRetryableByDefault && resolved.retryOnStatus.has(status)) {
+          const ra = response.headers.get("Retry-After");
+          delayMs = parseRetryAfterMs(ra, resolved.maxDelayMs) ?? computeBackoffWithJitterMs(attempt - 1, resolved.backoffBaseMs, resolved.maxDelayMs);
+          shouldRetry = true;
+        }
+      }
+      const attemptsRemain = attempt < maxAttempts;
+      if (!shouldRetry || !attemptsRemain) {
+        if (error) throw error;
+        return response;
+      }
+      if (signal?.aborted) {
+        if (error) throw error;
+        return response;
+      }
+      await abortableSleep(delayMs ?? 0, signal ?? void 0);
+    }
+    throw new Error("Retry loop exited unexpectedly");
+  };
+  return retryingFetch;
+}
+
+// src/core/openapi-client.ts
+function createAmigoFetch(config, mockFetch) {
+  const wrappedFetch = createRetryingFetch(
+    config.retry,
+    mockFetch ?? globalThis.fetch
+  );
+  const client = createClient({
+    baseUrl: config.baseUrl,
+    fetch: wrappedFetch
+  });
+  client.use(createErrorMiddleware());
+  client.use(createAuthMiddleware(config));
+  return client;
+}
+
+// src/resources/organization.ts
+var OrganizationResource = class {
+  constructor(c, orgId) {
+    this.c = c;
+    this.orgId = orgId;
+  }
+  /**
+   * Get organization details
+   * @param headers - The headers
+   * @returns The organization details
+   */
+  async getOrganization(headers) {
+    return extractData(
+      this.c.GET("/v1/{organization}/organization/", {
+        params: { path: { organization: this.orgId } },
+        headers
+      })
+    );
+  }
+};
+
+// src/resources/conversation.ts
+var ConversationResource = class {
+  constructor(c, orgId) {
+    this.c = c;
+    this.orgId = orgId;
+  }
+  async createConversation(body, queryParams, headers, options) {
+    const resp = await this.c.POST("/v1/{organization}/conversation/", {
+      params: { path: { organization: this.orgId }, query: queryParams },
+      body,
+      headers: {
+        Accept: "application/x-ndjson",
+        ...headers ?? {}
+      },
+      // Ensure we receive a stream for NDJSON
+      parseAs: "stream",
+      ...options?.signal && { signal: options.signal }
+    });
+    return parseNdjsonStream(
+      resp.response
+    );
+  }
+  async interactWithConversation(conversationId, input, queryParams, headers, options) {
+    let bodyToSend;
+    if (queryParams.request_format === "text") {
+      if (typeof input !== "string") {
+        throw new BadRequestError("textMessage is required when request_format is 'text'");
+      }
+      const form = new FormData();
+      const blob = new Blob([input], { type: "text/plain; charset=utf-8" });
+      form.append("recorded_message", blob, "message.txt");
+      bodyToSend = form;
+    } else if (queryParams.request_format === "voice") {
+      if (typeof input === "string") {
+        throw new BadRequestError(
+          "voice input must be a byte source when request_format is 'voice'"
+        );
+      }
+      bodyToSend = input;
+    } else {
+      throw new BadRequestError("Unsupported or missing request_format in params");
+    }
+    const normalizedQuery = {
+      ...queryParams,
+      request_audio_config: typeof queryParams.request_audio_config === "object" && queryParams.request_audio_config !== null ? JSON.stringify(queryParams.request_audio_config) : queryParams.request_audio_config ?? void 0
+    };
+    const resp = await this.c.POST("/v1/{organization}/conversation/{conversation_id}/interact", {
+      params: {
+        path: { organization: this.orgId, conversation_id: conversationId },
+        query: normalizedQuery
+      },
+      body: bodyToSend,
+      headers: {
+        Accept: "application/x-ndjson",
+        ...headers ?? {}
+      },
+      parseAs: "stream",
+      ...options?.signal && { signal: options.signal }
+    });
+    return parseNdjsonStream(resp.response);
+  }
+  async getConversations(queryParams, headers) {
+    return extractData(
+      this.c.GET("/v1/{organization}/conversation/", {
+        params: { path: { organization: this.orgId }, query: queryParams },
+        headers
+      })
+    );
+  }
+  async getConversationMessages(conversationId, queryParams, headers) {
+    return extractData(
+      this.c.GET("/v1/{organization}/conversation/{conversation_id}/messages/", {
+        params: {
+          path: { organization: this.orgId, conversation_id: conversationId },
+          query: queryParams
+        },
+        headers
+      })
+    );
+  }
+  async finishConversation(conversationId, headers) {
+    await this.c.POST("/v1/{organization}/conversation/{conversation_id}/finish/", {
+      params: { path: { organization: this.orgId, conversation_id: conversationId } },
+      headers,
+      // No content is expected; parse as text to access raw Response
+      parseAs: "text"
+    });
+    return;
+  }
+  async recommendResponsesForInteraction(conversationId, interactionId, headers) {
+    return extractData(
+      this.c.GET(
+        "/v1/{organization}/conversation/{conversation_id}/interaction/{interaction_id}/recommend_responses",
+        {
+          params: {
+            path: {
+              organization: this.orgId,
+              conversation_id: conversationId,
+              interaction_id: interactionId
+            }
+          },
+          headers
+        }
+      )
+    );
+  }
+  async getInteractionInsights(conversationId, interactionId, headers) {
+    return extractData(
+      this.c.GET(
+        "/v1/{organization}/conversation/{conversation_id}/interaction/{interaction_id}/insights",
+        {
+          params: {
+            path: {
+              organization: this.orgId,
+              conversation_id: conversationId,
+              interaction_id: interactionId
+            }
+          },
+          headers
+        }
+      )
+    );
+  }
+  // Note: the OpenAPI response schema isn't correct for this endpoint.
+  // TODO -- fix response typing.
+  async getMessageSource(conversationId, messageId, headers) {
+    return extractData(
+      this.c.GET("/v1/{organization}/conversation/{conversation_id}/messages/{message_id}/source", {
+        params: {
+          path: {
+            organization: this.orgId,
+            conversation_id: conversationId,
+            message_id: messageId
+          }
+        },
+        headers
+      })
+    );
+  }
+  async generateConversationStarters(body, headers) {
+    return extractData(
+      this.c.POST("/v1/{organization}/conversation/conversation_starter", {
+        params: { path: { organization: this.orgId } },
+        body,
+        headers
+      })
+    );
+  }
+};
+
+// src/resources/services.ts
+var ServiceResource = class {
+  constructor(c, orgId) {
+    this.c = c;
+    this.orgId = orgId;
+  }
+  /**
+   * Get services
+   * @param headers - The headers
+   * @returns The services
+   */
+  async getServices(queryParams, headers) {
+    return extractData(
+      this.c.GET("/v1/{organization}/service/", {
+        params: { path: { organization: this.orgId }, query: queryParams },
+        headers
+      })
+    );
+  }
+};
+
+// src/resources/user.ts
+var UserResource = class {
+  constructor(c, orgId) {
+    this.c = c;
+    this.orgId = orgId;
+  }
+  async getUsers(queryParams, headers) {
+    return extractData(
+      this.c.GET("/v1/{organization}/user/", {
+        params: { path: { organization: this.orgId }, query: queryParams },
+        headers
+      })
+    );
+  }
+  async createUser(body, headers) {
+    return extractData(
+      this.c.POST("/v1/{organization}/user/invite", {
+        params: { path: { organization: this.orgId } },
+        body,
+        headers
+      })
+    );
+  }
+  async deleteUser(userId, headers) {
+    await this.c.DELETE("/v1/{organization}/user/{requested_user_id}", {
+      params: { path: { organization: this.orgId, requested_user_id: userId } },
+      headers
+    });
+    return;
+  }
+  async updateUser(userId, body, headers) {
+    await this.c.POST("/v1/{organization}/user/{requested_user_id}/user", {
+      params: { path: { organization: this.orgId, requested_user_id: userId } },
+      body,
+      headers
+    });
+    return;
+  }
+};
+
+// src/index.ts
+var defaultBaseUrl = "https://api.amigo.ai";
+var AmigoClient = class {
+  constructor(config) {
+    __publicField(this, "organizations");
+    __publicField(this, "conversations");
+    __publicField(this, "services");
+    __publicField(this, "users");
+    __publicField(this, "config");
+    this.config = validateConfig(config);
+    const api = createAmigoFetch(this.config);
+    this.organizations = new OrganizationResource(api, this.config.orgId);
+    this.conversations = new ConversationResource(api, this.config.orgId);
+    this.services = new ServiceResource(api, this.config.orgId);
+    this.users = new UserResource(api, this.config.orgId);
+  }
+};
+function validateConfig(config) {
+  if (!config.apiKey) {
+    throw new ConfigurationError("API key is required", "apiKey");
+  }
+  if (!config.apiKeyId) {
+    throw new ConfigurationError("API key ID is required", "apiKeyId");
+  }
+  if (!config.userId) {
+    throw new ConfigurationError("User ID is required", "userId");
+  }
+  if (!config.orgId) {
+    throw new ConfigurationError("Organization ID is required", "orgId");
+  }
+  if (!config.baseUrl) {
+    config.baseUrl = defaultBaseUrl;
+  }
+  return config;
+}
+export {
+  AmigoClient,
+  errors_exports as errors
+};
+//# sourceMappingURL=index.js.map