@amigo-ai/sdk 1.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Amigo
+
+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,94 @@
+# Amigo TypeScript SDK
+
+[![Tests](https://github.com/amigo-ai/amigo-typescript-sdk/actions/workflows/test.yml/badge.svg)](https://github.com/amigo-ai/amigo-typescript-sdk/actions/workflows/test.yml)
+[![codecov](https://codecov.io/gh/amigo-ai/amigo-typescript-sdk/graph/badge.svg?token=PQU5JBU941)](https://codecov.io/gh/amigo-ai/amigo-typescript-sdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+The official TypeScript SDK for the Amigo API, providing a simple and intuitive interface to interact with Amigo's AI services.
+
+## Installation
+
+Install the SDK using npm:
+
+```bash
+npm install @amigo/amigo-typescript-sdk
+```
+
+## Quick Start
+
+```typescript
+import { AmigoClient } from '@amigo/amigo-typescript-sdk'
+
+// Initialize the client
+const client = new AmigoClient({
+  apiKey: 'your-api-key',
+  apiKeyId: 'your-api-key-id',
+  userId: 'user-id',
+  orgId: 'your-organization-id',
+})
+
+// Get organization details
+async function example() {
+  try {
+    const organization = await client.organizations.getOrganization('your-org-id')
+    console.log('Organization:', organization)
+  } catch (error) {
+    console.error('Error:', error)
+  }
+}
+
+example()
+```
+
+## Configuration
+
+The SDK requires the following configuration parameters:
+
+| Parameter  | Type   | Required | Description                                                    |
+| ---------- | ------ | -------- | -------------------------------------------------------------- |
+| `apiKey`   | string | ✅       | API key from Amigo dashboard                                   |
+| `apiKeyId` | string | ✅       | API key ID from Amigo dashboard                                |
+| `userId`   | string | ✅       | User ID on whose behalf the request is made                    |
+| `orgId`    | string | ✅       | Your organization ID                                           |
+| `baseUrl`  | string | ❌       | Base URL of the Amigo API (defaults to `https://api.amigo.ai`) |
+
+### Getting Your API Credentials
+
+1. **API Key & API Key ID**: Generate these from your Amigo admin dashboard or programmatically using the API
+2. **Organization ID**: Found in your Amigo dashboard URL or organization settings
+3. **User ID**: The ID of the user you want to impersonate for API calls
+
+For detailed instructions on generating API keys, see the [Authentication Guide](https://docs.amigo.ai/developer-guide).
+
+## Error Handling
+
+The SDK provides typed error handling:
+
+```typescript
+import { AmigoClient, errors } from '@amigo/amigo-typescript-sdk'
+
+try {
+  const result = await client.organizations.getOrganization('org-id')
+} catch (error) {
+  if (error instanceof errors.AuthenticationError) {
+    console.error('Authentication failed:', error.message)
+  } else if (error instanceof errors.NetworkError) {
+    console.error('Network error:', error.message)
+  } else {
+    console.error('Unexpected error:', error)
+  }
+}
+```
+
+## Documentation
+
+- **Developer Guide**: [https://docs.amigo.ai/developer-guide](https://docs.amigo.ai/developer-guide)
+- **API Reference**: [https://docs.amigo.ai/api-reference](https://docs.amigo.ai/api-reference)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Support
+
+For questions, issues, or feature requests, please visit our [GitHub repository](https://github.com/amigo-ai/amigo-typescript-sdk) or contact support through the Amigo dashboard.

package/dist/index.js

@@ -0,0 +1,353 @@
+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;
+  return result.data;
+}
+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 ErrorClass = map[response.status] ?? AmigoError;
+  const message = body && typeof body === "object" && "message" in body ? String(body.message) : response.statusText;
+  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/openapi-client.ts
+function createAmigoFetch(config, mockFetch) {
+  const client = createClient({
+    baseUrl: config.baseUrl,
+    ...mockFetch && { fetch: mockFetch }
+  });
+  client.use(createErrorMiddleware());
+  client.use(createAuthMiddleware(config));
+  return client;
+}
+
+// src/resources/organization.ts
+var OrganizationResource = class {
+  constructor(c) {
+    this.c = c;
+  }
+  async getOrganization(orgId) {
+    return extractData(
+      this.c.GET("/v1/{organization}/organization/", {
+        params: { path: { organization: orgId } }
+      })
+    );
+  }
+};
+
+// src/resources/services.ts
+var ServiceResource = class {
+  constructor(c) {
+    this.c = c;
+  }
+  async getServices(orgId) {
+    return extractData(
+      this.c.GET("/v1/{organization}/service/", {
+        params: { path: { organization: orgId } }
+      })
+    );
+  }
+};
+
+// src/index.ts
+var defaultBaseUrl = "https://api.amigo.ai";
+var AmigoClient = class {
+  constructor(config) {
+    __publicField(this, "organizations");
+    __publicField(this, "services");
+    __publicField(this, "config");
+    this.config = validateConfig(config);
+    const api = createAmigoFetch(this.config);
+    this.organizations = new OrganizationResource(api);
+    this.services = new ServiceResource(api);
+  }
+};
+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

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/core/errors.ts", "../src/core/utils.ts", "../src/core/openapi-client.ts", "../src/core/auth.ts", "../src/resources/organization.ts", "../src/resources/services.ts", "../src/index.ts"],
+  "sourcesContent": ["import type { Middleware } from 'openapi-fetch'\nimport { isNetworkError, parseResponseBody } from './utils'\n\n/**\n * Base error class for all Amigo SDK errors.\n * Provides common functionality and error identification.\n */\nexport class AmigoError extends Error {\n  /**\n   * Unique error code for programmatic error handling\n   */\n  readonly errorCode?: string\n\n  /**\n   * HTTP status code if applicable\n   */\n  readonly statusCode?: number\n\n  /**\n   * Additional context data\n   */\n  context?: Record<string, unknown>\n\n  constructor(message: string, options?: Record<string, unknown>) {\n    super(message)\n    this.name = this.constructor.name\n\n    // Ensure proper prototype chain for instanceof checks\n    Object.setPrototypeOf(this, new.target.prototype)\n\n    // Capture stack trace\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor)\n    }\n\n    // copies status, code, etc.\n    Object.assign(this, options)\n  }\n\n  /**\n   * Returns a JSON-serializable representation of the error\n   */\n  toJSON(): Record<string, unknown> {\n    return {\n      name: this.name,\n      message: this.message,\n      code: this.errorCode,\n      statusCode: this.statusCode,\n      context: this.context,\n      stack: this.stack,\n    }\n  }\n}\n\n/* 4xx client errors */\nexport class BadRequestError extends AmigoError {}\nexport class AuthenticationError extends AmigoError {}\nexport class PermissionError extends AmigoError {}\nexport class NotFoundError extends AmigoError {}\nexport class ConflictError extends AmigoError {}\nexport class RateLimitError extends AmigoError {}\n\n/* 5xx server errors */\nexport class ServerError extends AmigoError {}\nexport class ServiceUnavailableError extends ServerError {}\n\n/* Internal SDK errors */\nexport class ConfigurationError extends AmigoError {\n  constructor(\n    message: string,\n    public field?: string\n  ) {\n    super(message)\n    this.context = { field }\n  }\n}\n\n/* Validation errors */\nexport class ValidationError extends BadRequestError {\n  constructor(\n    msg: string,\n    public fieldErrors?: Record<string, string>\n  ) {\n    super(msg)\n  }\n}\n\n/* Network-related errors */\nexport class NetworkError extends AmigoError {\n  constructor(\n    message: string,\n    public readonly originalError?: Error,\n    public readonly request?: {\n      url?: string\n      method?: string\n    }\n  ) {\n    super(message, { cause: originalError })\n    this.context = { request }\n  }\n}\n\n/* Parsing errors */\nexport class ParseError extends AmigoError {\n  constructor(\n    message: string,\n    public readonly parseType: 'json' | 'response' | 'other',\n    public readonly originalError?: Error\n  ) {\n    super(message, { cause: originalError })\n    this.context = { parseType }\n  }\n}\n\n/* Type guard functions */\nexport function isAmigoError(error: unknown): error is AmigoError {\n  return error instanceof AmigoError\n}\n\n/* Error factory to create appropriate error instances from API responses */\nexport function createApiError(response: Response, body?: unknown): AmigoError {\n  const map: Record<number, typeof AmigoError> = {\n    400: BadRequestError,\n    401: AuthenticationError,\n    403: PermissionError,\n    404: NotFoundError,\n    409: ConflictError,\n    422: ValidationError,\n    429: RateLimitError,\n    500: ServerError,\n    503: ServiceUnavailableError,\n  }\n\n  const ErrorClass = map[response.status] ?? AmigoError\n  const message =\n    body && typeof body === 'object' && 'message' in body\n      ? String((body as Record<string, unknown>).message)\n      : response.statusText\n\n  const options = {\n    status: response.status,\n    code:\n      body && typeof body === 'object' && 'code' in body\n        ? (body as Record<string, unknown>).code\n        : undefined,\n    response: body,\n  }\n\n  const error = new ErrorClass(message, options)\n\n  return error\n}\n\nexport function createErrorMiddleware(): Middleware {\n  return {\n    onResponse: async ({ response }) => {\n      if (!response.ok) {\n        const body = await parseResponseBody(response)\n        throw createApiError(response, body)\n      }\n    },\n    onError: async ({ error, request }) => {\n      // Handle network-related errors consistently\n      if (isNetworkError(error)) {\n        throw new NetworkError(\n          `Network error: ${error instanceof Error ? error.message : String(error)}`,\n          error instanceof Error ? error : new Error(String(error)),\n          {\n            url: request?.url,\n            method: request?.method,\n          }\n        )\n      }\n      throw error\n    },\n  }\n}\n", "// Note: ParseError import removed as it's unused in current implementation\n\n// Type helper to extract the data type from openapi-fetch responses\nexport type ExtractDataType<T> = T extends { data?: infer D } ? D : never\n\n// Helper function to extract data from openapi-fetch responses\n// Since our middleware throws on errors, successful responses will have data\nexport async function extractData<T>(responsePromise: Promise<T>): Promise<ExtractDataType<T>> {\n  const result = await responsePromise\n  // openapi-fetch guarantees data exists on successful responses\n  return (result as { data: ExtractDataType<T> }).data\n}\n\n// Utility function to safely parse response bodies without throwing errors\nexport async function parseResponseBody(response: Response): Promise<unknown> {\n  try {\n    const text = await response.text()\n    if (!text) return undefined\n    try {\n      return JSON.parse(text)\n    } catch {\n      return text // Return as string if not valid JSON\n    }\n  } catch {\n    return undefined // Return undefined if any error occurs\n  }\n}\n\n// Helper to detect network-related errors\nexport function isNetworkError(error: unknown): boolean {\n  if (!(error instanceof Error)) return false\n\n  return (\n    error instanceof TypeError ||\n    error.message.includes('fetch') ||\n    error.message.includes('Failed to fetch') ||\n    error.message.includes('Network request failed') ||\n    error.message.includes('ECONNREFUSED') ||\n    error.message.includes('ETIMEDOUT') ||\n    error.message.includes('ENOTFOUND') ||\n    error.message.includes('network')\n  )\n}\n", "import createClient, { type Client } from 'openapi-fetch'\nimport { createErrorMiddleware } from './errors'\nimport { createAuthMiddleware } from './auth'\nimport type { paths } from '../generated/api-types'\nimport type { AmigoSdkConfig } from '..'\n\nexport type AmigoFetch = Client<paths>\n\nexport function createAmigoFetch(\n  config: AmigoSdkConfig,\n  mockFetch?: (input: Request) => Promise<Response>\n): AmigoFetch {\n  const client = createClient<paths>({\n    baseUrl: config.baseUrl,\n    ...(mockFetch && { fetch: mockFetch }),\n  })\n\n  // Apply error handling middleware first (to catch all errors)\n  client.use(createErrorMiddleware())\n\n  // Apply auth middleware after error handling (so auth errors are properly handled)\n  client.use(createAuthMiddleware(config))\n\n  return client\n}\n", "import type { Middleware } from 'openapi-fetch'\nimport type { components } from '../generated/api-types'\nimport type { AmigoSdkConfig } from '..'\nimport { AmigoError, AuthenticationError, NetworkError, ParseError, createApiError } from './errors'\nimport { isNetworkError, parseResponseBody } from './utils'\n\ntype SignInWithApiKeyResponse =\n  components['schemas']['src__app__endpoints__user__sign_in_with_api_key__Response']\n\n/** Helper function to trade API key for a bearer token */\nexport async function getBearerToken(config: AmigoSdkConfig): Promise<SignInWithApiKeyResponse> {\n  const url = `${config.baseUrl}/v1/${config.orgId}/user/signin_with_api_key`\n\n  try {\n    const response = await fetch(url, {\n      method: 'POST',\n      headers: {\n        'x-api-key': config.apiKey,\n        'x-api-key-id': config.apiKeyId,\n        'x-user-id': config.userId,\n      },\n    })\n\n    if (!response.ok) {\n      const body = await parseResponseBody(response)\n      const apiError = createApiError(response, body)\n\n      // Enhance authentication errors with additional context\n      if (response.status === 401) {\n        throw new AuthenticationError(`Authentication failed: ${apiError.message}`, {\n          ...apiError,\n          context: { ...apiError.context, endpoint: 'signin_with_api_key' },\n        })\n      }\n      throw apiError\n    }\n\n    return (await response.json()) as SignInWithApiKeyResponse\n  } catch (err) {\n    // Re-throw our custom errors as-is\n    if (err instanceof AmigoError) {\n      throw err\n    }\n\n    // Handle network errors\n    if (isNetworkError(err)) {\n      throw new NetworkError('Failed to connect to authentication endpoint', err as Error, {\n        url,\n        method: 'POST',\n      })\n    }\n\n    // Handle JSON parsing errors\n    throw new ParseError(\n      'Failed to parse authentication response',\n      'json',\n      err instanceof Error ? err : new Error(String(err))\n    )\n  }\n}\n\nexport function createAuthMiddleware(config: AmigoSdkConfig): Middleware {\n  let token: SignInWithApiKeyResponse | null = null\n  let refreshPromise: Promise<SignInWithApiKeyResponse> | null = null\n\n  const shouldRefreshToken = (tokenData: SignInWithApiKeyResponse): boolean => {\n    if (!tokenData.expires_at) return false\n\n    const expiryTime = new Date(tokenData.expires_at).getTime()\n    const currentTime = Date.now()\n    const timeUntilExpiry = expiryTime - currentTime\n    const refreshThreshold = 5 * 60 * 1000 // 5 minutes in milliseconds\n\n    return timeUntilExpiry <= refreshThreshold\n  }\n\n  const ensureValidToken = async (): Promise<SignInWithApiKeyResponse> => {\n    if (!token || shouldRefreshToken(token)) {\n      if (!refreshPromise) {\n        refreshPromise = getBearerToken(config)\n        try {\n          token = await refreshPromise\n        } finally {\n          refreshPromise = null\n        }\n      } else {\n        token = await refreshPromise\n      }\n    }\n    return token\n  }\n\n  return {\n    onRequest: async ({ request }) => {\n      try {\n        const validToken = await ensureValidToken()\n        if (validToken?.id_token) {\n          request.headers.set('Authorization', `Bearer ${validToken.id_token}`)\n        }\n      } catch (error) {\n        // Clear token and re-throw - getBearerToken already provides proper error types\n        token = null\n        throw error\n      }\n      return request\n    },\n\n    onResponse: async ({ response }) => {\n      // Handle 401 responses by clearing token to force refresh on next request\n      if (response.status === 401) {\n        token = null\n      }\n    },\n\n    onError: async ({ error }) => {\n      // Clear token on any error to force refresh\n      token = null\n      throw error\n    },\n  }\n}\n", "import type { AmigoFetch } from '../core/openapi-client'\nimport { extractData } from '../core/utils'\n\nexport class OrganizationResource {\n  constructor(private c: AmigoFetch) {}\n\n  async getOrganization(orgId: string) {\n    return extractData(\n      this.c.GET('/v1/{organization}/organization/', {\n        params: { path: { organization: orgId } },\n      })\n    )\n  }\n}\n", "import type { AmigoFetch } from '../core/openapi-client'\nimport { extractData } from '../core/utils'\n\nexport class ServiceResource {\n  constructor(private c: AmigoFetch) {}\n\n  async getServices(orgId: string) {\n    return extractData(\n      this.c.GET('/v1/{organization}/service/', {\n        params: { path: { organization: orgId } },\n      })\n    )\n  }\n}\n", "import { ConfigurationError } from './core/errors'\nimport { createAmigoFetch } from './core/openapi-client'\nimport { OrganizationResource } from './resources/organization'\nimport { ServiceResource } from './resources/services'\n\nexport interface AmigoSdkConfig {\n  /** API key from Amigo dashboard */\n  apiKey: string\n  /** API-key ID from Amigo dashboard */\n  apiKeyId: string\n  /** User ID on whose behalf the request is made */\n  userId: string\n  /** The Organization ID */\n  orgId: string\n  /** Base URL of the Amigo API */\n  baseUrl?: string\n}\n\nconst defaultBaseUrl = 'https://api.amigo.ai'\n\nexport class AmigoClient {\n  readonly organizations: OrganizationResource\n  readonly services: ServiceResource\n  readonly config: AmigoSdkConfig\n\n  constructor(config: AmigoSdkConfig) {\n    this.config = validateConfig(config)\n\n    const api = createAmigoFetch(this.config)\n    this.organizations = new OrganizationResource(api)\n    this.services = new ServiceResource(api)\n  }\n}\n\nfunction validateConfig(config: AmigoSdkConfig) {\n  if (!config.apiKey) {\n    throw new ConfigurationError('API key is required', 'apiKey')\n  }\n  if (!config.apiKeyId) {\n    throw new ConfigurationError('API key ID is required', 'apiKeyId')\n  }\n  if (!config.userId) {\n    throw new ConfigurationError('User ID is required', 'userId')\n  }\n  if (!config.orgId) {\n    throw new ConfigurationError('Organization ID is required', 'orgId')\n  }\n  if (!config.baseUrl) {\n    config.baseUrl = defaultBaseUrl\n  }\n  return config\n}\n\n// Export all errors as a namespace to avoid polluting the main import space\nexport * as errors from './core/errors'\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/types/src/core/auth.d.ts

@@ -0,0 +1,8 @@
+import type { Middleware } from 'openapi-fetch';
+import type { components } from '../generated/api-types';
+import type { AmigoSdkConfig } from '..';
+type SignInWithApiKeyResponse = components['schemas']['src__app__endpoints__user__sign_in_with_api_key__Response'];
+/** Helper function to trade API key for a bearer token */
+export declare function getBearerToken(config: AmigoSdkConfig): Promise<SignInWithApiKeyResponse>;
+export declare function createAuthMiddleware(config: AmigoSdkConfig): Middleware;
+export {};

package/dist/types/src/core/errors.d.ts

@@ -0,0 +1,67 @@
+import type { Middleware } from 'openapi-fetch';
+/**
+ * Base error class for all Amigo SDK errors.
+ * Provides common functionality and error identification.
+ */
+export declare class AmigoError extends Error {
+    /**
+     * Unique error code for programmatic error handling
+     */
+    readonly errorCode?: string;
+    /**
+     * HTTP status code if applicable
+     */
+    readonly statusCode?: number;
+    /**
+     * Additional context data
+     */
+    context?: Record<string, unknown>;
+    constructor(message: string, options?: Record<string, unknown>);
+    /**
+     * Returns a JSON-serializable representation of the error
+     */
+    toJSON(): Record<string, unknown>;
+}
+export declare class BadRequestError extends AmigoError {
+}
+export declare class AuthenticationError extends AmigoError {
+}
+export declare class PermissionError extends AmigoError {
+}
+export declare class NotFoundError extends AmigoError {
+}
+export declare class ConflictError extends AmigoError {
+}
+export declare class RateLimitError extends AmigoError {
+}
+export declare class ServerError extends AmigoError {
+}
+export declare class ServiceUnavailableError extends ServerError {
+}
+export declare class ConfigurationError extends AmigoError {
+    field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare class ValidationError extends BadRequestError {
+    fieldErrors?: Record<string, string> | undefined;
+    constructor(msg: string, fieldErrors?: Record<string, string> | undefined);
+}
+export declare class NetworkError extends AmigoError {
+    readonly originalError?: Error | undefined;
+    readonly request?: {
+        url?: string;
+        method?: string;
+    } | undefined;
+    constructor(message: string, originalError?: Error | undefined, request?: {
+        url?: string;
+        method?: string;
+    } | undefined);
+}
+export declare class ParseError extends AmigoError {
+    readonly parseType: 'json' | 'response' | 'other';
+    readonly originalError?: Error | undefined;
+    constructor(message: string, parseType: 'json' | 'response' | 'other', originalError?: Error | undefined);
+}
+export declare function isAmigoError(error: unknown): error is AmigoError;
+export declare function createApiError(response: Response, body?: unknown): AmigoError;
+export declare function createErrorMiddleware(): Middleware;

package/dist/types/src/core/openapi-client.d.ts

@@ -0,0 +1,5 @@
+import { type Client } from 'openapi-fetch';
+import type { paths } from '../generated/api-types';
+import type { AmigoSdkConfig } from '..';
+export type AmigoFetch = Client<paths>;
+export declare function createAmigoFetch(config: AmigoSdkConfig, mockFetch?: (input: Request) => Promise<Response>): AmigoFetch;

package/dist/types/src/core/utils.d.ts

@@ -0,0 +1,6 @@
+export type ExtractDataType<T> = T extends {
+    data?: infer D;
+} ? D : never;
+export declare function extractData<T>(responsePromise: Promise<T>): Promise<ExtractDataType<T>>;
+export declare function parseResponseBody(response: Response): Promise<unknown>;
+export declare function isNetworkError(error: unknown): boolean;